2 * Copyright (c) 2008 Atheros Communications Inc.
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19 static void ath9k_hw_analog_shift_rmw(struct ath_hw *ah,
25 regVal = REG_READ(ah, reg) & ~mask;
26 regVal |= (val << shift) & mask;
28 REG_WRITE(ah, reg, regVal);
30 if (ah->config.analog_shiftreg)
36 static inline u16 ath9k_hw_fbin2freq(u8 fbin, bool is2GHz)
39 if (fbin == AR5416_BCHAN_UNUSED)
42 return (u16) ((is2GHz) ? (2300 + fbin) : (4800 + 5 * fbin));
45 static inline int16_t ath9k_hw_interpolate(u16 target,
46 u16 srcLeft, u16 srcRight,
52 if (srcRight == srcLeft) {
55 rv = (int16_t) (((target - srcLeft) * targetRight +
56 (srcRight - target) * targetLeft) /
57 (srcRight - srcLeft));
62 static inline bool ath9k_hw_get_lower_upper_index(u8 target, u8 *pList,
63 u16 listSize, u16 *indexL,
68 if (target <= pList[0]) {
69 *indexL = *indexR = 0;
72 if (target >= pList[listSize - 1]) {
73 *indexL = *indexR = (u16) (listSize - 1);
77 for (i = 0; i < listSize - 1; i++) {
78 if (pList[i] == target) {
79 *indexL = *indexR = i;
82 if (target < pList[i + 1]) {
84 *indexR = (u16) (i + 1);
91 static inline bool ath9k_hw_nvram_read(struct ath_hw *ah, u32 off, u16 *data)
93 struct ath_softc *sc = ah->ah_sc;
95 return sc->bus_ops->eeprom_read(ah, off, data);
98 static inline bool ath9k_hw_fill_vpd_table(u8 pwrMin, u8 pwrMax, u8 *pPwrList,
99 u8 *pVpdList, u16 numIntercepts,
104 u16 idxL = 0, idxR = 0;
106 for (i = 0; i <= (pwrMax - pwrMin) / 2; i++) {
107 ath9k_hw_get_lower_upper_index(currPwr, pPwrList,
108 numIntercepts, &(idxL),
112 if (idxL == numIntercepts - 1)
113 idxL = (u16) (numIntercepts - 2);
114 if (pPwrList[idxL] == pPwrList[idxR])
117 k = (u16)(((currPwr - pPwrList[idxL]) * pVpdList[idxR] +
118 (pPwrList[idxR] - currPwr) * pVpdList[idxL]) /
119 (pPwrList[idxR] - pPwrList[idxL]));
120 pRetVpdList[i] = (u8) k;
127 static void ath9k_hw_get_legacy_target_powers(struct ath_hw *ah,
128 struct ath9k_channel *chan,
129 struct cal_target_power_leg *powInfo,
131 struct cal_target_power_leg *pNewPower,
132 u16 numRates, bool isExtTarget)
134 struct chan_centers centers;
137 int matchIndex = -1, lowIndex = -1;
140 ath9k_hw_get_channel_centers(ah, chan, ¢ers);
141 freq = (isExtTarget) ? centers.ext_center : centers.ctl_center;
143 if (freq <= ath9k_hw_fbin2freq(powInfo[0].bChannel,
144 IS_CHAN_2GHZ(chan))) {
147 for (i = 0; (i < numChannels) &&
148 (powInfo[i].bChannel != AR5416_BCHAN_UNUSED); i++) {
149 if (freq == ath9k_hw_fbin2freq(powInfo[i].bChannel,
150 IS_CHAN_2GHZ(chan))) {
153 } else if ((freq < ath9k_hw_fbin2freq(powInfo[i].bChannel,
154 IS_CHAN_2GHZ(chan))) &&
155 (freq > ath9k_hw_fbin2freq(powInfo[i - 1].bChannel,
156 IS_CHAN_2GHZ(chan)))) {
161 if ((matchIndex == -1) && (lowIndex == -1))
165 if (matchIndex != -1) {
166 *pNewPower = powInfo[matchIndex];
168 clo = ath9k_hw_fbin2freq(powInfo[lowIndex].bChannel,
170 chi = ath9k_hw_fbin2freq(powInfo[lowIndex + 1].bChannel,
173 for (i = 0; i < numRates; i++) {
174 pNewPower->tPow2x[i] =
175 (u8)ath9k_hw_interpolate(freq, clo, chi,
176 powInfo[lowIndex].tPow2x[i],
177 powInfo[lowIndex + 1].tPow2x[i]);
182 static void ath9k_hw_get_target_powers(struct ath_hw *ah,
183 struct ath9k_channel *chan,
184 struct cal_target_power_ht *powInfo,
186 struct cal_target_power_ht *pNewPower,
187 u16 numRates, bool isHt40Target)
189 struct chan_centers centers;
192 int matchIndex = -1, lowIndex = -1;
195 ath9k_hw_get_channel_centers(ah, chan, ¢ers);
196 freq = isHt40Target ? centers.synth_center : centers.ctl_center;
198 if (freq <= ath9k_hw_fbin2freq(powInfo[0].bChannel, IS_CHAN_2GHZ(chan))) {
201 for (i = 0; (i < numChannels) &&
202 (powInfo[i].bChannel != AR5416_BCHAN_UNUSED); i++) {
203 if (freq == ath9k_hw_fbin2freq(powInfo[i].bChannel,
204 IS_CHAN_2GHZ(chan))) {
208 if ((freq < ath9k_hw_fbin2freq(powInfo[i].bChannel,
209 IS_CHAN_2GHZ(chan))) &&
210 (freq > ath9k_hw_fbin2freq(powInfo[i - 1].bChannel,
211 IS_CHAN_2GHZ(chan)))) {
216 if ((matchIndex == -1) && (lowIndex == -1))
220 if (matchIndex != -1) {
221 *pNewPower = powInfo[matchIndex];
223 clo = ath9k_hw_fbin2freq(powInfo[lowIndex].bChannel,
225 chi = ath9k_hw_fbin2freq(powInfo[lowIndex + 1].bChannel,
228 for (i = 0; i < numRates; i++) {
229 pNewPower->tPow2x[i] = (u8)ath9k_hw_interpolate(freq,
231 powInfo[lowIndex].tPow2x[i],
232 powInfo[lowIndex + 1].tPow2x[i]);
237 static u16 ath9k_hw_get_max_edge_power(u16 freq,
238 struct cal_ctl_edges *pRdEdgesPower,
239 bool is2GHz, int num_band_edges)
241 u16 twiceMaxEdgePower = AR5416_MAX_RATE_POWER;
244 for (i = 0; (i < num_band_edges) &&
245 (pRdEdgesPower[i].bChannel != AR5416_BCHAN_UNUSED); i++) {
246 if (freq == ath9k_hw_fbin2freq(pRdEdgesPower[i].bChannel, is2GHz)) {
247 twiceMaxEdgePower = pRdEdgesPower[i].tPower;
249 } else if ((i > 0) &&
250 (freq < ath9k_hw_fbin2freq(pRdEdgesPower[i].bChannel,
252 if (ath9k_hw_fbin2freq(pRdEdgesPower[i - 1].bChannel,
254 pRdEdgesPower[i - 1].flag) {
256 pRdEdgesPower[i - 1].tPower;
262 return twiceMaxEdgePower;
265 /****************************************/
266 /* EEPROM Operations for 4K sized cards */
267 /****************************************/
269 static int ath9k_hw_4k_get_eeprom_ver(struct ath_hw *ah)
271 return ((ah->eeprom.map4k.baseEepHeader.version >> 12) & 0xF);
274 static int ath9k_hw_4k_get_eeprom_rev(struct ath_hw *ah)
276 return ((ah->eeprom.map4k.baseEepHeader.version) & 0xFFF);
279 static bool ath9k_hw_4k_fill_eeprom(struct ath_hw *ah)
281 #define SIZE_EEPROM_4K (sizeof(struct ar5416_eeprom_4k) / sizeof(u16))
282 struct ar5416_eeprom_4k *eep = &ah->eeprom.map4k;
284 int addr, eep_start_loc = 0;
288 if (!ath9k_hw_use_flash(ah)) {
289 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
290 "Reading from EEPROM, not flash\n");
293 eep_data = (u16 *)eep;
295 for (addr = 0; addr < SIZE_EEPROM_4K; addr++) {
296 if (!ath9k_hw_nvram_read(ah, addr + eep_start_loc, eep_data)) {
297 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
298 "Unable to read eeprom region \n");
304 #undef SIZE_EEPROM_4K
307 static int ath9k_hw_4k_check_eeprom(struct ath_hw *ah)
309 #define EEPROM_4K_SIZE (sizeof(struct ar5416_eeprom_4k) / sizeof(u16))
310 struct ar5416_eeprom_4k *eep =
311 (struct ar5416_eeprom_4k *) &ah->eeprom.map4k;
312 u16 *eepdata, temp, magic, magic2;
314 bool need_swap = false;
318 if (!ath9k_hw_use_flash(ah)) {
320 if (!ath9k_hw_nvram_read(ah, AR5416_EEPROM_MAGIC_OFFSET,
322 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
323 "Reading Magic # failed\n");
327 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
328 "Read Magic = 0x%04X\n", magic);
330 if (magic != AR5416_EEPROM_MAGIC) {
331 magic2 = swab16(magic);
333 if (magic2 == AR5416_EEPROM_MAGIC) {
335 eepdata = (u16 *) (&ah->eeprom);
337 for (addr = 0; addr < EEPROM_4K_SIZE; addr++) {
338 temp = swab16(*eepdata);
342 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
343 "0x%04X ", *eepdata);
345 if (((addr + 1) % 6) == 0)
347 ATH_DBG_EEPROM, "\n");
350 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
351 "Invalid EEPROM Magic. "
352 "endianness mismatch.\n");
358 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM, "need_swap = %s.\n",
359 need_swap ? "True" : "False");
362 el = swab16(ah->eeprom.map4k.baseEepHeader.length);
364 el = ah->eeprom.map4k.baseEepHeader.length;
366 if (el > sizeof(struct ar5416_eeprom_def))
367 el = sizeof(struct ar5416_eeprom_4k) / sizeof(u16);
369 el = el / sizeof(u16);
371 eepdata = (u16 *)(&ah->eeprom);
373 for (i = 0; i < el; i++)
380 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
381 "EEPROM Endianness is not native.. Changing \n");
383 word = swab16(eep->baseEepHeader.length);
384 eep->baseEepHeader.length = word;
386 word = swab16(eep->baseEepHeader.checksum);
387 eep->baseEepHeader.checksum = word;
389 word = swab16(eep->baseEepHeader.version);
390 eep->baseEepHeader.version = word;
392 word = swab16(eep->baseEepHeader.regDmn[0]);
393 eep->baseEepHeader.regDmn[0] = word;
395 word = swab16(eep->baseEepHeader.regDmn[1]);
396 eep->baseEepHeader.regDmn[1] = word;
398 word = swab16(eep->baseEepHeader.rfSilent);
399 eep->baseEepHeader.rfSilent = word;
401 word = swab16(eep->baseEepHeader.blueToothOptions);
402 eep->baseEepHeader.blueToothOptions = word;
404 word = swab16(eep->baseEepHeader.deviceCap);
405 eep->baseEepHeader.deviceCap = word;
407 integer = swab32(eep->modalHeader.antCtrlCommon);
408 eep->modalHeader.antCtrlCommon = integer;
410 for (i = 0; i < AR5416_MAX_CHAINS; i++) {
411 integer = swab32(eep->modalHeader.antCtrlChain[i]);
412 eep->modalHeader.antCtrlChain[i] = integer;
415 for (i = 0; i < AR5416_EEPROM_MODAL_SPURS; i++) {
416 word = swab16(eep->modalHeader.spurChans[i].spurChan);
417 eep->modalHeader.spurChans[i].spurChan = word;
421 if (sum != 0xffff || ah->eep_ops->get_eeprom_ver(ah) != AR5416_EEP_VER ||
422 ah->eep_ops->get_eeprom_rev(ah) < AR5416_EEP_NO_BACK_VER) {
423 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
424 "Bad EEPROM checksum 0x%x or revision 0x%04x\n",
425 sum, ah->eep_ops->get_eeprom_ver(ah));
430 #undef EEPROM_4K_SIZE
433 static u32 ath9k_hw_4k_get_eeprom(struct ath_hw *ah,
434 enum eeprom_param param)
436 struct ar5416_eeprom_4k *eep = &ah->eeprom.map4k;
437 struct modal_eep_4k_header *pModal = &eep->modalHeader;
438 struct base_eep_header_4k *pBase = &eep->baseEepHeader;
442 return pModal->noiseFloorThreshCh[0];
443 case AR_EEPROM_MAC(0):
444 return pBase->macAddr[0] << 8 | pBase->macAddr[1];
445 case AR_EEPROM_MAC(1):
446 return pBase->macAddr[2] << 8 | pBase->macAddr[3];
447 case AR_EEPROM_MAC(2):
448 return pBase->macAddr[4] << 8 | pBase->macAddr[5];
450 return pBase->regDmn[0];
452 return pBase->regDmn[1];
454 return pBase->deviceCap;
456 return pBase->opCapFlags;
458 return pBase->rfSilent;
460 return pModal->ob_01;
462 return pModal->db1_01;
464 return pBase->version & AR5416_EEP_VER_MINOR_MASK;
466 return pBase->txMask;
468 return pBase->rxMask;
476 static void ath9k_hw_get_4k_gain_boundaries_pdadcs(struct ath_hw *ah,
477 struct ath9k_channel *chan,
478 struct cal_data_per_freq_4k *pRawDataSet,
479 u8 *bChans, u16 availPiers,
480 u16 tPdGainOverlap, int16_t *pMinCalPower,
481 u16 *pPdGainBoundaries, u8 *pPDADCValues,
484 #define TMP_VAL_VPD_TABLE \
485 ((vpdTableI[i][sizeCurrVpdTable - 1] + (ss - maxIndex + 1) * vpdStep));
488 u16 idxL = 0, idxR = 0, numPiers;
489 static u8 vpdTableL[AR5416_EEP4K_NUM_PD_GAINS]
490 [AR5416_MAX_PWR_RANGE_IN_HALF_DB];
491 static u8 vpdTableR[AR5416_EEP4K_NUM_PD_GAINS]
492 [AR5416_MAX_PWR_RANGE_IN_HALF_DB];
493 static u8 vpdTableI[AR5416_EEP4K_NUM_PD_GAINS]
494 [AR5416_MAX_PWR_RANGE_IN_HALF_DB];
496 u8 *pVpdL, *pVpdR, *pPwrL, *pPwrR;
497 u8 minPwrT4[AR5416_EEP4K_NUM_PD_GAINS];
498 u8 maxPwrT4[AR5416_EEP4K_NUM_PD_GAINS];
501 u16 sizeCurrVpdTable, maxIndex, tgtIndex;
503 int16_t minDelta = 0;
504 struct chan_centers centers;
505 #define PD_GAIN_BOUNDARY_DEFAULT 58;
507 ath9k_hw_get_channel_centers(ah, chan, ¢ers);
509 for (numPiers = 0; numPiers < availPiers; numPiers++) {
510 if (bChans[numPiers] == AR5416_BCHAN_UNUSED)
514 match = ath9k_hw_get_lower_upper_index(
515 (u8)FREQ2FBIN(centers.synth_center,
516 IS_CHAN_2GHZ(chan)), bChans, numPiers,
520 for (i = 0; i < numXpdGains; i++) {
521 minPwrT4[i] = pRawDataSet[idxL].pwrPdg[i][0];
522 maxPwrT4[i] = pRawDataSet[idxL].pwrPdg[i][4];
523 ath9k_hw_fill_vpd_table(minPwrT4[i], maxPwrT4[i],
524 pRawDataSet[idxL].pwrPdg[i],
525 pRawDataSet[idxL].vpdPdg[i],
526 AR5416_EEP4K_PD_GAIN_ICEPTS,
530 for (i = 0; i < numXpdGains; i++) {
531 pVpdL = pRawDataSet[idxL].vpdPdg[i];
532 pPwrL = pRawDataSet[idxL].pwrPdg[i];
533 pVpdR = pRawDataSet[idxR].vpdPdg[i];
534 pPwrR = pRawDataSet[idxR].pwrPdg[i];
536 minPwrT4[i] = max(pPwrL[0], pPwrR[0]);
539 min(pPwrL[AR5416_EEP4K_PD_GAIN_ICEPTS - 1],
540 pPwrR[AR5416_EEP4K_PD_GAIN_ICEPTS - 1]);
543 ath9k_hw_fill_vpd_table(minPwrT4[i], maxPwrT4[i],
545 AR5416_EEP4K_PD_GAIN_ICEPTS,
547 ath9k_hw_fill_vpd_table(minPwrT4[i], maxPwrT4[i],
549 AR5416_EEP4K_PD_GAIN_ICEPTS,
552 for (j = 0; j <= (maxPwrT4[i] - minPwrT4[i]) / 2; j++) {
554 (u8)(ath9k_hw_interpolate((u16)
559 bChans[idxL], bChans[idxR],
560 vpdTableL[i][j], vpdTableR[i][j]));
565 *pMinCalPower = (int16_t)(minPwrT4[0] / 2);
569 for (i = 0; i < numXpdGains; i++) {
570 if (i == (numXpdGains - 1))
571 pPdGainBoundaries[i] =
572 (u16)(maxPwrT4[i] / 2);
574 pPdGainBoundaries[i] =
575 (u16)((maxPwrT4[i] + minPwrT4[i + 1]) / 4);
577 pPdGainBoundaries[i] =
578 min((u16)AR5416_MAX_RATE_POWER, pPdGainBoundaries[i]);
580 if ((i == 0) && !AR_SREV_5416_V20_OR_LATER(ah)) {
581 minDelta = pPdGainBoundaries[0] - 23;
582 pPdGainBoundaries[0] = 23;
588 if (AR_SREV_9280_10_OR_LATER(ah))
589 ss = (int16_t)(0 - (minPwrT4[i] / 2));
593 ss = (int16_t)((pPdGainBoundaries[i - 1] -
595 tPdGainOverlap + 1 + minDelta);
597 vpdStep = (int16_t)(vpdTableI[i][1] - vpdTableI[i][0]);
598 vpdStep = (int16_t)((vpdStep < 1) ? 1 : vpdStep);
600 while ((ss < 0) && (k < (AR5416_NUM_PDADC_VALUES - 1))) {
601 tmpVal = (int16_t)(vpdTableI[i][0] + ss * vpdStep);
602 pPDADCValues[k++] = (u8)((tmpVal < 0) ? 0 : tmpVal);
606 sizeCurrVpdTable = (u8) ((maxPwrT4[i] - minPwrT4[i]) / 2 + 1);
607 tgtIndex = (u8)(pPdGainBoundaries[i] + tPdGainOverlap -
609 maxIndex = (tgtIndex < sizeCurrVpdTable) ?
610 tgtIndex : sizeCurrVpdTable;
612 while ((ss < maxIndex) && (k < (AR5416_NUM_PDADC_VALUES - 1)))
613 pPDADCValues[k++] = vpdTableI[i][ss++];
615 vpdStep = (int16_t)(vpdTableI[i][sizeCurrVpdTable - 1] -
616 vpdTableI[i][sizeCurrVpdTable - 2]);
617 vpdStep = (int16_t)((vpdStep < 1) ? 1 : vpdStep);
619 if (tgtIndex > maxIndex) {
620 while ((ss <= tgtIndex) &&
621 (k < (AR5416_NUM_PDADC_VALUES - 1))) {
622 tmpVal = (int16_t) TMP_VAL_VPD_TABLE;
623 pPDADCValues[k++] = (u8)((tmpVal > 255) ?
630 while (i < AR5416_EEP4K_PD_GAINS_IN_MASK) {
631 pPdGainBoundaries[i] = PD_GAIN_BOUNDARY_DEFAULT;
635 while (k < AR5416_NUM_PDADC_VALUES) {
636 pPDADCValues[k] = pPDADCValues[k - 1];
641 #undef TMP_VAL_VPD_TABLE
644 static bool ath9k_hw_set_4k_power_cal_table(struct ath_hw *ah,
645 struct ath9k_channel *chan,
646 int16_t *pTxPowerIndexOffset)
648 struct ar5416_eeprom_4k *pEepData = &ah->eeprom.map4k;
649 struct cal_data_per_freq_4k *pRawDataset;
650 u8 *pCalBChans = NULL;
651 u16 pdGainOverlap_t2;
652 static u8 pdadcValues[AR5416_NUM_PDADC_VALUES];
653 u16 gainBoundaries[AR5416_PD_GAINS_IN_MASK];
655 int16_t tMinCalPower;
656 u16 numXpdGain, xpdMask;
657 u16 xpdGainValues[AR5416_NUM_PD_GAINS] = { 0, 0, 0, 0 };
658 u32 reg32, regOffset, regChainOffset;
660 xpdMask = pEepData->modalHeader.xpdGain;
662 if ((pEepData->baseEepHeader.version & AR5416_EEP_VER_MINOR_MASK) >=
663 AR5416_EEP_MINOR_VER_2) {
665 pEepData->modalHeader.pdGainOverlap;
667 pdGainOverlap_t2 = (u16)(MS(REG_READ(ah, AR_PHY_TPCRG5),
668 AR_PHY_TPCRG5_PD_GAIN_OVERLAP));
671 pCalBChans = pEepData->calFreqPier2G;
672 numPiers = AR5416_NUM_2G_CAL_PIERS;
676 for (i = 1; i <= AR5416_PD_GAINS_IN_MASK; i++) {
677 if ((xpdMask >> (AR5416_PD_GAINS_IN_MASK - i)) & 1) {
678 if (numXpdGain >= AR5416_NUM_PD_GAINS)
680 xpdGainValues[numXpdGain] =
681 (u16)(AR5416_PD_GAINS_IN_MASK - i);
686 REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_NUM_PD_GAIN,
687 (numXpdGain - 1) & 0x3);
688 REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_GAIN_1,
690 REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_GAIN_2,
692 REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_GAIN_3,
695 for (i = 0; i < AR5416_MAX_CHAINS; i++) {
696 if (AR_SREV_5416_V20_OR_LATER(ah) &&
697 (ah->rxchainmask == 5 || ah->txchainmask == 5) &&
699 regChainOffset = (i == 1) ? 0x2000 : 0x1000;
701 regChainOffset = i * 0x1000;
703 if (pEepData->baseEepHeader.txMask & (1 << i)) {
704 pRawDataset = pEepData->calPierData2G[i];
706 ath9k_hw_get_4k_gain_boundaries_pdadcs(ah, chan,
707 pRawDataset, pCalBChans,
708 numPiers, pdGainOverlap_t2,
709 &tMinCalPower, gainBoundaries,
710 pdadcValues, numXpdGain);
712 if ((i == 0) || AR_SREV_5416_V20_OR_LATER(ah)) {
713 REG_WRITE(ah, AR_PHY_TPCRG5 + regChainOffset,
715 AR_PHY_TPCRG5_PD_GAIN_OVERLAP)
716 | SM(gainBoundaries[0],
717 AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_1)
718 | SM(gainBoundaries[1],
719 AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_2)
720 | SM(gainBoundaries[2],
721 AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_3)
722 | SM(gainBoundaries[3],
723 AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_4));
726 regOffset = AR_PHY_BASE + (672 << 2) + regChainOffset;
727 for (j = 0; j < 32; j++) {
728 reg32 = ((pdadcValues[4 * j + 0] & 0xFF) << 0) |
729 ((pdadcValues[4 * j + 1] & 0xFF) << 8) |
730 ((pdadcValues[4 * j + 2] & 0xFF) << 16)|
731 ((pdadcValues[4 * j + 3] & 0xFF) << 24);
732 REG_WRITE(ah, regOffset, reg32);
734 DPRINTF(ah->ah_sc, ATH_DBG_REG_IO,
735 "PDADC (%d,%4x): %4.4x %8.8x\n",
736 i, regChainOffset, regOffset,
738 DPRINTF(ah->ah_sc, ATH_DBG_REG_IO,
740 "PDADC %3d Value %3d | "
741 "PDADC %3d Value %3d | "
742 "PDADC %3d Value %3d | "
743 "PDADC %3d Value %3d |\n",
744 i, 4 * j, pdadcValues[4 * j],
745 4 * j + 1, pdadcValues[4 * j + 1],
746 4 * j + 2, pdadcValues[4 * j + 2],
748 pdadcValues[4 * j + 3]);
755 *pTxPowerIndexOffset = 0;
760 static bool ath9k_hw_set_4k_power_per_rate_table(struct ath_hw *ah,
761 struct ath9k_channel *chan,
764 u16 AntennaReduction,
765 u16 twiceMaxRegulatoryPower,
768 struct ar5416_eeprom_4k *pEepData = &ah->eeprom.map4k;
769 u16 twiceMaxEdgePower = AR5416_MAX_RATE_POWER;
770 static const u16 tpScaleReductionTable[5] =
771 { 0, 3, 6, 9, AR5416_MAX_RATE_POWER };
774 int16_t twiceLargestAntenna;
775 struct cal_ctl_data_4k *rep;
776 struct cal_target_power_leg targetPowerOfdm, targetPowerCck = {
779 struct cal_target_power_leg targetPowerOfdmExt = {
780 0, { 0, 0, 0, 0} }, targetPowerCckExt = {
783 struct cal_target_power_ht targetPowerHt20, targetPowerHt40 = {
786 u16 scaledPower = 0, minCtlPower, maxRegAllowedPower;
787 u16 ctlModesFor11g[] =
788 { CTL_11B, CTL_11G, CTL_2GHT20, CTL_11B_EXT, CTL_11G_EXT,
791 u16 numCtlModes, *pCtlMode, ctlMode, freq;
792 struct chan_centers centers;
794 u16 twiceMinEdgePower;
796 tx_chainmask = ah->txchainmask;
798 ath9k_hw_get_channel_centers(ah, chan, ¢ers);
800 twiceLargestAntenna = pEepData->modalHeader.antennaGainCh[0];
802 twiceLargestAntenna = (int16_t)min(AntennaReduction -
803 twiceLargestAntenna, 0);
805 maxRegAllowedPower = twiceMaxRegulatoryPower + twiceLargestAntenna;
807 if (ah->regulatory.tp_scale != ATH9K_TP_SCALE_MAX) {
808 maxRegAllowedPower -=
809 (tpScaleReductionTable[(ah->regulatory.tp_scale)] * 2);
812 scaledPower = min(powerLimit, maxRegAllowedPower);
813 scaledPower = max((u16)0, scaledPower);
815 numCtlModes = ARRAY_SIZE(ctlModesFor11g) - SUB_NUM_CTL_MODES_AT_2G_40;
816 pCtlMode = ctlModesFor11g;
818 ath9k_hw_get_legacy_target_powers(ah, chan,
819 pEepData->calTargetPowerCck,
820 AR5416_NUM_2G_CCK_TARGET_POWERS,
821 &targetPowerCck, 4, false);
822 ath9k_hw_get_legacy_target_powers(ah, chan,
823 pEepData->calTargetPower2G,
824 AR5416_NUM_2G_20_TARGET_POWERS,
825 &targetPowerOfdm, 4, false);
826 ath9k_hw_get_target_powers(ah, chan,
827 pEepData->calTargetPower2GHT20,
828 AR5416_NUM_2G_20_TARGET_POWERS,
829 &targetPowerHt20, 8, false);
831 if (IS_CHAN_HT40(chan)) {
832 numCtlModes = ARRAY_SIZE(ctlModesFor11g);
833 ath9k_hw_get_target_powers(ah, chan,
834 pEepData->calTargetPower2GHT40,
835 AR5416_NUM_2G_40_TARGET_POWERS,
836 &targetPowerHt40, 8, true);
837 ath9k_hw_get_legacy_target_powers(ah, chan,
838 pEepData->calTargetPowerCck,
839 AR5416_NUM_2G_CCK_TARGET_POWERS,
840 &targetPowerCckExt, 4, true);
841 ath9k_hw_get_legacy_target_powers(ah, chan,
842 pEepData->calTargetPower2G,
843 AR5416_NUM_2G_20_TARGET_POWERS,
844 &targetPowerOfdmExt, 4, true);
847 for (ctlMode = 0; ctlMode < numCtlModes; ctlMode++) {
848 bool isHt40CtlMode = (pCtlMode[ctlMode] == CTL_5GHT40) ||
849 (pCtlMode[ctlMode] == CTL_2GHT40);
851 freq = centers.synth_center;
852 else if (pCtlMode[ctlMode] & EXT_ADDITIVE)
853 freq = centers.ext_center;
855 freq = centers.ctl_center;
857 if (ah->eep_ops->get_eeprom_ver(ah) == 14 &&
858 ah->eep_ops->get_eeprom_rev(ah) <= 2)
859 twiceMaxEdgePower = AR5416_MAX_RATE_POWER;
861 DPRINTF(ah->ah_sc, ATH_DBG_POWER_MGMT,
862 "LOOP-Mode ctlMode %d < %d, isHt40CtlMode %d, "
864 ctlMode, numCtlModes, isHt40CtlMode,
865 (pCtlMode[ctlMode] & EXT_ADDITIVE));
867 for (i = 0; (i < AR5416_NUM_CTLS) &&
868 pEepData->ctlIndex[i]; i++) {
869 DPRINTF(ah->ah_sc, ATH_DBG_POWER_MGMT,
870 " LOOP-Ctlidx %d: cfgCtl 0x%2.2x "
871 "pCtlMode 0x%2.2x ctlIndex 0x%2.2x "
873 i, cfgCtl, pCtlMode[ctlMode],
874 pEepData->ctlIndex[i], chan->channel);
876 if ((((cfgCtl & ~CTL_MODE_M) |
877 (pCtlMode[ctlMode] & CTL_MODE_M)) ==
878 pEepData->ctlIndex[i]) ||
879 (((cfgCtl & ~CTL_MODE_M) |
880 (pCtlMode[ctlMode] & CTL_MODE_M)) ==
881 ((pEepData->ctlIndex[i] & CTL_MODE_M) |
883 rep = &(pEepData->ctlData[i]);
886 ath9k_hw_get_max_edge_power(freq,
887 rep->ctlEdges[ar5416_get_ntxchains
890 AR5416_EEP4K_NUM_BAND_EDGES);
892 DPRINTF(ah->ah_sc, ATH_DBG_POWER_MGMT,
893 " MATCH-EE_IDX %d: ch %d is2 %d "
894 "2xMinEdge %d chainmask %d chains %d\n",
895 i, freq, IS_CHAN_2GHZ(chan),
896 twiceMinEdgePower, tx_chainmask,
899 if ((cfgCtl & ~CTL_MODE_M) == SD_NO_CTL) {
901 min(twiceMaxEdgePower,
904 twiceMaxEdgePower = twiceMinEdgePower;
910 minCtlPower = (u8)min(twiceMaxEdgePower, scaledPower);
912 DPRINTF(ah->ah_sc, ATH_DBG_POWER_MGMT,
913 " SEL-Min ctlMode %d pCtlMode %d "
914 "2xMaxEdge %d sP %d minCtlPwr %d\n",
915 ctlMode, pCtlMode[ctlMode], twiceMaxEdgePower,
916 scaledPower, minCtlPower);
918 switch (pCtlMode[ctlMode]) {
920 for (i = 0; i < ARRAY_SIZE(targetPowerCck.tPow2x);
922 targetPowerCck.tPow2x[i] =
923 min((u16)targetPowerCck.tPow2x[i],
928 for (i = 0; i < ARRAY_SIZE(targetPowerOfdm.tPow2x);
930 targetPowerOfdm.tPow2x[i] =
931 min((u16)targetPowerOfdm.tPow2x[i],
936 for (i = 0; i < ARRAY_SIZE(targetPowerHt20.tPow2x);
938 targetPowerHt20.tPow2x[i] =
939 min((u16)targetPowerHt20.tPow2x[i],
944 targetPowerCckExt.tPow2x[0] = min((u16)
945 targetPowerCckExt.tPow2x[0],
949 targetPowerOfdmExt.tPow2x[0] = min((u16)
950 targetPowerOfdmExt.tPow2x[0],
954 for (i = 0; i < ARRAY_SIZE(targetPowerHt40.tPow2x);
956 targetPowerHt40.tPow2x[i] =
957 min((u16)targetPowerHt40.tPow2x[i],
966 ratesArray[rate6mb] = ratesArray[rate9mb] = ratesArray[rate12mb] =
967 ratesArray[rate18mb] = ratesArray[rate24mb] =
968 targetPowerOfdm.tPow2x[0];
969 ratesArray[rate36mb] = targetPowerOfdm.tPow2x[1];
970 ratesArray[rate48mb] = targetPowerOfdm.tPow2x[2];
971 ratesArray[rate54mb] = targetPowerOfdm.tPow2x[3];
972 ratesArray[rateXr] = targetPowerOfdm.tPow2x[0];
974 for (i = 0; i < ARRAY_SIZE(targetPowerHt20.tPow2x); i++)
975 ratesArray[rateHt20_0 + i] = targetPowerHt20.tPow2x[i];
977 ratesArray[rate1l] = targetPowerCck.tPow2x[0];
978 ratesArray[rate2s] = ratesArray[rate2l] = targetPowerCck.tPow2x[1];
979 ratesArray[rate5_5s] = ratesArray[rate5_5l] = targetPowerCck.tPow2x[2];
980 ratesArray[rate11s] = ratesArray[rate11l] = targetPowerCck.tPow2x[3];
982 if (IS_CHAN_HT40(chan)) {
983 for (i = 0; i < ARRAY_SIZE(targetPowerHt40.tPow2x); i++) {
984 ratesArray[rateHt40_0 + i] =
985 targetPowerHt40.tPow2x[i];
987 ratesArray[rateDupOfdm] = targetPowerHt40.tPow2x[0];
988 ratesArray[rateDupCck] = targetPowerHt40.tPow2x[0];
989 ratesArray[rateExtOfdm] = targetPowerOfdmExt.tPow2x[0];
990 ratesArray[rateExtCck] = targetPowerCckExt.tPow2x[0];
995 static int ath9k_hw_4k_set_txpower(struct ath_hw *ah,
996 struct ath9k_channel *chan,
998 u8 twiceAntennaReduction,
999 u8 twiceMaxRegulatoryPower,
1002 struct ar5416_eeprom_4k *pEepData = &ah->eeprom.map4k;
1003 struct modal_eep_4k_header *pModal = &pEepData->modalHeader;
1004 int16_t ratesArray[Ar5416RateSize];
1005 int16_t txPowerIndexOffset = 0;
1006 u8 ht40PowerIncForPdadc = 2;
1009 memset(ratesArray, 0, sizeof(ratesArray));
1011 if ((pEepData->baseEepHeader.version & AR5416_EEP_VER_MINOR_MASK) >=
1012 AR5416_EEP_MINOR_VER_2) {
1013 ht40PowerIncForPdadc = pModal->ht40PowerIncForPdadc;
1016 if (!ath9k_hw_set_4k_power_per_rate_table(ah, chan,
1017 &ratesArray[0], cfgCtl,
1018 twiceAntennaReduction,
1019 twiceMaxRegulatoryPower,
1021 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
1022 "ath9k_hw_set_txpower: unable to set "
1023 "tx power per rate table\n");
1027 if (!ath9k_hw_set_4k_power_cal_table(ah, chan, &txPowerIndexOffset)) {
1028 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
1029 "ath9k_hw_set_txpower: unable to set power table\n");
1033 for (i = 0; i < ARRAY_SIZE(ratesArray); i++) {
1034 ratesArray[i] = (int16_t)(txPowerIndexOffset + ratesArray[i]);
1035 if (ratesArray[i] > AR5416_MAX_RATE_POWER)
1036 ratesArray[i] = AR5416_MAX_RATE_POWER;
1039 if (AR_SREV_9280_10_OR_LATER(ah)) {
1040 for (i = 0; i < Ar5416RateSize; i++)
1041 ratesArray[i] -= AR5416_PWR_TABLE_OFFSET * 2;
1044 REG_WRITE(ah, AR_PHY_POWER_TX_RATE1,
1045 ATH9K_POW_SM(ratesArray[rate18mb], 24)
1046 | ATH9K_POW_SM(ratesArray[rate12mb], 16)
1047 | ATH9K_POW_SM(ratesArray[rate9mb], 8)
1048 | ATH9K_POW_SM(ratesArray[rate6mb], 0));
1049 REG_WRITE(ah, AR_PHY_POWER_TX_RATE2,
1050 ATH9K_POW_SM(ratesArray[rate54mb], 24)
1051 | ATH9K_POW_SM(ratesArray[rate48mb], 16)
1052 | ATH9K_POW_SM(ratesArray[rate36mb], 8)
1053 | ATH9K_POW_SM(ratesArray[rate24mb], 0));
1055 if (IS_CHAN_2GHZ(chan)) {
1056 REG_WRITE(ah, AR_PHY_POWER_TX_RATE3,
1057 ATH9K_POW_SM(ratesArray[rate2s], 24)
1058 | ATH9K_POW_SM(ratesArray[rate2l], 16)
1059 | ATH9K_POW_SM(ratesArray[rateXr], 8)
1060 | ATH9K_POW_SM(ratesArray[rate1l], 0));
1061 REG_WRITE(ah, AR_PHY_POWER_TX_RATE4,
1062 ATH9K_POW_SM(ratesArray[rate11s], 24)
1063 | ATH9K_POW_SM(ratesArray[rate11l], 16)
1064 | ATH9K_POW_SM(ratesArray[rate5_5s], 8)
1065 | ATH9K_POW_SM(ratesArray[rate5_5l], 0));
1068 REG_WRITE(ah, AR_PHY_POWER_TX_RATE5,
1069 ATH9K_POW_SM(ratesArray[rateHt20_3], 24)
1070 | ATH9K_POW_SM(ratesArray[rateHt20_2], 16)
1071 | ATH9K_POW_SM(ratesArray[rateHt20_1], 8)
1072 | ATH9K_POW_SM(ratesArray[rateHt20_0], 0));
1073 REG_WRITE(ah, AR_PHY_POWER_TX_RATE6,
1074 ATH9K_POW_SM(ratesArray[rateHt20_7], 24)
1075 | ATH9K_POW_SM(ratesArray[rateHt20_6], 16)
1076 | ATH9K_POW_SM(ratesArray[rateHt20_5], 8)
1077 | ATH9K_POW_SM(ratesArray[rateHt20_4], 0));
1079 if (IS_CHAN_HT40(chan)) {
1080 REG_WRITE(ah, AR_PHY_POWER_TX_RATE7,
1081 ATH9K_POW_SM(ratesArray[rateHt40_3] +
1082 ht40PowerIncForPdadc, 24)
1083 | ATH9K_POW_SM(ratesArray[rateHt40_2] +
1084 ht40PowerIncForPdadc, 16)
1085 | ATH9K_POW_SM(ratesArray[rateHt40_1] +
1086 ht40PowerIncForPdadc, 8)
1087 | ATH9K_POW_SM(ratesArray[rateHt40_0] +
1088 ht40PowerIncForPdadc, 0));
1089 REG_WRITE(ah, AR_PHY_POWER_TX_RATE8,
1090 ATH9K_POW_SM(ratesArray[rateHt40_7] +
1091 ht40PowerIncForPdadc, 24)
1092 | ATH9K_POW_SM(ratesArray[rateHt40_6] +
1093 ht40PowerIncForPdadc, 16)
1094 | ATH9K_POW_SM(ratesArray[rateHt40_5] +
1095 ht40PowerIncForPdadc, 8)
1096 | ATH9K_POW_SM(ratesArray[rateHt40_4] +
1097 ht40PowerIncForPdadc, 0));
1099 REG_WRITE(ah, AR_PHY_POWER_TX_RATE9,
1100 ATH9K_POW_SM(ratesArray[rateExtOfdm], 24)
1101 | ATH9K_POW_SM(ratesArray[rateExtCck], 16)
1102 | ATH9K_POW_SM(ratesArray[rateDupOfdm], 8)
1103 | ATH9K_POW_SM(ratesArray[rateDupCck], 0));
1108 if (IS_CHAN_HT40(chan))
1110 else if (IS_CHAN_HT20(chan))
1113 if (AR_SREV_9280_10_OR_LATER(ah))
1114 ah->regulatory.max_power_level =
1115 ratesArray[i] + AR5416_PWR_TABLE_OFFSET * 2;
1117 ah->regulatory.max_power_level = ratesArray[i];
1122 static void ath9k_hw_4k_set_addac(struct ath_hw *ah,
1123 struct ath9k_channel *chan)
1125 struct modal_eep_4k_header *pModal;
1126 struct ar5416_eeprom_4k *eep = &ah->eeprom.map4k;
1129 if (ah->hw_version.macVersion != AR_SREV_VERSION_9160)
1132 if (ah->eep_ops->get_eeprom_rev(ah) < AR5416_EEP_MINOR_VER_7)
1135 pModal = &eep->modalHeader;
1137 if (pModal->xpaBiasLvl != 0xff) {
1138 biaslevel = pModal->xpaBiasLvl;
1139 INI_RA(&ah->iniAddac, 7, 1) =
1140 (INI_RA(&ah->iniAddac, 7, 1) & (~0x18)) | biaslevel << 3;
1144 static bool ath9k_hw_4k_set_board_values(struct ath_hw *ah,
1145 struct ath9k_channel *chan)
1147 struct modal_eep_4k_header *pModal;
1148 struct ar5416_eeprom_4k *eep = &ah->eeprom.map4k;
1151 u8 ob[5], db1[5], db2[5];
1152 u8 ant_div_control1, ant_div_control2;
1156 pModal = &eep->modalHeader;
1158 txRxAttenLocal = 23;
1160 REG_WRITE(ah, AR_PHY_SWITCH_COM,
1161 ah->eep_ops->get_eeprom_antenna_cfg(ah, chan));
1164 REG_WRITE(ah, AR_PHY_SWITCH_CHAIN_0 + regChainOffset,
1165 pModal->antCtrlChain[0]);
1167 REG_WRITE(ah, AR_PHY_TIMING_CTRL4(0) + regChainOffset,
1168 (REG_READ(ah, AR_PHY_TIMING_CTRL4(0) + regChainOffset) &
1169 ~(AR_PHY_TIMING_CTRL4_IQCORR_Q_Q_COFF |
1170 AR_PHY_TIMING_CTRL4_IQCORR_Q_I_COFF)) |
1171 SM(pModal->iqCalICh[0], AR_PHY_TIMING_CTRL4_IQCORR_Q_I_COFF) |
1172 SM(pModal->iqCalQCh[0], AR_PHY_TIMING_CTRL4_IQCORR_Q_Q_COFF));
1174 if ((eep->baseEepHeader.version & AR5416_EEP_VER_MINOR_MASK) >=
1175 AR5416_EEP_MINOR_VER_3) {
1176 txRxAttenLocal = pModal->txRxAttenCh[0];
1177 REG_RMW_FIELD(ah, AR_PHY_GAIN_2GHZ + regChainOffset,
1178 AR_PHY_GAIN_2GHZ_XATTEN1_MARGIN, pModal->bswMargin[0]);
1179 REG_RMW_FIELD(ah, AR_PHY_GAIN_2GHZ + regChainOffset,
1180 AR_PHY_GAIN_2GHZ_XATTEN1_DB, pModal->bswAtten[0]);
1181 REG_RMW_FIELD(ah, AR_PHY_GAIN_2GHZ + regChainOffset,
1182 AR_PHY_GAIN_2GHZ_XATTEN2_MARGIN,
1183 pModal->xatten2Margin[0]);
1184 REG_RMW_FIELD(ah, AR_PHY_GAIN_2GHZ + regChainOffset,
1185 AR_PHY_GAIN_2GHZ_XATTEN2_DB, pModal->xatten2Db[0]);
1188 REG_RMW_FIELD(ah, AR_PHY_RXGAIN + regChainOffset,
1189 AR9280_PHY_RXGAIN_TXRX_ATTEN, txRxAttenLocal);
1190 REG_RMW_FIELD(ah, AR_PHY_RXGAIN + regChainOffset,
1191 AR9280_PHY_RXGAIN_TXRX_MARGIN, pModal->rxTxMarginCh[0]);
1193 if (AR_SREV_9285_11(ah))
1194 REG_WRITE(ah, AR9285_AN_TOP4, (AR9285_AN_TOP4_DEFAULT | 0x14));
1196 /* Initialize Ant Diversity settings from EEPROM */
1197 if (pModal->version == 3) {
1198 ant_div_control1 = ((pModal->ob_234 >> 12) & 0xf);
1199 ant_div_control2 = ((pModal->db1_234 >> 12) & 0xf);
1200 regVal = REG_READ(ah, 0x99ac);
1201 regVal &= (~(0x7f000000));
1202 regVal |= ((ant_div_control1 & 0x1) << 24);
1203 regVal |= (((ant_div_control1 >> 1) & 0x1) << 29);
1204 regVal |= (((ant_div_control1 >> 2) & 0x1) << 30);
1205 regVal |= ((ant_div_control2 & 0x3) << 25);
1206 regVal |= (((ant_div_control2 >> 2) & 0x3) << 27);
1207 REG_WRITE(ah, 0x99ac, regVal);
1208 regVal = REG_READ(ah, 0x99ac);
1209 regVal = REG_READ(ah, 0xa208);
1210 regVal &= (~(0x1 << 13));
1211 regVal |= (((ant_div_control1 >> 3) & 0x1) << 13);
1212 REG_WRITE(ah, 0xa208, regVal);
1213 regVal = REG_READ(ah, 0xa208);
1216 if (pModal->version >= 2) {
1217 ob[0] = (pModal->ob_01 & 0xf);
1218 ob[1] = (pModal->ob_01 >> 4) & 0xf;
1219 ob[2] = (pModal->ob_234 & 0xf);
1220 ob[3] = ((pModal->ob_234 >> 4) & 0xf);
1221 ob[4] = ((pModal->ob_234 >> 8) & 0xf);
1223 db1[0] = (pModal->db1_01 & 0xf);
1224 db1[1] = ((pModal->db1_01 >> 4) & 0xf);
1225 db1[2] = (pModal->db1_234 & 0xf);
1226 db1[3] = ((pModal->db1_234 >> 4) & 0xf);
1227 db1[4] = ((pModal->db1_234 >> 8) & 0xf);
1229 db2[0] = (pModal->db2_01 & 0xf);
1230 db2[1] = ((pModal->db2_01 >> 4) & 0xf);
1231 db2[2] = (pModal->db2_234 & 0xf);
1232 db2[3] = ((pModal->db2_234 >> 4) & 0xf);
1233 db2[4] = ((pModal->db2_234 >> 8) & 0xf);
1235 } else if (pModal->version == 1) {
1237 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
1238 "EEPROM Model version is set to 1 \n");
1239 ob[0] = (pModal->ob_01 & 0xf);
1240 ob[1] = ob[2] = ob[3] = ob[4] = (pModal->ob_01 >> 4) & 0xf;
1241 db1[0] = (pModal->db1_01 & 0xf);
1242 db1[1] = db1[2] = db1[3] =
1243 db1[4] = ((pModal->db1_01 >> 4) & 0xf);
1244 db2[0] = (pModal->db2_01 & 0xf);
1245 db2[1] = db2[2] = db2[3] =
1246 db2[4] = ((pModal->db2_01 >> 4) & 0xf);
1249 for (i = 0; i < 5; i++) {
1250 ob[i] = pModal->ob_01;
1251 db1[i] = pModal->db1_01;
1252 db2[i] = pModal->db1_01;
1256 ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G3,
1257 AR9285_AN_RF2G3_OB_0, AR9285_AN_RF2G3_OB_0_S, ob[0]);
1258 ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G3,
1259 AR9285_AN_RF2G3_OB_1, AR9285_AN_RF2G3_OB_1_S, ob[1]);
1260 ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G3,
1261 AR9285_AN_RF2G3_OB_2, AR9285_AN_RF2G3_OB_2_S, ob[2]);
1262 ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G3,
1263 AR9285_AN_RF2G3_OB_3, AR9285_AN_RF2G3_OB_3_S, ob[3]);
1264 ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G3,
1265 AR9285_AN_RF2G3_OB_4, AR9285_AN_RF2G3_OB_4_S, ob[4]);
1267 ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G3,
1268 AR9285_AN_RF2G3_DB1_0, AR9285_AN_RF2G3_DB1_0_S, db1[0]);
1269 ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G3,
1270 AR9285_AN_RF2G3_DB1_1, AR9285_AN_RF2G3_DB1_1_S, db1[1]);
1271 ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G3,
1272 AR9285_AN_RF2G3_DB1_2, AR9285_AN_RF2G3_DB1_2_S, db1[2]);
1273 ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G4,
1274 AR9285_AN_RF2G4_DB1_3, AR9285_AN_RF2G4_DB1_3_S, db1[3]);
1275 ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G4,
1276 AR9285_AN_RF2G4_DB1_4, AR9285_AN_RF2G4_DB1_4_S, db1[4]);
1278 ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G4,
1279 AR9285_AN_RF2G4_DB2_0, AR9285_AN_RF2G4_DB2_0_S, db2[0]);
1280 ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G4,
1281 AR9285_AN_RF2G4_DB2_1, AR9285_AN_RF2G4_DB2_1_S, db2[1]);
1282 ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G4,
1283 AR9285_AN_RF2G4_DB2_2, AR9285_AN_RF2G4_DB2_2_S, db2[2]);
1284 ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G4,
1285 AR9285_AN_RF2G4_DB2_3, AR9285_AN_RF2G4_DB2_3_S, db2[3]);
1286 ath9k_hw_analog_shift_rmw(ah, AR9285_AN_RF2G4,
1287 AR9285_AN_RF2G4_DB2_4, AR9285_AN_RF2G4_DB2_4_S, db2[4]);
1290 if (AR_SREV_9285_11(ah))
1291 REG_WRITE(ah, AR9285_AN_TOP4, AR9285_AN_TOP4_DEFAULT);
1293 REG_RMW_FIELD(ah, AR_PHY_SETTLING, AR_PHY_SETTLING_SWITCH,
1294 pModal->switchSettling);
1295 REG_RMW_FIELD(ah, AR_PHY_DESIRED_SZ, AR_PHY_DESIRED_SZ_ADC,
1296 pModal->adcDesiredSize);
1298 REG_WRITE(ah, AR_PHY_RF_CTL4,
1299 SM(pModal->txEndToXpaOff, AR_PHY_RF_CTL4_TX_END_XPAA_OFF) |
1300 SM(pModal->txEndToXpaOff, AR_PHY_RF_CTL4_TX_END_XPAB_OFF) |
1301 SM(pModal->txFrameToXpaOn, AR_PHY_RF_CTL4_FRAME_XPAA_ON) |
1302 SM(pModal->txFrameToXpaOn, AR_PHY_RF_CTL4_FRAME_XPAB_ON));
1304 REG_RMW_FIELD(ah, AR_PHY_RF_CTL3, AR_PHY_TX_END_TO_A2_RX_ON,
1305 pModal->txEndToRxOn);
1306 REG_RMW_FIELD(ah, AR_PHY_CCA, AR9280_PHY_CCA_THRESH62,
1308 REG_RMW_FIELD(ah, AR_PHY_EXT_CCA0, AR_PHY_EXT_CCA0_THRESH62,
1311 if ((eep->baseEepHeader.version & AR5416_EEP_VER_MINOR_MASK) >=
1312 AR5416_EEP_MINOR_VER_2) {
1313 REG_RMW_FIELD(ah, AR_PHY_RF_CTL2, AR_PHY_TX_END_DATA_START,
1314 pModal->txFrameToDataStart);
1315 REG_RMW_FIELD(ah, AR_PHY_RF_CTL2, AR_PHY_TX_END_PA_ON,
1316 pModal->txFrameToPaOn);
1319 if ((eep->baseEepHeader.version & AR5416_EEP_VER_MINOR_MASK) >=
1320 AR5416_EEP_MINOR_VER_3) {
1321 if (IS_CHAN_HT40(chan))
1322 REG_RMW_FIELD(ah, AR_PHY_SETTLING,
1323 AR_PHY_SETTLING_SWITCH,
1324 pModal->swSettleHt40);
1330 static u16 ath9k_hw_4k_get_eeprom_antenna_cfg(struct ath_hw *ah,
1331 struct ath9k_channel *chan)
1333 struct ar5416_eeprom_4k *eep = &ah->eeprom.map4k;
1334 struct modal_eep_4k_header *pModal = &eep->modalHeader;
1336 return pModal->antCtrlCommon & 0xFFFF;
1339 static u8 ath9k_hw_4k_get_num_ant_config(struct ath_hw *ah,
1340 enum ieee80211_band freq_band)
1345 static u16 ath9k_hw_4k_get_spur_channel(struct ath_hw *ah, u16 i, bool is2GHz)
1347 #define EEP_MAP4K_SPURCHAN \
1348 (ah->eeprom.map4k.modalHeader.spurChans[i].spurChan)
1350 u16 spur_val = AR_NO_SPUR;
1352 DPRINTF(ah->ah_sc, ATH_DBG_ANI,
1353 "Getting spur idx %d is2Ghz. %d val %x\n",
1354 i, is2GHz, ah->config.spurchans[i][is2GHz]);
1356 switch (ah->config.spurmode) {
1359 case SPUR_ENABLE_IOCTL:
1360 spur_val = ah->config.spurchans[i][is2GHz];
1361 DPRINTF(ah->ah_sc, ATH_DBG_ANI,
1362 "Getting spur val from new loc. %d\n", spur_val);
1364 case SPUR_ENABLE_EEPROM:
1365 spur_val = EEP_MAP4K_SPURCHAN;
1371 #undef EEP_MAP4K_SPURCHAN
1374 static struct eeprom_ops eep_4k_ops = {
1375 .check_eeprom = ath9k_hw_4k_check_eeprom,
1376 .get_eeprom = ath9k_hw_4k_get_eeprom,
1377 .fill_eeprom = ath9k_hw_4k_fill_eeprom,
1378 .get_eeprom_ver = ath9k_hw_4k_get_eeprom_ver,
1379 .get_eeprom_rev = ath9k_hw_4k_get_eeprom_rev,
1380 .get_num_ant_config = ath9k_hw_4k_get_num_ant_config,
1381 .get_eeprom_antenna_cfg = ath9k_hw_4k_get_eeprom_antenna_cfg,
1382 .set_board_values = ath9k_hw_4k_set_board_values,
1383 .set_addac = ath9k_hw_4k_set_addac,
1384 .set_txpower = ath9k_hw_4k_set_txpower,
1385 .get_spur_channel = ath9k_hw_4k_get_spur_channel
1388 /************************************************/
1389 /* EEPROM Operations for non-4K (Default) cards */
1390 /************************************************/
1392 static int ath9k_hw_def_get_eeprom_ver(struct ath_hw *ah)
1394 return ((ah->eeprom.def.baseEepHeader.version >> 12) & 0xF);
1397 static int ath9k_hw_def_get_eeprom_rev(struct ath_hw *ah)
1399 return ((ah->eeprom.def.baseEepHeader.version) & 0xFFF);
1402 static bool ath9k_hw_def_fill_eeprom(struct ath_hw *ah)
1404 #define SIZE_EEPROM_DEF (sizeof(struct ar5416_eeprom_def) / sizeof(u16))
1405 struct ar5416_eeprom_def *eep = &ah->eeprom.def;
1407 int addr, ar5416_eep_start_loc = 0x100;
1409 eep_data = (u16 *)eep;
1411 for (addr = 0; addr < SIZE_EEPROM_DEF; addr++) {
1412 if (!ath9k_hw_nvram_read(ah, addr + ar5416_eep_start_loc,
1414 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
1415 "Unable to read eeprom region\n");
1421 #undef SIZE_EEPROM_DEF
1424 static int ath9k_hw_def_check_eeprom(struct ath_hw *ah)
1426 struct ar5416_eeprom_def *eep =
1427 (struct ar5416_eeprom_def *) &ah->eeprom.def;
1428 u16 *eepdata, temp, magic, magic2;
1430 bool need_swap = false;
1433 if (!ath9k_hw_nvram_read(ah, AR5416_EEPROM_MAGIC_OFFSET,
1435 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
1436 "Reading Magic # failed\n");
1440 if (!ath9k_hw_use_flash(ah)) {
1442 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
1443 "Read Magic = 0x%04X\n", magic);
1445 if (magic != AR5416_EEPROM_MAGIC) {
1446 magic2 = swab16(magic);
1448 if (magic2 == AR5416_EEPROM_MAGIC) {
1449 size = sizeof(struct ar5416_eeprom_def);
1451 eepdata = (u16 *) (&ah->eeprom);
1453 for (addr = 0; addr < size / sizeof(u16); addr++) {
1454 temp = swab16(*eepdata);
1458 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
1459 "0x%04X ", *eepdata);
1461 if (((addr + 1) % 6) == 0)
1463 ATH_DBG_EEPROM, "\n");
1466 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
1467 "Invalid EEPROM Magic. "
1468 "endianness mismatch.\n");
1474 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM, "need_swap = %s.\n",
1475 need_swap ? "True" : "False");
1478 el = swab16(ah->eeprom.def.baseEepHeader.length);
1480 el = ah->eeprom.def.baseEepHeader.length;
1482 if (el > sizeof(struct ar5416_eeprom_def))
1483 el = sizeof(struct ar5416_eeprom_def) / sizeof(u16);
1485 el = el / sizeof(u16);
1487 eepdata = (u16 *)(&ah->eeprom);
1489 for (i = 0; i < el; i++)
1496 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
1497 "EEPROM Endianness is not native.. Changing \n");
1499 word = swab16(eep->baseEepHeader.length);
1500 eep->baseEepHeader.length = word;
1502 word = swab16(eep->baseEepHeader.checksum);
1503 eep->baseEepHeader.checksum = word;
1505 word = swab16(eep->baseEepHeader.version);
1506 eep->baseEepHeader.version = word;
1508 word = swab16(eep->baseEepHeader.regDmn[0]);
1509 eep->baseEepHeader.regDmn[0] = word;
1511 word = swab16(eep->baseEepHeader.regDmn[1]);
1512 eep->baseEepHeader.regDmn[1] = word;
1514 word = swab16(eep->baseEepHeader.rfSilent);
1515 eep->baseEepHeader.rfSilent = word;
1517 word = swab16(eep->baseEepHeader.blueToothOptions);
1518 eep->baseEepHeader.blueToothOptions = word;
1520 word = swab16(eep->baseEepHeader.deviceCap);
1521 eep->baseEepHeader.deviceCap = word;
1523 for (j = 0; j < ARRAY_SIZE(eep->modalHeader); j++) {
1524 struct modal_eep_header *pModal =
1525 &eep->modalHeader[j];
1526 integer = swab32(pModal->antCtrlCommon);
1527 pModal->antCtrlCommon = integer;
1529 for (i = 0; i < AR5416_MAX_CHAINS; i++) {
1530 integer = swab32(pModal->antCtrlChain[i]);
1531 pModal->antCtrlChain[i] = integer;
1534 for (i = 0; i < AR5416_EEPROM_MODAL_SPURS; i++) {
1535 word = swab16(pModal->spurChans[i].spurChan);
1536 pModal->spurChans[i].spurChan = word;
1541 if (sum != 0xffff || ah->eep_ops->get_eeprom_ver(ah) != AR5416_EEP_VER ||
1542 ah->eep_ops->get_eeprom_rev(ah) < AR5416_EEP_NO_BACK_VER) {
1543 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
1544 "Bad EEPROM checksum 0x%x or revision 0x%04x\n",
1545 sum, ah->eep_ops->get_eeprom_ver(ah));
1552 static u32 ath9k_hw_def_get_eeprom(struct ath_hw *ah,
1553 enum eeprom_param param)
1555 #define AR5416_VER_MASK (pBase->version & AR5416_EEP_VER_MINOR_MASK)
1556 struct ar5416_eeprom_def *eep = &ah->eeprom.def;
1557 struct modal_eep_header *pModal = eep->modalHeader;
1558 struct base_eep_header *pBase = &eep->baseEepHeader;
1561 case EEP_NFTHRESH_5:
1562 return pModal[0].noiseFloorThreshCh[0];
1563 case EEP_NFTHRESH_2:
1564 return pModal[1].noiseFloorThreshCh[0];
1565 case AR_EEPROM_MAC(0):
1566 return pBase->macAddr[0] << 8 | pBase->macAddr[1];
1567 case AR_EEPROM_MAC(1):
1568 return pBase->macAddr[2] << 8 | pBase->macAddr[3];
1569 case AR_EEPROM_MAC(2):
1570 return pBase->macAddr[4] << 8 | pBase->macAddr[5];
1572 return pBase->regDmn[0];
1574 return pBase->regDmn[1];
1576 return pBase->deviceCap;
1578 return pBase->opCapFlags;
1580 return pBase->rfSilent;
1582 return pModal[0].ob;
1584 return pModal[0].db;
1586 return pModal[1].ob;
1588 return pModal[1].db;
1590 return AR5416_VER_MASK;
1592 return pBase->txMask;
1594 return pBase->rxMask;
1595 case EEP_RXGAIN_TYPE:
1596 return pBase->rxGainType;
1597 case EEP_TXGAIN_TYPE:
1598 return pBase->txGainType;
1599 case EEP_DAC_HPWR_5G:
1600 if (AR5416_VER_MASK >= AR5416_EEP_MINOR_VER_20)
1601 return pBase->dacHiPwrMode_5G;
1605 if (AR5416_VER_MASK >= AR5416_EEP_MINOR_VER_22)
1606 return pBase->frac_n_5g;
1612 #undef AR5416_VER_MASK
1615 /* XXX: Clean me up, make me more legible */
1616 static bool ath9k_hw_def_set_board_values(struct ath_hw *ah,
1617 struct ath9k_channel *chan)
1619 #define AR5416_VER_MASK (eep->baseEepHeader.version & AR5416_EEP_VER_MINOR_MASK)
1620 struct modal_eep_header *pModal;
1621 struct ar5416_eeprom_def *eep = &ah->eeprom.def;
1622 int i, regChainOffset;
1625 pModal = &(eep->modalHeader[IS_CHAN_2GHZ(chan)]);
1627 txRxAttenLocal = IS_CHAN_2GHZ(chan) ? 23 : 44;
1629 REG_WRITE(ah, AR_PHY_SWITCH_COM,
1630 ah->eep_ops->get_eeprom_antenna_cfg(ah, chan));
1632 for (i = 0; i < AR5416_MAX_CHAINS; i++) {
1633 if (AR_SREV_9280(ah)) {
1638 if (AR_SREV_5416_V20_OR_LATER(ah) &&
1639 (ah->rxchainmask == 5 || ah->txchainmask == 5)
1641 regChainOffset = (i == 1) ? 0x2000 : 0x1000;
1643 regChainOffset = i * 0x1000;
1645 REG_WRITE(ah, AR_PHY_SWITCH_CHAIN_0 + regChainOffset,
1646 pModal->antCtrlChain[i]);
1648 REG_WRITE(ah, AR_PHY_TIMING_CTRL4(0) + regChainOffset,
1650 AR_PHY_TIMING_CTRL4(0) +
1652 ~(AR_PHY_TIMING_CTRL4_IQCORR_Q_Q_COFF |
1653 AR_PHY_TIMING_CTRL4_IQCORR_Q_I_COFF)) |
1654 SM(pModal->iqCalICh[i],
1655 AR_PHY_TIMING_CTRL4_IQCORR_Q_I_COFF) |
1656 SM(pModal->iqCalQCh[i],
1657 AR_PHY_TIMING_CTRL4_IQCORR_Q_Q_COFF));
1659 if ((i == 0) || AR_SREV_5416_V20_OR_LATER(ah)) {
1660 if (AR5416_VER_MASK >= AR5416_EEP_MINOR_VER_3) {
1661 txRxAttenLocal = pModal->txRxAttenCh[i];
1662 if (AR_SREV_9280_10_OR_LATER(ah)) {
1666 AR_PHY_GAIN_2GHZ_XATTEN1_MARGIN,
1672 AR_PHY_GAIN_2GHZ_XATTEN1_DB,
1678 AR_PHY_GAIN_2GHZ_XATTEN2_MARGIN,
1684 AR_PHY_GAIN_2GHZ_XATTEN2_DB,
1694 ~AR_PHY_GAIN_2GHZ_BSW_MARGIN)
1697 AR_PHY_GAIN_2GHZ_BSW_MARGIN));
1704 ~AR_PHY_GAIN_2GHZ_BSW_ATTEN)
1705 | SM(pModal->bswAtten[i],
1706 AR_PHY_GAIN_2GHZ_BSW_ATTEN));
1709 if (AR_SREV_9280_10_OR_LATER(ah)) {
1713 AR9280_PHY_RXGAIN_TXRX_ATTEN,
1718 AR9280_PHY_RXGAIN_TXRX_MARGIN,
1719 pModal->rxTxMarginCh[i]);
1722 AR_PHY_RXGAIN + regChainOffset,
1726 ~AR_PHY_RXGAIN_TXRX_ATTEN) |
1728 AR_PHY_RXGAIN_TXRX_ATTEN));
1735 ~AR_PHY_GAIN_2GHZ_RXTX_MARGIN) |
1736 SM(pModal->rxTxMarginCh[i],
1737 AR_PHY_GAIN_2GHZ_RXTX_MARGIN));
1742 if (AR_SREV_9280_10_OR_LATER(ah)) {
1743 if (IS_CHAN_2GHZ(chan)) {
1744 ath9k_hw_analog_shift_rmw(ah, AR_AN_RF2G1_CH0,
1746 AR_AN_RF2G1_CH0_OB_S,
1748 ath9k_hw_analog_shift_rmw(ah, AR_AN_RF2G1_CH0,
1750 AR_AN_RF2G1_CH0_DB_S,
1752 ath9k_hw_analog_shift_rmw(ah, AR_AN_RF2G1_CH1,
1754 AR_AN_RF2G1_CH1_OB_S,
1756 ath9k_hw_analog_shift_rmw(ah, AR_AN_RF2G1_CH1,
1758 AR_AN_RF2G1_CH1_DB_S,
1761 ath9k_hw_analog_shift_rmw(ah, AR_AN_RF5G1_CH0,
1762 AR_AN_RF5G1_CH0_OB5,
1763 AR_AN_RF5G1_CH0_OB5_S,
1765 ath9k_hw_analog_shift_rmw(ah, AR_AN_RF5G1_CH0,
1766 AR_AN_RF5G1_CH0_DB5,
1767 AR_AN_RF5G1_CH0_DB5_S,
1769 ath9k_hw_analog_shift_rmw(ah, AR_AN_RF5G1_CH1,
1770 AR_AN_RF5G1_CH1_OB5,
1771 AR_AN_RF5G1_CH1_OB5_S,
1773 ath9k_hw_analog_shift_rmw(ah, AR_AN_RF5G1_CH1,
1774 AR_AN_RF5G1_CH1_DB5,
1775 AR_AN_RF5G1_CH1_DB5_S,
1778 ath9k_hw_analog_shift_rmw(ah, AR_AN_TOP2,
1779 AR_AN_TOP2_XPABIAS_LVL,
1780 AR_AN_TOP2_XPABIAS_LVL_S,
1781 pModal->xpaBiasLvl);
1782 ath9k_hw_analog_shift_rmw(ah, AR_AN_TOP2,
1783 AR_AN_TOP2_LOCALBIAS,
1784 AR_AN_TOP2_LOCALBIAS_S,
1785 pModal->local_bias);
1786 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM, "ForceXPAon: %d\n",
1787 pModal->force_xpaon);
1788 REG_RMW_FIELD(ah, AR_PHY_XPA_CFG, AR_PHY_FORCE_XPA_CFG,
1789 pModal->force_xpaon);
1792 REG_RMW_FIELD(ah, AR_PHY_SETTLING, AR_PHY_SETTLING_SWITCH,
1793 pModal->switchSettling);
1794 REG_RMW_FIELD(ah, AR_PHY_DESIRED_SZ, AR_PHY_DESIRED_SZ_ADC,
1795 pModal->adcDesiredSize);
1797 if (!AR_SREV_9280_10_OR_LATER(ah))
1798 REG_RMW_FIELD(ah, AR_PHY_DESIRED_SZ,
1799 AR_PHY_DESIRED_SZ_PGA,
1800 pModal->pgaDesiredSize);
1802 REG_WRITE(ah, AR_PHY_RF_CTL4,
1803 SM(pModal->txEndToXpaOff, AR_PHY_RF_CTL4_TX_END_XPAA_OFF)
1804 | SM(pModal->txEndToXpaOff,
1805 AR_PHY_RF_CTL4_TX_END_XPAB_OFF)
1806 | SM(pModal->txFrameToXpaOn,
1807 AR_PHY_RF_CTL4_FRAME_XPAA_ON)
1808 | SM(pModal->txFrameToXpaOn,
1809 AR_PHY_RF_CTL4_FRAME_XPAB_ON));
1811 REG_RMW_FIELD(ah, AR_PHY_RF_CTL3, AR_PHY_TX_END_TO_A2_RX_ON,
1812 pModal->txEndToRxOn);
1813 if (AR_SREV_9280_10_OR_LATER(ah)) {
1814 REG_RMW_FIELD(ah, AR_PHY_CCA, AR9280_PHY_CCA_THRESH62,
1816 REG_RMW_FIELD(ah, AR_PHY_EXT_CCA0,
1817 AR_PHY_EXT_CCA0_THRESH62,
1820 REG_RMW_FIELD(ah, AR_PHY_CCA, AR_PHY_CCA_THRESH62,
1822 REG_RMW_FIELD(ah, AR_PHY_EXT_CCA,
1823 AR_PHY_EXT_CCA_THRESH62,
1827 if (AR5416_VER_MASK >= AR5416_EEP_MINOR_VER_2) {
1828 REG_RMW_FIELD(ah, AR_PHY_RF_CTL2,
1829 AR_PHY_TX_END_DATA_START,
1830 pModal->txFrameToDataStart);
1831 REG_RMW_FIELD(ah, AR_PHY_RF_CTL2, AR_PHY_TX_END_PA_ON,
1832 pModal->txFrameToPaOn);
1835 if (AR5416_VER_MASK >= AR5416_EEP_MINOR_VER_3) {
1836 if (IS_CHAN_HT40(chan))
1837 REG_RMW_FIELD(ah, AR_PHY_SETTLING,
1838 AR_PHY_SETTLING_SWITCH,
1839 pModal->swSettleHt40);
1842 if (AR_SREV_9280_20(ah) && AR5416_VER_MASK >= AR5416_EEP_MINOR_VER_20) {
1843 if (IS_CHAN_HT20(chan))
1844 REG_RMW_FIELD(ah, AR_AN_TOP1, AR_AN_TOP1_DACIPMODE,
1845 eep->baseEepHeader.dacLpMode);
1846 else if (eep->baseEepHeader.dacHiPwrMode_5G)
1847 REG_RMW_FIELD(ah, AR_AN_TOP1, AR_AN_TOP1_DACIPMODE, 0);
1849 REG_RMW_FIELD(ah, AR_AN_TOP1, AR_AN_TOP1_DACIPMODE,
1850 eep->baseEepHeader.dacLpMode);
1852 REG_RMW_FIELD(ah, AR_PHY_FRAME_CTL, AR_PHY_FRAME_CTL_TX_CLIP,
1853 pModal->miscBits >> 2);
1857 #undef AR5416_VER_MASK
1860 static void ath9k_hw_def_set_addac(struct ath_hw *ah,
1861 struct ath9k_channel *chan)
1863 #define XPA_LVL_FREQ(cnt) (pModal->xpaBiasLvlFreq[cnt])
1864 struct modal_eep_header *pModal;
1865 struct ar5416_eeprom_def *eep = &ah->eeprom.def;
1868 if (ah->hw_version.macVersion != AR_SREV_VERSION_9160)
1871 if (ah->eep_ops->get_eeprom_rev(ah) < AR5416_EEP_MINOR_VER_7)
1874 pModal = &(eep->modalHeader[IS_CHAN_2GHZ(chan)]);
1876 if (pModal->xpaBiasLvl != 0xff) {
1877 biaslevel = pModal->xpaBiasLvl;
1879 u16 resetFreqBin, freqBin, freqCount = 0;
1880 struct chan_centers centers;
1882 ath9k_hw_get_channel_centers(ah, chan, ¢ers);
1884 resetFreqBin = FREQ2FBIN(centers.synth_center,
1885 IS_CHAN_2GHZ(chan));
1886 freqBin = XPA_LVL_FREQ(0) & 0xff;
1887 biaslevel = (u8) (XPA_LVL_FREQ(0) >> 14);
1891 while (freqCount < 3) {
1892 if (XPA_LVL_FREQ(freqCount) == 0x0)
1895 freqBin = XPA_LVL_FREQ(freqCount) & 0xff;
1896 if (resetFreqBin >= freqBin)
1897 biaslevel = (u8)(XPA_LVL_FREQ(freqCount) >> 14);
1904 if (IS_CHAN_2GHZ(chan)) {
1905 INI_RA(&ah->iniAddac, 7, 1) = (INI_RA(&ah->iniAddac,
1906 7, 1) & (~0x18)) | biaslevel << 3;
1908 INI_RA(&ah->iniAddac, 6, 1) = (INI_RA(&ah->iniAddac,
1909 6, 1) & (~0xc0)) | biaslevel << 6;
1914 static void ath9k_hw_get_def_gain_boundaries_pdadcs(struct ath_hw *ah,
1915 struct ath9k_channel *chan,
1916 struct cal_data_per_freq *pRawDataSet,
1917 u8 *bChans, u16 availPiers,
1918 u16 tPdGainOverlap, int16_t *pMinCalPower,
1919 u16 *pPdGainBoundaries, u8 *pPDADCValues,
1924 u16 idxL = 0, idxR = 0, numPiers;
1925 static u8 vpdTableL[AR5416_NUM_PD_GAINS]
1926 [AR5416_MAX_PWR_RANGE_IN_HALF_DB];
1927 static u8 vpdTableR[AR5416_NUM_PD_GAINS]
1928 [AR5416_MAX_PWR_RANGE_IN_HALF_DB];
1929 static u8 vpdTableI[AR5416_NUM_PD_GAINS]
1930 [AR5416_MAX_PWR_RANGE_IN_HALF_DB];
1932 u8 *pVpdL, *pVpdR, *pPwrL, *pPwrR;
1933 u8 minPwrT4[AR5416_NUM_PD_GAINS];
1934 u8 maxPwrT4[AR5416_NUM_PD_GAINS];
1937 u16 sizeCurrVpdTable, maxIndex, tgtIndex;
1939 int16_t minDelta = 0;
1940 struct chan_centers centers;
1942 ath9k_hw_get_channel_centers(ah, chan, ¢ers);
1944 for (numPiers = 0; numPiers < availPiers; numPiers++) {
1945 if (bChans[numPiers] == AR5416_BCHAN_UNUSED)
1949 match = ath9k_hw_get_lower_upper_index((u8)FREQ2FBIN(centers.synth_center,
1950 IS_CHAN_2GHZ(chan)),
1951 bChans, numPiers, &idxL, &idxR);
1954 for (i = 0; i < numXpdGains; i++) {
1955 minPwrT4[i] = pRawDataSet[idxL].pwrPdg[i][0];
1956 maxPwrT4[i] = pRawDataSet[idxL].pwrPdg[i][4];
1957 ath9k_hw_fill_vpd_table(minPwrT4[i], maxPwrT4[i],
1958 pRawDataSet[idxL].pwrPdg[i],
1959 pRawDataSet[idxL].vpdPdg[i],
1960 AR5416_PD_GAIN_ICEPTS,
1964 for (i = 0; i < numXpdGains; i++) {
1965 pVpdL = pRawDataSet[idxL].vpdPdg[i];
1966 pPwrL = pRawDataSet[idxL].pwrPdg[i];
1967 pVpdR = pRawDataSet[idxR].vpdPdg[i];
1968 pPwrR = pRawDataSet[idxR].pwrPdg[i];
1970 minPwrT4[i] = max(pPwrL[0], pPwrR[0]);
1973 min(pPwrL[AR5416_PD_GAIN_ICEPTS - 1],
1974 pPwrR[AR5416_PD_GAIN_ICEPTS - 1]);
1977 ath9k_hw_fill_vpd_table(minPwrT4[i], maxPwrT4[i],
1979 AR5416_PD_GAIN_ICEPTS,
1981 ath9k_hw_fill_vpd_table(minPwrT4[i], maxPwrT4[i],
1983 AR5416_PD_GAIN_ICEPTS,
1986 for (j = 0; j <= (maxPwrT4[i] - minPwrT4[i]) / 2; j++) {
1988 (u8)(ath9k_hw_interpolate((u16)
1993 bChans[idxL], bChans[idxR],
1994 vpdTableL[i][j], vpdTableR[i][j]));
1999 *pMinCalPower = (int16_t)(minPwrT4[0] / 2);
2003 for (i = 0; i < numXpdGains; i++) {
2004 if (i == (numXpdGains - 1))
2005 pPdGainBoundaries[i] =
2006 (u16)(maxPwrT4[i] / 2);
2008 pPdGainBoundaries[i] =
2009 (u16)((maxPwrT4[i] + minPwrT4[i + 1]) / 4);
2011 pPdGainBoundaries[i] =
2012 min((u16)AR5416_MAX_RATE_POWER, pPdGainBoundaries[i]);
2014 if ((i == 0) && !AR_SREV_5416_V20_OR_LATER(ah)) {
2015 minDelta = pPdGainBoundaries[0] - 23;
2016 pPdGainBoundaries[0] = 23;
2022 if (AR_SREV_9280_10_OR_LATER(ah))
2023 ss = (int16_t)(0 - (minPwrT4[i] / 2));
2027 ss = (int16_t)((pPdGainBoundaries[i - 1] -
2028 (minPwrT4[i] / 2)) -
2029 tPdGainOverlap + 1 + minDelta);
2031 vpdStep = (int16_t)(vpdTableI[i][1] - vpdTableI[i][0]);
2032 vpdStep = (int16_t)((vpdStep < 1) ? 1 : vpdStep);
2034 while ((ss < 0) && (k < (AR5416_NUM_PDADC_VALUES - 1))) {
2035 tmpVal = (int16_t)(vpdTableI[i][0] + ss * vpdStep);
2036 pPDADCValues[k++] = (u8)((tmpVal < 0) ? 0 : tmpVal);
2040 sizeCurrVpdTable = (u8) ((maxPwrT4[i] - minPwrT4[i]) / 2 + 1);
2041 tgtIndex = (u8)(pPdGainBoundaries[i] + tPdGainOverlap -
2043 maxIndex = (tgtIndex < sizeCurrVpdTable) ?
2044 tgtIndex : sizeCurrVpdTable;
2046 while ((ss < maxIndex) && (k < (AR5416_NUM_PDADC_VALUES - 1))) {
2047 pPDADCValues[k++] = vpdTableI[i][ss++];
2050 vpdStep = (int16_t)(vpdTableI[i][sizeCurrVpdTable - 1] -
2051 vpdTableI[i][sizeCurrVpdTable - 2]);
2052 vpdStep = (int16_t)((vpdStep < 1) ? 1 : vpdStep);
2054 if (tgtIndex > maxIndex) {
2055 while ((ss <= tgtIndex) &&
2056 (k < (AR5416_NUM_PDADC_VALUES - 1))) {
2057 tmpVal = (int16_t)((vpdTableI[i][sizeCurrVpdTable - 1] +
2058 (ss - maxIndex + 1) * vpdStep));
2059 pPDADCValues[k++] = (u8)((tmpVal > 255) ?
2066 while (i < AR5416_PD_GAINS_IN_MASK) {
2067 pPdGainBoundaries[i] = pPdGainBoundaries[i - 1];
2071 while (k < AR5416_NUM_PDADC_VALUES) {
2072 pPDADCValues[k] = pPDADCValues[k - 1];
2079 static bool ath9k_hw_set_def_power_cal_table(struct ath_hw *ah,
2080 struct ath9k_channel *chan,
2081 int16_t *pTxPowerIndexOffset)
2083 struct ar5416_eeprom_def *pEepData = &ah->eeprom.def;
2084 struct cal_data_per_freq *pRawDataset;
2085 u8 *pCalBChans = NULL;
2086 u16 pdGainOverlap_t2;
2087 static u8 pdadcValues[AR5416_NUM_PDADC_VALUES];
2088 u16 gainBoundaries[AR5416_PD_GAINS_IN_MASK];
2090 int16_t tMinCalPower;
2091 u16 numXpdGain, xpdMask;
2092 u16 xpdGainValues[AR5416_NUM_PD_GAINS] = { 0, 0, 0, 0 };
2093 u32 reg32, regOffset, regChainOffset;
2096 modalIdx = IS_CHAN_2GHZ(chan) ? 1 : 0;
2097 xpdMask = pEepData->modalHeader[modalIdx].xpdGain;
2099 if ((pEepData->baseEepHeader.version & AR5416_EEP_VER_MINOR_MASK) >=
2100 AR5416_EEP_MINOR_VER_2) {
2102 pEepData->modalHeader[modalIdx].pdGainOverlap;
2104 pdGainOverlap_t2 = (u16)(MS(REG_READ(ah, AR_PHY_TPCRG5),
2105 AR_PHY_TPCRG5_PD_GAIN_OVERLAP));
2108 if (IS_CHAN_2GHZ(chan)) {
2109 pCalBChans = pEepData->calFreqPier2G;
2110 numPiers = AR5416_NUM_2G_CAL_PIERS;
2112 pCalBChans = pEepData->calFreqPier5G;
2113 numPiers = AR5416_NUM_5G_CAL_PIERS;
2118 for (i = 1; i <= AR5416_PD_GAINS_IN_MASK; i++) {
2119 if ((xpdMask >> (AR5416_PD_GAINS_IN_MASK - i)) & 1) {
2120 if (numXpdGain >= AR5416_NUM_PD_GAINS)
2122 xpdGainValues[numXpdGain] =
2123 (u16)(AR5416_PD_GAINS_IN_MASK - i);
2128 REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_NUM_PD_GAIN,
2129 (numXpdGain - 1) & 0x3);
2130 REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_GAIN_1,
2132 REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_GAIN_2,
2134 REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_GAIN_3,
2137 for (i = 0; i < AR5416_MAX_CHAINS; i++) {
2138 if (AR_SREV_5416_V20_OR_LATER(ah) &&
2139 (ah->rxchainmask == 5 || ah->txchainmask == 5) &&
2141 regChainOffset = (i == 1) ? 0x2000 : 0x1000;
2143 regChainOffset = i * 0x1000;
2145 if (pEepData->baseEepHeader.txMask & (1 << i)) {
2146 if (IS_CHAN_2GHZ(chan))
2147 pRawDataset = pEepData->calPierData2G[i];
2149 pRawDataset = pEepData->calPierData5G[i];
2151 ath9k_hw_get_def_gain_boundaries_pdadcs(ah, chan,
2152 pRawDataset, pCalBChans,
2153 numPiers, pdGainOverlap_t2,
2154 &tMinCalPower, gainBoundaries,
2155 pdadcValues, numXpdGain);
2157 if ((i == 0) || AR_SREV_5416_V20_OR_LATER(ah)) {
2159 AR_PHY_TPCRG5 + regChainOffset,
2160 SM(pdGainOverlap_t2,
2161 AR_PHY_TPCRG5_PD_GAIN_OVERLAP)
2162 | SM(gainBoundaries[0],
2163 AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_1)
2164 | SM(gainBoundaries[1],
2165 AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_2)
2166 | SM(gainBoundaries[2],
2167 AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_3)
2168 | SM(gainBoundaries[3],
2169 AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_4));
2172 regOffset = AR_PHY_BASE + (672 << 2) + regChainOffset;
2173 for (j = 0; j < 32; j++) {
2174 reg32 = ((pdadcValues[4 * j + 0] & 0xFF) << 0) |
2175 ((pdadcValues[4 * j + 1] & 0xFF) << 8) |
2176 ((pdadcValues[4 * j + 2] & 0xFF) << 16)|
2177 ((pdadcValues[4 * j + 3] & 0xFF) << 24);
2178 REG_WRITE(ah, regOffset, reg32);
2180 DPRINTF(ah->ah_sc, ATH_DBG_REG_IO,
2181 "PDADC (%d,%4x): %4.4x %8.8x\n",
2182 i, regChainOffset, regOffset,
2184 DPRINTF(ah->ah_sc, ATH_DBG_REG_IO,
2185 "PDADC: Chain %d | PDADC %3d "
2186 "Value %3d | PDADC %3d Value %3d | "
2187 "PDADC %3d Value %3d | PDADC %3d "
2189 i, 4 * j, pdadcValues[4 * j],
2190 4 * j + 1, pdadcValues[4 * j + 1],
2191 4 * j + 2, pdadcValues[4 * j + 2],
2193 pdadcValues[4 * j + 3]);
2200 *pTxPowerIndexOffset = 0;
2205 static bool ath9k_hw_set_def_power_per_rate_table(struct ath_hw *ah,
2206 struct ath9k_channel *chan,
2207 int16_t *ratesArray,
2209 u16 AntennaReduction,
2210 u16 twiceMaxRegulatoryPower,
2213 #define REDUCE_SCALED_POWER_BY_TWO_CHAIN 6 /* 10*log10(2)*2 */
2214 #define REDUCE_SCALED_POWER_BY_THREE_CHAIN 10 /* 10*log10(3)*2 */
2216 struct ar5416_eeprom_def *pEepData = &ah->eeprom.def;
2217 u16 twiceMaxEdgePower = AR5416_MAX_RATE_POWER;
2218 static const u16 tpScaleReductionTable[5] =
2219 { 0, 3, 6, 9, AR5416_MAX_RATE_POWER };
2222 int16_t twiceLargestAntenna;
2223 struct cal_ctl_data *rep;
2224 struct cal_target_power_leg targetPowerOfdm, targetPowerCck = {
2227 struct cal_target_power_leg targetPowerOfdmExt = {
2228 0, { 0, 0, 0, 0} }, targetPowerCckExt = {
2231 struct cal_target_power_ht targetPowerHt20, targetPowerHt40 = {
2234 u16 scaledPower = 0, minCtlPower, maxRegAllowedPower;
2235 u16 ctlModesFor11a[] =
2236 { CTL_11A, CTL_5GHT20, CTL_11A_EXT, CTL_5GHT40 };
2237 u16 ctlModesFor11g[] =
2238 { CTL_11B, CTL_11G, CTL_2GHT20, CTL_11B_EXT, CTL_11G_EXT,
2241 u16 numCtlModes, *pCtlMode, ctlMode, freq;
2242 struct chan_centers centers;
2244 u16 twiceMinEdgePower;
2246 tx_chainmask = ah->txchainmask;
2248 ath9k_hw_get_channel_centers(ah, chan, ¢ers);
2250 twiceLargestAntenna = max(
2251 pEepData->modalHeader
2252 [IS_CHAN_2GHZ(chan)].antennaGainCh[0],
2253 pEepData->modalHeader
2254 [IS_CHAN_2GHZ(chan)].antennaGainCh[1]);
2256 twiceLargestAntenna = max((u8)twiceLargestAntenna,
2257 pEepData->modalHeader
2258 [IS_CHAN_2GHZ(chan)].antennaGainCh[2]);
2260 twiceLargestAntenna = (int16_t)min(AntennaReduction -
2261 twiceLargestAntenna, 0);
2263 maxRegAllowedPower = twiceMaxRegulatoryPower + twiceLargestAntenna;
2265 if (ah->regulatory.tp_scale != ATH9K_TP_SCALE_MAX) {
2266 maxRegAllowedPower -=
2267 (tpScaleReductionTable[(ah->regulatory.tp_scale)] * 2);
2270 scaledPower = min(powerLimit, maxRegAllowedPower);
2272 switch (ar5416_get_ntxchains(tx_chainmask)) {
2276 scaledPower -= REDUCE_SCALED_POWER_BY_TWO_CHAIN;
2279 scaledPower -= REDUCE_SCALED_POWER_BY_THREE_CHAIN;
2283 scaledPower = max((u16)0, scaledPower);
2285 if (IS_CHAN_2GHZ(chan)) {
2286 numCtlModes = ARRAY_SIZE(ctlModesFor11g) -
2287 SUB_NUM_CTL_MODES_AT_2G_40;
2288 pCtlMode = ctlModesFor11g;
2290 ath9k_hw_get_legacy_target_powers(ah, chan,
2291 pEepData->calTargetPowerCck,
2292 AR5416_NUM_2G_CCK_TARGET_POWERS,
2293 &targetPowerCck, 4, false);
2294 ath9k_hw_get_legacy_target_powers(ah, chan,
2295 pEepData->calTargetPower2G,
2296 AR5416_NUM_2G_20_TARGET_POWERS,
2297 &targetPowerOfdm, 4, false);
2298 ath9k_hw_get_target_powers(ah, chan,
2299 pEepData->calTargetPower2GHT20,
2300 AR5416_NUM_2G_20_TARGET_POWERS,
2301 &targetPowerHt20, 8, false);
2303 if (IS_CHAN_HT40(chan)) {
2304 numCtlModes = ARRAY_SIZE(ctlModesFor11g);
2305 ath9k_hw_get_target_powers(ah, chan,
2306 pEepData->calTargetPower2GHT40,
2307 AR5416_NUM_2G_40_TARGET_POWERS,
2308 &targetPowerHt40, 8, true);
2309 ath9k_hw_get_legacy_target_powers(ah, chan,
2310 pEepData->calTargetPowerCck,
2311 AR5416_NUM_2G_CCK_TARGET_POWERS,
2312 &targetPowerCckExt, 4, true);
2313 ath9k_hw_get_legacy_target_powers(ah, chan,
2314 pEepData->calTargetPower2G,
2315 AR5416_NUM_2G_20_TARGET_POWERS,
2316 &targetPowerOfdmExt, 4, true);
2319 numCtlModes = ARRAY_SIZE(ctlModesFor11a) -
2320 SUB_NUM_CTL_MODES_AT_5G_40;
2321 pCtlMode = ctlModesFor11a;
2323 ath9k_hw_get_legacy_target_powers(ah, chan,
2324 pEepData->calTargetPower5G,
2325 AR5416_NUM_5G_20_TARGET_POWERS,
2326 &targetPowerOfdm, 4, false);
2327 ath9k_hw_get_target_powers(ah, chan,
2328 pEepData->calTargetPower5GHT20,
2329 AR5416_NUM_5G_20_TARGET_POWERS,
2330 &targetPowerHt20, 8, false);
2332 if (IS_CHAN_HT40(chan)) {
2333 numCtlModes = ARRAY_SIZE(ctlModesFor11a);
2334 ath9k_hw_get_target_powers(ah, chan,
2335 pEepData->calTargetPower5GHT40,
2336 AR5416_NUM_5G_40_TARGET_POWERS,
2337 &targetPowerHt40, 8, true);
2338 ath9k_hw_get_legacy_target_powers(ah, chan,
2339 pEepData->calTargetPower5G,
2340 AR5416_NUM_5G_20_TARGET_POWERS,
2341 &targetPowerOfdmExt, 4, true);
2345 for (ctlMode = 0; ctlMode < numCtlModes; ctlMode++) {
2346 bool isHt40CtlMode = (pCtlMode[ctlMode] == CTL_5GHT40) ||
2347 (pCtlMode[ctlMode] == CTL_2GHT40);
2349 freq = centers.synth_center;
2350 else if (pCtlMode[ctlMode] & EXT_ADDITIVE)
2351 freq = centers.ext_center;
2353 freq = centers.ctl_center;
2355 if (ah->eep_ops->get_eeprom_ver(ah) == 14 &&
2356 ah->eep_ops->get_eeprom_rev(ah) <= 2)
2357 twiceMaxEdgePower = AR5416_MAX_RATE_POWER;
2359 DPRINTF(ah->ah_sc, ATH_DBG_POWER_MGMT,
2360 "LOOP-Mode ctlMode %d < %d, isHt40CtlMode %d, "
2361 "EXT_ADDITIVE %d\n",
2362 ctlMode, numCtlModes, isHt40CtlMode,
2363 (pCtlMode[ctlMode] & EXT_ADDITIVE));
2365 for (i = 0; (i < AR5416_NUM_CTLS) && pEepData->ctlIndex[i]; i++) {
2366 DPRINTF(ah->ah_sc, ATH_DBG_POWER_MGMT,
2367 " LOOP-Ctlidx %d: cfgCtl 0x%2.2x "
2368 "pCtlMode 0x%2.2x ctlIndex 0x%2.2x "
2370 i, cfgCtl, pCtlMode[ctlMode],
2371 pEepData->ctlIndex[i], chan->channel);
2373 if ((((cfgCtl & ~CTL_MODE_M) |
2374 (pCtlMode[ctlMode] & CTL_MODE_M)) ==
2375 pEepData->ctlIndex[i]) ||
2376 (((cfgCtl & ~CTL_MODE_M) |
2377 (pCtlMode[ctlMode] & CTL_MODE_M)) ==
2378 ((pEepData->ctlIndex[i] & CTL_MODE_M) | SD_NO_CTL))) {
2379 rep = &(pEepData->ctlData[i]);
2381 twiceMinEdgePower = ath9k_hw_get_max_edge_power(freq,
2382 rep->ctlEdges[ar5416_get_ntxchains(tx_chainmask) - 1],
2383 IS_CHAN_2GHZ(chan), AR5416_NUM_BAND_EDGES);
2385 DPRINTF(ah->ah_sc, ATH_DBG_POWER_MGMT,
2386 " MATCH-EE_IDX %d: ch %d is2 %d "
2387 "2xMinEdge %d chainmask %d chains %d\n",
2388 i, freq, IS_CHAN_2GHZ(chan),
2389 twiceMinEdgePower, tx_chainmask,
2390 ar5416_get_ntxchains
2392 if ((cfgCtl & ~CTL_MODE_M) == SD_NO_CTL) {
2393 twiceMaxEdgePower = min(twiceMaxEdgePower,
2396 twiceMaxEdgePower = twiceMinEdgePower;
2402 minCtlPower = min(twiceMaxEdgePower, scaledPower);
2404 DPRINTF(ah->ah_sc, ATH_DBG_POWER_MGMT,
2405 " SEL-Min ctlMode %d pCtlMode %d "
2406 "2xMaxEdge %d sP %d minCtlPwr %d\n",
2407 ctlMode, pCtlMode[ctlMode], twiceMaxEdgePower,
2408 scaledPower, minCtlPower);
2410 switch (pCtlMode[ctlMode]) {
2412 for (i = 0; i < ARRAY_SIZE(targetPowerCck.tPow2x); i++) {
2413 targetPowerCck.tPow2x[i] =
2414 min((u16)targetPowerCck.tPow2x[i],
2420 for (i = 0; i < ARRAY_SIZE(targetPowerOfdm.tPow2x); i++) {
2421 targetPowerOfdm.tPow2x[i] =
2422 min((u16)targetPowerOfdm.tPow2x[i],
2428 for (i = 0; i < ARRAY_SIZE(targetPowerHt20.tPow2x); i++) {
2429 targetPowerHt20.tPow2x[i] =
2430 min((u16)targetPowerHt20.tPow2x[i],
2435 targetPowerCckExt.tPow2x[0] = min((u16)
2436 targetPowerCckExt.tPow2x[0],
2441 targetPowerOfdmExt.tPow2x[0] = min((u16)
2442 targetPowerOfdmExt.tPow2x[0],
2447 for (i = 0; i < ARRAY_SIZE(targetPowerHt40.tPow2x); i++) {
2448 targetPowerHt40.tPow2x[i] =
2449 min((u16)targetPowerHt40.tPow2x[i],
2458 ratesArray[rate6mb] = ratesArray[rate9mb] = ratesArray[rate12mb] =
2459 ratesArray[rate18mb] = ratesArray[rate24mb] =
2460 targetPowerOfdm.tPow2x[0];
2461 ratesArray[rate36mb] = targetPowerOfdm.tPow2x[1];
2462 ratesArray[rate48mb] = targetPowerOfdm.tPow2x[2];
2463 ratesArray[rate54mb] = targetPowerOfdm.tPow2x[3];
2464 ratesArray[rateXr] = targetPowerOfdm.tPow2x[0];
2466 for (i = 0; i < ARRAY_SIZE(targetPowerHt20.tPow2x); i++)
2467 ratesArray[rateHt20_0 + i] = targetPowerHt20.tPow2x[i];
2469 if (IS_CHAN_2GHZ(chan)) {
2470 ratesArray[rate1l] = targetPowerCck.tPow2x[0];
2471 ratesArray[rate2s] = ratesArray[rate2l] =
2472 targetPowerCck.tPow2x[1];
2473 ratesArray[rate5_5s] = ratesArray[rate5_5l] =
2474 targetPowerCck.tPow2x[2];
2476 ratesArray[rate11s] = ratesArray[rate11l] =
2477 targetPowerCck.tPow2x[3];
2480 if (IS_CHAN_HT40(chan)) {
2481 for (i = 0; i < ARRAY_SIZE(targetPowerHt40.tPow2x); i++) {
2482 ratesArray[rateHt40_0 + i] =
2483 targetPowerHt40.tPow2x[i];
2485 ratesArray[rateDupOfdm] = targetPowerHt40.tPow2x[0];
2486 ratesArray[rateDupCck] = targetPowerHt40.tPow2x[0];
2487 ratesArray[rateExtOfdm] = targetPowerOfdmExt.tPow2x[0];
2488 if (IS_CHAN_2GHZ(chan)) {
2489 ratesArray[rateExtCck] =
2490 targetPowerCckExt.tPow2x[0];
2496 static int ath9k_hw_def_set_txpower(struct ath_hw *ah,
2497 struct ath9k_channel *chan,
2499 u8 twiceAntennaReduction,
2500 u8 twiceMaxRegulatoryPower,
2503 struct ar5416_eeprom_def *pEepData = &ah->eeprom.def;
2504 struct modal_eep_header *pModal =
2505 &(pEepData->modalHeader[IS_CHAN_2GHZ(chan)]);
2506 int16_t ratesArray[Ar5416RateSize];
2507 int16_t txPowerIndexOffset = 0;
2508 u8 ht40PowerIncForPdadc = 2;
2511 memset(ratesArray, 0, sizeof(ratesArray));
2513 if ((pEepData->baseEepHeader.version & AR5416_EEP_VER_MINOR_MASK) >=
2514 AR5416_EEP_MINOR_VER_2) {
2515 ht40PowerIncForPdadc = pModal->ht40PowerIncForPdadc;
2518 if (!ath9k_hw_set_def_power_per_rate_table(ah, chan,
2519 &ratesArray[0], cfgCtl,
2520 twiceAntennaReduction,
2521 twiceMaxRegulatoryPower,
2523 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
2524 "ath9k_hw_set_txpower: unable to set "
2525 "tx power per rate table\n");
2529 if (!ath9k_hw_set_def_power_cal_table(ah, chan, &txPowerIndexOffset)) {
2530 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
2531 "ath9k_hw_set_txpower: unable to set power table\n");
2535 for (i = 0; i < ARRAY_SIZE(ratesArray); i++) {
2536 ratesArray[i] = (int16_t)(txPowerIndexOffset + ratesArray[i]);
2537 if (ratesArray[i] > AR5416_MAX_RATE_POWER)
2538 ratesArray[i] = AR5416_MAX_RATE_POWER;
2541 if (AR_SREV_9280_10_OR_LATER(ah)) {
2542 for (i = 0; i < Ar5416RateSize; i++)
2543 ratesArray[i] -= AR5416_PWR_TABLE_OFFSET * 2;
2546 REG_WRITE(ah, AR_PHY_POWER_TX_RATE1,
2547 ATH9K_POW_SM(ratesArray[rate18mb], 24)
2548 | ATH9K_POW_SM(ratesArray[rate12mb], 16)
2549 | ATH9K_POW_SM(ratesArray[rate9mb], 8)
2550 | ATH9K_POW_SM(ratesArray[rate6mb], 0));
2551 REG_WRITE(ah, AR_PHY_POWER_TX_RATE2,
2552 ATH9K_POW_SM(ratesArray[rate54mb], 24)
2553 | ATH9K_POW_SM(ratesArray[rate48mb], 16)
2554 | ATH9K_POW_SM(ratesArray[rate36mb], 8)
2555 | ATH9K_POW_SM(ratesArray[rate24mb], 0));
2557 if (IS_CHAN_2GHZ(chan)) {
2558 REG_WRITE(ah, AR_PHY_POWER_TX_RATE3,
2559 ATH9K_POW_SM(ratesArray[rate2s], 24)
2560 | ATH9K_POW_SM(ratesArray[rate2l], 16)
2561 | ATH9K_POW_SM(ratesArray[rateXr], 8)
2562 | ATH9K_POW_SM(ratesArray[rate1l], 0));
2563 REG_WRITE(ah, AR_PHY_POWER_TX_RATE4,
2564 ATH9K_POW_SM(ratesArray[rate11s], 24)
2565 | ATH9K_POW_SM(ratesArray[rate11l], 16)
2566 | ATH9K_POW_SM(ratesArray[rate5_5s], 8)
2567 | ATH9K_POW_SM(ratesArray[rate5_5l], 0));
2570 REG_WRITE(ah, AR_PHY_POWER_TX_RATE5,
2571 ATH9K_POW_SM(ratesArray[rateHt20_3], 24)
2572 | ATH9K_POW_SM(ratesArray[rateHt20_2], 16)
2573 | ATH9K_POW_SM(ratesArray[rateHt20_1], 8)
2574 | ATH9K_POW_SM(ratesArray[rateHt20_0], 0));
2575 REG_WRITE(ah, AR_PHY_POWER_TX_RATE6,
2576 ATH9K_POW_SM(ratesArray[rateHt20_7], 24)
2577 | ATH9K_POW_SM(ratesArray[rateHt20_6], 16)
2578 | ATH9K_POW_SM(ratesArray[rateHt20_5], 8)
2579 | ATH9K_POW_SM(ratesArray[rateHt20_4], 0));
2581 if (IS_CHAN_HT40(chan)) {
2582 REG_WRITE(ah, AR_PHY_POWER_TX_RATE7,
2583 ATH9K_POW_SM(ratesArray[rateHt40_3] +
2584 ht40PowerIncForPdadc, 24)
2585 | ATH9K_POW_SM(ratesArray[rateHt40_2] +
2586 ht40PowerIncForPdadc, 16)
2587 | ATH9K_POW_SM(ratesArray[rateHt40_1] +
2588 ht40PowerIncForPdadc, 8)
2589 | ATH9K_POW_SM(ratesArray[rateHt40_0] +
2590 ht40PowerIncForPdadc, 0));
2591 REG_WRITE(ah, AR_PHY_POWER_TX_RATE8,
2592 ATH9K_POW_SM(ratesArray[rateHt40_7] +
2593 ht40PowerIncForPdadc, 24)
2594 | ATH9K_POW_SM(ratesArray[rateHt40_6] +
2595 ht40PowerIncForPdadc, 16)
2596 | ATH9K_POW_SM(ratesArray[rateHt40_5] +
2597 ht40PowerIncForPdadc, 8)
2598 | ATH9K_POW_SM(ratesArray[rateHt40_4] +
2599 ht40PowerIncForPdadc, 0));
2601 REG_WRITE(ah, AR_PHY_POWER_TX_RATE9,
2602 ATH9K_POW_SM(ratesArray[rateExtOfdm], 24)
2603 | ATH9K_POW_SM(ratesArray[rateExtCck], 16)
2604 | ATH9K_POW_SM(ratesArray[rateDupOfdm], 8)
2605 | ATH9K_POW_SM(ratesArray[rateDupCck], 0));
2608 REG_WRITE(ah, AR_PHY_POWER_TX_SUB,
2609 ATH9K_POW_SM(pModal->pwrDecreaseFor3Chain, 6)
2610 | ATH9K_POW_SM(pModal->pwrDecreaseFor2Chain, 0));
2614 if (IS_CHAN_HT40(chan))
2616 else if (IS_CHAN_HT20(chan))
2619 if (AR_SREV_9280_10_OR_LATER(ah))
2620 ah->regulatory.max_power_level =
2621 ratesArray[i] + AR5416_PWR_TABLE_OFFSET * 2;
2623 ah->regulatory.max_power_level = ratesArray[i];
2625 switch(ar5416_get_ntxchains(ah->txchainmask)) {
2629 ah->regulatory.max_power_level += INCREASE_MAXPOW_BY_TWO_CHAIN;
2632 ah->regulatory.max_power_level += INCREASE_MAXPOW_BY_THREE_CHAIN;
2635 DPRINTF(ah->ah_sc, ATH_DBG_EEPROM,
2636 "Invalid chainmask configuration\n");
2643 static u8 ath9k_hw_def_get_num_ant_config(struct ath_hw *ah,
2644 enum ieee80211_band freq_band)
2646 struct ar5416_eeprom_def *eep = &ah->eeprom.def;
2647 struct modal_eep_header *pModal =
2648 &(eep->modalHeader[ATH9K_HAL_FREQ_BAND_2GHZ == freq_band]);
2649 struct base_eep_header *pBase = &eep->baseEepHeader;
2654 if (pBase->version >= 0x0E0D)
2655 if (pModal->useAnt1)
2656 num_ant_config += 1;
2658 return num_ant_config;
2661 static u16 ath9k_hw_def_get_eeprom_antenna_cfg(struct ath_hw *ah,
2662 struct ath9k_channel *chan)
2664 struct ar5416_eeprom_def *eep = &ah->eeprom.def;
2665 struct modal_eep_header *pModal =
2666 &(eep->modalHeader[IS_CHAN_2GHZ(chan)]);
2668 return pModal->antCtrlCommon & 0xFFFF;
2671 static u16 ath9k_hw_def_get_spur_channel(struct ath_hw *ah, u16 i, bool is2GHz)
2673 #define EEP_DEF_SPURCHAN \
2674 (ah->eeprom.def.modalHeader[is2GHz].spurChans[i].spurChan)
2676 u16 spur_val = AR_NO_SPUR;
2678 DPRINTF(ah->ah_sc, ATH_DBG_ANI,
2679 "Getting spur idx %d is2Ghz. %d val %x\n",
2680 i, is2GHz, ah->config.spurchans[i][is2GHz]);
2682 switch (ah->config.spurmode) {
2685 case SPUR_ENABLE_IOCTL:
2686 spur_val = ah->config.spurchans[i][is2GHz];
2687 DPRINTF(ah->ah_sc, ATH_DBG_ANI,
2688 "Getting spur val from new loc. %d\n", spur_val);
2690 case SPUR_ENABLE_EEPROM:
2691 spur_val = EEP_DEF_SPURCHAN;
2697 #undef EEP_DEF_SPURCHAN
2700 static struct eeprom_ops eep_def_ops = {
2701 .check_eeprom = ath9k_hw_def_check_eeprom,
2702 .get_eeprom = ath9k_hw_def_get_eeprom,
2703 .fill_eeprom = ath9k_hw_def_fill_eeprom,
2704 .get_eeprom_ver = ath9k_hw_def_get_eeprom_ver,
2705 .get_eeprom_rev = ath9k_hw_def_get_eeprom_rev,
2706 .get_num_ant_config = ath9k_hw_def_get_num_ant_config,
2707 .get_eeprom_antenna_cfg = ath9k_hw_def_get_eeprom_antenna_cfg,
2708 .set_board_values = ath9k_hw_def_set_board_values,
2709 .set_addac = ath9k_hw_def_set_addac,
2710 .set_txpower = ath9k_hw_def_set_txpower,
2711 .get_spur_channel = ath9k_hw_def_get_spur_channel
2714 int ath9k_hw_eeprom_attach(struct ath_hw *ah)
2718 if (AR_SREV_9285(ah)) {
2719 ah->eep_map = EEP_MAP_4KBITS;
2720 ah->eep_ops = &eep_4k_ops;
2722 ah->eep_map = EEP_MAP_DEFAULT;
2723 ah->eep_ops = &eep_def_ops;
2726 if (!ah->eep_ops->fill_eeprom(ah))
2729 status = ah->eep_ops->check_eeprom(ah);