1 /*
   2  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
   3  * Use is subject to license terms.
   4  */
   5 
   6 /*
   7  * Copyright (c) 2008 Atheros Communications Inc.
   8  *
   9  * Permission to use, copy, modify, and/or distribute this software for any
  10  * purpose with or without fee is hereby granted, provided that the above
  11  * copyright notice and this permission notice appear in all copies.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  14  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  15  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  16  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  17  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  18  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  19  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  20  */
  21 
  22 #include <sys/param.h>
  23 #include <sys/types.h>
  24 #include <sys/signal.h>
  25 #include <sys/stream.h>
  26 #include <sys/termio.h>
  27 #include <sys/errno.h>
  28 #include <sys/file.h>
  29 #include <sys/cmn_err.h>
  30 #include <sys/stropts.h>
  31 #include <sys/strsubr.h>
  32 #include <sys/strtty.h>
  33 #include <sys/kbio.h>
  34 #include <sys/cred.h>
  35 #include <sys/stat.h>
  36 #include <sys/consdev.h>
  37 #include <sys/kmem.h>
  38 #include <sys/modctl.h>
  39 #include <sys/ddi.h>
  40 #include <sys/sunddi.h>
  41 #include <sys/pci.h>
  42 #include <sys/errno.h>
  43 #include <sys/gld.h>
  44 #include <sys/dlpi.h>
  45 #include <sys/ethernet.h>
  46 #include <sys/list.h>
  47 #include <sys/byteorder.h>
  48 #include <sys/strsun.h>
  49 #include <inet/common.h>
  50 #include <inet/nd.h>
  51 #include <inet/mi.h>
  52 #include <inet/wifi_ioctl.h>
  53 
  54 #include "arn_core.h"
  55 #include "arn_hw.h"
  56 #include "arn_reg.h"
  57 #include "arn_phy.h"
  58 
  59 static void
  60 ath9k_hw_analog_shift_rmw(struct ath_hal *ah,
  61     uint32_t reg, uint32_t mask,
  62     uint32_t shift, uint32_t val)
  63 {
  64         uint32_t regVal;
  65 
  66         regVal = REG_READ(ah, reg) & ~mask;
  67         regVal |= (val << shift) & mask;
  68 
  69         REG_WRITE(ah, reg, regVal);
  70 
  71         if (ah->ah_config.analog_shiftreg)
  72                 drv_usecwait(100);
  73 }
  74 
  75 static inline uint16_t
  76 ath9k_hw_fbin2freq(uint8_t fbin, boolean_t is2GHz)
  77 {
  78 
  79         if (fbin == AR5416_BCHAN_UNUSED)
  80                 return (fbin);
  81 
  82         return ((uint16_t)((is2GHz) ? (2300 + fbin) : (4800 + 5 * fbin)));
  83 }
  84 
  85 static inline int16_t
  86 ath9k_hw_interpolate(uint16_t target, uint16_t srcLeft, uint16_t srcRight,
  87     int16_t targetLeft, int16_t targetRight)
  88 {
  89         int16_t rv;
  90 
  91         if (srcRight == srcLeft) {
  92                 rv = targetLeft;
  93         } else {
  94                 rv = (int16_t)(((target - srcLeft) * targetRight +
  95                     (srcRight - target) * targetLeft) /
  96                     (srcRight - srcLeft));
  97         }
  98         return (rv);
  99 }
 100 
 101 static inline boolean_t
 102 ath9k_hw_get_lower_upper_index(uint8_t target, uint8_t *pList,
 103     uint16_t listSize, uint16_t *indexL, uint16_t *indexR)
 104 {
 105         uint16_t i;
 106 
 107         if (target <= pList[0]) {
 108                 *indexL = *indexR = 0;
 109                 return (B_TRUE);
 110         }
 111         if (target >= pList[listSize - 1]) {
 112                 *indexL = *indexR = (uint16_t)(listSize - 1);
 113                 return (B_TRUE);
 114         }
 115 
 116         for (i = 0; i < listSize - 1; i++) {
 117                 if (pList[i] == target) {
 118                         *indexL = *indexR = i;
 119                         return (B_TRUE);
 120                 }
 121                 if (target < pList[i + 1]) {
 122                         *indexL = i;
 123                         *indexR = (uint16_t)(i + 1);
 124                         return (B_FALSE);
 125                 }
 126         }
 127         return (B_FALSE);
 128 }
 129 
 130 static boolean_t
 131 ath9k_hw_eeprom_read(struct ath_hal *ah, uint32_t off, uint16_t *data)
 132 {
 133         (void) REG_READ(ah, AR5416_EEPROM_OFFSET + (off << AR5416_EEPROM_S));
 134 
 135         if (!ath9k_hw_wait(ah, AR_EEPROM_STATUS_DATA,
 136             AR_EEPROM_STATUS_DATA_BUSY |
 137             AR_EEPROM_STATUS_DATA_PROT_ACCESS, 0)) {
 138                 return (B_FALSE);
 139         }
 140 
 141         *data = MS(REG_READ(ah, AR_EEPROM_STATUS_DATA),
 142             AR_EEPROM_STATUS_DATA_VAL);
 143 
 144         return (B_TRUE);
 145 }
 146 
 147 /* ARGSUSED */
 148 static int
 149 ath9k_hw_flash_map(struct ath_hal *ah)
 150 {
 151         ARN_DBG((ARN_DBG_EEPROM, "arn: ath9k_hw_flash_map(): "
 152             "using flash but eepom\n"));
 153 
 154         return (0);
 155 }
 156 
 157 static boolean_t
 158 ath9k_hw_flash_read(struct ath_hal *ah, uint32_t off, uint16_t *data)
 159 {
 160         *data = FLASH_READ(ah, off);
 161 
 162         return (B_TRUE);
 163 }
 164 
 165 static inline boolean_t
 166 ath9k_hw_nvram_read(struct ath_hal *ah, uint32_t off, uint16_t *data)
 167 {
 168         if (ath9k_hw_use_flash(ah))
 169                 return (ath9k_hw_flash_read(ah, off, data));
 170         else
 171                 return (ath9k_hw_eeprom_read(ah, off, data));
 172 }
 173 
 174 static boolean_t
 175 ath9k_hw_fill_4k_eeprom(struct ath_hal *ah)
 176 {
 177 #define SIZE_EEPROM_4K  (sizeof (struct ar5416_eeprom_4k) / sizeof (uint16_t))
 178         struct ath_hal_5416 *ahp = AH5416(ah);
 179         struct ar5416_eeprom_4k *eep = &ahp->ah_eeprom.map4k;
 180         uint16_t *eep_data;
 181         int addr, eep_start_loc = 0;
 182 
 183         eep_start_loc = 64;
 184 
 185         if (!ath9k_hw_use_flash(ah)) {
 186                 ARN_DBG((ARN_DBG_EEPROM,
 187                     "Reading from EEPROM, not flash\n"));
 188         }
 189 
 190         eep_data = (uint16_t *)eep;
 191 
 192         for (addr = 0; addr < SIZE_EEPROM_4K; addr++) {
 193                 if (!ath9k_hw_nvram_read(ah, addr + eep_start_loc, eep_data)) {
 194                         ARN_DBG((ARN_DBG_EEPROM,
 195                             "Unable to read eeprom region \n"));
 196                         return (B_FALSE);
 197                 }
 198                 eep_data++;
 199         }
 200         return (B_TRUE);
 201 #undef SIZE_EEPROM_4K
 202 }
 203 
 204 static boolean_t
 205 ath9k_hw_fill_def_eeprom(struct ath_hal *ah)
 206 {
 207 #define SIZE_EEPROM_DEF (sizeof (struct ar5416_eeprom_def) / sizeof (uint16_t))
 208         struct ath_hal_5416 *ahp = AH5416(ah);
 209         struct ar5416_eeprom_def *eep = &ahp->ah_eeprom.def;
 210         uint16_t *eep_data;
 211         int addr, ar5416_eep_start_loc = 0x100;
 212 
 213         eep_data = (uint16_t *)eep;
 214 
 215         for (addr = 0; addr < SIZE_EEPROM_DEF; addr++) {
 216                 if (!ath9k_hw_nvram_read(ah, addr + ar5416_eep_start_loc,
 217                     eep_data)) {
 218                         ARN_DBG((ARN_DBG_EEPROM,
 219                             "Unable to read eeprom region\n"));
 220                         return (B_FALSE);
 221                 }
 222                 eep_data++;
 223         }
 224         return (B_TRUE);
 225 #undef SIZE_EEPROM_DEF
 226 }
 227 
 228 static boolean_t (*ath9k_fill_eeprom[]) (struct ath_hal *) = {
 229         ath9k_hw_fill_def_eeprom,
 230         ath9k_hw_fill_4k_eeprom
 231 };
 232 
 233 static inline boolean_t
 234 ath9k_hw_fill_eeprom(struct ath_hal *ah)
 235 {
 236         struct ath_hal_5416 *ahp = AH5416(ah);
 237 
 238         return (ath9k_fill_eeprom[ahp->ah_eep_map](ah));
 239 }
 240 
 241 static int
 242 ath9k_hw_check_def_eeprom(struct ath_hal *ah)
 243 {
 244         struct ath_hal_5416 *ahp = AH5416(ah);
 245         struct ar5416_eeprom_def *eep =
 246             (struct ar5416_eeprom_def *)&ahp->ah_eeprom.def;
 247         uint16_t *eepdata, temp, magic, magic2;
 248         uint32_t sum = 0, el;
 249         boolean_t need_swap = B_FALSE;
 250         int i, addr, size;
 251         if (!ath9k_hw_nvram_read(ah, AR5416_EEPROM_MAGIC_OFFSET, &magic)) {
 252                 ARN_DBG((ARN_DBG_EEPROM, "arn: "
 253                     "%s: Reading Magic # failed\n", __func__));
 254                 return (B_FALSE);
 255         }
 256 
 257         if (!ath9k_hw_use_flash(ah)) {
 258                 ARN_DBG((ARN_DBG_EEPROM, "ath9k: "
 259                     "%s: Read Magic = 0x%04X\n", __func__, magic));
 260 
 261                 if (magic != AR5416_EEPROM_MAGIC) {
 262                         magic2 = swab16(magic);
 263 
 264                         if (magic2 == AR5416_EEPROM_MAGIC) {
 265                                 size = sizeof (struct ar5416_eeprom_def);
 266                                 need_swap = B_TRUE;
 267                                 eepdata = (uint16_t *)(&ahp->ah_eeprom);
 268 
 269                                 for (addr = 0; addr < size / sizeof (uint16_t);
 270                                     addr++) {
 271                                         temp = swab16(*eepdata);
 272                                         *eepdata = temp;
 273                                         eepdata++;
 274 
 275                                         ARN_DBG((ARN_DBG_EEPROM,
 276                                             "0x%04X  ", *eepdata));
 277 
 278                                         if (((addr + 1) % 6) == 0)
 279                                                 ARN_DBG((ARN_DBG_EEPROM,
 280                                                     "arn: "
 281                                                     "%s\n", __func__));
 282                                 }
 283                         } else {
 284                                 ARN_DBG((ARN_DBG_EEPROM,
 285                                     "Invalid EEPROM Magic. "
 286                                     "endianness mismatch.\n"));
 287                                 return (EINVAL);
 288                         }
 289                 }
 290         }
 291 
 292         ARN_DBG((ARN_DBG_EEPROM, "need_swap = %s.\n",
 293             need_swap ? "TRUE" : "FALSE"));
 294 
 295         if (need_swap)
 296                 el = swab16(ahp->ah_eeprom.def.baseEepHeader.length);
 297         else
 298                 el = ahp->ah_eeprom.def.baseEepHeader.length;
 299 
 300         if (el > sizeof (struct ar5416_eeprom_def))
 301                 el = sizeof (struct ar5416_eeprom_def) / sizeof (uint16_t);
 302         else
 303                 el = el / sizeof (uint16_t);
 304 
 305         eepdata = (uint16_t *)(&ahp->ah_eeprom);
 306 
 307         for (i = 0; i < el; i++)
 308                 sum ^= *eepdata++;
 309 
 310         if (need_swap) {
 311                 uint32_t integer, j;
 312                 uint16_t word;
 313 
 314                 ARN_DBG((ARN_DBG_EEPROM,
 315                     "EEPROM Endianness is not native.. Changing \n"));
 316 
 317                 word = swab16(eep->baseEepHeader.length);
 318                 eep->baseEepHeader.length = word;
 319 
 320                 word = swab16(eep->baseEepHeader.checksum);
 321                 eep->baseEepHeader.checksum = word;
 322 
 323                 word = swab16(eep->baseEepHeader.version);
 324                 eep->baseEepHeader.version = word;
 325 
 326                 word = swab16(eep->baseEepHeader.regDmn[0]);
 327                 eep->baseEepHeader.regDmn[0] = word;
 328 
 329                 word = swab16(eep->baseEepHeader.regDmn[1]);
 330                 eep->baseEepHeader.regDmn[1] = word;
 331 
 332                 word = swab16(eep->baseEepHeader.rfSilent);
 333                 eep->baseEepHeader.rfSilent = word;
 334 
 335                 word = swab16(eep->baseEepHeader.blueToothOptions);
 336                 eep->baseEepHeader.blueToothOptions = word;
 337 
 338                 word = swab16(eep->baseEepHeader.deviceCap);
 339                 eep->baseEepHeader.deviceCap = word;
 340 
 341                 for (j = 0; j < ARRAY_SIZE(eep->modalHeader); j++) {
 342                         struct modal_eep_header *pModal =
 343                             &eep->modalHeader[j];
 344                         integer = swab32(pModal->antCtrlCommon);
 345                         pModal->antCtrlCommon = integer;
 346 
 347                         for (i = 0; i < AR5416_MAX_CHAINS; i++) {
 348                                 integer = swab32(pModal->antCtrlChain[i]);
 349                                 pModal->antCtrlChain[i] = integer;
 350                         }
 351 
 352                         for (i = 0; i < AR5416_EEPROM_MODAL_SPURS; i++) {
 353                                 word = swab16(pModal->spurChans[i].spurChan);
 354                                 pModal->spurChans[i].spurChan = word;
 355                         }
 356                 }
 357         }
 358 
 359         if (sum != 0xffff || ar5416_get_eep_ver(ahp) != AR5416_EEP_VER ||
 360             ar5416_get_eep_rev(ahp) < AR5416_EEP_NO_BACK_VER) {
 361                 ARN_DBG((ARN_DBG_EEPROM,
 362                     "Bad EEPROM checksum 0x%x or revision 0x%04x\n",
 363                     sum, ar5416_get_eep_ver(ahp)));
 364                 return (EINVAL);
 365         }
 366 
 367         return (0);
 368 }
 369 
 370 static int
 371 ath9k_hw_check_4k_eeprom(struct ath_hal *ah)
 372 {
 373 #define EEPROM_4K_SIZE  (sizeof (struct ar5416_eeprom_4k) / sizeof (uint16_t))
 374         struct ath_hal_5416 *ahp = AH5416(ah);
 375         struct ar5416_eeprom_4k *eep =
 376             (struct ar5416_eeprom_4k *)&ahp->ah_eeprom.map4k;
 377         uint16_t *eepdata, temp, magic, magic2;
 378         uint32_t sum = 0, el;
 379         boolean_t need_swap = B_FALSE;
 380         int i, addr;
 381 
 382 
 383         if (!ath9k_hw_use_flash(ah)) {
 384 
 385                 if (!ath9k_hw_nvram_read(ah, AR5416_EEPROM_MAGIC_OFFSET,
 386                     &magic)) {
 387                         ARN_DBG((ARN_DBG_EEPROM,
 388                             "Reading Magic # failed\n"));
 389                         return (B_FALSE);
 390                 }
 391 
 392                 ARN_DBG((ARN_DBG_EEPROM,
 393                     "Read Magic = 0x%04X\n", magic));
 394 
 395                 if (magic != AR5416_EEPROM_MAGIC) {
 396                         magic2 = swab16(magic);
 397 
 398                         if (magic2 == AR5416_EEPROM_MAGIC) {
 399                                 need_swap = B_TRUE;
 400                                 eepdata = (uint16_t *)(&ahp->ah_eeprom);
 401 
 402                                 for (addr = 0; addr < EEPROM_4K_SIZE; addr++) {
 403                                         temp = swab16(*eepdata);
 404                                         *eepdata = temp;
 405                                         eepdata++;
 406 
 407                                         ARN_DBG((ARN_DBG_EEPROM,
 408                                             "0x%04X  ", *eepdata));
 409 
 410                                         if (((addr + 1) % 6) == 0)
 411                                                 ARN_DBG((ARN_DBG_EEPROM, "\n"));
 412                                 }
 413                         } else {
 414                                 ARN_DBG((ARN_DBG_EEPROM,
 415                                     "Invalid EEPROM Magic. "
 416                                     "endianness mismatch.\n"));
 417                                 return (EINVAL);
 418                         }
 419                 }
 420         }
 421 
 422         ARN_DBG((ARN_DBG_EEPROM, "need_swap = %s.\n",
 423             need_swap ? "True" : "False"));
 424 
 425         if (need_swap)
 426                 el = swab16(ahp->ah_eeprom.map4k.baseEepHeader.length);
 427         else
 428                 el = ahp->ah_eeprom.map4k.baseEepHeader.length;
 429 
 430         if (el > sizeof (struct ar5416_eeprom_def))
 431                 el = sizeof (struct ar5416_eeprom_4k) / sizeof (uint16_t);
 432         else
 433                 el = el / sizeof (uint16_t);
 434 
 435         eepdata = (uint16_t *)(&ahp->ah_eeprom);
 436 
 437         for (i = 0; i < el; i++)
 438                 sum ^= *eepdata++;
 439 
 440         if (need_swap) {
 441                 uint32_t integer;
 442                 uint16_t word;
 443 
 444                 ARN_DBG((ARN_DBG_EEPROM,
 445                     "EEPROM Endianness is not native.. Changing \n"));
 446 
 447                 word = swab16(eep->baseEepHeader.length);
 448                 eep->baseEepHeader.length = word;
 449 
 450                 word = swab16(eep->baseEepHeader.checksum);
 451                 eep->baseEepHeader.checksum = word;
 452 
 453                 word = swab16(eep->baseEepHeader.version);
 454                 eep->baseEepHeader.version = word;
 455 
 456                 word = swab16(eep->baseEepHeader.regDmn[0]);
 457                 eep->baseEepHeader.regDmn[0] = word;
 458 
 459                 word = swab16(eep->baseEepHeader.regDmn[1]);
 460                 eep->baseEepHeader.regDmn[1] = word;
 461 
 462                 word = swab16(eep->baseEepHeader.rfSilent);
 463                 eep->baseEepHeader.rfSilent = word;
 464 
 465                 word = swab16(eep->baseEepHeader.blueToothOptions);
 466                 eep->baseEepHeader.blueToothOptions = word;
 467 
 468                 word = swab16(eep->baseEepHeader.deviceCap);
 469                 eep->baseEepHeader.deviceCap = word;
 470 
 471                 integer = swab32(eep->modalHeader.antCtrlCommon);
 472                 eep->modalHeader.antCtrlCommon = integer;
 473 
 474                 for (i = 0; i < AR5416_MAX_CHAINS; i++) {
 475                         integer = swab32(eep->modalHeader.antCtrlChain[i]);
 476                         eep->modalHeader.antCtrlChain[i] = integer;
 477                 }
 478 
 479                 for (i = 0; i < AR5416_EEPROM_MODAL_SPURS; i++) {
 480                         word = swab16(eep->modalHeader.spurChans[i].spurChan);
 481                         eep->modalHeader.spurChans[i].spurChan = word;
 482                 }
 483         }
 484 
 485         if (sum != 0xffff || ar5416_get_eep4k_ver(ahp) != AR5416_EEP_VER ||
 486             ar5416_get_eep4k_rev(ahp) < AR5416_EEP_NO_BACK_VER) {
 487                 ARN_DBG((ARN_DBG_EEPROM,
 488                     "Bad EEPROM checksum 0x%x or revision 0x%04x\n",
 489                     sum, ar5416_get_eep4k_ver(ahp)));
 490                 return (EINVAL);
 491         }
 492 
 493         return (0);
 494 #undef EEPROM_4K_SIZE
 495 }
 496 
 497 static int
 498 (*ath9k_check_eeprom[]) (struct ath_hal *) = {
 499     ath9k_hw_check_def_eeprom,
 500     ath9k_hw_check_4k_eeprom
 501 };
 502 
 503 static inline int
 504 ath9k_hw_check_eeprom(struct ath_hal *ah)
 505 {
 506         struct ath_hal_5416 *ahp = AH5416(ah);
 507 
 508         return (ath9k_check_eeprom[ahp->ah_eep_map](ah));
 509 }
 510 
 511 static inline boolean_t
 512 ath9k_hw_fill_vpd_table(uint8_t pwrMin, uint8_t pwrMax, uint8_t *pPwrList,
 513     uint8_t *pVpdList, uint16_t numIntercepts, uint8_t *pRetVpdList)
 514 {
 515         uint16_t i, k;
 516         uint8_t currPwr = pwrMin;
 517         uint16_t idxL = 0, idxR = 0;
 518 
 519         for (i = 0; i <= (pwrMax - pwrMin) / 2; i++) {
 520                 (void) ath9k_hw_get_lower_upper_index(currPwr, pPwrList,
 521                     numIntercepts, &(idxL), &(idxR));
 522                 if (idxR < 1)
 523                         idxR = 1;
 524                 if (idxL == numIntercepts - 1)
 525                         idxL = (uint16_t)(numIntercepts - 2);
 526                 if (pPwrList[idxL] == pPwrList[idxR])
 527                         k = pVpdList[idxL];
 528                 else
 529                         k = (uint16_t)
 530                             (((currPwr - pPwrList[idxL]) * pVpdList[idxR] +
 531                             (pPwrList[idxR] - currPwr) * pVpdList[idxL]) /
 532                             (pPwrList[idxR] - pPwrList[idxL]));
 533                 pRetVpdList[i] = (uint8_t)k;
 534                 currPwr += 2;
 535         }
 536 
 537         return (B_TRUE);
 538 }
 539 
 540 static void
 541 ath9k_hw_get_4k_gain_boundaries_pdadcs(struct ath_hal *ah,
 542     struct ath9k_channel *chan,
 543     struct cal_data_per_freq_4k *pRawDataSet,
 544     uint8_t *bChans, uint16_t availPiers,
 545     uint16_t tPdGainOverlap, int16_t *pMinCalPower,
 546     uint16_t *pPdGainBoundaries, uint8_t *pPDADCValues,
 547     uint16_t numXpdGains)
 548 {
 549 #define TMP_VAL_VPD_TABLE \
 550         ((vpdTableI[i][sizeCurrVpdTable - 1] + (ss - maxIndex + 1) * vpdStep));
 551         int i, j, k;
 552         int16_t ss;
 553         uint16_t idxL = 0, idxR = 0, numPiers;
 554         static uint8_t vpdTableL[AR5416_EEP4K_NUM_PD_GAINS]
 555             [AR5416_MAX_PWR_RANGE_IN_HALF_DB];
 556         static uint8_t vpdTableR[AR5416_EEP4K_NUM_PD_GAINS]
 557             [AR5416_MAX_PWR_RANGE_IN_HALF_DB];
 558         static uint8_t vpdTableI[AR5416_EEP4K_NUM_PD_GAINS]
 559             [AR5416_MAX_PWR_RANGE_IN_HALF_DB];
 560 
 561         uint8_t *pVpdL, *pVpdR, *pPwrL, *pPwrR;
 562         uint8_t minPwrT4[AR5416_EEP4K_NUM_PD_GAINS];
 563         uint8_t maxPwrT4[AR5416_EEP4K_NUM_PD_GAINS];
 564         int16_t vpdStep;
 565         int16_t tmpVal;
 566         uint16_t sizeCurrVpdTable, maxIndex, tgtIndex;
 567         boolean_t match;
 568         int16_t minDelta = 0;
 569         struct chan_centers centers;
 570 #define PD_GAIN_BOUNDARY_DEFAULT        58;
 571 
 572         ath9k_hw_get_channel_centers(ah, chan, &centers);
 573 
 574         for (numPiers = 0; numPiers < availPiers; numPiers++) {
 575                 if (bChans[numPiers] == AR5416_BCHAN_UNUSED)
 576                         break;
 577         }
 578 
 579         match = ath9k_hw_get_lower_upper_index(
 580             (uint8_t)FREQ2FBIN(centers.synth_center,
 581             IS_CHAN_2GHZ(chan)), bChans, numPiers,
 582             &idxL, &idxR);
 583 
 584         if (match) {
 585                 for (i = 0; i < numXpdGains; i++) {
 586                         minPwrT4[i] = pRawDataSet[idxL].pwrPdg[i][0];
 587                         maxPwrT4[i] = pRawDataSet[idxL].pwrPdg[i][4];
 588                         (void) ath9k_hw_fill_vpd_table(minPwrT4[i], maxPwrT4[i],
 589                             pRawDataSet[idxL].pwrPdg[i],
 590                             pRawDataSet[idxL].vpdPdg[i],
 591                             AR5416_EEP4K_PD_GAIN_ICEPTS,
 592                             vpdTableI[i]);
 593                 }
 594         } else {
 595                 for (i = 0; i < numXpdGains; i++) {
 596                         pVpdL = pRawDataSet[idxL].vpdPdg[i];
 597                         pPwrL = pRawDataSet[idxL].pwrPdg[i];
 598                         pVpdR = pRawDataSet[idxR].vpdPdg[i];
 599                         pPwrR = pRawDataSet[idxR].pwrPdg[i];
 600 
 601                         minPwrT4[i] = max(pPwrL[0], pPwrR[0]);
 602 
 603                         maxPwrT4[i] =
 604                             min(pPwrL[AR5416_EEP4K_PD_GAIN_ICEPTS - 1],
 605                             pPwrR[AR5416_EEP4K_PD_GAIN_ICEPTS - 1]);
 606 
 607 
 608                         (void) ath9k_hw_fill_vpd_table(minPwrT4[i], maxPwrT4[i],
 609                             pPwrL, pVpdL,
 610                             AR5416_EEP4K_PD_GAIN_ICEPTS,
 611                             vpdTableL[i]);
 612                         (void) ath9k_hw_fill_vpd_table(minPwrT4[i], maxPwrT4[i],
 613                             pPwrR, pVpdR,
 614                             AR5416_EEP4K_PD_GAIN_ICEPTS,
 615                             vpdTableR[i]);
 616 
 617                         for (j = 0; j <= (maxPwrT4[i] - minPwrT4[i]) / 2; j++) {
 618                                 vpdTableI[i][j] =
 619                                     (uint8_t)(ath9k_hw_interpolate((uint16_t)
 620                                     FREQ2FBIN(centers.
 621                                     synth_center,
 622                                     IS_CHAN_2GHZ
 623                                     (chan)),
 624                                     bChans[idxL], bChans[idxR],
 625                                     vpdTableL[i][j], vpdTableR[i][j]));
 626                         }
 627                 }
 628         }
 629 
 630         *pMinCalPower = (int16_t)(minPwrT4[0] / 2);
 631 
 632         k = 0;
 633 
 634         for (i = 0; i < numXpdGains; i++) {
 635                 if (i == (numXpdGains - 1))
 636                         pPdGainBoundaries[i] =
 637                             (uint16_t)(maxPwrT4[i] / 2);
 638                 else
 639                         pPdGainBoundaries[i] =
 640                             (uint16_t)((maxPwrT4[i] + minPwrT4[i + 1]) / 4);
 641 
 642                 pPdGainBoundaries[i] =
 643                     min((uint16_t)AR5416_MAX_RATE_POWER, pPdGainBoundaries[i]);
 644 
 645                 if ((i == 0) && !AR_SREV_5416_V20_OR_LATER(ah)) {
 646                         minDelta = pPdGainBoundaries[0] - 23;
 647                         pPdGainBoundaries[0] = 23;
 648                 } else {
 649                         minDelta = 0;
 650                 }
 651 
 652                 if (i == 0) {
 653                         if (AR_SREV_9280_10_OR_LATER(ah))
 654                                 ss = (int16_t)(0 - (minPwrT4[i] / 2));
 655                         else
 656                                 ss = 0;
 657                 } else {
 658                         ss = (int16_t)((pPdGainBoundaries[i - 1] -
 659                             (minPwrT4[i] / 2)) -
 660                             tPdGainOverlap + 1 + minDelta);
 661                 }
 662                 vpdStep = (int16_t)(vpdTableI[i][1] - vpdTableI[i][0]);
 663                 vpdStep = (int16_t)((vpdStep < 1) ? 1 : vpdStep);
 664 
 665                 while ((ss < 0) && (k < (AR5416_NUM_PDADC_VALUES - 1))) {
 666                         tmpVal = (int16_t)(vpdTableI[i][0] + ss * vpdStep);
 667                         pPDADCValues[k++] =
 668                             (uint8_t)((tmpVal < 0) ? 0 : tmpVal);
 669                         ss++;
 670                 }
 671 
 672                 sizeCurrVpdTable =
 673                     (uint8_t)((maxPwrT4[i] - minPwrT4[i]) / 2 + 1);
 674                 tgtIndex = (uint8_t)
 675                     (pPdGainBoundaries[i] + tPdGainOverlap - (minPwrT4[i] / 2));
 676                 maxIndex =
 677                     (tgtIndex < sizeCurrVpdTable) ? tgtIndex : sizeCurrVpdTable;
 678 
 679                 while ((ss < maxIndex) && (k < (AR5416_NUM_PDADC_VALUES - 1)))
 680                         pPDADCValues[k++] = vpdTableI[i][ss++];
 681 
 682                 vpdStep = (int16_t)(vpdTableI[i][sizeCurrVpdTable - 1] -
 683                     vpdTableI[i][sizeCurrVpdTable - 2]);
 684                 vpdStep = (int16_t)((vpdStep < 1) ? 1 : vpdStep);
 685 
 686                 if (tgtIndex > maxIndex) {
 687                         while ((ss <= tgtIndex) &&
 688                             (k < (AR5416_NUM_PDADC_VALUES - 1))) {
 689                                 tmpVal = (int16_t)TMP_VAL_VPD_TABLE;
 690                                 pPDADCValues[k++] = (uint8_t)
 691                                     ((tmpVal > 255) ? 255 : tmpVal);
 692                                 ss++;
 693                         }
 694                 }
 695         }
 696 
 697         while (i < AR5416_EEP4K_PD_GAINS_IN_MASK) {
 698                 pPdGainBoundaries[i] = PD_GAIN_BOUNDARY_DEFAULT;
 699                 i++;
 700         }
 701 
 702         while (k < AR5416_NUM_PDADC_VALUES) {
 703                 pPDADCValues[k] = pPDADCValues[k - 1];
 704                 k++;
 705         }
 706 
 707         return;
 708 #undef TMP_VAL_VPD_TABLE
 709 }
 710 
 711 static void
 712 ath9k_hw_get_def_gain_boundaries_pdadcs(struct ath_hal *ah,
 713     struct ath9k_channel *chan,
 714     struct cal_data_per_freq *pRawDataSet,
 715     uint8_t *bChans, uint16_t availPiers,
 716     uint16_t tPdGainOverlap, int16_t *pMinCalPower,
 717     uint16_t *pPdGainBoundaries, uint8_t *pPDADCValues,
 718     uint16_t numXpdGains)
 719 {
 720         int i, j, k;
 721         int16_t ss;
 722         uint16_t idxL = 0, idxR = 0, numPiers;
 723         static uint8_t vpdTableL[AR5416_NUM_PD_GAINS]
 724             [AR5416_MAX_PWR_RANGE_IN_HALF_DB];
 725         static uint8_t vpdTableR[AR5416_NUM_PD_GAINS]
 726             [AR5416_MAX_PWR_RANGE_IN_HALF_DB];
 727         static uint8_t vpdTableI[AR5416_NUM_PD_GAINS]
 728             [AR5416_MAX_PWR_RANGE_IN_HALF_DB];
 729 
 730         uint8_t *pVpdL, *pVpdR, *pPwrL, *pPwrR;
 731         uint8_t minPwrT4[AR5416_NUM_PD_GAINS];
 732         uint8_t maxPwrT4[AR5416_NUM_PD_GAINS];
 733         int16_t vpdStep;
 734         int16_t tmpVal;
 735         uint16_t sizeCurrVpdTable, maxIndex, tgtIndex;
 736         boolean_t match;
 737         int16_t minDelta = 0;
 738         struct chan_centers centers;
 739 
 740         ath9k_hw_get_channel_centers(ah, chan, &centers);
 741 
 742         for (numPiers = 0; numPiers < availPiers; numPiers++) {
 743                 if (bChans[numPiers] == AR5416_BCHAN_UNUSED)
 744                         break;
 745         }
 746 
 747         match =
 748             ath9k_hw_get_lower_upper_index(
 749             (uint8_t)FREQ2FBIN(centers.synth_center, IS_CHAN_2GHZ(chan)),
 750             bChans, numPiers, &idxL, &idxR);
 751 
 752         if (match) {
 753                 for (i = 0; i < numXpdGains; i++) {
 754                         minPwrT4[i] = pRawDataSet[idxL].pwrPdg[i][0];
 755                         maxPwrT4[i] = pRawDataSet[idxL].pwrPdg[i][4];
 756                         (void) ath9k_hw_fill_vpd_table(minPwrT4[i], maxPwrT4[i],
 757                             pRawDataSet[idxL].pwrPdg[i],
 758                             pRawDataSet[idxL].vpdPdg[i],
 759                             AR5416_PD_GAIN_ICEPTS,
 760                             vpdTableI[i]);
 761                 }
 762         } else {
 763                 for (i = 0; i < numXpdGains; i++) {
 764                         pVpdL = pRawDataSet[idxL].vpdPdg[i];
 765                         pPwrL = pRawDataSet[idxL].pwrPdg[i];
 766                         pVpdR = pRawDataSet[idxR].vpdPdg[i];
 767                         pPwrR = pRawDataSet[idxR].pwrPdg[i];
 768 
 769                         minPwrT4[i] = max(pPwrL[0], pPwrR[0]);
 770 
 771                         maxPwrT4[i] =
 772                             min(pPwrL[AR5416_PD_GAIN_ICEPTS - 1],
 773                             pPwrR[AR5416_PD_GAIN_ICEPTS - 1]);
 774 
 775 
 776                         (void) ath9k_hw_fill_vpd_table(minPwrT4[i], maxPwrT4[i],
 777                             pPwrL, pVpdL,
 778                             AR5416_PD_GAIN_ICEPTS,
 779                             vpdTableL[i]);
 780                         (void) ath9k_hw_fill_vpd_table(minPwrT4[i], maxPwrT4[i],
 781                             pPwrR, pVpdR,
 782                             AR5416_PD_GAIN_ICEPTS,
 783                             vpdTableR[i]);
 784 
 785                         for (j = 0; j <= (maxPwrT4[i] - minPwrT4[i]) / 2; j++) {
 786                                 vpdTableI[i][j] =
 787                                     (uint8_t)(ath9k_hw_interpolate((uint16_t)
 788                                     FREQ2FBIN(centers.
 789                                     synth_center,
 790                                     IS_CHAN_2GHZ
 791                                     (chan)),
 792                                     bChans[idxL], bChans[idxR],
 793                                     vpdTableL[i][j], vpdTableR[i][j]));
 794                         }
 795                 }
 796         }
 797 
 798         *pMinCalPower = (int16_t)(minPwrT4[0] / 2);
 799 
 800         k = 0;
 801 
 802         for (i = 0; i < numXpdGains; i++) {
 803                 if (i == (numXpdGains - 1))
 804                         pPdGainBoundaries[i] =
 805                             (uint16_t)(maxPwrT4[i] / 2);
 806                 else
 807                         pPdGainBoundaries[i] =
 808                             (uint16_t)((maxPwrT4[i] + minPwrT4[i + 1]) / 4);
 809 
 810                 pPdGainBoundaries[i] =
 811                     min((uint16_t)AR5416_MAX_RATE_POWER, pPdGainBoundaries[i]);
 812 
 813                 if ((i == 0) && !AR_SREV_5416_V20_OR_LATER(ah)) {
 814                         minDelta = pPdGainBoundaries[0] - 23;
 815                         pPdGainBoundaries[0] = 23;
 816                 } else {
 817                         minDelta = 0;
 818                 }
 819 
 820                 if (i == 0) {
 821                         if (AR_SREV_9280_10_OR_LATER(ah))
 822                                 ss = (int16_t)(0 - (minPwrT4[i] / 2));
 823                         else
 824                                 ss = 0;
 825                 } else {
 826                         ss = (int16_t)((pPdGainBoundaries[i - 1] -
 827                             (minPwrT4[i] / 2)) -
 828                             tPdGainOverlap + 1 + minDelta);
 829                 }
 830                 vpdStep = (int16_t)(vpdTableI[i][1] - vpdTableI[i][0]);
 831                 vpdStep = (int16_t)((vpdStep < 1) ? 1 : vpdStep);
 832 
 833                 while ((ss < 0) && (k < (AR5416_NUM_PDADC_VALUES - 1))) {
 834                         tmpVal = (int16_t)(vpdTableI[i][0] + ss * vpdStep);
 835                         pPDADCValues[k++] =
 836                             (uint8_t)((tmpVal < 0) ? 0 : tmpVal);
 837                         ss++;
 838                 }
 839 
 840                 sizeCurrVpdTable =
 841                     (uint8_t)((maxPwrT4[i] - minPwrT4[i]) / 2 + 1);
 842                 tgtIndex = (uint8_t)(pPdGainBoundaries[i] + tPdGainOverlap -
 843                     (minPwrT4[i] / 2));
 844                 maxIndex = (tgtIndex < sizeCurrVpdTable) ?
 845                     tgtIndex : sizeCurrVpdTable;
 846 
 847                 while ((ss < maxIndex) && (k < (AR5416_NUM_PDADC_VALUES - 1))) {
 848                         pPDADCValues[k++] = vpdTableI[i][ss++];
 849                 }
 850 
 851                 vpdStep = (int16_t)(vpdTableI[i][sizeCurrVpdTable - 1] -
 852                     vpdTableI[i][sizeCurrVpdTable - 2]);
 853                 vpdStep = (int16_t)((vpdStep < 1) ? 1 : vpdStep);
 854 
 855                 if (tgtIndex > maxIndex) {
 856                         while ((ss <= tgtIndex) &&
 857                             (k < (AR5416_NUM_PDADC_VALUES - 1))) {
 858                                 tmpVal =
 859                                     (int16_t)
 860                                     ((vpdTableI[i][sizeCurrVpdTable - 1] +
 861                                     (ss - maxIndex + 1) * vpdStep));
 862                                 pPDADCValues[k++] = (uint8_t)((tmpVal > 255) ?
 863                                     255 : tmpVal);
 864                                 ss++;
 865                         }
 866                 }
 867         }
 868 
 869         while (i < AR5416_PD_GAINS_IN_MASK) {
 870                 pPdGainBoundaries[i] = pPdGainBoundaries[i - 1];
 871                 i++;
 872         }
 873 
 874         while (k < AR5416_NUM_PDADC_VALUES) {
 875                 pPDADCValues[k] = pPDADCValues[k - 1];
 876                 k++;
 877         }
 878 }
 879 
 880 static void
 881 ath9k_hw_get_legacy_target_powers(struct ath_hal *ah,
 882     struct ath9k_channel *chan,
 883     struct cal_target_power_leg *powInfo,
 884     uint16_t numChannels,
 885     struct cal_target_power_leg *pNewPower,
 886     uint16_t numRates, boolean_t isExtTarget)
 887 {
 888         struct chan_centers centers;
 889         uint16_t clo, chi;
 890         int i;
 891         int matchIndex = -1, lowIndex = -1;
 892         uint16_t freq;
 893 
 894         ath9k_hw_get_channel_centers(ah, chan, &centers);
 895         freq = (isExtTarget) ? centers.ext_center : centers.ctl_center;
 896 
 897         if (freq <= ath9k_hw_fbin2freq(powInfo[0].bChannel,
 898             IS_CHAN_2GHZ(chan))) {
 899                 matchIndex = 0;
 900         } else {
 901                 for (i = 0; (i < numChannels) &&
 902                     (powInfo[i].bChannel != AR5416_BCHAN_UNUSED); i++) {
 903                         if (freq == ath9k_hw_fbin2freq(powInfo[i].bChannel,
 904                             IS_CHAN_2GHZ(chan))) {
 905                                 matchIndex = i;
 906                                 break;
 907                         } else if ((freq <
 908                             ath9k_hw_fbin2freq(powInfo[i].bChannel,
 909                             IS_CHAN_2GHZ(chan))) &&
 910                             (freq > ath9k_hw_fbin2freq(powInfo[i - 1].bChannel,
 911                             IS_CHAN_2GHZ(chan)))) {
 912                                 lowIndex = i - 1;
 913                                 break;
 914                         }
 915                 }
 916                 if ((matchIndex == -1) && (lowIndex == -1))
 917                         matchIndex = i - 1;
 918         }
 919 
 920         if (matchIndex != -1) {
 921                 *pNewPower = powInfo[matchIndex];
 922         } else {
 923                 clo = ath9k_hw_fbin2freq(powInfo[lowIndex].bChannel,
 924                     IS_CHAN_2GHZ(chan));
 925                 chi = ath9k_hw_fbin2freq(powInfo[lowIndex + 1].bChannel,
 926                     IS_CHAN_2GHZ(chan));
 927 
 928                 for (i = 0; i < numRates; i++) {
 929                         pNewPower->tPow2x[i] =
 930                             (uint8_t)ath9k_hw_interpolate(freq, clo, chi,
 931                             powInfo[lowIndex].tPow2x[i],
 932                             powInfo[lowIndex + 1].tPow2x[i]);
 933                 }
 934         }
 935 }
 936 
 937 static void
 938 ath9k_hw_get_target_powers(struct ath_hal *ah,
 939     struct ath9k_channel *chan,
 940     struct cal_target_power_ht *powInfo,
 941     uint16_t numChannels,
 942     struct cal_target_power_ht *pNewPower,
 943     uint16_t numRates, boolean_t isHt40Target)
 944 {
 945         struct chan_centers centers;
 946         uint16_t clo, chi;
 947         int i;
 948         int matchIndex = -1, lowIndex = -1;
 949         uint16_t freq;
 950 
 951         ath9k_hw_get_channel_centers(ah, chan, &centers);
 952         freq = isHt40Target ? centers.synth_center : centers.ctl_center;
 953 
 954         if (freq <=
 955             ath9k_hw_fbin2freq(powInfo[0].bChannel, IS_CHAN_2GHZ(chan))) {
 956                 matchIndex = 0;
 957         } else {
 958                 for (i = 0; (i < numChannels) &&
 959                     (powInfo[i].bChannel != AR5416_BCHAN_UNUSED); i++) {
 960                         if (freq == ath9k_hw_fbin2freq(powInfo[i].bChannel,
 961                             IS_CHAN_2GHZ(chan))) {
 962                                 matchIndex = i;
 963                                 break;
 964                         } else
 965                                 if ((freq <
 966                                     ath9k_hw_fbin2freq(powInfo[i].bChannel,
 967                                     IS_CHAN_2GHZ(chan))) &&
 968                                     (freq > ath9k_hw_fbin2freq
 969                                     (powInfo[i - 1].bChannel,
 970                                     IS_CHAN_2GHZ(chan)))) {
 971                                         lowIndex = i - 1;
 972                                         break;
 973                                 }
 974                 }
 975                 if ((matchIndex == -1) && (lowIndex == -1))
 976                         matchIndex = i - 1;
 977         }
 978 
 979         if (matchIndex != -1) {
 980                 *pNewPower = powInfo[matchIndex];
 981         } else {
 982                 clo = ath9k_hw_fbin2freq(powInfo[lowIndex].bChannel,
 983                     IS_CHAN_2GHZ(chan));
 984                 chi = ath9k_hw_fbin2freq(powInfo[lowIndex + 1].bChannel,
 985                     IS_CHAN_2GHZ(chan));
 986 
 987                 for (i = 0; i < numRates; i++) {
 988                         pNewPower->tPow2x[i] =
 989                             (uint8_t)ath9k_hw_interpolate(freq,
 990                             clo, chi,
 991                             powInfo[lowIndex].tPow2x[i],
 992                             powInfo[lowIndex + 1].tPow2x[i]);
 993                 }
 994         }
 995 }
 996 
 997 static uint16_t
 998 ath9k_hw_get_max_edge_power(uint16_t freq,
 999     struct cal_ctl_edges *pRdEdgesPower,
1000     boolean_t is2GHz, int num_band_edges)
1001 {
1002         uint16_t twiceMaxEdgePower = AR5416_MAX_RATE_POWER;
1003         int i;
1004 
1005         for (i = 0; (i < num_band_edges) &&
1006             (pRdEdgesPower[i].bChannel != AR5416_BCHAN_UNUSED); i++) {
1007                 if (freq == ath9k_hw_fbin2freq(pRdEdgesPower[i].bChannel,
1008                     is2GHz)) {
1009                         twiceMaxEdgePower = pRdEdgesPower[i].tPower;
1010                         break;
1011                 } else if ((i > 0) &&
1012                     (freq < ath9k_hw_fbin2freq(pRdEdgesPower[i].bChannel,
1013                     is2GHz))) {
1014                         if (ath9k_hw_fbin2freq(pRdEdgesPower[i - 1].bChannel,
1015                             is2GHz) < freq &&
1016                             pRdEdgesPower[i - 1].flag) {
1017                                 twiceMaxEdgePower =
1018                                     pRdEdgesPower[i - 1].tPower;
1019                         }
1020                         break;
1021                 }
1022         }
1023 
1024         return (twiceMaxEdgePower);
1025 }
1026 
1027 static boolean_t
1028 ath9k_hw_set_def_power_cal_table(struct ath_hal *ah,
1029     struct ath9k_channel *chan, int16_t *pTxPowerIndexOffset)
1030 {
1031         struct ath_hal_5416 *ahp = AH5416(ah);
1032         struct ar5416_eeprom_def *pEepData = &ahp->ah_eeprom.def;
1033         struct cal_data_per_freq *pRawDataset;
1034         uint8_t *pCalBChans = NULL;
1035         uint16_t pdGainOverlap_t2;
1036         static uint8_t pdadcValues[AR5416_NUM_PDADC_VALUES];
1037         uint16_t gainBoundaries[AR5416_PD_GAINS_IN_MASK];
1038         uint16_t numPiers, i, j;
1039         int16_t tMinCalPower;
1040         uint16_t numXpdGain, xpdMask;
1041         uint16_t xpdGainValues[AR5416_NUM_PD_GAINS] = { 0, 0, 0, 0 };
1042         uint32_t reg32, regOffset, regChainOffset;
1043         int16_t modalIdx;
1044 
1045         modalIdx = IS_CHAN_2GHZ(chan) ? 1 : 0;
1046         xpdMask = pEepData->modalHeader[modalIdx].xpdGain;
1047 
1048         if ((pEepData->baseEepHeader.version & AR5416_EEP_VER_MINOR_MASK) >=
1049             AR5416_EEP_MINOR_VER_2) {
1050                 pdGainOverlap_t2 =
1051                     pEepData->modalHeader[modalIdx].pdGainOverlap;
1052         } else {
1053                 pdGainOverlap_t2 =
1054                     (uint16_t)(MS(REG_READ(ah, AR_PHY_TPCRG5),
1055                     AR_PHY_TPCRG5_PD_GAIN_OVERLAP));
1056         }
1057 
1058         if (IS_CHAN_2GHZ(chan)) {
1059                 pCalBChans = pEepData->calFreqPier2G;
1060                 numPiers = AR5416_NUM_2G_CAL_PIERS;
1061         } else {
1062                 pCalBChans = pEepData->calFreqPier5G;
1063                 numPiers = AR5416_NUM_5G_CAL_PIERS;
1064         }
1065 
1066         numXpdGain = 0;
1067 
1068         for (i = 1; i <= AR5416_PD_GAINS_IN_MASK; i++) {
1069                 if ((xpdMask >> (AR5416_PD_GAINS_IN_MASK - i)) & 1) {
1070                         if (numXpdGain >= AR5416_NUM_PD_GAINS)
1071                                 break;
1072                         xpdGainValues[numXpdGain] =
1073                             (uint16_t)(AR5416_PD_GAINS_IN_MASK - i);
1074                         numXpdGain++;
1075                 }
1076         }
1077 
1078         REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_NUM_PD_GAIN,
1079             (numXpdGain - 1) & 0x3);
1080         REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_GAIN_1,
1081             xpdGainValues[0]);
1082         REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_GAIN_2,
1083             xpdGainValues[1]);
1084         REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_GAIN_3,
1085             xpdGainValues[2]);
1086 
1087         for (i = 0; i < AR5416_MAX_CHAINS; i++) {
1088                 if (AR_SREV_5416_V20_OR_LATER(ah) &&
1089                     (ahp->ah_rxchainmask == 5 || ahp->ah_txchainmask == 5) &&
1090                     (i != 0)) {
1091                         regChainOffset = (i == 1) ? 0x2000 : 0x1000;
1092                 } else
1093                         regChainOffset = i * 0x1000;
1094 
1095                 if (pEepData->baseEepHeader.txMask & (1 << i)) {
1096                         if (IS_CHAN_2GHZ(chan))
1097                                 pRawDataset = pEepData->calPierData2G[i];
1098                         else
1099                                 pRawDataset = pEepData->calPierData5G[i];
1100 
1101                         ath9k_hw_get_def_gain_boundaries_pdadcs(ah, chan,
1102                             pRawDataset, pCalBChans,
1103                             numPiers, pdGainOverlap_t2,
1104                             &tMinCalPower, gainBoundaries,
1105                             pdadcValues, numXpdGain);
1106 
1107                         if ((i == 0) || AR_SREV_5416_V20_OR_LATER(ah)) {
1108                                 REG_WRITE(ah,
1109                                     AR_PHY_TPCRG5 + regChainOffset,
1110                                     SM(pdGainOverlap_t2,
1111                                     AR_PHY_TPCRG5_PD_GAIN_OVERLAP) |
1112                                     SM(gainBoundaries[0],
1113                                     AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_1) |
1114                                     SM(gainBoundaries[1],
1115                                     AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_2) |
1116                                     SM(gainBoundaries[2],
1117                                     AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_3) |
1118                                     SM(gainBoundaries[3],
1119                                     AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_4));
1120                         }
1121 
1122                         regOffset = AR_PHY_BASE + (672 << 2) + regChainOffset;
1123                         for (j = 0; j < 32; j++) {
1124                                 reg32 = ((pdadcValues[4 * j + 0] & 0xFF) << 0) |
1125                                     ((pdadcValues[4 * j + 1] & 0xFF) << 8) |
1126                                     ((pdadcValues[4 * j + 2] & 0xFF) << 16)|
1127                                     ((pdadcValues[4 * j + 3] & 0xFF) << 24);
1128                                 REG_WRITE(ah, regOffset, reg32);
1129 
1130                                 ARN_DBG((ARN_DBG_REG_IO,
1131                                     "PDADC (%d,%4x): %4.4x %8.8x\n",
1132                                     i, regChainOffset, regOffset,
1133                                     reg32));
1134                                 ARN_DBG((ARN_DBG_REG_IO,
1135                                     "PDADC: Chain %d | PDADC %3d "
1136                                     "Value %3d | PDADC %3d Value %3d | "
1137                                     "PDADC %3d Value %3d | PDADC %3d "
1138                                     "Value %3d |\n",
1139                                     i, 4 * j, pdadcValues[4 * j],
1140                                     4 * j + 1, pdadcValues[4 * j + 1],
1141                                     4 * j + 2, pdadcValues[4 * j + 2],
1142                                     4 * j + 3,
1143                                     pdadcValues[4 * j + 3]));
1144 
1145                                 regOffset += 4;
1146                         }
1147                 }
1148         }
1149 
1150         *pTxPowerIndexOffset = 0;
1151 
1152         return (B_TRUE);
1153 }
1154 
1155 static boolean_t
1156 ath9k_hw_set_4k_power_cal_table(struct ath_hal *ah,
1157     struct ath9k_channel *chan, int16_t *pTxPowerIndexOffset)
1158 {
1159         struct ath_hal_5416 *ahp = AH5416(ah);
1160         struct ar5416_eeprom_4k *pEepData = &ahp->ah_eeprom.map4k;
1161         struct cal_data_per_freq_4k *pRawDataset;
1162         uint8_t *pCalBChans = NULL;
1163         uint16_t pdGainOverlap_t2;
1164         static uint8_t pdadcValues[AR5416_NUM_PDADC_VALUES];
1165         uint16_t gainBoundaries[AR5416_PD_GAINS_IN_MASK];
1166         uint16_t numPiers, i, j;
1167         int16_t tMinCalPower;
1168         uint16_t numXpdGain, xpdMask;
1169         uint16_t xpdGainValues[AR5416_NUM_PD_GAINS] = { 0, 0, 0, 0 };
1170         uint32_t reg32, regOffset, regChainOffset;
1171 
1172         xpdMask = pEepData->modalHeader.xpdGain;
1173 
1174         if ((pEepData->baseEepHeader.version & AR5416_EEP_VER_MINOR_MASK) >=
1175             AR5416_EEP_MINOR_VER_2) {
1176                 pdGainOverlap_t2 =
1177                     pEepData->modalHeader.pdGainOverlap;
1178         } else {
1179                 pdGainOverlap_t2 = (uint16_t)(MS(REG_READ(ah, AR_PHY_TPCRG5),
1180                     AR_PHY_TPCRG5_PD_GAIN_OVERLAP));
1181         }
1182 
1183         pCalBChans = pEepData->calFreqPier2G;
1184         numPiers = AR5416_NUM_2G_CAL_PIERS;
1185 
1186         numXpdGain = 0;
1187 
1188         for (i = 1; i <= AR5416_PD_GAINS_IN_MASK; i++) {
1189                 if ((xpdMask >> (AR5416_PD_GAINS_IN_MASK - i)) & 1) {
1190                         if (numXpdGain >= AR5416_NUM_PD_GAINS)
1191                                 break;
1192                         xpdGainValues[numXpdGain] =
1193                             (uint16_t)(AR5416_PD_GAINS_IN_MASK - i);
1194                         numXpdGain++;
1195                 }
1196         }
1197 
1198         REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_NUM_PD_GAIN,
1199             (numXpdGain - 1) & 0x3);
1200         REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_GAIN_1,
1201             xpdGainValues[0]);
1202         REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_GAIN_2,
1203             xpdGainValues[1]);
1204         REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_GAIN_3,
1205             xpdGainValues[2]);
1206 
1207         for (i = 0; i < AR5416_MAX_CHAINS; i++) {
1208                 if (AR_SREV_5416_V20_OR_LATER(ah) &&
1209                     (ahp->ah_rxchainmask == 5 || ahp->ah_txchainmask == 5) &&
1210                     (i != 0)) {
1211                         regChainOffset = (i == 1) ? 0x2000 : 0x1000;
1212                 } else
1213                         regChainOffset = i * 0x1000;
1214 
1215                 if (pEepData->baseEepHeader.txMask & (1 << i)) {
1216                         pRawDataset = pEepData->calPierData2G[i];
1217 
1218                         ath9k_hw_get_4k_gain_boundaries_pdadcs(ah, chan,
1219                             pRawDataset, pCalBChans,
1220                             numPiers, pdGainOverlap_t2,
1221                             &tMinCalPower, gainBoundaries,
1222                             pdadcValues, numXpdGain);
1223 
1224                         if ((i == 0) || AR_SREV_5416_V20_OR_LATER(ah)) {
1225                                 REG_WRITE(ah, AR_PHY_TPCRG5 + regChainOffset,
1226                                     SM(pdGainOverlap_t2,
1227                                     AR_PHY_TPCRG5_PD_GAIN_OVERLAP) |
1228                                     SM(gainBoundaries[0],
1229                                     AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_1) |
1230                                     SM(gainBoundaries[1],
1231                                     AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_2) |
1232                                     SM(gainBoundaries[2],
1233                                     AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_3) |
1234                                     SM(gainBoundaries[3],
1235                                     AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_4));
1236                         }
1237 
1238                         regOffset = AR_PHY_BASE + (672 << 2) + regChainOffset;
1239                         for (j = 0; j < 32; j++) {
1240                                 reg32 = ((pdadcValues[4 * j + 0] & 0xFF) << 0) |
1241                                     ((pdadcValues[4 * j + 1] & 0xFF) << 8) |
1242                                     ((pdadcValues[4 * j + 2] & 0xFF) << 16)|
1243                                     ((pdadcValues[4 * j + 3] & 0xFF) << 24);
1244                                 REG_WRITE(ah, regOffset, reg32);
1245 
1246                                 ARN_DBG((ARN_DBG_REG_IO,
1247                                     "PDADC (%d,%4x): %4.4x %8.8x\n",
1248                                     i, regChainOffset, regOffset,
1249                                     reg32));
1250                                 ARN_DBG((ARN_DBG_REG_IO,
1251                                     "PDADC: Chain %d | "
1252                                     "PDADC %3d Value %3d | "
1253                                     "PDADC %3d Value %3d | "
1254                                     "PDADC %3d Value %3d | "
1255                                     "PDADC %3d Value %3d |\n",
1256                                     i, 4 * j, pdadcValues[4 * j],
1257                                     4 * j + 1, pdadcValues[4 * j + 1],
1258                                     4 * j + 2, pdadcValues[4 * j + 2],
1259                                     4 * j + 3,
1260                                     pdadcValues[4 * j + 3]));
1261 
1262                                 regOffset += 4;
1263                         }
1264                 }
1265         }
1266 
1267         *pTxPowerIndexOffset = 0;
1268 
1269         return (B_TRUE);
1270 }
1271 
1272 static boolean_t
1273 ath9k_hw_set_def_power_per_rate_table(struct ath_hal *ah,
1274     struct ath9k_channel *chan,
1275     int16_t *ratesArray,
1276     uint16_t cfgCtl,
1277     uint16_t AntennaReduction,
1278     uint16_t twiceMaxRegulatoryPower,
1279     uint16_t powerLimit)
1280 {
1281 #define REDUCE_SCALED_POWER_BY_TWO_CHAIN        6  /* 10*log10(2)*2 */
1282 #define REDUCE_SCALED_POWER_BY_THREE_CHAIN      10 /* 10*log10(3)*2 */
1283         struct ath_hal_5416 *ahp = AH5416(ah);
1284         struct ar5416_eeprom_def *pEepData = &ahp->ah_eeprom.def;
1285         uint16_t twiceMaxEdgePower = AR5416_MAX_RATE_POWER;
1286         static const uint16_t tpScaleReductionTable[5] =
1287             { 0, 3, 6, 9, AR5416_MAX_RATE_POWER };
1288 
1289         int i;
1290         int8_t twiceLargestAntenna;
1291         struct cal_ctl_data *rep;
1292         struct cal_target_power_leg targetPowerOfdm, targetPowerCck = {
1293                 0, { 0, 0, 0, 0}
1294         };
1295         struct cal_target_power_leg targetPowerOfdmExt = {
1296                 0, { 0, 0, 0, 0} }, targetPowerCckExt = {
1297                 0, { 0, 0, 0, 0 }
1298         };
1299         struct cal_target_power_ht targetPowerHt20, targetPowerHt40 = {
1300                 0, {0, 0, 0, 0}
1301         };
1302         uint16_t scaledPower = 0, minCtlPower, maxRegAllowedPower;
1303         uint16_t ctlModesFor11a[] =
1304                 { CTL_11A, CTL_5GHT20, CTL_11A_EXT, CTL_5GHT40 };
1305         uint16_t ctlModesFor11g[] =
1306                 { CTL_11B, CTL_11G, CTL_2GHT20, CTL_11B_EXT, CTL_11G_EXT,
1307                     CTL_2GHT40
1308                 };
1309         uint16_t numCtlModes, *pCtlMode, ctlMode, freq;
1310         struct chan_centers centers;
1311         int tx_chainmask;
1312         uint16_t twiceMinEdgePower;
1313 
1314         tx_chainmask = ahp->ah_txchainmask;
1315 
1316         ath9k_hw_get_channel_centers(ah, chan, &centers);
1317 
1318         twiceLargestAntenna = max(
1319             pEepData->modalHeader
1320             [IS_CHAN_2GHZ(chan)].antennaGainCh[0],
1321             pEepData->modalHeader
1322             [IS_CHAN_2GHZ(chan)].antennaGainCh[1]);
1323 
1324         twiceLargestAntenna =
1325             max((uint8_t)twiceLargestAntenna,
1326             pEepData->modalHeader
1327             [IS_CHAN_2GHZ(chan)].antennaGainCh[2]);
1328 
1329         twiceLargestAntenna =
1330             (int16_t)min(AntennaReduction - twiceLargestAntenna, 0);
1331 
1332         maxRegAllowedPower =
1333             twiceMaxRegulatoryPower + twiceLargestAntenna;
1334 
1335         if (ah->ah_tpScale != ATH9K_TP_SCALE_MAX) {
1336                 maxRegAllowedPower -=
1337                     (tpScaleReductionTable[(ah->ah_tpScale)] * 2);
1338         }
1339 
1340         scaledPower = min(powerLimit, maxRegAllowedPower);
1341 
1342         switch (ar5416_get_ntxchains(tx_chainmask)) {
1343         case 1:
1344                 break;
1345         case 2:
1346                 scaledPower -= REDUCE_SCALED_POWER_BY_TWO_CHAIN;
1347                 break;
1348         case 3:
1349                 scaledPower -= REDUCE_SCALED_POWER_BY_THREE_CHAIN;
1350                 break;
1351         }
1352 
1353         scaledPower = max((uint16_t)0, scaledPower);
1354 
1355         if (IS_CHAN_2GHZ(chan)) {
1356                 numCtlModes = ARRAY_SIZE(ctlModesFor11g) -
1357                     SUB_NUM_CTL_MODES_AT_2G_40;
1358                 pCtlMode = ctlModesFor11g;
1359 
1360                 ath9k_hw_get_legacy_target_powers(ah, chan,
1361                     pEepData->calTargetPowerCck,
1362                     AR5416_NUM_2G_CCK_TARGET_POWERS,
1363                     &targetPowerCck, 4, B_FALSE);
1364                 ath9k_hw_get_legacy_target_powers(ah, chan,
1365                     pEepData->calTargetPower2G,
1366                     AR5416_NUM_2G_20_TARGET_POWERS,
1367                     &targetPowerOfdm, 4, B_FALSE);
1368                 ath9k_hw_get_target_powers(ah, chan,
1369                     pEepData->calTargetPower2GHT20,
1370                     AR5416_NUM_2G_20_TARGET_POWERS,
1371                     &targetPowerHt20, 8, B_FALSE);
1372 
1373                 if (IS_CHAN_HT40(chan)) {
1374                         numCtlModes = ARRAY_SIZE(ctlModesFor11g);
1375                         ath9k_hw_get_target_powers(ah, chan,
1376                             pEepData->calTargetPower2GHT40,
1377                             AR5416_NUM_2G_40_TARGET_POWERS,
1378                             &targetPowerHt40, 8, B_TRUE);
1379                         ath9k_hw_get_legacy_target_powers(ah, chan,
1380                             pEepData->calTargetPowerCck,
1381                             AR5416_NUM_2G_CCK_TARGET_POWERS,
1382                             &targetPowerCckExt, 4, B_TRUE);
1383                         ath9k_hw_get_legacy_target_powers(ah, chan,
1384                             pEepData->calTargetPower2G,
1385                             AR5416_NUM_2G_20_TARGET_POWERS,
1386                             &targetPowerOfdmExt, 4, B_TRUE);
1387                 }
1388         } else {
1389                 numCtlModes = ARRAY_SIZE(ctlModesFor11a) -
1390                     SUB_NUM_CTL_MODES_AT_5G_40;
1391                 pCtlMode = ctlModesFor11a;
1392 
1393                 ath9k_hw_get_legacy_target_powers(ah, chan,
1394                     pEepData->calTargetPower5G,
1395                     AR5416_NUM_5G_20_TARGET_POWERS,
1396                     &targetPowerOfdm, 4, B_FALSE);
1397                 ath9k_hw_get_target_powers(ah, chan,
1398                     pEepData->calTargetPower5GHT20,
1399                     AR5416_NUM_5G_20_TARGET_POWERS,
1400                     &targetPowerHt20, 8, B_FALSE);
1401 
1402                 if (IS_CHAN_HT40(chan)) {
1403                         numCtlModes = ARRAY_SIZE(ctlModesFor11a);
1404                         ath9k_hw_get_target_powers(ah, chan,
1405                             pEepData->calTargetPower5GHT40,
1406                             AR5416_NUM_5G_40_TARGET_POWERS,
1407                             &targetPowerHt40, 8, B_TRUE);
1408                         ath9k_hw_get_legacy_target_powers(ah, chan,
1409                             pEepData->calTargetPower5G,
1410                             AR5416_NUM_5G_20_TARGET_POWERS,
1411                             &targetPowerOfdmExt, 4, B_TRUE);
1412                 }
1413         }
1414 
1415         for (ctlMode = 0; ctlMode < numCtlModes; ctlMode++) {
1416                 boolean_t isHt40CtlMode =
1417                     (pCtlMode[ctlMode] == CTL_5GHT40) ||
1418                     (pCtlMode[ctlMode] == CTL_2GHT40);
1419                 if (isHt40CtlMode)
1420                         freq = centers.synth_center;
1421                 else if (pCtlMode[ctlMode] & EXT_ADDITIVE)
1422                         freq = centers.ext_center;
1423                 else
1424                         freq = centers.ctl_center;
1425 
1426                 if (ar5416_get_eep_ver(ahp) == 14 &&
1427                     ar5416_get_eep_rev(ahp) <= 2)
1428                         twiceMaxEdgePower = AR5416_MAX_RATE_POWER;
1429 
1430                 ARN_DBG((ARN_DBG_EEPROM, "arn: "
1431                     "LOOP-Mode ctlMode %d < %d, isHt40CtlMode %d, "
1432                     "EXT_ADDITIVE %d\n",
1433                     ctlMode, numCtlModes, isHt40CtlMode,
1434                     (pCtlMode[ctlMode] & EXT_ADDITIVE)));
1435 
1436                 for (i = 0; (i < AR5416_NUM_CTLS) && pEepData->ctlIndex[i];
1437                     i++) {
1438 
1439                         ARN_DBG((ARN_DBG_EEPROM, "arn: "
1440                             "LOOP-Ctlidx %d: cfgCtl 0x%2.2x "
1441                             "pCtlMode 0x%2.2x ctlIndex 0x%2.2x "
1442                             "chan %d\n",
1443                             i, cfgCtl, pCtlMode[ctlMode],
1444                             pEepData->ctlIndex[i], chan->channel));
1445 
1446                         if ((((cfgCtl & ~CTL_MODE_M) |
1447                             (pCtlMode[ctlMode] & CTL_MODE_M)) ==
1448                             pEepData->ctlIndex[i]) ||
1449                             (((cfgCtl & ~CTL_MODE_M) |
1450                             (pCtlMode[ctlMode] & CTL_MODE_M)) ==
1451                             ((pEepData->ctlIndex[i] & CTL_MODE_M) |
1452                             SD_NO_CTL))) {
1453                                 rep = &(pEepData->ctlData[i]);
1454 
1455                                 twiceMinEdgePower =
1456                                     ath9k_hw_get_max_edge_power(freq,
1457                                     rep->ctlEdges[ar5416_get_ntxchains
1458                                     (tx_chainmask) - 1],
1459                                     IS_CHAN_2GHZ(chan), AR5416_NUM_BAND_EDGES);
1460 
1461                                 ARN_DBG((ARN_DBG_EEPROM, "arn: "
1462                                     "MATCH-EE_IDX %d: ch %d is2 %d "
1463                                     "2xMinEdge %d chainmask %d chains %d\n",
1464                                     i, freq, IS_CHAN_2GHZ(chan),
1465                                     twiceMinEdgePower, tx_chainmask,
1466                                     ar5416_get_ntxchains(tx_chainmask)));
1467 
1468                                 if ((cfgCtl & ~CTL_MODE_M) == SD_NO_CTL) {
1469                                         twiceMaxEdgePower =
1470                                             min(twiceMaxEdgePower,
1471                                             twiceMinEdgePower);
1472                                 } else {
1473                                         twiceMaxEdgePower = twiceMinEdgePower;
1474                                         break;
1475                                 }
1476                         }
1477                 }
1478 
1479                 minCtlPower = min(twiceMaxEdgePower, scaledPower);
1480 
1481                 ARN_DBG((ARN_DBG_EEPROM, "arn: "
1482                     "SEL-Min ctlMode %d pCtlMode %d "
1483                     "2xMaxEdge %d sP %d minCtlPwr %d\n",
1484                     ctlMode, pCtlMode[ctlMode], twiceMaxEdgePower,
1485                     scaledPower, minCtlPower));
1486 
1487                 switch (pCtlMode[ctlMode]) {
1488                 case CTL_11B:
1489                         for (i = 0; i < ARRAY_SIZE(targetPowerCck.tPow2x);
1490                             i++) {
1491                                 targetPowerCck.tPow2x[i] =
1492                                     min((uint16_t)targetPowerCck.tPow2x[i],
1493                                     minCtlPower);
1494                         }
1495                         break;
1496                 case CTL_11A:
1497                 case CTL_11G:
1498                         for (i = 0; i < ARRAY_SIZE(targetPowerOfdm.tPow2x);
1499                             i++) {
1500                                 targetPowerOfdm.tPow2x[i] =
1501                                     min((uint16_t)targetPowerOfdm.tPow2x[i],
1502                                     minCtlPower);
1503                         }
1504                         break;
1505                 case CTL_5GHT20:
1506                 case CTL_2GHT20:
1507                         for (i = 0; i < ARRAY_SIZE(targetPowerHt20.tPow2x);
1508                             i++) {
1509                                 targetPowerHt20.tPow2x[i] =
1510                                     min((uint16_t)targetPowerHt20.tPow2x[i],
1511                                     minCtlPower);
1512                         }
1513                         break;
1514                 case CTL_11B_EXT:
1515                         targetPowerCckExt.tPow2x[0] =
1516                             min((uint16_t)targetPowerCckExt.tPow2x[0],
1517                             minCtlPower);
1518                         break;
1519                 case CTL_11A_EXT:
1520                 case CTL_11G_EXT:
1521                         targetPowerOfdmExt.tPow2x[0] =
1522                             min((uint16_t)targetPowerOfdmExt.tPow2x[0],
1523                             minCtlPower);
1524                         break;
1525                 case CTL_5GHT40:
1526                 case CTL_2GHT40:
1527                         for (i = 0; i < ARRAY_SIZE(targetPowerHt40.tPow2x);
1528                             i++) {
1529                                 targetPowerHt40.tPow2x[i] =
1530                                     min((uint16_t)targetPowerHt40.tPow2x[i],
1531                                     minCtlPower);
1532                         }
1533                         break;
1534                 default:
1535                         break;
1536                 }
1537         }
1538 
1539         ratesArray[rate6mb] = ratesArray[rate9mb] = ratesArray[rate12mb] =
1540             ratesArray[rate18mb] = ratesArray[rate24mb] =
1541             targetPowerOfdm.tPow2x[0];
1542         ratesArray[rate36mb] = targetPowerOfdm.tPow2x[1];
1543         ratesArray[rate48mb] = targetPowerOfdm.tPow2x[2];
1544         ratesArray[rate54mb] = targetPowerOfdm.tPow2x[3];
1545         ratesArray[rateXr] = targetPowerOfdm.tPow2x[0];
1546 
1547         for (i = 0; i < ARRAY_SIZE(targetPowerHt20.tPow2x); i++)
1548                 ratesArray[rateHt20_0 + i] = targetPowerHt20.tPow2x[i];
1549 
1550         if (IS_CHAN_2GHZ(chan)) {
1551                 ratesArray[rate1l] = targetPowerCck.tPow2x[0];
1552                 ratesArray[rate2s] = ratesArray[rate2l] =
1553                     targetPowerCck.tPow2x[1];
1554                 ratesArray[rate5_5s] = ratesArray[rate5_5l] =
1555                     targetPowerCck.tPow2x[2];
1556                 ;
1557                 ratesArray[rate11s] = ratesArray[rate11l] =
1558                     targetPowerCck.tPow2x[3];
1559                 ;
1560         }
1561         if (IS_CHAN_HT40(chan)) {
1562                 for (i = 0; i < ARRAY_SIZE(targetPowerHt40.tPow2x); i++) {
1563                         ratesArray[rateHt40_0 + i] =
1564                             targetPowerHt40.tPow2x[i];
1565                 }
1566                 ratesArray[rateDupOfdm] = targetPowerHt40.tPow2x[0];
1567                 ratesArray[rateDupCck] = targetPowerHt40.tPow2x[0];
1568                 ratesArray[rateExtOfdm] = targetPowerOfdmExt.tPow2x[0];
1569                 if (IS_CHAN_2GHZ(chan)) {
1570                         ratesArray[rateExtCck] =
1571                             targetPowerCckExt.tPow2x[0];
1572                 }
1573         }
1574         return (B_TRUE);
1575 }
1576 
1577 static boolean_t
1578 ath9k_hw_set_4k_power_per_rate_table(struct ath_hal *ah,
1579     struct ath9k_channel *chan,
1580     int16_t *ratesArray,
1581     uint16_t cfgCtl,
1582     uint16_t AntennaReduction,
1583     uint16_t twiceMaxRegulatoryPower,
1584     uint16_t powerLimit)
1585 {
1586         struct ath_hal_5416 *ahp = AH5416(ah);
1587         struct ar5416_eeprom_4k *pEepData = &ahp->ah_eeprom.map4k;
1588         uint16_t twiceMaxEdgePower = AR5416_MAX_RATE_POWER;
1589         static const uint16_t tpScaleReductionTable[5] =
1590                 { 0, 3, 6, 9, AR5416_MAX_RATE_POWER };
1591 
1592         int i;
1593         int16_t twiceLargestAntenna;
1594         struct cal_ctl_data_4k *rep;
1595         struct cal_target_power_leg targetPowerOfdm, targetPowerCck = {
1596                 0, { 0, 0, 0, 0}
1597         };
1598         struct cal_target_power_leg targetPowerOfdmExt = {
1599                 0, { 0, 0, 0, 0} }, targetPowerCckExt = {
1600                 0, { 0, 0, 0, 0 }
1601         };
1602         struct cal_target_power_ht targetPowerHt20, targetPowerHt40 = {
1603                 0, {0, 0, 0, 0}
1604         };
1605         uint16_t scaledPower = 0, minCtlPower, maxRegAllowedPower;
1606         uint16_t ctlModesFor11g[] =
1607             { CTL_11B, CTL_11G, CTL_2GHT20, CTL_11B_EXT, CTL_11G_EXT,
1608             CTL_2GHT40
1609             };
1610         uint16_t numCtlModes, *pCtlMode, ctlMode, freq;
1611         struct chan_centers centers;
1612         int tx_chainmask;
1613         uint16_t twiceMinEdgePower;
1614 
1615         tx_chainmask = ahp->ah_txchainmask;
1616 
1617         ath9k_hw_get_channel_centers(ah, chan, &centers);
1618 
1619         twiceLargestAntenna = pEepData->modalHeader.antennaGainCh[0];
1620 
1621         twiceLargestAntenna =
1622             (int16_t)min(AntennaReduction - twiceLargestAntenna, 0);
1623 
1624         maxRegAllowedPower = twiceMaxRegulatoryPower + twiceLargestAntenna;
1625 
1626         if (ah->ah_tpScale != ATH9K_TP_SCALE_MAX) {
1627                 maxRegAllowedPower -=
1628                     (tpScaleReductionTable[(ah->ah_tpScale)] * 2);
1629         }
1630 
1631         scaledPower = min(powerLimit, maxRegAllowedPower);
1632         scaledPower = max((uint16_t)0, scaledPower);
1633 
1634         numCtlModes = ARRAY_SIZE(ctlModesFor11g) - SUB_NUM_CTL_MODES_AT_2G_40;
1635         pCtlMode = ctlModesFor11g;
1636 
1637         ath9k_hw_get_legacy_target_powers(ah, chan,
1638             pEepData->calTargetPowerCck,
1639             AR5416_NUM_2G_CCK_TARGET_POWERS,
1640             &targetPowerCck, 4, B_FALSE);
1641         ath9k_hw_get_legacy_target_powers(ah, chan,
1642             pEepData->calTargetPower2G,
1643             AR5416_NUM_2G_20_TARGET_POWERS,
1644             &targetPowerOfdm, 4, B_FALSE);
1645         ath9k_hw_get_target_powers(ah, chan,
1646             pEepData->calTargetPower2GHT20,
1647             AR5416_NUM_2G_20_TARGET_POWERS,
1648             &targetPowerHt20, 8, B_FALSE);
1649 
1650         if (IS_CHAN_HT40(chan)) {
1651                 numCtlModes = ARRAY_SIZE(ctlModesFor11g);
1652                 ath9k_hw_get_target_powers(ah, chan,
1653                     pEepData->calTargetPower2GHT40,
1654                     AR5416_NUM_2G_40_TARGET_POWERS,
1655                     &targetPowerHt40, 8, B_TRUE);
1656                 ath9k_hw_get_legacy_target_powers(ah, chan,
1657                     pEepData->calTargetPowerCck,
1658                     AR5416_NUM_2G_CCK_TARGET_POWERS,
1659                     &targetPowerCckExt, 4, B_TRUE);
1660                 ath9k_hw_get_legacy_target_powers(ah, chan,
1661                     pEepData->calTargetPower2G,
1662                     AR5416_NUM_2G_20_TARGET_POWERS,
1663                     &targetPowerOfdmExt, 4, B_TRUE);
1664         }
1665 
1666         for (ctlMode = 0; ctlMode < numCtlModes; ctlMode++) {
1667                 boolean_t isHt40CtlMode = (pCtlMode[ctlMode] == CTL_5GHT40) ||
1668                     (pCtlMode[ctlMode] == CTL_2GHT40);
1669                 if (isHt40CtlMode)
1670                         freq = centers.synth_center;
1671                 else if (pCtlMode[ctlMode] & EXT_ADDITIVE)
1672                         freq = centers.ext_center;
1673                 else
1674                         freq = centers.ctl_center;
1675 
1676                 if (ar5416_get_eep_ver(ahp) == 14 &&
1677                     ar5416_get_eep_rev(ahp) <= 2)
1678                         twiceMaxEdgePower = AR5416_MAX_RATE_POWER;
1679 
1680                 ARN_DBG((ARN_DBG_POWER_MGMT,
1681                     "LOOP-Mode ctlMode %d < %d, isHt40CtlMode %d, "
1682                     "EXT_ADDITIVE %d\n",
1683                     ctlMode, numCtlModes, isHt40CtlMode,
1684                     (pCtlMode[ctlMode] & EXT_ADDITIVE)));
1685 
1686                 for (i = 0; (i < AR5416_NUM_CTLS) &&
1687                     pEepData->ctlIndex[i]; i++) {
1688                         ARN_DBG((ARN_DBG_POWER_MGMT,
1689                             "  LOOP-Ctlidx %d: cfgCtl 0x%2.2x "
1690                             "pCtlMode 0x%2.2x ctlIndex 0x%2.2x "
1691                             "chan %d\n",
1692                             i, cfgCtl, pCtlMode[ctlMode],
1693                             pEepData->ctlIndex[i], chan->channel));
1694 
1695                         if ((((cfgCtl & ~CTL_MODE_M) |
1696                             (pCtlMode[ctlMode] & CTL_MODE_M)) ==
1697                             pEepData->ctlIndex[i]) ||
1698                             (((cfgCtl & ~CTL_MODE_M) |
1699                             (pCtlMode[ctlMode] & CTL_MODE_M)) ==
1700                             ((pEepData->ctlIndex[i] & CTL_MODE_M) |
1701                             SD_NO_CTL))) {
1702                                 rep = &(pEepData->ctlData[i]);
1703 
1704                                 twiceMinEdgePower =
1705                                     ath9k_hw_get_max_edge_power(freq,
1706                                     rep->ctlEdges[ar5416_get_ntxchains
1707                                     (tx_chainmask) - 1],
1708                                     IS_CHAN_2GHZ(chan),
1709                                     AR5416_EEP4K_NUM_BAND_EDGES);
1710 
1711                                 ARN_DBG((ARN_DBG_POWER_MGMT,
1712                                     "   MATCH-EE_IDX %d: ch %d is2 %d "
1713                                     "2xMinEdge %d chainmask %d chains %d\n",
1714                                     i, freq, IS_CHAN_2GHZ(chan),
1715                                     twiceMinEdgePower, tx_chainmask,
1716                                     ar5416_get_ntxchains
1717                                     (tx_chainmask)));
1718                                 if ((cfgCtl & ~CTL_MODE_M) == SD_NO_CTL) {
1719                                         twiceMaxEdgePower =
1720                                             min(twiceMaxEdgePower,
1721                                             twiceMinEdgePower);
1722                                 } else {
1723                                         twiceMaxEdgePower = twiceMinEdgePower;
1724                                         break;
1725                                 }
1726                         }
1727                 }
1728 
1729                 minCtlPower = (uint8_t)min(twiceMaxEdgePower, scaledPower);
1730 
1731                 ARN_DBG((ARN_DBG_POWER_MGMT,
1732                     "    SEL-Min ctlMode %d pCtlMode %d "
1733                     "2xMaxEdge %d sP %d minCtlPwr %d\n",
1734                     ctlMode, pCtlMode[ctlMode], twiceMaxEdgePower,
1735                     scaledPower, minCtlPower));
1736 
1737                 switch (pCtlMode[ctlMode]) {
1738                 case CTL_11B:
1739                         for (i = 0; i < ARRAY_SIZE(targetPowerCck.tPow2x);
1740                             i++) {
1741                                 targetPowerCck.tPow2x[i] =
1742                                     min((uint16_t)targetPowerCck.tPow2x[i],
1743                                     minCtlPower);
1744                         }
1745                         break;
1746                 case CTL_11G:
1747                         for (i = 0; i < ARRAY_SIZE(targetPowerOfdm.tPow2x);
1748                             i++) {
1749                                 targetPowerOfdm.tPow2x[i] =
1750                                     min((uint16_t)targetPowerOfdm.tPow2x[i],
1751                                     minCtlPower);
1752                         }
1753                         break;
1754                 case CTL_2GHT20:
1755                         for (i = 0; i < ARRAY_SIZE(targetPowerHt20.tPow2x);
1756                             i++) {
1757                                 targetPowerHt20.tPow2x[i] =
1758                                     min((uint16_t)targetPowerHt20.tPow2x[i],
1759                                     minCtlPower);
1760                         }
1761                         break;
1762                 case CTL_11B_EXT:
1763                         targetPowerCckExt.tPow2x[0] = min((uint16_t)
1764                             targetPowerCckExt.tPow2x[0],
1765                             minCtlPower);
1766                         break;
1767                 case CTL_11G_EXT:
1768                         targetPowerOfdmExt.tPow2x[0] = min((uint16_t)
1769                             targetPowerOfdmExt.tPow2x[0],
1770                             minCtlPower);
1771                         break;
1772                 case CTL_2GHT40:
1773                         for (i = 0; i < ARRAY_SIZE(targetPowerHt40.tPow2x);
1774                             i++) {
1775                                 targetPowerHt40.tPow2x[i] =
1776                                     min((uint16_t)targetPowerHt40.tPow2x[i],
1777                                     minCtlPower);
1778                         }
1779                         break;
1780                 default:
1781                         break;
1782                 }
1783         }
1784 
1785         ratesArray[rate6mb] = ratesArray[rate9mb] = ratesArray[rate12mb] =
1786             ratesArray[rate18mb] = ratesArray[rate24mb] =
1787             targetPowerOfdm.tPow2x[0];
1788         ratesArray[rate36mb] = targetPowerOfdm.tPow2x[1];
1789         ratesArray[rate48mb] = targetPowerOfdm.tPow2x[2];
1790         ratesArray[rate54mb] = targetPowerOfdm.tPow2x[3];
1791         ratesArray[rateXr] = targetPowerOfdm.tPow2x[0];
1792 
1793         for (i = 0; i < ARRAY_SIZE(targetPowerHt20.tPow2x); i++)
1794                 ratesArray[rateHt20_0 + i] = targetPowerHt20.tPow2x[i];
1795 
1796         ratesArray[rate1l] = targetPowerCck.tPow2x[0];
1797         ratesArray[rate2s] = ratesArray[rate2l] = targetPowerCck.tPow2x[1];
1798         ratesArray[rate5_5s] = ratesArray[rate5_5l] = targetPowerCck.tPow2x[2];
1799         ratesArray[rate11s] = ratesArray[rate11l] = targetPowerCck.tPow2x[3];
1800 
1801         if (IS_CHAN_HT40(chan)) {
1802                 for (i = 0; i < ARRAY_SIZE(targetPowerHt40.tPow2x); i++) {
1803                         ratesArray[rateHt40_0 + i] =
1804                             targetPowerHt40.tPow2x[i];
1805                 }
1806                 ratesArray[rateDupOfdm] = targetPowerHt40.tPow2x[0];
1807                 ratesArray[rateDupCck] = targetPowerHt40.tPow2x[0];
1808                 ratesArray[rateExtOfdm] = targetPowerOfdmExt.tPow2x[0];
1809                 ratesArray[rateExtCck] = targetPowerCckExt.tPow2x[0];
1810         }
1811         return (B_TRUE);
1812 }
1813 
1814 static int
1815 ath9k_hw_def_set_txpower(struct ath_hal *ah, struct ath9k_channel *chan,
1816     uint16_t cfgCtl, uint8_t twiceAntennaReduction,
1817     uint8_t twiceMaxRegulatoryPower, uint8_t powerLimit)
1818 {
1819         struct ath_hal_5416 *ahp = AH5416(ah);
1820         struct ar5416_eeprom_def *pEepData = &ahp->ah_eeprom.def;
1821         struct modal_eep_header *pModal =
1822             &(pEepData->modalHeader[IS_CHAN_2GHZ(chan)]);
1823         int16_t ratesArray[Ar5416RateSize];
1824         int16_t txPowerIndexOffset = 0;
1825         uint8_t ht40PowerIncForPdadc = 2;
1826         int i;
1827 
1828         (void) memset(ratesArray, 0, sizeof (ratesArray));
1829 
1830         if ((pEepData->baseEepHeader.version & AR5416_EEP_VER_MINOR_MASK) >=
1831             AR5416_EEP_MINOR_VER_2) {
1832                 ht40PowerIncForPdadc = pModal->ht40PowerIncForPdadc;
1833         }
1834 
1835         if (!ath9k_hw_set_def_power_per_rate_table(ah, chan,
1836             &ratesArray[0], cfgCtl,
1837             twiceAntennaReduction,
1838             twiceMaxRegulatoryPower,
1839             powerLimit)) {
1840 
1841                 ARN_DBG((ARN_DBG_EEPROM,
1842                     "ath9k_hw_set_txpower: unable to set "
1843                     "tx power per rate table\n"));
1844 
1845                 return (EIO);
1846         }
1847 
1848         if (!ath9k_hw_set_def_power_cal_table(ah, chan, &txPowerIndexOffset)) {
1849                 ARN_DBG((ARN_DBG_EEPROM, "ath9k: "
1850                     "ath9k_hw_set_txpower: unable to set power table\n"));
1851                 return (EIO);
1852         }
1853 
1854         for (i = 0; i < ARRAY_SIZE(ratesArray); i++) {
1855                 ratesArray[i] = (int16_t)(txPowerIndexOffset + ratesArray[i]);
1856                 if (ratesArray[i] > AR5416_MAX_RATE_POWER)
1857                         ratesArray[i] = AR5416_MAX_RATE_POWER;
1858         }
1859 
1860         if (AR_SREV_9280_10_OR_LATER(ah)) {
1861                 for (i = 0; i < Ar5416RateSize; i++)
1862                         ratesArray[i] -= AR5416_PWR_TABLE_OFFSET * 2;
1863         }
1864 
1865         REG_WRITE(ah, AR_PHY_POWER_TX_RATE1,
1866             ATH9K_POW_SM(ratesArray[rate18mb], 24) |
1867             ATH9K_POW_SM(ratesArray[rate12mb], 16) |
1868             ATH9K_POW_SM(ratesArray[rate9mb], 8) |
1869             ATH9K_POW_SM(ratesArray[rate6mb], 0));
1870         REG_WRITE(ah, AR_PHY_POWER_TX_RATE2,
1871             ATH9K_POW_SM(ratesArray[rate54mb], 24) |
1872             ATH9K_POW_SM(ratesArray[rate48mb], 16) |
1873             ATH9K_POW_SM(ratesArray[rate36mb], 8) |
1874             ATH9K_POW_SM(ratesArray[rate24mb], 0));
1875 
1876         if (IS_CHAN_2GHZ(chan)) {
1877                 REG_WRITE(ah, AR_PHY_POWER_TX_RATE3,
1878                     ATH9K_POW_SM(ratesArray[rate2s], 24) |
1879                     ATH9K_POW_SM(ratesArray[rate2l], 16) |
1880                     ATH9K_POW_SM(ratesArray[rateXr], 8) |
1881                     ATH9K_POW_SM(ratesArray[rate1l], 0));
1882                 REG_WRITE(ah, AR_PHY_POWER_TX_RATE4,
1883                     ATH9K_POW_SM(ratesArray[rate11s], 24) |
1884                     ATH9K_POW_SM(ratesArray[rate11l], 16) |
1885                     ATH9K_POW_SM(ratesArray[rate5_5s], 8) |
1886                     ATH9K_POW_SM(ratesArray[rate5_5l], 0));
1887         }
1888 
1889         REG_WRITE(ah, AR_PHY_POWER_TX_RATE5,
1890             ATH9K_POW_SM(ratesArray[rateHt20_3], 24) |
1891             ATH9K_POW_SM(ratesArray[rateHt20_2], 16) |
1892             ATH9K_POW_SM(ratesArray[rateHt20_1], 8) |
1893             ATH9K_POW_SM(ratesArray[rateHt20_0], 0));
1894         REG_WRITE(ah, AR_PHY_POWER_TX_RATE6,
1895             ATH9K_POW_SM(ratesArray[rateHt20_7], 24) |
1896             ATH9K_POW_SM(ratesArray[rateHt20_6], 16) |
1897             ATH9K_POW_SM(ratesArray[rateHt20_5], 8) |
1898             ATH9K_POW_SM(ratesArray[rateHt20_4], 0));
1899 
1900         if (IS_CHAN_HT40(chan)) {
1901                 REG_WRITE(ah, AR_PHY_POWER_TX_RATE7,
1902                     ATH9K_POW_SM(ratesArray[rateHt40_3] +
1903                     ht40PowerIncForPdadc, 24) |
1904                     ATH9K_POW_SM(ratesArray[rateHt40_2] +
1905                     ht40PowerIncForPdadc, 16) |
1906                     ATH9K_POW_SM(ratesArray[rateHt40_1] +
1907                     ht40PowerIncForPdadc, 8) |
1908                     ATH9K_POW_SM(ratesArray[rateHt40_0] +
1909                     ht40PowerIncForPdadc, 0));
1910                 REG_WRITE(ah, AR_PHY_POWER_TX_RATE8,
1911                     ATH9K_POW_SM(ratesArray[rateHt40_7] +
1912                     ht40PowerIncForPdadc, 24) |
1913                     ATH9K_POW_SM(ratesArray[rateHt40_6] +
1914                     ht40PowerIncForPdadc, 16) |
1915                     ATH9K_POW_SM(ratesArray[rateHt40_5] +
1916                     ht40PowerIncForPdadc, 8) |
1917                     ATH9K_POW_SM(ratesArray[rateHt40_4] +
1918                     ht40PowerIncForPdadc, 0));
1919 
1920                 REG_WRITE(ah, AR_PHY_POWER_TX_RATE9,
1921                     ATH9K_POW_SM(ratesArray[rateExtOfdm], 24) |
1922                     ATH9K_POW_SM(ratesArray[rateExtCck], 16) |
1923                     ATH9K_POW_SM(ratesArray[rateDupOfdm], 8) |
1924                     ATH9K_POW_SM(ratesArray[rateDupCck], 0));
1925         }
1926 
1927         REG_WRITE(ah, AR_PHY_POWER_TX_SUB,
1928             ATH9K_POW_SM(pModal->pwrDecreaseFor3Chain, 6) |
1929             ATH9K_POW_SM(pModal->pwrDecreaseFor2Chain, 0));
1930 
1931         i = rate6mb;
1932 
1933         if (IS_CHAN_HT40(chan))
1934                 i = rateHt40_0;
1935         else if (IS_CHAN_HT20(chan))
1936                 i = rateHt20_0;
1937 
1938         if (AR_SREV_9280_10_OR_LATER(ah))
1939                 ah->ah_maxPowerLevel =
1940                     ratesArray[i] + AR5416_PWR_TABLE_OFFSET * 2;
1941         else
1942                 ah->ah_maxPowerLevel = ratesArray[i];
1943 
1944         return (0);
1945 }
1946 
1947 static int
1948 ath9k_hw_4k_set_txpower(struct ath_hal *ah,
1949     struct ath9k_channel *chan,
1950     uint16_t cfgCtl,
1951     uint8_t twiceAntennaReduction,
1952     uint8_t twiceMaxRegulatoryPower,
1953     uint8_t powerLimit)
1954 {
1955         struct ath_hal_5416 *ahp = AH5416(ah);
1956         struct ar5416_eeprom_4k *pEepData = &ahp->ah_eeprom.map4k;
1957         struct modal_eep_4k_header *pModal = &pEepData->modalHeader;
1958         int16_t ratesArray[Ar5416RateSize];
1959         int16_t txPowerIndexOffset = 0;
1960         uint8_t ht40PowerIncForPdadc = 2;
1961         int i;
1962 
1963         (void) memset(ratesArray, 0, sizeof (ratesArray));
1964 
1965         if ((pEepData->baseEepHeader.version & AR5416_EEP_VER_MINOR_MASK) >=
1966             AR5416_EEP_MINOR_VER_2) {
1967                 ht40PowerIncForPdadc = pModal->ht40PowerIncForPdadc;
1968         }
1969 
1970         if (!ath9k_hw_set_4k_power_per_rate_table(ah, chan,
1971             &ratesArray[0], cfgCtl,
1972             twiceAntennaReduction,
1973             twiceMaxRegulatoryPower,
1974             powerLimit)) {
1975                 ARN_DBG((ARN_DBG_EEPROM,
1976                     "ath9k_hw_set_txpower: unable to set "
1977                     "tx power per rate table\n"));
1978                 return (EIO);
1979         }
1980 
1981         if (!ath9k_hw_set_4k_power_cal_table(ah, chan, &txPowerIndexOffset)) {
1982                 ARN_DBG((ARN_DBG_EEPROM,
1983                     "ath9k_hw_set_txpower: unable to set power table\n"));
1984                 return (EIO);
1985         }
1986 
1987         for (i = 0; i < ARRAY_SIZE(ratesArray); i++) {
1988                 ratesArray[i] = (int16_t)(txPowerIndexOffset + ratesArray[i]);
1989                 if (ratesArray[i] > AR5416_MAX_RATE_POWER)
1990                         ratesArray[i] = AR5416_MAX_RATE_POWER;
1991         }
1992 
1993         if (AR_SREV_9280_10_OR_LATER(ah)) {
1994                 for (i = 0; i < Ar5416RateSize; i++)
1995                         ratesArray[i] -= AR5416_PWR_TABLE_OFFSET * 2;
1996         }
1997 
1998         REG_WRITE(ah, AR_PHY_POWER_TX_RATE1,
1999             ATH9K_POW_SM(ratesArray[rate18mb], 24) |
2000             ATH9K_POW_SM(ratesArray[rate12mb], 16) |
2001             ATH9K_POW_SM(ratesArray[rate9mb], 8) |
2002             ATH9K_POW_SM(ratesArray[rate6mb], 0));
2003         REG_WRITE(ah, AR_PHY_POWER_TX_RATE2,
2004             ATH9K_POW_SM(ratesArray[rate54mb], 24) |
2005             ATH9K_POW_SM(ratesArray[rate48mb], 16) |
2006             ATH9K_POW_SM(ratesArray[rate36mb], 8) |
2007             ATH9K_POW_SM(ratesArray[rate24mb], 0));
2008 
2009         if (IS_CHAN_2GHZ(chan)) {
2010                 REG_WRITE(ah, AR_PHY_POWER_TX_RATE3,
2011                     ATH9K_POW_SM(ratesArray[rate2s], 24) |
2012                     ATH9K_POW_SM(ratesArray[rate2l], 16) |
2013                     ATH9K_POW_SM(ratesArray[rateXr], 8) |
2014                     ATH9K_POW_SM(ratesArray[rate1l], 0));
2015                 REG_WRITE(ah, AR_PHY_POWER_TX_RATE4,
2016                     ATH9K_POW_SM(ratesArray[rate11s], 24) |
2017                     ATH9K_POW_SM(ratesArray[rate11l], 16) |
2018                     ATH9K_POW_SM(ratesArray[rate5_5s], 8) |
2019                     ATH9K_POW_SM(ratesArray[rate5_5l], 0));
2020         }
2021 
2022         REG_WRITE(ah, AR_PHY_POWER_TX_RATE5,
2023             ATH9K_POW_SM(ratesArray[rateHt20_3], 24) |
2024             ATH9K_POW_SM(ratesArray[rateHt20_2], 16) |
2025             ATH9K_POW_SM(ratesArray[rateHt20_1], 8) |
2026             ATH9K_POW_SM(ratesArray[rateHt20_0], 0));
2027         REG_WRITE(ah, AR_PHY_POWER_TX_RATE6,
2028             ATH9K_POW_SM(ratesArray[rateHt20_7], 24) |
2029             ATH9K_POW_SM(ratesArray[rateHt20_6], 16) |
2030             ATH9K_POW_SM(ratesArray[rateHt20_5], 8) |
2031             ATH9K_POW_SM(ratesArray[rateHt20_4], 0));
2032 
2033         if (IS_CHAN_HT40(chan)) {
2034                 REG_WRITE(ah, AR_PHY_POWER_TX_RATE7,
2035                     ATH9K_POW_SM(ratesArray[rateHt40_3] +
2036                     ht40PowerIncForPdadc, 24) |
2037                     ATH9K_POW_SM(ratesArray[rateHt40_2] +
2038                     ht40PowerIncForPdadc, 16) |
2039                     ATH9K_POW_SM(ratesArray[rateHt40_1] +
2040                     ht40PowerIncForPdadc, 8) |
2041                     ATH9K_POW_SM(ratesArray[rateHt40_0] +
2042                     ht40PowerIncForPdadc, 0));
2043 
2044                 REG_WRITE(ah, AR_PHY_POWER_TX_RATE8,
2045                     ATH9K_POW_SM(ratesArray[rateHt40_7] +
2046                     ht40PowerIncForPdadc, 24) |
2047                     ATH9K_POW_SM(ratesArray[rateHt40_6] +
2048                     ht40PowerIncForPdadc, 16) |
2049                     ATH9K_POW_SM(ratesArray[rateHt40_5] +
2050                     ht40PowerIncForPdadc, 8) |
2051                     ATH9K_POW_SM(ratesArray[rateHt40_4] +
2052                     ht40PowerIncForPdadc, 0));
2053 
2054                 REG_WRITE(ah, AR_PHY_POWER_TX_RATE9,
2055                     ATH9K_POW_SM(ratesArray[rateExtOfdm], 24) |
2056                     ATH9K_POW_SM(ratesArray[rateExtCck], 16) |
2057                     ATH9K_POW_SM(ratesArray[rateDupOfdm], 8) |
2058                     ATH9K_POW_SM(ratesArray[rateDupCck], 0));
2059         }
2060 
2061         i = rate6mb;
2062 
2063         if (IS_CHAN_HT40(chan))
2064                 i = rateHt40_0;
2065         else if (IS_CHAN_HT20(chan))
2066                 i = rateHt20_0;
2067 
2068         if (AR_SREV_9280_10_OR_LATER(ah))
2069                 ah->ah_maxPowerLevel =
2070                     ratesArray[i] + AR5416_PWR_TABLE_OFFSET * 2;
2071         else
2072                 ah->ah_maxPowerLevel = ratesArray[i];
2073 
2074         return (0);
2075 }
2076 
2077 int
2078 ath9k_hw_set_txpower(struct ath_hal *ah,
2079     struct ath9k_channel *chan,
2080     uint16_t cfgCtl,
2081     uint8_t twiceAntennaReduction,
2082     uint8_t twiceMaxRegulatoryPower,
2083     uint8_t powerLimit)
2084 {
2085         struct ath_hal_5416 *ahp = AH5416(ah);
2086         int val;
2087 
2088         if (ahp->ah_eep_map == EEP_MAP_DEFAULT)
2089                 val = ath9k_hw_def_set_txpower(ah, chan, cfgCtl,
2090                     twiceAntennaReduction, twiceMaxRegulatoryPower,
2091                     powerLimit);
2092         else if (ahp->ah_eep_map == EEP_MAP_4KBITS)
2093                 val = ath9k_hw_4k_set_txpower(ah, chan, cfgCtl,
2094                     twiceAntennaReduction, twiceMaxRegulatoryPower,
2095                     powerLimit);
2096         return (val);
2097 }
2098 
2099 static void
2100 ath9k_hw_set_def_addac(struct ath_hal *ah, struct ath9k_channel *chan)
2101 {
2102 #define XPA_LVL_FREQ(cnt)       (pModal->xpaBiasLvlFreq[cnt])
2103         struct modal_eep_header *pModal;
2104         struct ath_hal_5416 *ahp = AH5416(ah);
2105         struct ar5416_eeprom_def *eep = &ahp->ah_eeprom.def;
2106         uint8_t biaslevel;
2107 
2108         if (ah->ah_macVersion != AR_SREV_VERSION_9160)
2109                 return;
2110 
2111         if (ar5416_get_eep_rev(ahp) < AR5416_EEP_MINOR_VER_7)
2112                 return;
2113 
2114         pModal = &(eep->modalHeader[IS_CHAN_2GHZ(chan)]);
2115 
2116         if (pModal->xpaBiasLvl != 0xff) {
2117                 biaslevel = pModal->xpaBiasLvl;
2118         } else {
2119                 uint16_t resetFreqBin, freqBin, freqCount = 0;
2120                 struct chan_centers centers;
2121 
2122                 ath9k_hw_get_channel_centers(ah, chan, &centers);
2123 
2124                 resetFreqBin =
2125                     FREQ2FBIN(centers.synth_center, IS_CHAN_2GHZ(chan));
2126                 freqBin = XPA_LVL_FREQ(freqCount) & 0xff;
2127                 biaslevel = (uint8_t)(XPA_LVL_FREQ(0) >> 14);
2128 
2129                 freqCount++;
2130 
2131                 while (freqCount < 3) {
2132                         if (XPA_LVL_FREQ(freqCount) == 0x0)
2133                                 break;
2134 
2135                         freqBin = XPA_LVL_FREQ(freqCount) & 0xff;
2136                         if (resetFreqBin >= freqBin) {
2137                                 biaslevel =
2138                                     (uint8_t)
2139                                     (XPA_LVL_FREQ(freqCount) >> 14);
2140                         } else {
2141                                 break;
2142                         }
2143                         freqCount++;
2144                 }
2145         }
2146 
2147         if (IS_CHAN_2GHZ(chan)) {
2148                 INI_RA(&ahp->ah_iniAddac, 7, 1) =
2149                     (INI_RA(&ahp->ah_iniAddac, 7, 1) &
2150                     (~0x18)) | biaslevel << 3;
2151         } else {
2152                 INI_RA(&ahp->ah_iniAddac, 6, 1) =
2153                     (INI_RA(&ahp->ah_iniAddac, 6, 1) &
2154                     (~0xc0)) | biaslevel << 6;
2155         }
2156 #undef XPA_LVL_FREQ
2157 }
2158 
2159 /* ARGSUSED */
2160 static void
2161 ath9k_hw_set_4k_addac(struct ath_hal *ah, struct ath9k_channel *chan)
2162 {
2163         struct modal_eep_4k_header *pModal;
2164         struct ath_hal_5416 *ahp = AH5416(ah);
2165         struct ar5416_eeprom_4k *eep = &ahp->ah_eeprom.map4k;
2166         uint8_t biaslevel;
2167 
2168         if (ah->ah_macVersion != AR_SREV_VERSION_9160)
2169                 return;
2170 
2171         if (ar5416_get_eep_rev(ahp) < AR5416_EEP_MINOR_VER_7)
2172                 return;
2173 
2174         pModal = &eep->modalHeader;
2175 
2176         if (pModal->xpaBiasLvl != 0xff) {
2177                 biaslevel = pModal->xpaBiasLvl;
2178                 INI_RA(&ahp->ah_iniAddac, 7, 1) =
2179                     (INI_RA(&ahp->ah_iniAddac, 7, 1) & (~0x18)) |
2180                     biaslevel << 3;
2181         }
2182 }
2183 
2184 void
2185 ath9k_hw_set_addac(struct ath_hal *ah, struct ath9k_channel *chan)
2186 {
2187         struct ath_hal_5416 *ahp = AH5416(ah);
2188 
2189         if (ahp->ah_eep_map == EEP_MAP_DEFAULT)
2190                 ath9k_hw_set_def_addac(ah, chan);
2191         else if (ahp->ah_eep_map == EEP_MAP_4KBITS)
2192                 ath9k_hw_set_4k_addac(ah, chan);
2193 }
2194 
2195 /* XXX: Clean me up, make me more legible */
2196 static boolean_t
2197 ath9k_hw_eeprom_set_def_board_values(struct ath_hal *ah,
2198     struct ath9k_channel *chan)
2199 {
2200         struct modal_eep_header *pModal;
2201         struct ath_hal_5416 *ahp = AH5416(ah);
2202         struct ar5416_eeprom_def *eep = &ahp->ah_eeprom.def;
2203         int i, regChainOffset;
2204         uint8_t txRxAttenLocal;
2205         uint16_t ant_config;
2206 
2207         pModal = &(eep->modalHeader[IS_CHAN_2GHZ(chan)]);
2208 
2209         txRxAttenLocal = IS_CHAN_2GHZ(chan) ? 23 : 44;
2210 
2211         (void) ath9k_hw_get_eeprom_antenna_cfg(ah, chan, 0, &ant_config);
2212         REG_WRITE(ah, AR_PHY_SWITCH_COM, ant_config);
2213 
2214         for (i = 0; i < AR5416_MAX_CHAINS; i++) {
2215                 if (AR_SREV_9280(ah)) {
2216                         if (i >= 2)
2217                                 break;
2218                 }
2219 
2220                 if (AR_SREV_5416_V20_OR_LATER(ah) &&
2221                     (ahp->ah_rxchainmask == 5 || ahp->ah_txchainmask == 5) &&
2222                     (i != 0))
2223                         regChainOffset = (i == 1) ? 0x2000 : 0x1000;
2224                 else
2225                         regChainOffset = i * 0x1000;
2226 
2227                 REG_WRITE(ah, AR_PHY_SWITCH_CHAIN_0 + regChainOffset,
2228                     pModal->antCtrlChain[i]);
2229 
2230                 REG_WRITE(ah, AR_PHY_TIMING_CTRL4(0) + regChainOffset,
2231                     (REG_READ(ah, AR_PHY_TIMING_CTRL4(0) + regChainOffset) &
2232                     ~(AR_PHY_TIMING_CTRL4_IQCORR_Q_Q_COFF |
2233                     AR_PHY_TIMING_CTRL4_IQCORR_Q_I_COFF)) |
2234                     SM(pModal->iqCalICh[i],
2235                     AR_PHY_TIMING_CTRL4_IQCORR_Q_I_COFF) |
2236                     SM(pModal->iqCalQCh[i],
2237                     AR_PHY_TIMING_CTRL4_IQCORR_Q_Q_COFF));
2238 
2239                 if ((i == 0) || AR_SREV_5416_V20_OR_LATER(ah)) {
2240                         if ((eep->baseEepHeader.version &
2241                             AR5416_EEP_VER_MINOR_MASK) >=
2242                             AR5416_EEP_MINOR_VER_3) {
2243                                 txRxAttenLocal = pModal->txRxAttenCh[i];
2244                                 if (AR_SREV_9280_10_OR_LATER(ah)) {
2245                                         REG_RMW_FIELD(ah,
2246                                             AR_PHY_GAIN_2GHZ +
2247                                             regChainOffset,
2248                                             AR_PHY_GAIN_2GHZ_XATTEN1_MARGIN,
2249                                             pModal->
2250                                             bswMargin[i]);
2251                                         REG_RMW_FIELD(ah,
2252                                             AR_PHY_GAIN_2GHZ +
2253                                             regChainOffset,
2254                                             AR_PHY_GAIN_2GHZ_XATTEN1_DB,
2255                                             pModal->
2256                                             bswAtten[i]);
2257                                         REG_RMW_FIELD(ah,
2258                                             AR_PHY_GAIN_2GHZ +
2259                                             regChainOffset,
2260                                             AR_PHY_GAIN_2GHZ_XATTEN2_MARGIN,
2261                                             pModal->
2262                                             xatten2Margin[i]);
2263                                         REG_RMW_FIELD(ah,
2264                                             AR_PHY_GAIN_2GHZ +
2265                                             regChainOffset,
2266                                             AR_PHY_GAIN_2GHZ_XATTEN2_DB,
2267                                             pModal->
2268                                             xatten2Db[i]);
2269                                 } else {
2270                                         REG_WRITE(ah,
2271                                             AR_PHY_GAIN_2GHZ +
2272                                             regChainOffset,
2273                                             (REG_READ(ah,
2274                                             AR_PHY_GAIN_2GHZ +
2275                                             regChainOffset) &
2276                                             ~AR_PHY_GAIN_2GHZ_BSW_MARGIN)
2277                                             | SM(pModal->
2278                                             bswMargin[i],
2279                                             AR_PHY_GAIN_2GHZ_BSW_MARGIN));
2280                                         REG_WRITE(ah,
2281                                             AR_PHY_GAIN_2GHZ +
2282                                             regChainOffset,
2283                                             (REG_READ(ah,
2284                                             AR_PHY_GAIN_2GHZ +
2285                                             regChainOffset) &
2286                                             ~AR_PHY_GAIN_2GHZ_BSW_ATTEN)
2287                                             | SM(pModal->bswAtten[i],
2288                                             AR_PHY_GAIN_2GHZ_BSW_ATTEN));
2289                                 }
2290                         }
2291                         if (AR_SREV_9280_10_OR_LATER(ah)) {
2292                                 REG_RMW_FIELD(ah,
2293                                     AR_PHY_RXGAIN +
2294                                     regChainOffset,
2295                                     AR9280_PHY_RXGAIN_TXRX_ATTEN,
2296                                     txRxAttenLocal);
2297                                 REG_RMW_FIELD(ah,
2298                                     AR_PHY_RXGAIN +
2299                                     regChainOffset,
2300                                     AR9280_PHY_RXGAIN_TXRX_MARGIN,
2301                                     pModal->rxTxMarginCh[i]);
2302                         } else {
2303                                 REG_WRITE(ah,
2304                                     AR_PHY_RXGAIN + regChainOffset,
2305                                     (REG_READ(ah,
2306                                     AR_PHY_RXGAIN +
2307                                     regChainOffset) &
2308                                     ~AR_PHY_RXGAIN_TXRX_ATTEN) |
2309                                     SM(txRxAttenLocal,
2310                                     AR_PHY_RXGAIN_TXRX_ATTEN));
2311                                 REG_WRITE(ah,
2312                                     AR_PHY_GAIN_2GHZ +
2313                                     regChainOffset,
2314                                     (REG_READ(ah,
2315                                     AR_PHY_GAIN_2GHZ +
2316                                     regChainOffset) &
2317                                     ~AR_PHY_GAIN_2GHZ_RXTX_MARGIN) |
2318                                     SM(pModal->rxTxMarginCh[i],
2319                                     AR_PHY_GAIN_2GHZ_RXTX_MARGIN));
2320                         }
2321                 }
2322         }
2323 
2324         if (AR_SREV_9280_10_OR_LATER(ah)) {
2325                 if (IS_CHAN_2GHZ(chan)) {
2326                         ath9k_hw_analog_shift_rmw(ah, AR_AN_RF2G1_CH0,
2327                             AR_AN_RF2G1_CH0_OB,
2328                             AR_AN_RF2G1_CH0_OB_S,
2329                             pModal->ob);
2330                         ath9k_hw_analog_shift_rmw(ah, AR_AN_RF2G1_CH0,
2331                             AR_AN_RF2G1_CH0_DB,
2332                             AR_AN_RF2G1_CH0_DB_S,
2333                             pModal->db);
2334                         ath9k_hw_analog_shift_rmw(ah, AR_AN_RF2G1_CH1,
2335                             AR_AN_RF2G1_CH1_OB,
2336                             AR_AN_RF2G1_CH1_OB_S,
2337                             pModal->ob_ch1);
2338                         ath9k_hw_analog_shift_rmw(ah, AR_AN_RF2G1_CH1,
2339                             AR_AN_RF2G1_CH1_DB,
2340                             AR_AN_RF2G1_CH1_DB_S,
2341                             pModal->db_ch1);
2342                 } else {
2343                         ath9k_hw_analog_shift_rmw(ah, AR_AN_RF5G1_CH0,
2344                             AR_AN_RF5G1_CH0_OB5,
2345                             AR_AN_RF5G1_CH0_OB5_S,
2346                             pModal->ob);
2347                         ath9k_hw_analog_shift_rmw(ah, AR_AN_RF5G1_CH0,
2348                             AR_AN_RF5G1_CH0_DB5,
2349                             AR_AN_RF5G1_CH0_DB5_S,
2350                             pModal->db);
2351                         ath9k_hw_analog_shift_rmw(ah, AR_AN_RF5G1_CH1,
2352                             AR_AN_RF5G1_CH1_OB5,
2353                             AR_AN_RF5G1_CH1_OB5_S,
2354                             pModal->ob_ch1);
2355                         ath9k_hw_analog_shift_rmw(ah, AR_AN_RF5G1_CH1,
2356                             AR_AN_RF5G1_CH1_DB5,
2357                             AR_AN_RF5G1_CH1_DB5_S,
2358                             pModal->db_ch1);
2359                 }
2360                 ath9k_hw_analog_shift_rmw(ah, AR_AN_TOP2,
2361                     AR_AN_TOP2_XPABIAS_LVL,
2362                     AR_AN_TOP2_XPABIAS_LVL_S,
2363                     pModal->xpaBiasLvl);
2364                 ath9k_hw_analog_shift_rmw(ah, AR_AN_TOP2,
2365                     AR_AN_TOP2_LOCALBIAS,
2366                     AR_AN_TOP2_LOCALBIAS_S,
2367                     pModal->local_bias);
2368 
2369                 ARN_DBG((ARN_DBG_EEPROM, "arn: "
2370                     "ForceXPAon: %d\n", pModal->force_xpaon));
2371 
2372                 REG_RMW_FIELD(ah, AR_PHY_XPA_CFG, AR_PHY_FORCE_XPA_CFG,
2373                     pModal->force_xpaon);
2374         }
2375 
2376         REG_RMW_FIELD(ah, AR_PHY_SETTLING, AR_PHY_SETTLING_SWITCH,
2377             pModal->switchSettling);
2378         REG_RMW_FIELD(ah, AR_PHY_DESIRED_SZ, AR_PHY_DESIRED_SZ_ADC,
2379             pModal->adcDesiredSize);
2380 
2381         if (!AR_SREV_9280_10_OR_LATER(ah))
2382                 REG_RMW_FIELD(ah, AR_PHY_DESIRED_SZ,
2383                     AR_PHY_DESIRED_SZ_PGA,
2384                     pModal->pgaDesiredSize);
2385 
2386         REG_WRITE(ah, AR_PHY_RF_CTL4,
2387             SM(pModal->txEndToXpaOff, AR_PHY_RF_CTL4_TX_END_XPAA_OFF) |
2388             SM(pModal->txEndToXpaOff, AR_PHY_RF_CTL4_TX_END_XPAB_OFF) |
2389             SM(pModal->txFrameToXpaOn, AR_PHY_RF_CTL4_FRAME_XPAA_ON) |
2390             SM(pModal->txFrameToXpaOn, AR_PHY_RF_CTL4_FRAME_XPAB_ON));
2391 
2392         REG_RMW_FIELD(ah, AR_PHY_RF_CTL3, AR_PHY_TX_END_TO_A2_RX_ON,
2393             pModal->txEndToRxOn);
2394         if (AR_SREV_9280_10_OR_LATER(ah)) {
2395                 REG_RMW_FIELD(ah, AR_PHY_CCA, AR9280_PHY_CCA_THRESH62,
2396                     pModal->thresh62);
2397                 REG_RMW_FIELD(ah, AR_PHY_EXT_CCA0,
2398                     AR_PHY_EXT_CCA0_THRESH62,
2399                     pModal->thresh62);
2400         } else {
2401                 REG_RMW_FIELD(ah, AR_PHY_CCA, AR_PHY_CCA_THRESH62,
2402                     pModal->thresh62);
2403                 REG_RMW_FIELD(ah, AR_PHY_EXT_CCA,
2404                     AR_PHY_EXT_CCA_THRESH62,
2405                     pModal->thresh62);
2406         }
2407 
2408         if ((eep->baseEepHeader.version & AR5416_EEP_VER_MINOR_MASK) >=
2409             AR5416_EEP_MINOR_VER_2) {
2410                 REG_RMW_FIELD(ah, AR_PHY_RF_CTL2,
2411                     AR_PHY_TX_END_DATA_START,
2412                     pModal->txFrameToDataStart);
2413                 REG_RMW_FIELD(ah, AR_PHY_RF_CTL2, AR_PHY_TX_END_PA_ON,
2414                     pModal->txFrameToPaOn);
2415         }
2416 
2417         if ((eep->baseEepHeader.version & AR5416_EEP_VER_MINOR_MASK) >=
2418             AR5416_EEP_MINOR_VER_3) {
2419                 if (IS_CHAN_HT40(chan))
2420                         REG_RMW_FIELD(ah, AR_PHY_SETTLING,
2421                             AR_PHY_SETTLING_SWITCH,
2422                             pModal->swSettleHt40);
2423         }
2424 
2425         return (B_TRUE);
2426 }
2427 
2428 static boolean_t
2429 ath9k_hw_eeprom_set_4k_board_values(struct ath_hal *ah,
2430     struct ath9k_channel *chan)
2431 {
2432         struct modal_eep_4k_header *pModal;
2433         struct ath_hal_5416 *ahp = AH5416(ah);
2434         struct ar5416_eeprom_4k *eep = &ahp->ah_eeprom.map4k;
2435         int regChainOffset;
2436         uint8_t txRxAttenLocal;
2437         uint16_t ant_config = 0;
2438         uint8_t ob[5], db1[5], db2[5];
2439         uint8_t ant_div_control1, ant_div_control2;
2440         uint32_t regVal;
2441 
2442 
2443         pModal = &eep->modalHeader;
2444 
2445         txRxAttenLocal = 23;
2446 
2447         (void) ath9k_hw_get_eeprom_antenna_cfg(ah, chan, 0, &ant_config);
2448         REG_WRITE(ah, AR_PHY_SWITCH_COM, ant_config);
2449 
2450         regChainOffset = 0;
2451         REG_WRITE(ah, AR_PHY_SWITCH_CHAIN_0 + regChainOffset,
2452             pModal->antCtrlChain[0]);
2453 
2454         REG_WRITE(ah, AR_PHY_TIMING_CTRL4(0) + regChainOffset,
2455             (REG_READ(ah, AR_PHY_TIMING_CTRL4(0) + regChainOffset) &
2456             ~(AR_PHY_TIMING_CTRL4_IQCORR_Q_Q_COFF |
2457             AR_PHY_TIMING_CTRL4_IQCORR_Q_I_COFF)) |
2458             SM(pModal->iqCalICh[0], AR_PHY_TIMING_CTRL4_IQCORR_Q_I_COFF) |
2459             SM(pModal->iqCalQCh[0], AR_PHY_TIMING_CTRL4_IQCORR_Q_Q_COFF));
2460 
2461         if ((eep->baseEepHeader.version & AR5416_EEP_VER_MINOR_MASK) >=
2462             AR5416_EEP_MINOR_VER_3) {
2463                 txRxAttenLocal = pModal->txRxAttenCh[0];
2464                 REG_RMW_FIELD(ah, AR_PHY_GAIN_2GHZ + regChainOffset,
2465                     AR_PHY_GAIN_2GHZ_XATTEN1_MARGIN, pModal->bswMargin[0]);
2466                 REG_RMW_FIELD(ah, AR_PHY_GAIN_2GHZ + regChainOffset,
2467                     AR_PHY_GAIN_2GHZ_XATTEN1_DB, pModal->bswAtten[0]);
2468                 REG_RMW_FIELD(ah, AR_PHY_GAIN_2GHZ + regChainOffset,
2469                     AR_PHY_GAIN_2GHZ_XATTEN2_MARGIN,
2470                     pModal->xatten2Margin[0]);
2471                 REG_RMW_FIELD(ah, AR_PHY_GAIN_2GHZ + regChainOffset,
2472                     AR_PHY_GAIN_2GHZ_XATTEN2_DB, pModal->xatten2Db[0]);
2473         }
2474 
2475         REG_RMW_FIELD(ah, AR_PHY_RXGAIN + regChainOffset,
2476             AR9280_PHY_RXGAIN_TXRX_ATTEN, txRxAttenLocal);
2477         REG_RMW_FIELD(ah, AR_PHY_RXGAIN + regChainOffset,
2478             AR9280_PHY_RXGAIN_TXRX_MARGIN, pModal->rxTxMarginCh[0]);
2479 
2480         if (AR_SREV_9285_11(ah))
2481                 REG_WRITE(ah, AR9285_AN_TOP4, (AR9285_AN_TOP4_DEFAULT | 0x14));
2482 
2483         /* Initialize Ant Diversity settings from EEPROM */
2484         if (pModal->version == 3) {
2485                 ant_div_control1 = ((pModal->ob_234 >> 12) & 0xf);
2486                 ant_div_control2 = ((pModal->db1_234 >> 12) & 0xf);
2487                 regVal = REG_READ(ah, 0x99ac);
2488                 regVal &= (~(0x7f000000));
2489                 regVal |= ((ant_div_control1 & 0x1) << 24);
2490                 regVal |= (((ant_div_control1 >> 1) & 0x1) << 29);
2491                 regVal |= (((ant_div_control1 >> 2) & 0x1) << 30);
2492                 regVal |= ((ant_div_control2 & 0x3) << 25);
2493                 regVal |= (((ant_div_control2 >> 2) & 0x3) << 27);
2494                 REG_WRITE(ah, 0x99ac, regVal);
2495                 regVal = REG_READ(ah, 0x99ac);
2496                 regVal = REG_READ(ah, 0xa208);
2497                 regVal &= (~(0x1 << 13));
2498                 regVal |= (((ant_div_control1 >> 3) & 0x1) << 13);
2499                 REG_WRITE(ah, 0xa208, regVal);
2500                 regVal = REG_READ(ah, 0xa208);
2501         }
2502 
2503         if (pModal->version >= 2) {
2504                 ob[0] = (pModal->ob_01 & 0xf);
2505                 ob[1] = (pModal->ob_01 >> 4) & 0xf;
2506                 ob[2] = (pModal->ob_234 & 0xf);
2507                 ob[3] = ((pModal->ob_234 >> 4) & 0xf);
2508                 ob[4] = ((pModal->ob_234 >> 8) & 0xf);
2509 
2510                 db1[0] = (pModal->db1_01 & 0xf);
2511                 db1[1] = ((pModal->db1_01 >> 4) & 0xf);
2512                 db1[2] = (pModal->db1_234 & 0xf);
2513                 db1[3] = ((pModal->db1_234 >> 4) & 0xf);
2514                 db1[4] = ((pModal->db1_234 >> 8) & 0xf);
2515 
2516                 db2[0] = (pModal->db2_01 & 0xf);
2517                 db2[1] = ((pModal->db2_01 >> 4) & 0xf);
2518                 db2[2] = (pModal->db2_234 & 0xf);
2519                 db2[3] = ((pModal->db2_234 >> 4) & 0xf);
2520                 db2[4] = ((pModal->db2_234 >> 8) & 0xf);
2521 
2522         } else if (pModal->version == 1) {
2523 
2524                 ARN_DBG((ARN_DBG_EEPROM,
2525                     "EEPROM Model version is set to 1 \n"));
2526                 ob[0] = (pModal->ob_01 & 0xf);
2527                 ob[1] = ob[2] = ob[3] = ob[4] = (pModal->ob_01 >> 4) & 0xf;
2528                 db1[0] = (pModal->db1_01 & 0xf);
2529                 db1[1] = db1[2] = db1[3] = db1[4] =
2530                     ((pModal->db1_01 >> 4) & 0xf);
2531                 db2[0] = (pModal->db2_01 & 0xf);
2532                 db2[1] = db2[2] = db2[3] = db2[4] =
2533                     ((pModal->db2_01 >> 4) & 0xf);
2534         } else {
2535                 int i;
2536                 for (i = 0; i < 5; i++) {
2537                         ob[i] = pModal->ob_01;
2538                         db1[i] = pModal->db1_01;
2539                         db2[i] = pModal->db1_01;
2540                 }
2541         }
2542 
2543         ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G3,
2544             AR9285_AN_RF2G3_OB_0, AR9285_AN_RF2G3_OB_0_S, ob[0]);
2545         ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G3,
2546             AR9285_AN_RF2G3_OB_1, AR9285_AN_RF2G3_OB_1_S, ob[1]);
2547         ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G3,
2548             AR9285_AN_RF2G3_OB_2, AR9285_AN_RF2G3_OB_2_S, ob[2]);
2549         ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G3,
2550             AR9285_AN_RF2G3_OB_3, AR9285_AN_RF2G3_OB_3_S, ob[3]);
2551         ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G3,
2552             AR9285_AN_RF2G3_OB_4, AR9285_AN_RF2G3_OB_4_S, ob[4]);
2553 
2554         ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G3,
2555             AR9285_AN_RF2G3_DB1_0, AR9285_AN_RF2G3_DB1_0_S, db1[0]);
2556         ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G3,
2557             AR9285_AN_RF2G3_DB1_1, AR9285_AN_RF2G3_DB1_1_S, db1[1]);
2558         ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G3,
2559             AR9285_AN_RF2G3_DB1_2, AR9285_AN_RF2G3_DB1_2_S, db1[2]);
2560         ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G4,
2561             AR9285_AN_RF2G4_DB1_3, AR9285_AN_RF2G4_DB1_3_S, db1[3]);
2562         ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G4,
2563             AR9285_AN_RF2G4_DB1_4, AR9285_AN_RF2G4_DB1_4_S, db1[4]);
2564 
2565         ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G4,
2566             AR9285_AN_RF2G4_DB2_0, AR9285_AN_RF2G4_DB2_0_S, db2[0]);
2567         ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G4,
2568             AR9285_AN_RF2G4_DB2_1, AR9285_AN_RF2G4_DB2_1_S, db2[1]);
2569         ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G4,
2570             AR9285_AN_RF2G4_DB2_2, AR9285_AN_RF2G4_DB2_2_S, db2[2]);
2571         ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G4,
2572             AR9285_AN_RF2G4_DB2_3, AR9285_AN_RF2G4_DB2_3_S, db2[3]);
2573         ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G4,
2574             AR9285_AN_RF2G4_DB2_4, AR9285_AN_RF2G4_DB2_4_S, db2[4]);
2575 
2576 
2577         if (AR_SREV_9285_11(ah))
2578                 REG_WRITE(ah, AR9285_AN_TOP4, AR9285_AN_TOP4_DEFAULT);
2579 
2580         REG_RMW_FIELD(ah, AR_PHY_SETTLING, AR_PHY_SETTLING_SWITCH,
2581             pModal->switchSettling);
2582         REG_RMW_FIELD(ah, AR_PHY_DESIRED_SZ, AR_PHY_DESIRED_SZ_ADC,
2583             pModal->adcDesiredSize);
2584 
2585         REG_WRITE(ah, AR_PHY_RF_CTL4,
2586             SM(pModal->txEndToXpaOff, AR_PHY_RF_CTL4_TX_END_XPAA_OFF) |
2587             SM(pModal->txEndToXpaOff, AR_PHY_RF_CTL4_TX_END_XPAB_OFF) |
2588             SM(pModal->txFrameToXpaOn, AR_PHY_RF_CTL4_FRAME_XPAA_ON)  |
2589             SM(pModal->txFrameToXpaOn, AR_PHY_RF_CTL4_FRAME_XPAB_ON));
2590 
2591         REG_RMW_FIELD(ah, AR_PHY_RF_CTL3, AR_PHY_TX_END_TO_A2_RX_ON,
2592             pModal->txEndToRxOn);
2593         REG_RMW_FIELD(ah, AR_PHY_CCA, AR9280_PHY_CCA_THRESH62,
2594             pModal->thresh62);
2595         REG_RMW_FIELD(ah, AR_PHY_EXT_CCA0, AR_PHY_EXT_CCA0_THRESH62,
2596             pModal->thresh62);
2597 
2598         if ((eep->baseEepHeader.version & AR5416_EEP_VER_MINOR_MASK) >=
2599             AR5416_EEP_MINOR_VER_2) {
2600                 REG_RMW_FIELD(ah, AR_PHY_RF_CTL2, AR_PHY_TX_END_DATA_START,
2601                     pModal->txFrameToDataStart);
2602                 REG_RMW_FIELD(ah, AR_PHY_RF_CTL2, AR_PHY_TX_END_PA_ON,
2603                     pModal->txFrameToPaOn);
2604         }
2605 
2606         if ((eep->baseEepHeader.version & AR5416_EEP_VER_MINOR_MASK) >=
2607             AR5416_EEP_MINOR_VER_3) {
2608                 if (IS_CHAN_HT40(chan))
2609                         REG_RMW_FIELD(ah, AR_PHY_SETTLING,
2610                             AR_PHY_SETTLING_SWITCH, pModal->swSettleHt40);
2611         }
2612 
2613         return (B_TRUE);
2614 }
2615 
2616 boolean_t
2617 ath9k_hw_eeprom_set_board_values(struct ath_hal *ah, struct ath9k_channel *chan)
2618 {
2619         struct ath_hal_5416 *ahp = AH5416(ah);
2620         boolean_t val;
2621 
2622         if (ahp->ah_eep_map == EEP_MAP_DEFAULT)
2623                 val = ath9k_hw_eeprom_set_def_board_values(ah, chan);
2624         else if (ahp->ah_eep_map == EEP_MAP_4KBITS)
2625                 val = ath9k_hw_eeprom_set_4k_board_values(ah, chan);
2626 
2627         return (val);
2628 }
2629 
2630 static int
2631 ath9k_hw_get_def_eeprom_antenna_cfg(struct ath_hal *ah,
2632     struct ath9k_channel *chan,
2633     uint8_t index, uint16_t *config)
2634 {
2635         struct ath_hal_5416 *ahp = AH5416(ah);
2636         struct ar5416_eeprom_def *eep = &ahp->ah_eeprom.def;
2637         struct modal_eep_header *pModal =
2638             &(eep->modalHeader[IS_CHAN_2GHZ(chan)]);
2639         struct base_eep_header *pBase = &eep->baseEepHeader;
2640 
2641         switch (index) {
2642         case 0:
2643                 *config = pModal->antCtrlCommon & 0xFFFF;
2644                 return (0);
2645         case 1:
2646                 if (pBase->version >= 0x0E0D) {
2647                         if (pModal->useAnt1) {
2648                                 *config =
2649                                     ((pModal->antCtrlCommon & 0xFFFF0000)
2650                                     >> 16);
2651                                 return (0);
2652                         }
2653                 }
2654                 break;
2655         default:
2656                 break;
2657         }
2658 
2659         return (-EINVAL);
2660 }
2661 
2662 /* ARGSUSED */
2663 static int
2664 ath9k_hw_get_4k_eeprom_antenna_cfg(struct ath_hal *ah,
2665     struct ath9k_channel *chan,
2666     uint8_t index, uint16_t *config)
2667 {
2668         struct ath_hal_5416 *ahp = AH5416(ah);
2669         struct ar5416_eeprom_4k *eep = &ahp->ah_eeprom.map4k;
2670         struct modal_eep_4k_header *pModal = &eep->modalHeader;
2671 
2672         switch (index) {
2673         case 0:
2674                 *config = pModal->antCtrlCommon & 0xFFFF;
2675                 return (0);
2676         default:
2677                 break;
2678         }
2679 
2680         return (EINVAL);
2681 }
2682 
2683 int
2684 ath9k_hw_get_eeprom_antenna_cfg(struct ath_hal *ah,
2685     struct ath9k_channel *chan,
2686     uint8_t index, uint16_t *config)
2687 {
2688         struct ath_hal_5416 *ahp = AH5416(ah);
2689         int val;
2690 
2691         if (ahp->ah_eep_map == EEP_MAP_DEFAULT)
2692                 val = ath9k_hw_get_def_eeprom_antenna_cfg(ah, chan,
2693                     index, config);
2694         else if (ahp->ah_eep_map == EEP_MAP_4KBITS)
2695                 val = ath9k_hw_get_4k_eeprom_antenna_cfg(ah, chan,
2696                     index, config);
2697 
2698         return (val);
2699 }
2700 
2701 /* ARGSUSED */
2702 static uint8_t
2703 ath9k_hw_get_4k_num_ant_config(struct ath_hal *ah,
2704     enum ath9k_band freq_band)
2705 {
2706         return (1);
2707 }
2708 
2709 static uint8_t
2710 ath9k_hw_get_def_num_ant_config(struct ath_hal *ah,
2711     enum ath9k_band freq_band)
2712 {
2713         struct ath_hal_5416 *ahp = AH5416(ah);
2714         struct ar5416_eeprom_def *eep = &ahp->ah_eeprom.def;
2715 
2716         struct modal_eep_header *pModal =
2717             &(eep->modalHeader[ATH9K_BAND_5GHZ == freq_band]);
2718         struct base_eep_header *pBase = &eep->baseEepHeader;
2719         uint8_t num_ant_config;
2720 
2721         num_ant_config = 1;
2722 
2723         if (pBase->version >= 0x0E0D)
2724                 if (pModal->useAnt1)
2725                         num_ant_config += 1;
2726 
2727         return (num_ant_config);
2728 }
2729 
2730 uint8_t
2731 ath9k_hw_get_num_ant_config(struct ath_hal *ah,
2732     enum ath9k_band freq_band)
2733 {
2734         struct ath_hal_5416 *ahp = AH5416(ah);
2735         uint8_t val;
2736 
2737         if (ahp->ah_eep_map == EEP_MAP_DEFAULT)
2738                 val = ath9k_hw_get_def_num_ant_config(ah, freq_band);
2739         else if (ahp->ah_eep_map == EEP_MAP_4KBITS)
2740                 val = ath9k_hw_get_4k_num_ant_config(ah, freq_band);
2741 
2742         return (val);
2743 }
2744 
2745 uint16_t
2746 ath9k_hw_eeprom_get_spur_chan(struct ath_hal *ah, uint16_t i, boolean_t is2GHz)
2747 {
2748 #define EEP_MAP4K_SPURCHAN \
2749         (ahp->ah_eeprom.map4k.modalHeader.spurChans[i].spurChan)
2750 #define EEP_DEF_SPURCHAN \
2751         (ahp->ah_eeprom.def.modalHeader[is2GHz].spurChans[i].spurChan)
2752 
2753         struct ath_hal_5416 *ahp = AH5416(ah);
2754         uint16_t spur_val = AR_NO_SPUR;
2755 
2756         ARN_DBG((ARN_DBG_ANI, "arn: "
2757             "Getting spur idx %d is2Ghz. %d val %x\n",
2758             i, is2GHz, ah->ah_config.spurchans[i][is2GHz]));
2759 
2760         switch (ah->ah_config.spurmode) {
2761         case SPUR_DISABLE:
2762                 break;
2763         case SPUR_ENABLE_IOCTL:
2764                 spur_val = ah->ah_config.spurchans[i][is2GHz];
2765                 ARN_DBG((ARN_DBG_ANI, "arn: "
2766                     "Getting spur val from new loc. %d\n", spur_val));
2767                 break;
2768         case SPUR_ENABLE_EEPROM:
2769                 if (ahp->ah_eep_map == EEP_MAP_4KBITS)
2770                         spur_val = EEP_MAP4K_SPURCHAN;
2771                 else
2772                         spur_val = EEP_DEF_SPURCHAN;
2773                 break;
2774 
2775         }
2776 
2777         return (spur_val);
2778 #undef EEP_DEF_SPURCHAN
2779 #undef EEP_MAP4K_SPURCHAN
2780 }
2781 
2782 static uint32_t
2783 ath9k_hw_get_eeprom_4k(struct ath_hal *ah,
2784     enum eeprom_param param)
2785 {
2786         struct ath_hal_5416 *ahp = AH5416(ah);
2787         struct ar5416_eeprom_4k *eep = &ahp->ah_eeprom.map4k;
2788         struct modal_eep_4k_header *pModal = &eep->modalHeader;
2789         struct base_eep_header_4k *pBase = &eep->baseEepHeader;
2790 
2791         switch (param) {
2792         case EEP_NFTHRESH_2:
2793                 return (pModal[1].noiseFloorThreshCh[0]);
2794         case AR_EEPROM_MAC(0):
2795                 return (pBase->macAddr[0] << 8 | pBase->macAddr[1]);
2796         case AR_EEPROM_MAC(1):
2797                 return (pBase->macAddr[2] << 8 | pBase->macAddr[3]);
2798         case AR_EEPROM_MAC(2):
2799                 return (pBase->macAddr[4] << 8 | pBase->macAddr[5]);
2800         case EEP_REG_0:
2801                 return (pBase->regDmn[0]);
2802         case EEP_REG_1:
2803                 return (pBase->regDmn[1]);
2804         case EEP_OP_CAP:
2805                 return (pBase->deviceCap);
2806         case EEP_OP_MODE:
2807                 return (pBase->opCapFlags);
2808         case EEP_RF_SILENT:
2809                 return (pBase->rfSilent);
2810         case EEP_OB_2:
2811                 return (pModal->ob_01);
2812         case EEP_DB_2:
2813                 return (pModal->db1_01);
2814         case EEP_MINOR_REV:
2815                 return (pBase->version & AR5416_EEP_VER_MINOR_MASK);
2816         case EEP_TX_MASK:
2817                 return (pBase->txMask);
2818         case EEP_RX_MASK:
2819                 return (pBase->rxMask);
2820         /* 2.6.30 */
2821         case EEP_FRAC_N_5G:
2822                 return (0);
2823         default:
2824                 return (0);
2825         }
2826 }
2827 
2828 uint32_t
2829 ath9k_hw_get_eeprom_def(struct ath_hal *ah, enum eeprom_param param)
2830 {
2831         struct ath_hal_5416     *ahp = AH5416(ah);
2832         struct ar5416_eeprom_def *eep = &ahp->ah_eeprom.def;
2833         struct modal_eep_header *pModal = eep->modalHeader;
2834         struct base_eep_header  *pBase = &eep->baseEepHeader;
2835 
2836         switch (param) {
2837         case EEP_NFTHRESH_5:
2838                 return (pModal[0].noiseFloorThreshCh[0]);
2839         case EEP_NFTHRESH_2:
2840                 return (pModal[1].noiseFloorThreshCh[0]);
2841         case AR_EEPROM_MAC(0):
2842                 return (pBase->macAddr[0] << 8 | pBase->macAddr[1]);
2843         case AR_EEPROM_MAC(1):
2844                 return (pBase->macAddr[2] << 8 | pBase->macAddr[3]);
2845         case AR_EEPROM_MAC(2):
2846                 return (pBase->macAddr[4] << 8 | pBase->macAddr[5]);
2847         case EEP_REG_0:
2848                 return (pBase->regDmn[0]);
2849         case EEP_REG_1:
2850                 return (pBase->regDmn[1]);
2851         case EEP_OP_CAP:
2852                 return (pBase->deviceCap);
2853         case EEP_OP_MODE:
2854                 return (pBase->opCapFlags);
2855         case EEP_RF_SILENT:
2856                 return (pBase->rfSilent);
2857         case EEP_OB_5:
2858                 return (pModal[0].ob);
2859         case EEP_DB_5:
2860                 return (pModal[0].db);
2861         case EEP_OB_2:
2862                 return (pModal[1].ob);
2863         case EEP_DB_2:
2864                 return (pModal[1].db);
2865         case EEP_MINOR_REV:
2866                 return (pBase->version & AR5416_EEP_VER_MINOR_MASK);
2867         case EEP_TX_MASK:
2868                 return (pBase->txMask);
2869         case EEP_RX_MASK:
2870                 return (pBase->rxMask);
2871         case EEP_RXGAIN_TYPE:
2872                 return (pBase->rxGainType);
2873         case EEP_TXGAIN_TYPE:
2874                 return (pBase->txGainType);
2875         /* 2.6.30 */
2876         case EEP_OL_PWRCTRL:
2877                 if (AR5416_VER_MASK >= AR5416_EEP_MINOR_VER_19)
2878                         return (pBase->openLoopPwrCntl ? B_TRUE: B_FALSE);
2879                 else
2880                         return (B_FALSE);
2881         case EEP_RC_CHAIN_MASK:
2882                 if (AR5416_VER_MASK >= AR5416_EEP_MINOR_VER_19)
2883                         return (pBase->rcChainMask);
2884                 else
2885                         return (0);
2886         case EEP_DAC_HPWR_5G:
2887                 if (AR5416_VER_MASK >= AR5416_EEP_MINOR_VER_20)
2888                         return (pBase->dacHiPwrMode_5G);
2889                 else
2890                         return (0);
2891         case EEP_FRAC_N_5G:
2892                 if (AR5416_VER_MASK >= AR5416_EEP_MINOR_VER_22)
2893                         return (pBase->frac_n_5g);
2894                 else
2895                         return (0);
2896 
2897         default:
2898                 return (0);
2899         }
2900 }
2901 
2902 uint32_t
2903 ath9k_hw_get_eeprom(struct ath_hal *ah, enum eeprom_param param)
2904 {
2905         struct ath_hal_5416 *ahp = AH5416(ah);
2906         uint32_t val;
2907 
2908         if (ahp->ah_eep_map == EEP_MAP_DEFAULT)
2909                 val = ath9k_hw_get_eeprom_def(ah, param);
2910         else if (ahp->ah_eep_map == EEP_MAP_4KBITS)
2911                 val = ath9k_hw_get_eeprom_4k(ah, param);
2912 
2913         return (val);
2914 }
2915 
2916 int
2917 ath9k_hw_eeprom_attach(struct ath_hal *ah)
2918 {
2919         int status;
2920         struct ath_hal_5416 *ahp = AH5416(ah);
2921 
2922         if (ath9k_hw_use_flash(ah))
2923                 (void) ath9k_hw_flash_map(ah);
2924 
2925         if (AR_SREV_9285(ah))
2926                 ahp->ah_eep_map = EEP_MAP_4KBITS;
2927         else
2928                 ahp->ah_eep_map = EEP_MAP_DEFAULT;
2929 
2930         if (!ath9k_hw_fill_eeprom(ah))
2931                 return (EIO);
2932 
2933         status = ath9k_hw_check_eeprom(ah);
2934 
2935         return (status);
2936 }