1 /*- 2 * SPDX-License-Identifier: ISC 3 * 4 * Copyright (c) 2002-2009 Sam Leffler, Errno Consulting 5 * Copyright (c) 2002-2008 Atheros Communications, Inc. 6 * 7 * Permission to use, copy, modify, and/or distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 * 19 * $FreeBSD$ 20 */ 21 #include "opt_ah.h" 22 23 #include "ah.h" 24 #include "ah_internal.h" 25 #include "ah_devid.h" 26 27 #include "ar5212/ar5212.h" 28 #include "ar5212/ar5212reg.h" 29 #include "ar5212/ar5212phy.h" 30 31 #include "ah_eeprom_v3.h" 32 33 /* Additional Time delay to wait after activiting the Base band */ 34 #define BASE_ACTIVATE_DELAY 100 /* 100 usec */ 35 #define PLL_SETTLE_DELAY 300 /* 300 usec */ 36 37 static HAL_BOOL ar5212SetResetReg(struct ath_hal *, uint32_t resetMask); 38 /* NB: public for 5312 use */ 39 HAL_BOOL ar5212IsSpurChannel(struct ath_hal *, 40 const struct ieee80211_channel *); 41 HAL_BOOL ar5212ChannelChange(struct ath_hal *, 42 const struct ieee80211_channel *); 43 int16_t ar5212GetNf(struct ath_hal *, struct ieee80211_channel *); 44 HAL_BOOL ar5212SetBoardValues(struct ath_hal *, 45 const struct ieee80211_channel *); 46 void ar5212SetDeltaSlope(struct ath_hal *, 47 const struct ieee80211_channel *); 48 HAL_BOOL ar5212SetTransmitPower(struct ath_hal *ah, 49 const struct ieee80211_channel *chan, uint16_t *rfXpdGain); 50 static HAL_BOOL ar5212SetRateTable(struct ath_hal *, 51 const struct ieee80211_channel *, int16_t tpcScaleReduction, 52 int16_t powerLimit, 53 HAL_BOOL commit, int16_t *minPower, int16_t *maxPower); 54 static void ar5212CorrectGainDelta(struct ath_hal *, int twiceOfdmCckDelta); 55 static void ar5212GetTargetPowers(struct ath_hal *, 56 const struct ieee80211_channel *, 57 const TRGT_POWER_INFO *pPowerInfo, uint16_t numChannels, 58 TRGT_POWER_INFO *pNewPower); 59 static uint16_t ar5212GetMaxEdgePower(uint16_t channel, 60 const RD_EDGES_POWER *pRdEdgesPower); 61 void ar5212SetRateDurationTable(struct ath_hal *, 62 const struct ieee80211_channel *); 63 void ar5212SetIFSTiming(struct ath_hal *, 64 const struct ieee80211_channel *); 65 66 /* NB: public for RF backend use */ 67 void ar5212GetLowerUpperValues(uint16_t value, 68 uint16_t *pList, uint16_t listSize, 69 uint16_t *pLowerValue, uint16_t *pUpperValue); 70 void ar5212ModifyRfBuffer(uint32_t *rfBuf, uint32_t reg32, 71 uint32_t numBits, uint32_t firstBit, uint32_t column); 72 73 static int 74 write_common(struct ath_hal *ah, const HAL_INI_ARRAY *ia, 75 HAL_BOOL bChannelChange, int writes) 76 { 77 #define IS_NO_RESET_TIMER_ADDR(x) \ 78 ( (((x) >= AR_BEACON) && ((x) <= AR_CFP_DUR)) || \ 79 (((x) >= AR_SLEEP1) && ((x) <= AR_SLEEP3))) 80 #define V(r, c) (ia)->data[((r)*(ia)->cols) + (c)] 81 int r; 82 83 /* Write Common Array Parameters */ 84 for (r = 0; r < ia->rows; r++) { 85 uint32_t reg = V(r, 0); 86 /* XXX timer/beacon setup registers? */ 87 /* On channel change, don't reset the PCU registers */ 88 if (!(bChannelChange && IS_NO_RESET_TIMER_ADDR(reg))) { 89 OS_REG_WRITE(ah, reg, V(r, 1)); 90 DMA_YIELD(writes); 91 } 92 } 93 return writes; 94 #undef IS_NO_RESET_TIMER_ADDR 95 #undef V 96 } 97 98 #define IS_DISABLE_FAST_ADC_CHAN(x) (((x) == 2462) || ((x) == 2467)) 99 100 /* 101 * XXX NDIS 5.x code had MAX_RESET_WAIT set to 2000 for AP code 102 * and 10 for Client code 103 */ 104 #define MAX_RESET_WAIT 10 105 106 #define TX_QUEUEPEND_CHECK 1 107 #define TX_ENABLE_CHECK 2 108 #define RX_ENABLE_CHECK 4 109 110 /* 111 * Places the device in and out of reset and then places sane 112 * values in the registers based on EEPROM config, initialization 113 * vectors (as determined by the mode), and station configuration 114 * 115 * bChannelChange is used to preserve DMA/PCU registers across 116 * a HW Reset during channel change. 117 */ 118 HAL_BOOL 119 ar5212Reset(struct ath_hal *ah, HAL_OPMODE opmode, 120 struct ieee80211_channel *chan, 121 HAL_BOOL bChannelChange, 122 HAL_RESET_TYPE resetType, 123 HAL_STATUS *status) 124 { 125 #define N(a) (sizeof (a) / sizeof (a[0])) 126 #define FAIL(_code) do { ecode = _code; goto bad; } while (0) 127 struct ath_hal_5212 *ahp = AH5212(ah); 128 HAL_CHANNEL_INTERNAL *ichan = AH_NULL; 129 const HAL_EEPROM *ee; 130 uint32_t softLedCfg, softLedState; 131 uint32_t saveFrameSeqCount, saveDefAntenna, saveLedState; 132 uint32_t macStaId1, synthDelay, txFrm2TxDStart; 133 uint16_t rfXpdGain[MAX_NUM_PDGAINS_PER_CHANNEL]; 134 int16_t cckOfdmPwrDelta = 0; 135 u_int modesIndex, freqIndex; 136 HAL_STATUS ecode; 137 int i, regWrites; 138 uint32_t testReg, powerVal; 139 int8_t twiceAntennaGain, twiceAntennaReduction; 140 uint32_t ackTpcPow, ctsTpcPow, chirpTpcPow; 141 HAL_BOOL isBmode = AH_FALSE; 142 143 HALASSERT(ah->ah_magic == AR5212_MAGIC); 144 ee = AH_PRIVATE(ah)->ah_eeprom; 145 146 OS_MARK(ah, AH_MARK_RESET, bChannelChange); 147 148 /* Bring out of sleep mode */ 149 if (!ar5212SetPowerMode(ah, HAL_PM_AWAKE, AH_TRUE)) { 150 HALDEBUG(ah, HAL_DEBUG_ANY, "%s: chip did not wakeup\n", 151 __func__); 152 FAIL(HAL_EIO); 153 } 154 155 /* 156 * Map public channel to private. 157 */ 158 ichan = ath_hal_checkchannel(ah, chan); 159 if (ichan == AH_NULL) 160 FAIL(HAL_EINVAL); 161 switch (opmode) { 162 case HAL_M_STA: 163 case HAL_M_IBSS: 164 case HAL_M_HOSTAP: 165 case HAL_M_MONITOR: 166 break; 167 default: 168 HALDEBUG(ah, HAL_DEBUG_ANY, "%s: invalid operating mode %u\n", 169 __func__, opmode); 170 FAIL(HAL_EINVAL); 171 break; 172 } 173 HALASSERT(AH_PRIVATE(ah)->ah_eeversion >= AR_EEPROM_VER3); 174 175 SAVE_CCK(ah, chan, isBmode); 176 177 /* Preserve certain DMA hardware registers on a channel change */ 178 if (bChannelChange) { 179 /* 180 * On Venice, the TSF is almost preserved across a reset; 181 * it requires doubling writes to the RESET_TSF 182 * bit in the AR_BEACON register; it also has the quirk 183 * of the TSF going back in time on the station (station 184 * latches onto the last beacon's tsf during a reset 50% 185 * of the times); the latter is not a problem for adhoc 186 * stations since as long as the TSF is behind, it will 187 * get resynchronized on receiving the next beacon; the 188 * TSF going backwards in time could be a problem for the 189 * sleep operation (supported on infrastructure stations 190 * only) - the best and most general fix for this situation 191 * is to resynchronize the various sleep/beacon timers on 192 * the receipt of the next beacon i.e. when the TSF itself 193 * gets resynchronized to the AP's TSF - power save is 194 * needed to be temporarily disabled until that time 195 * 196 * Need to save the sequence number to restore it after 197 * the reset! 198 */ 199 saveFrameSeqCount = OS_REG_READ(ah, AR_D_SEQNUM); 200 } else 201 saveFrameSeqCount = 0; /* NB: silence compiler */ 202 203 /* Blank the channel survey statistics */ 204 ath_hal_survey_clear(ah); 205 206 #if 0 207 /* 208 * XXX disable for now; this appears to sometimes cause OFDM 209 * XXX timing error floods when ani is enabled and bg scanning 210 * XXX kicks in 211 */ 212 /* If the channel change is across the same mode - perform a fast channel change */ 213 if (IS_2413(ah) || IS_5413(ah)) { 214 /* 215 * Fast channel change can only be used when: 216 * -channel change requested - so it's not the initial reset. 217 * -it's not a change to the current channel - 218 * often called when switching modes on a channel 219 * -the modes of the previous and requested channel are the 220 * same 221 * XXX opmode shouldn't change either? 222 */ 223 if (bChannelChange && 224 (AH_PRIVATE(ah)->ah_curchan != AH_NULL) && 225 (chan->ic_freq != AH_PRIVATE(ah)->ah_curchan->ic_freq) && 226 ((chan->ic_flags & IEEE80211_CHAN_ALLTURBO) == 227 (AH_PRIVATE(ah)->ah_curchan->ic_flags & IEEE80211_CHAN_ALLTURBO))) { 228 if (ar5212ChannelChange(ah, chan)) { 229 /* If ChannelChange completed - skip the rest of reset */ 230 /* XXX ani? */ 231 goto done; 232 } 233 } 234 } 235 #endif 236 /* 237 * Preserve the antenna on a channel change 238 */ 239 saveDefAntenna = OS_REG_READ(ah, AR_DEF_ANTENNA); 240 if (saveDefAntenna == 0) /* XXX magic constants */ 241 saveDefAntenna = 1; 242 243 /* Save hardware flag before chip reset clears the register */ 244 macStaId1 = OS_REG_READ(ah, AR_STA_ID1) & 245 (AR_STA_ID1_BASE_RATE_11B | AR_STA_ID1_USE_DEFANT); 246 247 /* Save led state from pci config register */ 248 saveLedState = OS_REG_READ(ah, AR_PCICFG) & 249 (AR_PCICFG_LEDCTL | AR_PCICFG_LEDMODE | AR_PCICFG_LEDBLINK | 250 AR_PCICFG_LEDSLOW); 251 softLedCfg = OS_REG_READ(ah, AR_GPIOCR); 252 softLedState = OS_REG_READ(ah, AR_GPIODO); 253 254 ar5212RestoreClock(ah, opmode); /* move to refclk operation */ 255 256 /* 257 * Adjust gain parameters before reset if 258 * there's an outstanding gain updated. 259 */ 260 (void) ar5212GetRfgain(ah); 261 262 if (!ar5212ChipReset(ah, chan)) { 263 HALDEBUG(ah, HAL_DEBUG_ANY, "%s: chip reset failed\n", __func__); 264 FAIL(HAL_EIO); 265 } 266 267 /* Setup the indices for the next set of register array writes */ 268 if (IEEE80211_IS_CHAN_2GHZ(chan)) { 269 freqIndex = 2; 270 if (IEEE80211_IS_CHAN_108G(chan)) 271 modesIndex = 5; 272 else if (IEEE80211_IS_CHAN_G(chan)) 273 modesIndex = 4; 274 else if (IEEE80211_IS_CHAN_B(chan)) 275 modesIndex = 3; 276 else { 277 HALDEBUG(ah, HAL_DEBUG_ANY, 278 "%s: invalid channel %u/0x%x\n", 279 __func__, chan->ic_freq, chan->ic_flags); 280 FAIL(HAL_EINVAL); 281 } 282 } else { 283 freqIndex = 1; 284 if (IEEE80211_IS_CHAN_TURBO(chan)) 285 modesIndex = 2; 286 else if (IEEE80211_IS_CHAN_A(chan)) 287 modesIndex = 1; 288 else { 289 HALDEBUG(ah, HAL_DEBUG_ANY, 290 "%s: invalid channel %u/0x%x\n", 291 __func__, chan->ic_freq, chan->ic_flags); 292 FAIL(HAL_EINVAL); 293 } 294 } 295 296 OS_MARK(ah, AH_MARK_RESET_LINE, __LINE__); 297 298 /* Set correct Baseband to analog shift setting to access analog chips. */ 299 OS_REG_WRITE(ah, AR_PHY(0), 0x00000007); 300 301 regWrites = ath_hal_ini_write(ah, &ahp->ah_ini_modes, modesIndex, 0); 302 regWrites = write_common(ah, &ahp->ah_ini_common, bChannelChange, 303 regWrites); 304 #ifdef AH_RXCFG_SDMAMW_4BYTES 305 /* 306 * Nala doesn't work with 128 byte bursts on pb42(hydra) (ar71xx), 307 * use 4 instead. Enabling it on all platforms would hurt performance, 308 * so we only enable it on the ones that are affected by it. 309 */ 310 OS_REG_WRITE(ah, AR_RXCFG, 0); 311 #endif 312 ahp->ah_rfHal->writeRegs(ah, modesIndex, freqIndex, regWrites); 313 314 OS_MARK(ah, AH_MARK_RESET_LINE, __LINE__); 315 316 if (IEEE80211_IS_CHAN_HALF(chan) || IEEE80211_IS_CHAN_QUARTER(chan)) { 317 ar5212SetIFSTiming(ah, chan); 318 if (IS_5413(ah)) { 319 /* 320 * Force window_length for 1/2 and 1/4 rate channels, 321 * the ini file sets this to zero otherwise. 322 */ 323 OS_REG_RMW_FIELD(ah, AR_PHY_FRAME_CTL, 324 AR_PHY_FRAME_CTL_WINLEN, 3); 325 } 326 } 327 328 /* Overwrite INI values for revised chipsets */ 329 if (AH_PRIVATE(ah)->ah_phyRev >= AR_PHY_CHIP_ID_REV_2) { 330 /* ADC_CTL */ 331 OS_REG_WRITE(ah, AR_PHY_ADC_CTL, 332 SM(2, AR_PHY_ADC_CTL_OFF_INBUFGAIN) | 333 SM(2, AR_PHY_ADC_CTL_ON_INBUFGAIN) | 334 AR_PHY_ADC_CTL_OFF_PWDDAC | 335 AR_PHY_ADC_CTL_OFF_PWDADC); 336 337 /* TX_PWR_ADJ */ 338 if (ichan->channel == 2484) { 339 cckOfdmPwrDelta = SCALE_OC_DELTA( 340 ee->ee_cckOfdmPwrDelta - 341 ee->ee_scaledCh14FilterCckDelta); 342 } else { 343 cckOfdmPwrDelta = SCALE_OC_DELTA( 344 ee->ee_cckOfdmPwrDelta); 345 } 346 347 if (IEEE80211_IS_CHAN_G(chan)) { 348 OS_REG_WRITE(ah, AR_PHY_TXPWRADJ, 349 SM((ee->ee_cckOfdmPwrDelta*-1), 350 AR_PHY_TXPWRADJ_CCK_GAIN_DELTA) | 351 SM((cckOfdmPwrDelta*-1), 352 AR_PHY_TXPWRADJ_CCK_PCDAC_INDEX)); 353 } else { 354 OS_REG_WRITE(ah, AR_PHY_TXPWRADJ, 0); 355 } 356 357 /* Add barker RSSI thresh enable as disabled */ 358 OS_REG_CLR_BIT(ah, AR_PHY_DAG_CTRLCCK, 359 AR_PHY_DAG_CTRLCCK_EN_RSSI_THR); 360 OS_REG_RMW_FIELD(ah, AR_PHY_DAG_CTRLCCK, 361 AR_PHY_DAG_CTRLCCK_RSSI_THR, 2); 362 363 /* Set the mute mask to the correct default */ 364 OS_REG_WRITE(ah, AR_SEQ_MASK, 0x0000000F); 365 } 366 367 if (AH_PRIVATE(ah)->ah_phyRev >= AR_PHY_CHIP_ID_REV_3) { 368 /* Clear reg to alllow RX_CLEAR line debug */ 369 OS_REG_WRITE(ah, AR_PHY_BLUETOOTH, 0); 370 } 371 if (AH_PRIVATE(ah)->ah_phyRev >= AR_PHY_CHIP_ID_REV_4) { 372 #ifdef notyet 373 /* Enable burst prefetch for the data queues */ 374 OS_REG_RMW_FIELD(ah, AR_D_FPCTL, ... ); 375 /* Enable double-buffering */ 376 OS_REG_CLR_BIT(ah, AR_TXCFG, AR_TXCFG_DBL_BUF_DIS); 377 #endif 378 } 379 380 /* Set ADC/DAC select values */ 381 OS_REG_WRITE(ah, AR_PHY_SLEEP_SCAL, 0x0e); 382 383 if (IS_5413(ah) || IS_2417(ah)) { 384 uint32_t newReg = 1; 385 if (IS_DISABLE_FAST_ADC_CHAN(ichan->channel)) 386 newReg = 0; 387 /* As it's a clock changing register, only write when the value needs to be changed */ 388 if (OS_REG_READ(ah, AR_PHY_FAST_ADC) != newReg) 389 OS_REG_WRITE(ah, AR_PHY_FAST_ADC, newReg); 390 } 391 392 /* Setup the transmit power values. */ 393 if (!ar5212SetTransmitPower(ah, chan, rfXpdGain)) { 394 HALDEBUG(ah, HAL_DEBUG_ANY, 395 "%s: error init'ing transmit power\n", __func__); 396 FAIL(HAL_EIO); 397 } 398 399 /* Write the analog registers */ 400 if (!ahp->ah_rfHal->setRfRegs(ah, chan, modesIndex, rfXpdGain)) { 401 HALDEBUG(ah, HAL_DEBUG_ANY, "%s: ar5212SetRfRegs failed\n", 402 __func__); 403 FAIL(HAL_EIO); 404 } 405 406 /* Write delta slope for OFDM enabled modes (A, G, Turbo) */ 407 if (IEEE80211_IS_CHAN_OFDM(chan)) { 408 if (IS_5413(ah) || 409 AH_PRIVATE(ah)->ah_eeversion >= AR_EEPROM_VER5_3) 410 ar5212SetSpurMitigation(ah, chan); 411 ar5212SetDeltaSlope(ah, chan); 412 } 413 414 /* Setup board specific options for EEPROM version 3 */ 415 if (!ar5212SetBoardValues(ah, chan)) { 416 HALDEBUG(ah, HAL_DEBUG_ANY, 417 "%s: error setting board options\n", __func__); 418 FAIL(HAL_EIO); 419 } 420 421 /* Restore certain DMA hardware registers on a channel change */ 422 if (bChannelChange) 423 OS_REG_WRITE(ah, AR_D_SEQNUM, saveFrameSeqCount); 424 425 OS_MARK(ah, AH_MARK_RESET_LINE, __LINE__); 426 427 OS_REG_WRITE(ah, AR_STA_ID0, LE_READ_4(ahp->ah_macaddr)); 428 OS_REG_WRITE(ah, AR_STA_ID1, LE_READ_2(ahp->ah_macaddr + 4) 429 | macStaId1 430 | AR_STA_ID1_RTS_USE_DEF 431 | ahp->ah_staId1Defaults 432 ); 433 ar5212SetOperatingMode(ah, opmode); 434 435 /* Set Venice BSSID mask according to current state */ 436 OS_REG_WRITE(ah, AR_BSSMSKL, LE_READ_4(ahp->ah_bssidmask)); 437 OS_REG_WRITE(ah, AR_BSSMSKU, LE_READ_2(ahp->ah_bssidmask + 4)); 438 439 /* Restore previous led state */ 440 OS_REG_WRITE(ah, AR_PCICFG, OS_REG_READ(ah, AR_PCICFG) | saveLedState); 441 442 /* Restore soft Led state to GPIO */ 443 OS_REG_WRITE(ah, AR_GPIOCR, softLedCfg); 444 OS_REG_WRITE(ah, AR_GPIODO, softLedState); 445 446 /* Restore previous antenna */ 447 OS_REG_WRITE(ah, AR_DEF_ANTENNA, saveDefAntenna); 448 449 /* then our BSSID and associate id */ 450 OS_REG_WRITE(ah, AR_BSS_ID0, LE_READ_4(ahp->ah_bssid)); 451 OS_REG_WRITE(ah, AR_BSS_ID1, LE_READ_2(ahp->ah_bssid + 4) | 452 (ahp->ah_assocId & 0x3fff) << AR_BSS_ID1_AID_S); 453 454 /* Restore bmiss rssi & count thresholds */ 455 OS_REG_WRITE(ah, AR_RSSI_THR, ahp->ah_rssiThr); 456 457 OS_REG_WRITE(ah, AR_ISR, ~0); /* cleared on write */ 458 459 if (!ar5212SetChannel(ah, chan)) 460 FAIL(HAL_EIO); 461 462 OS_MARK(ah, AH_MARK_RESET_LINE, __LINE__); 463 464 ar5212SetCoverageClass(ah, AH_PRIVATE(ah)->ah_coverageClass, 1); 465 466 ar5212SetRateDurationTable(ah, chan); 467 468 /* Set Tx frame start to tx data start delay */ 469 if (IS_RAD5112_ANY(ah) && 470 (IEEE80211_IS_CHAN_HALF(chan) || IEEE80211_IS_CHAN_QUARTER(chan))) { 471 txFrm2TxDStart = 472 IEEE80211_IS_CHAN_HALF(chan) ? 473 TX_FRAME_D_START_HALF_RATE: 474 TX_FRAME_D_START_QUARTER_RATE; 475 OS_REG_RMW_FIELD(ah, AR_PHY_TX_CTL, 476 AR_PHY_TX_FRAME_TO_TX_DATA_START, txFrm2TxDStart); 477 } 478 479 /* 480 * Setup fast diversity. 481 * Fast diversity can be enabled or disabled via regadd.txt. 482 * Default is enabled. 483 * For reference, 484 * Disable: reg val 485 * 0x00009860 0x00009d18 (if 11a / 11g, else no change) 486 * 0x00009970 0x192bb514 487 * 0x0000a208 0xd03e4648 488 * 489 * Enable: 0x00009860 0x00009d10 (if 11a / 11g, else no change) 490 * 0x00009970 0x192fb514 491 * 0x0000a208 0xd03e6788 492 */ 493 494 /* XXX Setup pre PHY ENABLE EAR additions */ 495 /* 496 * Wait for the frequency synth to settle (synth goes on 497 * via AR_PHY_ACTIVE_EN). Read the phy active delay register. 498 * Value is in 100ns increments. 499 */ 500 synthDelay = OS_REG_READ(ah, AR_PHY_RX_DELAY) & AR_PHY_RX_DELAY_DELAY; 501 if (IEEE80211_IS_CHAN_B(chan)) { 502 synthDelay = (4 * synthDelay) / 22; 503 } else { 504 synthDelay /= 10; 505 } 506 507 /* Activate the PHY (includes baseband activate and synthesizer on) */ 508 OS_REG_WRITE(ah, AR_PHY_ACTIVE, AR_PHY_ACTIVE_EN); 509 510 /* 511 * There is an issue if the AP starts the calibration before 512 * the base band timeout completes. This could result in the 513 * rx_clear false triggering. As a workaround we add delay an 514 * extra BASE_ACTIVATE_DELAY usecs to ensure this condition 515 * does not happen. 516 */ 517 if (IEEE80211_IS_CHAN_HALF(chan)) { 518 OS_DELAY((synthDelay << 1) + BASE_ACTIVATE_DELAY); 519 } else if (IEEE80211_IS_CHAN_QUARTER(chan)) { 520 OS_DELAY((synthDelay << 2) + BASE_ACTIVATE_DELAY); 521 } else { 522 OS_DELAY(synthDelay + BASE_ACTIVATE_DELAY); 523 } 524 525 /* 526 * The udelay method is not reliable with notebooks. 527 * Need to check to see if the baseband is ready 528 */ 529 testReg = OS_REG_READ(ah, AR_PHY_TESTCTRL); 530 /* Selects the Tx hold */ 531 OS_REG_WRITE(ah, AR_PHY_TESTCTRL, AR_PHY_TESTCTRL_TXHOLD); 532 i = 0; 533 while ((i++ < 20) && 534 (OS_REG_READ(ah, 0x9c24) & 0x10)) /* test if baseband not ready */ OS_DELAY(200); 535 OS_REG_WRITE(ah, AR_PHY_TESTCTRL, testReg); 536 537 /* Calibrate the AGC and start a NF calculation */ 538 OS_REG_WRITE(ah, AR_PHY_AGC_CONTROL, 539 OS_REG_READ(ah, AR_PHY_AGC_CONTROL) 540 | AR_PHY_AGC_CONTROL_CAL 541 | AR_PHY_AGC_CONTROL_NF); 542 543 if (!IEEE80211_IS_CHAN_B(chan) && ahp->ah_bIQCalibration != IQ_CAL_DONE) { 544 /* Start IQ calibration w/ 2^(INIT_IQCAL_LOG_COUNT_MAX+1) samples */ 545 OS_REG_RMW_FIELD(ah, AR_PHY_TIMING_CTRL4, 546 AR_PHY_TIMING_CTRL4_IQCAL_LOG_COUNT_MAX, 547 INIT_IQCAL_LOG_COUNT_MAX); 548 OS_REG_SET_BIT(ah, AR_PHY_TIMING_CTRL4, 549 AR_PHY_TIMING_CTRL4_DO_IQCAL); 550 ahp->ah_bIQCalibration = IQ_CAL_RUNNING; 551 } else 552 ahp->ah_bIQCalibration = IQ_CAL_INACTIVE; 553 554 /* Setup compression registers */ 555 ar5212SetCompRegs(ah); 556 557 /* Set 1:1 QCU to DCU mapping for all queues */ 558 for (i = 0; i < AR_NUM_DCU; i++) 559 OS_REG_WRITE(ah, AR_DQCUMASK(i), 1 << i); 560 561 ahp->ah_intrTxqs = 0; 562 for (i = 0; i < AH_PRIVATE(ah)->ah_caps.halTotalQueues; i++) 563 ar5212ResetTxQueue(ah, i); 564 565 /* 566 * Setup interrupt handling. Note that ar5212ResetTxQueue 567 * manipulates the secondary IMR's as queues are enabled 568 * and disabled. This is done with RMW ops to insure the 569 * settings we make here are preserved. 570 */ 571 ahp->ah_maskReg = AR_IMR_TXOK | AR_IMR_TXERR | AR_IMR_TXURN 572 | AR_IMR_RXOK | AR_IMR_RXERR | AR_IMR_RXORN 573 | AR_IMR_HIUERR 574 ; 575 if (opmode == HAL_M_HOSTAP) 576 ahp->ah_maskReg |= AR_IMR_MIB; 577 OS_REG_WRITE(ah, AR_IMR, ahp->ah_maskReg); 578 /* Enable bus errors that are OR'd to set the HIUERR bit */ 579 OS_REG_WRITE(ah, AR_IMR_S2, 580 OS_REG_READ(ah, AR_IMR_S2) 581 | AR_IMR_S2_MCABT | AR_IMR_S2_SSERR | AR_IMR_S2_DPERR); 582 583 if (AH_PRIVATE(ah)->ah_rfkillEnabled) 584 ar5212EnableRfKill(ah); 585 586 if (!ath_hal_wait(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_CAL, 0)) { 587 HALDEBUG(ah, HAL_DEBUG_ANY, 588 "%s: offset calibration failed to complete in 1ms;" 589 " noisy environment?\n", __func__); 590 } 591 592 /* 593 * Set clocks back to 32kHz if they had been using refClk, then 594 * use an external 32kHz crystal when sleeping, if one exists. 595 */ 596 ar5212SetupClock(ah, opmode); 597 598 /* 599 * Writing to AR_BEACON will start timers. Hence it should 600 * be the last register to be written. Do not reset tsf, do 601 * not enable beacons at this point, but preserve other values 602 * like beaconInterval. 603 */ 604 OS_REG_WRITE(ah, AR_BEACON, 605 (OS_REG_READ(ah, AR_BEACON) &~ (AR_BEACON_EN | AR_BEACON_RESET_TSF))); 606 607 /* XXX Setup post reset EAR additions */ 608 609 /* QoS support */ 610 if (AH_PRIVATE(ah)->ah_macVersion > AR_SREV_VERSION_VENICE || 611 (AH_PRIVATE(ah)->ah_macVersion == AR_SREV_VERSION_VENICE && 612 AH_PRIVATE(ah)->ah_macRev >= AR_SREV_GRIFFIN_LITE)) { 613 OS_REG_WRITE(ah, AR_QOS_CONTROL, 0x100aa); /* XXX magic */ 614 OS_REG_WRITE(ah, AR_QOS_SELECT, 0x3210); /* XXX magic */ 615 } 616 617 /* Turn on NOACK Support for QoS packets */ 618 OS_REG_WRITE(ah, AR_NOACK, 619 SM(2, AR_NOACK_2BIT_VALUE) | 620 SM(5, AR_NOACK_BIT_OFFSET) | 621 SM(0, AR_NOACK_BYTE_OFFSET)); 622 623 /* Get Antenna Gain reduction */ 624 if (IEEE80211_IS_CHAN_5GHZ(chan)) { 625 ath_hal_eepromGet(ah, AR_EEP_ANTGAINMAX_5, &twiceAntennaGain); 626 } else { 627 ath_hal_eepromGet(ah, AR_EEP_ANTGAINMAX_2, &twiceAntennaGain); 628 } 629 twiceAntennaReduction = 630 ath_hal_getantennareduction(ah, chan, twiceAntennaGain); 631 632 /* TPC for self-generated frames */ 633 634 ackTpcPow = MS(ahp->ah_macTPC, AR_TPC_ACK); 635 if ((ackTpcPow-ahp->ah_txPowerIndexOffset) > chan->ic_maxpower) 636 ackTpcPow = chan->ic_maxpower+ahp->ah_txPowerIndexOffset; 637 638 if (ackTpcPow > (2*chan->ic_maxregpower - twiceAntennaReduction)) 639 ackTpcPow = (2*chan->ic_maxregpower - twiceAntennaReduction) 640 + ahp->ah_txPowerIndexOffset; 641 642 ctsTpcPow = MS(ahp->ah_macTPC, AR_TPC_CTS); 643 if ((ctsTpcPow-ahp->ah_txPowerIndexOffset) > chan->ic_maxpower) 644 ctsTpcPow = chan->ic_maxpower+ahp->ah_txPowerIndexOffset; 645 646 if (ctsTpcPow > (2*chan->ic_maxregpower - twiceAntennaReduction)) 647 ctsTpcPow = (2*chan->ic_maxregpower - twiceAntennaReduction) 648 + ahp->ah_txPowerIndexOffset; 649 650 chirpTpcPow = MS(ahp->ah_macTPC, AR_TPC_CHIRP); 651 if ((chirpTpcPow-ahp->ah_txPowerIndexOffset) > chan->ic_maxpower) 652 chirpTpcPow = chan->ic_maxpower+ahp->ah_txPowerIndexOffset; 653 654 if (chirpTpcPow > (2*chan->ic_maxregpower - twiceAntennaReduction)) 655 chirpTpcPow = (2*chan->ic_maxregpower - twiceAntennaReduction) 656 + ahp->ah_txPowerIndexOffset; 657 658 if (ackTpcPow > 63) 659 ackTpcPow = 63; 660 if (ctsTpcPow > 63) 661 ctsTpcPow = 63; 662 if (chirpTpcPow > 63) 663 chirpTpcPow = 63; 664 665 powerVal = SM(ackTpcPow, AR_TPC_ACK) | 666 SM(ctsTpcPow, AR_TPC_CTS) | 667 SM(chirpTpcPow, AR_TPC_CHIRP); 668 669 OS_REG_WRITE(ah, AR_TPC, powerVal); 670 671 /* Restore user-specified settings */ 672 if (ahp->ah_miscMode != 0) 673 OS_REG_WRITE(ah, AR_MISC_MODE, ahp->ah_miscMode); 674 if (ahp->ah_sifstime != (u_int) -1) 675 ar5212SetSifsTime(ah, ahp->ah_sifstime); 676 if (ahp->ah_slottime != (u_int) -1) 677 ar5212SetSlotTime(ah, ahp->ah_slottime); 678 if (ahp->ah_acktimeout != (u_int) -1) 679 ar5212SetAckTimeout(ah, ahp->ah_acktimeout); 680 if (ahp->ah_ctstimeout != (u_int) -1) 681 ar5212SetCTSTimeout(ah, ahp->ah_ctstimeout); 682 if (AH_PRIVATE(ah)->ah_diagreg != 0) 683 OS_REG_WRITE(ah, AR_DIAG_SW, AH_PRIVATE(ah)->ah_diagreg); 684 685 AH_PRIVATE(ah)->ah_opmode = opmode; /* record operating mode */ 686 #if 0 687 done: 688 #endif 689 if (bChannelChange && !IEEE80211_IS_CHAN_DFS(chan)) 690 chan->ic_state &= ~IEEE80211_CHANSTATE_CWINT; 691 692 HALDEBUG(ah, HAL_DEBUG_RESET, "%s: done\n", __func__); 693 694 RESTORE_CCK(ah, chan, isBmode); 695 696 OS_MARK(ah, AH_MARK_RESET_DONE, 0); 697 698 return AH_TRUE; 699 bad: 700 RESTORE_CCK(ah, chan, isBmode); 701 702 OS_MARK(ah, AH_MARK_RESET_DONE, ecode); 703 if (status != AH_NULL) 704 *status = ecode; 705 return AH_FALSE; 706 #undef FAIL 707 #undef N 708 } 709 710 /* 711 * Call the rf backend to change the channel. 712 */ 713 HAL_BOOL 714 ar5212SetChannel(struct ath_hal *ah, const struct ieee80211_channel *chan) 715 { 716 struct ath_hal_5212 *ahp = AH5212(ah); 717 718 /* Change the synth */ 719 if (!ahp->ah_rfHal->setChannel(ah, chan)) 720 return AH_FALSE; 721 return AH_TRUE; 722 } 723 724 /* 725 * This channel change evaluates whether the selected hardware can 726 * perform a synthesizer-only channel change (no reset). If the 727 * TX is not stopped, or the RFBus cannot be granted in the given 728 * time, the function returns false as a reset is necessary 729 */ 730 HAL_BOOL 731 ar5212ChannelChange(struct ath_hal *ah, const struct ieee80211_channel *chan) 732 { 733 uint32_t ulCount; 734 uint32_t data, synthDelay, qnum; 735 uint16_t rfXpdGain[MAX_NUM_PDGAINS_PER_CHANNEL]; 736 HAL_BOOL txStopped = AH_TRUE; 737 HAL_CHANNEL_INTERNAL *ichan; 738 739 /* 740 * Map public channel to private. 741 */ 742 ichan = ath_hal_checkchannel(ah, chan); 743 744 /* TX must be stopped or RF Bus grant will not work */ 745 for (qnum = 0; qnum < AH_PRIVATE(ah)->ah_caps.halTotalQueues; qnum++) { 746 if (ar5212NumTxPending(ah, qnum)) { 747 txStopped = AH_FALSE; 748 break; 749 } 750 } 751 if (!txStopped) 752 return AH_FALSE; 753 754 /* Kill last Baseband Rx Frame */ 755 OS_REG_WRITE(ah, AR_PHY_RFBUS_REQ, AR_PHY_RFBUS_REQ_REQUEST); /* Request analog bus grant */ 756 for (ulCount = 0; ulCount < 100; ulCount++) { 757 if (OS_REG_READ(ah, AR_PHY_RFBUS_GNT)) 758 break; 759 OS_DELAY(5); 760 } 761 if (ulCount >= 100) 762 return AH_FALSE; 763 764 /* Change the synth */ 765 if (!ar5212SetChannel(ah, chan)) 766 return AH_FALSE; 767 768 /* 769 * Wait for the frequency synth to settle (synth goes on via PHY_ACTIVE_EN). 770 * Read the phy active delay register. Value is in 100ns increments. 771 */ 772 data = OS_REG_READ(ah, AR_PHY_RX_DELAY) & AR_PHY_RX_DELAY_DELAY; 773 if (IEEE80211_IS_CHAN_B(chan)) { 774 synthDelay = (4 * data) / 22; 775 } else { 776 synthDelay = data / 10; 777 } 778 OS_DELAY(synthDelay + BASE_ACTIVATE_DELAY); 779 780 /* Setup the transmit power values. */ 781 if (!ar5212SetTransmitPower(ah, chan, rfXpdGain)) { 782 HALDEBUG(ah, HAL_DEBUG_ANY, 783 "%s: error init'ing transmit power\n", __func__); 784 return AH_FALSE; 785 } 786 787 /* Write delta slope for OFDM enabled modes (A, G, Turbo) */ 788 if (IEEE80211_IS_CHAN_OFDM(chan)) { 789 if (IS_5413(ah) || 790 AH_PRIVATE(ah)->ah_eeversion >= AR_EEPROM_VER5_3) 791 ar5212SetSpurMitigation(ah, chan); 792 ar5212SetDeltaSlope(ah, chan); 793 } 794 795 /* Release the RFBus Grant */ 796 OS_REG_WRITE(ah, AR_PHY_RFBUS_REQ, 0); 797 798 /* Start Noise Floor Cal */ 799 OS_REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_NF); 800 return AH_TRUE; 801 } 802 803 void 804 ar5212SetOperatingMode(struct ath_hal *ah, int opmode) 805 { 806 uint32_t val; 807 808 val = OS_REG_READ(ah, AR_STA_ID1); 809 val &= ~(AR_STA_ID1_STA_AP | AR_STA_ID1_ADHOC); 810 switch (opmode) { 811 case HAL_M_HOSTAP: 812 OS_REG_WRITE(ah, AR_STA_ID1, val | AR_STA_ID1_STA_AP 813 | AR_STA_ID1_KSRCH_MODE); 814 OS_REG_CLR_BIT(ah, AR_CFG, AR_CFG_AP_ADHOC_INDICATION); 815 break; 816 case HAL_M_IBSS: 817 OS_REG_WRITE(ah, AR_STA_ID1, val | AR_STA_ID1_ADHOC 818 | AR_STA_ID1_KSRCH_MODE); 819 OS_REG_SET_BIT(ah, AR_CFG, AR_CFG_AP_ADHOC_INDICATION); 820 break; 821 case HAL_M_STA: 822 case HAL_M_MONITOR: 823 OS_REG_WRITE(ah, AR_STA_ID1, val | AR_STA_ID1_KSRCH_MODE); 824 break; 825 } 826 } 827 828 /* 829 * Places the PHY and Radio chips into reset. A full reset 830 * must be called to leave this state. The PCI/MAC/PCU are 831 * not placed into reset as we must receive interrupt to 832 * re-enable the hardware. 833 */ 834 HAL_BOOL 835 ar5212PhyDisable(struct ath_hal *ah) 836 { 837 return ar5212SetResetReg(ah, AR_RC_BB); 838 } 839 840 /* 841 * Places all of hardware into reset 842 */ 843 HAL_BOOL 844 ar5212Disable(struct ath_hal *ah) 845 { 846 if (!ar5212SetPowerMode(ah, HAL_PM_AWAKE, AH_TRUE)) 847 return AH_FALSE; 848 /* 849 * Reset the HW - PCI must be reset after the rest of the 850 * device has been reset. 851 */ 852 return ar5212SetResetReg(ah, AR_RC_MAC | AR_RC_BB | AR_RC_PCI); 853 } 854 855 /* 856 * Places the hardware into reset and then pulls it out of reset 857 * 858 * TODO: Only write the PLL if we're changing to or from CCK mode 859 * 860 * WARNING: The order of the PLL and mode registers must be correct. 861 */ 862 HAL_BOOL 863 ar5212ChipReset(struct ath_hal *ah, const struct ieee80211_channel *chan) 864 { 865 866 OS_MARK(ah, AH_MARK_CHIPRESET, chan ? chan->ic_freq : 0); 867 868 /* 869 * Reset the HW - PCI must be reset after the rest of the 870 * device has been reset 871 */ 872 if (!ar5212SetResetReg(ah, AR_RC_MAC | AR_RC_BB | AR_RC_PCI)) 873 return AH_FALSE; 874 875 /* Bring out of sleep mode (AGAIN) */ 876 if (!ar5212SetPowerMode(ah, HAL_PM_AWAKE, AH_TRUE)) 877 return AH_FALSE; 878 879 /* Clear warm reset register */ 880 if (!ar5212SetResetReg(ah, 0)) 881 return AH_FALSE; 882 883 /* 884 * Perform warm reset before the mode/PLL/turbo registers 885 * are changed in order to deactivate the radio. Mode changes 886 * with an active radio can result in corrupted shifts to the 887 * radio device. 888 */ 889 890 /* 891 * Set CCK and Turbo modes correctly. 892 */ 893 if (chan != AH_NULL) { /* NB: can be null during attach */ 894 uint32_t rfMode, phyPLL = 0, curPhyPLL, turbo; 895 896 if (IS_5413(ah)) { /* NB: =>'s 5424 also */ 897 rfMode = AR_PHY_MODE_AR5112; 898 if (IEEE80211_IS_CHAN_HALF(chan)) 899 rfMode |= AR_PHY_MODE_HALF; 900 else if (IEEE80211_IS_CHAN_QUARTER(chan)) 901 rfMode |= AR_PHY_MODE_QUARTER; 902 903 if (IEEE80211_IS_CHAN_CCK(chan)) 904 phyPLL = AR_PHY_PLL_CTL_44_5112; 905 else 906 phyPLL = AR_PHY_PLL_CTL_40_5413; 907 } else if (IS_RAD5111(ah)) { 908 rfMode = AR_PHY_MODE_AR5111; 909 if (IEEE80211_IS_CHAN_CCK(chan)) 910 phyPLL = AR_PHY_PLL_CTL_44; 911 else 912 phyPLL = AR_PHY_PLL_CTL_40; 913 if (IEEE80211_IS_CHAN_HALF(chan)) 914 phyPLL = AR_PHY_PLL_CTL_HALF; 915 else if (IEEE80211_IS_CHAN_QUARTER(chan)) 916 phyPLL = AR_PHY_PLL_CTL_QUARTER; 917 } else { /* 5112, 2413, 2316, 2317 */ 918 rfMode = AR_PHY_MODE_AR5112; 919 if (IEEE80211_IS_CHAN_CCK(chan)) 920 phyPLL = AR_PHY_PLL_CTL_44_5112; 921 else 922 phyPLL = AR_PHY_PLL_CTL_40_5112; 923 if (IEEE80211_IS_CHAN_HALF(chan)) 924 phyPLL |= AR_PHY_PLL_CTL_HALF; 925 else if (IEEE80211_IS_CHAN_QUARTER(chan)) 926 phyPLL |= AR_PHY_PLL_CTL_QUARTER; 927 } 928 if (IEEE80211_IS_CHAN_G(chan)) 929 rfMode |= AR_PHY_MODE_DYNAMIC; 930 else if (IEEE80211_IS_CHAN_OFDM(chan)) 931 rfMode |= AR_PHY_MODE_OFDM; 932 else 933 rfMode |= AR_PHY_MODE_CCK; 934 if (IEEE80211_IS_CHAN_5GHZ(chan)) 935 rfMode |= AR_PHY_MODE_RF5GHZ; 936 else 937 rfMode |= AR_PHY_MODE_RF2GHZ; 938 turbo = IEEE80211_IS_CHAN_TURBO(chan) ? 939 (AR_PHY_FC_TURBO_MODE | AR_PHY_FC_TURBO_SHORT) : 0; 940 curPhyPLL = OS_REG_READ(ah, AR_PHY_PLL_CTL); 941 /* 942 * PLL, Mode, and Turbo values must be written in the correct 943 * order to ensure: 944 * - The PLL cannot be set to 44 unless the CCK or DYNAMIC 945 * mode bit is set 946 * - Turbo cannot be set at the same time as CCK or DYNAMIC 947 */ 948 if (IEEE80211_IS_CHAN_CCK(chan)) { 949 OS_REG_WRITE(ah, AR_PHY_TURBO, turbo); 950 OS_REG_WRITE(ah, AR_PHY_MODE, rfMode); 951 if (curPhyPLL != phyPLL) { 952 OS_REG_WRITE(ah, AR_PHY_PLL_CTL, phyPLL); 953 /* Wait for the PLL to settle */ 954 OS_DELAY(PLL_SETTLE_DELAY); 955 } 956 } else { 957 if (curPhyPLL != phyPLL) { 958 OS_REG_WRITE(ah, AR_PHY_PLL_CTL, phyPLL); 959 /* Wait for the PLL to settle */ 960 OS_DELAY(PLL_SETTLE_DELAY); 961 } 962 OS_REG_WRITE(ah, AR_PHY_TURBO, turbo); 963 OS_REG_WRITE(ah, AR_PHY_MODE, rfMode); 964 } 965 } 966 return AH_TRUE; 967 } 968 969 /* 970 * Recalibrate the lower PHY chips to account for temperature/environment 971 * changes. 972 */ 973 HAL_BOOL 974 ar5212PerCalibrationN(struct ath_hal *ah, 975 struct ieee80211_channel *chan, 976 u_int chainMask, HAL_BOOL longCal, HAL_BOOL *isCalDone) 977 { 978 #define IQ_CAL_TRIES 10 979 struct ath_hal_5212 *ahp = AH5212(ah); 980 HAL_CHANNEL_INTERNAL *ichan; 981 int32_t qCoff, qCoffDenom; 982 int32_t iqCorrMeas, iCoff, iCoffDenom; 983 uint32_t powerMeasQ, powerMeasI; 984 HAL_BOOL isBmode = AH_FALSE; 985 986 OS_MARK(ah, AH_MARK_PERCAL, chan->ic_freq); 987 *isCalDone = AH_FALSE; 988 ichan = ath_hal_checkchannel(ah, chan); 989 if (ichan == AH_NULL) { 990 HALDEBUG(ah, HAL_DEBUG_ANY, 991 "%s: invalid channel %u/0x%x; no mapping\n", 992 __func__, chan->ic_freq, chan->ic_flags); 993 return AH_FALSE; 994 } 995 SAVE_CCK(ah, chan, isBmode); 996 997 if (ahp->ah_bIQCalibration == IQ_CAL_DONE || 998 ahp->ah_bIQCalibration == IQ_CAL_INACTIVE) 999 *isCalDone = AH_TRUE; 1000 1001 /* IQ calibration in progress. Check to see if it has finished. */ 1002 if (ahp->ah_bIQCalibration == IQ_CAL_RUNNING && 1003 !(OS_REG_READ(ah, AR_PHY_TIMING_CTRL4) & AR_PHY_TIMING_CTRL4_DO_IQCAL)) { 1004 int i; 1005 1006 /* IQ Calibration has finished. */ 1007 ahp->ah_bIQCalibration = IQ_CAL_INACTIVE; 1008 *isCalDone = AH_TRUE; 1009 1010 /* workaround for misgated IQ Cal results */ 1011 i = 0; 1012 do { 1013 /* Read calibration results. */ 1014 powerMeasI = OS_REG_READ(ah, AR_PHY_IQCAL_RES_PWR_MEAS_I); 1015 powerMeasQ = OS_REG_READ(ah, AR_PHY_IQCAL_RES_PWR_MEAS_Q); 1016 iqCorrMeas = OS_REG_READ(ah, AR_PHY_IQCAL_RES_IQ_CORR_MEAS); 1017 if (powerMeasI && powerMeasQ) 1018 break; 1019 /* Do we really need this??? */ 1020 OS_REG_SET_BIT(ah, AR_PHY_TIMING_CTRL4, 1021 AR_PHY_TIMING_CTRL4_DO_IQCAL); 1022 } while (++i < IQ_CAL_TRIES); 1023 1024 HALDEBUG(ah, HAL_DEBUG_PERCAL, 1025 "%s: IQ cal finished: %d tries\n", __func__, i); 1026 HALDEBUG(ah, HAL_DEBUG_PERCAL, 1027 "%s: powerMeasI %u powerMeasQ %u iqCorrMeas %d\n", 1028 __func__, powerMeasI, powerMeasQ, iqCorrMeas); 1029 1030 /* 1031 * Prescale these values to remove 64-bit operation 1032 * requirement at the loss of a little precision. 1033 */ 1034 iCoffDenom = (powerMeasI / 2 + powerMeasQ / 2) / 128; 1035 qCoffDenom = powerMeasQ / 128; 1036 1037 /* Protect against divide-by-0 and loss of sign bits. */ 1038 if (iCoffDenom != 0 && qCoffDenom >= 2) { 1039 iCoff = (int8_t)(-iqCorrMeas) / iCoffDenom; 1040 /* IQCORR_Q_I_COFF is a signed 6 bit number */ 1041 if (iCoff < -32) { 1042 iCoff = -32; 1043 } else if (iCoff > 31) { 1044 iCoff = 31; 1045 } 1046 1047 /* IQCORR_Q_Q_COFF is a signed 5 bit number */ 1048 qCoff = (powerMeasI / qCoffDenom) - 128; 1049 if (qCoff < -16) { 1050 qCoff = -16; 1051 } else if (qCoff > 15) { 1052 qCoff = 15; 1053 } 1054 1055 HALDEBUG(ah, HAL_DEBUG_PERCAL, 1056 "%s: iCoff %d qCoff %d\n", __func__, iCoff, qCoff); 1057 1058 /* Write values and enable correction */ 1059 OS_REG_RMW_FIELD(ah, AR_PHY_TIMING_CTRL4, 1060 AR_PHY_TIMING_CTRL4_IQCORR_Q_I_COFF, iCoff); 1061 OS_REG_RMW_FIELD(ah, AR_PHY_TIMING_CTRL4, 1062 AR_PHY_TIMING_CTRL4_IQCORR_Q_Q_COFF, qCoff); 1063 OS_REG_SET_BIT(ah, AR_PHY_TIMING_CTRL4, 1064 AR_PHY_TIMING_CTRL4_IQCORR_ENABLE); 1065 1066 ahp->ah_bIQCalibration = IQ_CAL_DONE; 1067 ichan->privFlags |= CHANNEL_IQVALID; 1068 ichan->iCoff = iCoff; 1069 ichan->qCoff = qCoff; 1070 } 1071 } else if (!IEEE80211_IS_CHAN_B(chan) && 1072 ahp->ah_bIQCalibration == IQ_CAL_DONE && 1073 (ichan->privFlags & CHANNEL_IQVALID) == 0) { 1074 /* 1075 * Start IQ calibration if configured channel has changed. 1076 * Use a magic number of 15 based on default value. 1077 */ 1078 OS_REG_RMW_FIELD(ah, AR_PHY_TIMING_CTRL4, 1079 AR_PHY_TIMING_CTRL4_IQCAL_LOG_COUNT_MAX, 1080 INIT_IQCAL_LOG_COUNT_MAX); 1081 OS_REG_SET_BIT(ah, AR_PHY_TIMING_CTRL4, 1082 AR_PHY_TIMING_CTRL4_DO_IQCAL); 1083 ahp->ah_bIQCalibration = IQ_CAL_RUNNING; 1084 } 1085 /* XXX EAR */ 1086 1087 if (longCal) { 1088 /* Check noise floor results */ 1089 ar5212GetNf(ah, chan); 1090 if (!IEEE80211_IS_CHAN_CWINT(chan)) { 1091 /* Perform cal for 5Ghz channels and any OFDM on 5112 */ 1092 if (IEEE80211_IS_CHAN_5GHZ(chan) || 1093 (IS_RAD5112(ah) && IEEE80211_IS_CHAN_OFDM(chan))) 1094 ar5212RequestRfgain(ah); 1095 } 1096 } 1097 RESTORE_CCK(ah, chan, isBmode); 1098 1099 return AH_TRUE; 1100 #undef IQ_CAL_TRIES 1101 } 1102 1103 HAL_BOOL 1104 ar5212PerCalibration(struct ath_hal *ah, struct ieee80211_channel *chan, 1105 HAL_BOOL *isIQdone) 1106 { 1107 return ar5212PerCalibrationN(ah, chan, 0x1, AH_TRUE, isIQdone); 1108 } 1109 1110 HAL_BOOL 1111 ar5212ResetCalValid(struct ath_hal *ah, const struct ieee80211_channel *chan) 1112 { 1113 HAL_CHANNEL_INTERNAL *ichan; 1114 1115 ichan = ath_hal_checkchannel(ah, chan); 1116 if (ichan == AH_NULL) { 1117 HALDEBUG(ah, HAL_DEBUG_ANY, 1118 "%s: invalid channel %u/0x%x; no mapping\n", 1119 __func__, chan->ic_freq, chan->ic_flags); 1120 return AH_FALSE; 1121 } 1122 ichan->privFlags &= ~CHANNEL_IQVALID; 1123 return AH_TRUE; 1124 } 1125 1126 /************************************************************** 1127 * ar5212MacStop 1128 * 1129 * Disables all active QCUs and ensure that the mac is in a 1130 * quiessence state. 1131 */ 1132 static HAL_BOOL 1133 ar5212MacStop(struct ath_hal *ah) 1134 { 1135 HAL_BOOL status; 1136 uint32_t count; 1137 uint32_t pendFrameCount; 1138 uint32_t macStateFlag; 1139 uint32_t queue; 1140 1141 status = AH_FALSE; 1142 1143 /* Disable Rx Operation ***********************************/ 1144 OS_REG_SET_BIT(ah, AR_CR, AR_CR_RXD); 1145 1146 /* Disable TX Operation ***********************************/ 1147 #ifdef NOT_YET 1148 ar5212SetTxdpInvalid(ah); 1149 #endif 1150 OS_REG_SET_BIT(ah, AR_Q_TXD, AR_Q_TXD_M); 1151 1152 /* Polling operation for completion of disable ************/ 1153 macStateFlag = TX_ENABLE_CHECK | RX_ENABLE_CHECK; 1154 1155 for (count = 0; count < MAX_RESET_WAIT; count++) { 1156 if (macStateFlag & RX_ENABLE_CHECK) { 1157 if (!OS_REG_IS_BIT_SET(ah, AR_CR, AR_CR_RXE)) { 1158 macStateFlag &= ~RX_ENABLE_CHECK; 1159 } 1160 } 1161 1162 if (macStateFlag & TX_ENABLE_CHECK) { 1163 if (!OS_REG_IS_BIT_SET(ah, AR_Q_TXE, AR_Q_TXE_M)) { 1164 macStateFlag &= ~TX_ENABLE_CHECK; 1165 macStateFlag |= TX_QUEUEPEND_CHECK; 1166 } 1167 } 1168 if (macStateFlag & TX_QUEUEPEND_CHECK) { 1169 pendFrameCount = 0; 1170 for (queue = 0; queue < AR_NUM_DCU; queue++) { 1171 pendFrameCount += OS_REG_READ(ah, 1172 AR_Q0_STS + (queue * 4)) & 1173 AR_Q_STS_PEND_FR_CNT; 1174 } 1175 if (pendFrameCount == 0) { 1176 macStateFlag &= ~TX_QUEUEPEND_CHECK; 1177 } 1178 } 1179 if (macStateFlag == 0) { 1180 status = AH_TRUE; 1181 break; 1182 } 1183 OS_DELAY(50); 1184 } 1185 1186 if (status != AH_TRUE) { 1187 HALDEBUG(ah, HAL_DEBUG_RESET, 1188 "%s:Failed to stop the MAC state 0x%x\n", 1189 __func__, macStateFlag); 1190 } 1191 1192 return status; 1193 } 1194 1195 1196 /* 1197 * Write the given reset bit mask into the reset register 1198 */ 1199 static HAL_BOOL 1200 ar5212SetResetReg(struct ath_hal *ah, uint32_t resetMask) 1201 { 1202 uint32_t mask = resetMask ? resetMask : ~0; 1203 HAL_BOOL rt; 1204 1205 /* Never reset the PCIE core */ 1206 if (AH_PRIVATE(ah)->ah_ispcie) { 1207 resetMask &= ~AR_RC_PCI; 1208 } 1209 1210 if (resetMask & (AR_RC_MAC | AR_RC_PCI)) { 1211 /* 1212 * To ensure that the driver can reset the 1213 * MAC, wake up the chip 1214 */ 1215 rt = ar5212SetPowerMode(ah, HAL_PM_AWAKE, AH_TRUE); 1216 1217 if (rt != AH_TRUE) { 1218 return rt; 1219 } 1220 1221 /* 1222 * Disable interrupts 1223 */ 1224 OS_REG_WRITE(ah, AR_IER, AR_IER_DISABLE); 1225 OS_REG_READ(ah, AR_IER); 1226 1227 if (ar5212MacStop(ah) != AH_TRUE) { 1228 /* 1229 * Failed to stop the MAC gracefully; let's be more forceful then 1230 */ 1231 1232 /* need some delay before flush any pending MMR writes */ 1233 OS_DELAY(15); 1234 OS_REG_READ(ah, AR_RXDP); 1235 1236 resetMask |= AR_RC_MAC | AR_RC_BB; 1237 /* _Never_ reset PCI Express core */ 1238 if (! AH_PRIVATE(ah)->ah_ispcie) { 1239 resetMask |= AR_RC_PCI; 1240 } 1241 #if 0 1242 /* 1243 * Flush the park address of the PCI controller 1244 */ 1245 /* Read PCI slot information less than Hainan revision */ 1246 if (AH_PRIVATE(ah)->ah_bustype == HAL_BUS_TYPE_PCI) { 1247 if (!IS_5112_REV5_UP(ah)) { 1248 #define PCI_COMMON_CONFIG_STATUS 0x06 1249 u_int32_t i; 1250 u_int16_t reg16; 1251 1252 for (i = 0; i < 32; i++) { 1253 ath_hal_read_pci_config_space(ah, 1254 PCI_COMMON_CONFIG_STATUS, 1255 ®16, sizeof(reg16)); 1256 } 1257 } 1258 #undef PCI_COMMON_CONFIG_STATUS 1259 } 1260 #endif 1261 } else { 1262 /* 1263 * MAC stopped gracefully; no need to warm-reset the PCI bus 1264 */ 1265 1266 resetMask &= ~AR_RC_PCI; 1267 1268 /* need some delay before flush any pending MMR writes */ 1269 OS_DELAY(15); 1270 OS_REG_READ(ah, AR_RXDP); 1271 } 1272 } 1273 1274 (void) OS_REG_READ(ah, AR_RXDP);/* flush any pending MMR writes */ 1275 OS_REG_WRITE(ah, AR_RC, resetMask); 1276 OS_DELAY(15); /* need to wait at least 128 clocks 1277 when reseting PCI before read */ 1278 mask &= (AR_RC_MAC | AR_RC_BB); 1279 resetMask &= (AR_RC_MAC | AR_RC_BB); 1280 rt = ath_hal_wait(ah, AR_RC, mask, resetMask); 1281 if ((resetMask & AR_RC_MAC) == 0) { 1282 if (isBigEndian()) { 1283 /* 1284 * Set CFG, little-endian for descriptor accesses. 1285 */ 1286 mask = INIT_CONFIG_STATUS | AR_CFG_SWRD; 1287 #ifndef AH_NEED_DESC_SWAP 1288 mask |= AR_CFG_SWTD; 1289 #endif 1290 OS_REG_WRITE(ah, AR_CFG, mask); 1291 } else 1292 OS_REG_WRITE(ah, AR_CFG, INIT_CONFIG_STATUS); 1293 if (ar5212SetPowerMode(ah, HAL_PM_AWAKE, AH_TRUE)) 1294 (void) OS_REG_READ(ah, AR_ISR_RAC); 1295 } 1296 1297 /* track PHY power state so we don't try to r/w BB registers */ 1298 AH5212(ah)->ah_phyPowerOn = ((resetMask & AR_RC_BB) == 0); 1299 return rt; 1300 } 1301 1302 int16_t 1303 ar5212GetNoiseFloor(struct ath_hal *ah) 1304 { 1305 int16_t nf = (OS_REG_READ(ah, AR_PHY(25)) >> 19) & 0x1ff; 1306 if (nf & 0x100) 1307 nf = 0 - ((nf ^ 0x1ff) + 1); 1308 return nf; 1309 } 1310 1311 static HAL_BOOL 1312 getNoiseFloorThresh(struct ath_hal *ah, const struct ieee80211_channel *chan, 1313 int16_t *nft) 1314 { 1315 const HAL_EEPROM *ee = AH_PRIVATE(ah)->ah_eeprom; 1316 1317 HALASSERT(ah->ah_magic == AR5212_MAGIC); 1318 1319 switch (chan->ic_flags & IEEE80211_CHAN_ALLFULL) { 1320 case IEEE80211_CHAN_A: 1321 *nft = ee->ee_noiseFloorThresh[headerInfo11A]; 1322 break; 1323 case IEEE80211_CHAN_B: 1324 *nft = ee->ee_noiseFloorThresh[headerInfo11B]; 1325 break; 1326 case IEEE80211_CHAN_G: 1327 case IEEE80211_CHAN_PUREG: /* NB: really 108G */ 1328 *nft = ee->ee_noiseFloorThresh[headerInfo11G]; 1329 break; 1330 default: 1331 HALDEBUG(ah, HAL_DEBUG_ANY, 1332 "%s: invalid channel flags %u/0x%x\n", 1333 __func__, chan->ic_freq, chan->ic_flags); 1334 return AH_FALSE; 1335 } 1336 return AH_TRUE; 1337 } 1338 1339 /* 1340 * Setup the noise floor cal history buffer. 1341 */ 1342 void 1343 ar5212InitNfCalHistBuffer(struct ath_hal *ah) 1344 { 1345 struct ath_hal_5212 *ahp = AH5212(ah); 1346 int i; 1347 1348 ahp->ah_nfCalHist.first_run = 1; 1349 ahp->ah_nfCalHist.currIndex = 0; 1350 ahp->ah_nfCalHist.privNF = AR5212_CCA_MAX_GOOD_VALUE; 1351 ahp->ah_nfCalHist.invalidNFcount = AR512_NF_CAL_HIST_MAX; 1352 for (i = 0; i < AR512_NF_CAL_HIST_MAX; i ++) 1353 ahp->ah_nfCalHist.nfCalBuffer[i] = AR5212_CCA_MAX_GOOD_VALUE; 1354 } 1355 1356 /* 1357 * Add a noise floor value to the ring buffer. 1358 */ 1359 static __inline void 1360 updateNFHistBuff(struct ar5212NfCalHist *h, int16_t nf) 1361 { 1362 h->nfCalBuffer[h->currIndex] = nf; 1363 if (++h->currIndex >= AR512_NF_CAL_HIST_MAX) 1364 h->currIndex = 0; 1365 } 1366 1367 /* 1368 * Return the median noise floor value in the ring buffer. 1369 */ 1370 int16_t 1371 ar5212GetNfHistMid(const int16_t calData[AR512_NF_CAL_HIST_MAX]) 1372 { 1373 int16_t sort[AR512_NF_CAL_HIST_MAX]; 1374 int i, j; 1375 1376 OS_MEMCPY(sort, calData, AR512_NF_CAL_HIST_MAX*sizeof(int16_t)); 1377 for (i = 0; i < AR512_NF_CAL_HIST_MAX-1; i ++) { 1378 for (j = 1; j < AR512_NF_CAL_HIST_MAX-i; j ++) { 1379 if (sort[j] > sort[j-1]) { 1380 int16_t nf = sort[j]; 1381 sort[j] = sort[j-1]; 1382 sort[j-1] = nf; 1383 } 1384 } 1385 } 1386 return sort[(AR512_NF_CAL_HIST_MAX-1)>>1]; 1387 } 1388 1389 /* 1390 * Read the NF and check it against the noise floor threshold 1391 */ 1392 int16_t 1393 ar5212GetNf(struct ath_hal *ah, struct ieee80211_channel *chan) 1394 { 1395 struct ath_hal_5212 *ahp = AH5212(ah); 1396 struct ar5212NfCalHist *h = &ahp->ah_nfCalHist; 1397 HAL_CHANNEL_INTERNAL *ichan = ath_hal_checkchannel(ah, chan); 1398 int16_t nf, nfThresh; 1399 int32_t val; 1400 1401 if (OS_REG_READ(ah, AR_PHY_AGC_CONTROL) & AR_PHY_AGC_CONTROL_NF) { 1402 HALDEBUG(ah, HAL_DEBUG_ANY, 1403 "%s: NF did not complete in calibration window\n", __func__); 1404 ichan->rawNoiseFloor = h->privNF; /* most recent value */ 1405 return ichan->rawNoiseFloor; 1406 } 1407 1408 /* 1409 * Finished NF cal, check against threshold. 1410 */ 1411 nf = ar5212GetNoiseFloor(ah); 1412 if (getNoiseFloorThresh(ah, chan, &nfThresh)) { 1413 if (nf > nfThresh) { 1414 HALDEBUG(ah, HAL_DEBUG_ANY, 1415 "%s: noise floor failed detected; detected %u, " 1416 "threshold %u\n", __func__, nf, nfThresh); 1417 /* 1418 * NB: Don't discriminate 2.4 vs 5Ghz, if this 1419 * happens it indicates a problem regardless 1420 * of the band. 1421 */ 1422 chan->ic_state |= IEEE80211_CHANSTATE_CWINT; 1423 nf = 0; 1424 } 1425 } else 1426 nf = 0; 1427 1428 /* 1429 * Pass through histogram and write median value as 1430 * calculated from the accrued window. We require a 1431 * full window of in-range values to be seen before we 1432 * start using the history. 1433 */ 1434 updateNFHistBuff(h, nf); 1435 if (h->first_run) { 1436 if (nf < AR5212_CCA_MIN_BAD_VALUE || 1437 nf > AR5212_CCA_MAX_HIGH_VALUE) { 1438 nf = AR5212_CCA_MAX_GOOD_VALUE; 1439 h->invalidNFcount = AR512_NF_CAL_HIST_MAX; 1440 } else if (--(h->invalidNFcount) == 0) { 1441 h->first_run = 0; 1442 h->privNF = nf = ar5212GetNfHistMid(h->nfCalBuffer); 1443 } else { 1444 nf = AR5212_CCA_MAX_GOOD_VALUE; 1445 } 1446 } else { 1447 h->privNF = nf = ar5212GetNfHistMid(h->nfCalBuffer); 1448 } 1449 1450 val = OS_REG_READ(ah, AR_PHY(25)); 1451 val &= 0xFFFFFE00; 1452 val |= (((uint32_t)nf << 1) & 0x1FF); 1453 OS_REG_WRITE(ah, AR_PHY(25), val); 1454 OS_REG_CLR_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_ENABLE_NF); 1455 OS_REG_CLR_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_NO_UPDATE_NF); 1456 OS_REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_NF); 1457 1458 if (!ath_hal_wait(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_NF, 0)) { 1459 #ifdef AH_DEBUG 1460 ath_hal_printf(ah, "%s: AGC not ready AGC_CONTROL 0x%x\n", 1461 __func__, OS_REG_READ(ah, AR_PHY_AGC_CONTROL)); 1462 #endif 1463 } 1464 1465 /* 1466 * Now load a high maxCCAPower value again so that we're 1467 * not capped by the median we just loaded 1468 */ 1469 val &= 0xFFFFFE00; 1470 val |= (((uint32_t)(-50) << 1) & 0x1FF); 1471 OS_REG_WRITE(ah, AR_PHY(25), val); 1472 OS_REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_ENABLE_NF); 1473 OS_REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_NO_UPDATE_NF); 1474 OS_REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_NF); 1475 1476 return (ichan->rawNoiseFloor = nf); 1477 } 1478 1479 /* 1480 * Set up compression configuration registers 1481 */ 1482 void 1483 ar5212SetCompRegs(struct ath_hal *ah) 1484 { 1485 struct ath_hal_5212 *ahp = AH5212(ah); 1486 int i; 1487 1488 /* Check if h/w supports compression */ 1489 if (!AH_PRIVATE(ah)->ah_caps.halCompressSupport) 1490 return; 1491 1492 OS_REG_WRITE(ah, AR_DCCFG, 1); 1493 1494 OS_REG_WRITE(ah, AR_CCFG, 1495 (AR_COMPRESSION_WINDOW_SIZE >> 8) & AR_CCFG_WIN_M); 1496 1497 OS_REG_WRITE(ah, AR_CCFG, 1498 OS_REG_READ(ah, AR_CCFG) | AR_CCFG_MIB_INT_EN); 1499 OS_REG_WRITE(ah, AR_CCUCFG, 1500 AR_CCUCFG_RESET_VAL | AR_CCUCFG_CATCHUP_EN); 1501 1502 OS_REG_WRITE(ah, AR_CPCOVF, 0); 1503 1504 /* reset decompression mask */ 1505 for (i = 0; i < HAL_DECOMP_MASK_SIZE; i++) { 1506 OS_REG_WRITE(ah, AR_DCM_A, i); 1507 OS_REG_WRITE(ah, AR_DCM_D, ahp->ah_decompMask[i]); 1508 } 1509 } 1510 1511 HAL_BOOL 1512 ar5212SetAntennaSwitchInternal(struct ath_hal *ah, HAL_ANT_SETTING settings, 1513 const struct ieee80211_channel *chan) 1514 { 1515 #define ANT_SWITCH_TABLE1 AR_PHY(88) 1516 #define ANT_SWITCH_TABLE2 AR_PHY(89) 1517 struct ath_hal_5212 *ahp = AH5212(ah); 1518 const HAL_EEPROM *ee = AH_PRIVATE(ah)->ah_eeprom; 1519 uint32_t antSwitchA, antSwitchB; 1520 int ix; 1521 1522 HALASSERT(ah->ah_magic == AR5212_MAGIC); 1523 HALASSERT(ahp->ah_phyPowerOn); 1524 1525 switch (chan->ic_flags & IEEE80211_CHAN_ALLFULL) { 1526 case IEEE80211_CHAN_A: 1527 ix = 0; 1528 break; 1529 case IEEE80211_CHAN_G: 1530 case IEEE80211_CHAN_PUREG: /* NB: 108G */ 1531 ix = 2; 1532 break; 1533 case IEEE80211_CHAN_B: 1534 if (IS_2425(ah) || IS_2417(ah)) { 1535 /* NB: Nala/Swan: 11b is handled using 11g */ 1536 ix = 2; 1537 } else 1538 ix = 1; 1539 break; 1540 default: 1541 HALDEBUG(ah, HAL_DEBUG_ANY, "%s: invalid channel flags 0x%x\n", 1542 __func__, chan->ic_flags); 1543 return AH_FALSE; 1544 } 1545 1546 antSwitchA = ee->ee_antennaControl[1][ix] 1547 | (ee->ee_antennaControl[2][ix] << 6) 1548 | (ee->ee_antennaControl[3][ix] << 12) 1549 | (ee->ee_antennaControl[4][ix] << 18) 1550 | (ee->ee_antennaControl[5][ix] << 24) 1551 ; 1552 antSwitchB = ee->ee_antennaControl[6][ix] 1553 | (ee->ee_antennaControl[7][ix] << 6) 1554 | (ee->ee_antennaControl[8][ix] << 12) 1555 | (ee->ee_antennaControl[9][ix] << 18) 1556 | (ee->ee_antennaControl[10][ix] << 24) 1557 ; 1558 /* 1559 * For fixed antenna, give the same setting for both switch banks 1560 */ 1561 switch (settings) { 1562 case HAL_ANT_FIXED_A: 1563 antSwitchB = antSwitchA; 1564 break; 1565 case HAL_ANT_FIXED_B: 1566 antSwitchA = antSwitchB; 1567 break; 1568 case HAL_ANT_VARIABLE: 1569 break; 1570 default: 1571 HALDEBUG(ah, HAL_DEBUG_ANY, "%s: bad antenna setting %u\n", 1572 __func__, settings); 1573 return AH_FALSE; 1574 } 1575 if (antSwitchB == antSwitchA) { 1576 HALDEBUG(ah, HAL_DEBUG_RFPARAM, 1577 "%s: Setting fast diversity off.\n", __func__); 1578 OS_REG_CLR_BIT(ah,AR_PHY_CCK_DETECT, 1579 AR_PHY_CCK_DETECT_BB_ENABLE_ANT_FAST_DIV); 1580 ahp->ah_diversity = AH_FALSE; 1581 } else { 1582 HALDEBUG(ah, HAL_DEBUG_RFPARAM, 1583 "%s: Setting fast diversity on.\n", __func__); 1584 OS_REG_SET_BIT(ah,AR_PHY_CCK_DETECT, 1585 AR_PHY_CCK_DETECT_BB_ENABLE_ANT_FAST_DIV); 1586 ahp->ah_diversity = AH_TRUE; 1587 } 1588 ahp->ah_antControl = settings; 1589 1590 OS_REG_WRITE(ah, ANT_SWITCH_TABLE1, antSwitchA); 1591 OS_REG_WRITE(ah, ANT_SWITCH_TABLE2, antSwitchB); 1592 1593 return AH_TRUE; 1594 #undef ANT_SWITCH_TABLE2 1595 #undef ANT_SWITCH_TABLE1 1596 } 1597 1598 HAL_BOOL 1599 ar5212IsSpurChannel(struct ath_hal *ah, const struct ieee80211_channel *chan) 1600 { 1601 uint16_t freq = ath_hal_gethwchannel(ah, chan); 1602 uint32_t clockFreq = 1603 ((IS_5413(ah) || IS_RAD5112_ANY(ah) || IS_2417(ah)) ? 40 : 32); 1604 return ( ((freq % clockFreq) != 0) 1605 && (((freq % clockFreq) < 10) 1606 || (((freq) % clockFreq) > 22)) ); 1607 } 1608 1609 /* 1610 * Read EEPROM header info and program the device for correct operation 1611 * given the channel value. 1612 */ 1613 HAL_BOOL 1614 ar5212SetBoardValues(struct ath_hal *ah, const struct ieee80211_channel *chan) 1615 { 1616 #define NO_FALSE_DETECT_BACKOFF 2 1617 #define CB22_FALSE_DETECT_BACKOFF 6 1618 #define AR_PHY_BIS(_ah, _reg, _mask, _val) \ 1619 OS_REG_WRITE(_ah, AR_PHY(_reg), \ 1620 (OS_REG_READ(_ah, AR_PHY(_reg)) & _mask) | (_val)); 1621 struct ath_hal_5212 *ahp = AH5212(ah); 1622 const HAL_EEPROM *ee = AH_PRIVATE(ah)->ah_eeprom; 1623 int arrayMode, falseDectectBackoff; 1624 int is2GHz = IEEE80211_IS_CHAN_2GHZ(chan); 1625 HAL_CHANNEL_INTERNAL *ichan = ath_hal_checkchannel(ah, chan); 1626 int8_t adcDesiredSize, pgaDesiredSize; 1627 uint16_t switchSettling, txrxAtten, rxtxMargin; 1628 int iCoff, qCoff; 1629 1630 HALASSERT(ah->ah_magic == AR5212_MAGIC); 1631 1632 switch (chan->ic_flags & IEEE80211_CHAN_ALLTURBOFULL) { 1633 case IEEE80211_CHAN_A: 1634 case IEEE80211_CHAN_ST: 1635 arrayMode = headerInfo11A; 1636 if (!IS_RAD5112_ANY(ah) && !IS_2413(ah) && !IS_5413(ah)) 1637 OS_REG_RMW_FIELD(ah, AR_PHY_FRAME_CTL, 1638 AR_PHY_FRAME_CTL_TX_CLIP, 1639 ahp->ah_gainValues.currStep->paramVal[GP_TXCLIP]); 1640 break; 1641 case IEEE80211_CHAN_B: 1642 arrayMode = headerInfo11B; 1643 break; 1644 case IEEE80211_CHAN_G: 1645 case IEEE80211_CHAN_108G: 1646 arrayMode = headerInfo11G; 1647 break; 1648 default: 1649 HALDEBUG(ah, HAL_DEBUG_ANY, "%s: invalid channel flags 0x%x\n", 1650 __func__, chan->ic_flags); 1651 return AH_FALSE; 1652 } 1653 1654 /* Set the antenna register(s) correctly for the chip revision */ 1655 AR_PHY_BIS(ah, 68, 0xFFFFFC06, 1656 (ee->ee_antennaControl[0][arrayMode] << 4) | 0x1); 1657 1658 ar5212SetAntennaSwitchInternal(ah, ahp->ah_antControl, chan); 1659 1660 /* Set the Noise Floor Thresh on ar5211 devices */ 1661 OS_REG_WRITE(ah, AR_PHY(90), 1662 (ee->ee_noiseFloorThresh[arrayMode] & 0x1FF) 1663 | (1 << 9)); 1664 1665 if (ee->ee_version >= AR_EEPROM_VER5_0 && IEEE80211_IS_CHAN_TURBO(chan)) { 1666 switchSettling = ee->ee_switchSettlingTurbo[is2GHz]; 1667 adcDesiredSize = ee->ee_adcDesiredSizeTurbo[is2GHz]; 1668 pgaDesiredSize = ee->ee_pgaDesiredSizeTurbo[is2GHz]; 1669 txrxAtten = ee->ee_txrxAttenTurbo[is2GHz]; 1670 rxtxMargin = ee->ee_rxtxMarginTurbo[is2GHz]; 1671 } else { 1672 switchSettling = ee->ee_switchSettling[arrayMode]; 1673 adcDesiredSize = ee->ee_adcDesiredSize[arrayMode]; 1674 pgaDesiredSize = ee->ee_pgaDesiredSize[is2GHz]; 1675 txrxAtten = ee->ee_txrxAtten[is2GHz]; 1676 rxtxMargin = ee->ee_rxtxMargin[is2GHz]; 1677 } 1678 1679 OS_REG_RMW_FIELD(ah, AR_PHY_SETTLING, 1680 AR_PHY_SETTLING_SWITCH, switchSettling); 1681 OS_REG_RMW_FIELD(ah, AR_PHY_DESIRED_SZ, 1682 AR_PHY_DESIRED_SZ_ADC, adcDesiredSize); 1683 OS_REG_RMW_FIELD(ah, AR_PHY_DESIRED_SZ, 1684 AR_PHY_DESIRED_SZ_PGA, pgaDesiredSize); 1685 OS_REG_RMW_FIELD(ah, AR_PHY_RXGAIN, 1686 AR_PHY_RXGAIN_TXRX_ATTEN, txrxAtten); 1687 OS_REG_WRITE(ah, AR_PHY(13), 1688 (ee->ee_txEndToXPAOff[arrayMode] << 24) 1689 | (ee->ee_txEndToXPAOff[arrayMode] << 16) 1690 | (ee->ee_txFrameToXPAOn[arrayMode] << 8) 1691 | ee->ee_txFrameToXPAOn[arrayMode]); 1692 AR_PHY_BIS(ah, 10, 0xFFFF00FF, 1693 ee->ee_txEndToXLNAOn[arrayMode] << 8); 1694 AR_PHY_BIS(ah, 25, 0xFFF80FFF, 1695 (ee->ee_thresh62[arrayMode] << 12) & 0x7F000); 1696 1697 /* 1698 * False detect backoff - suspected 32 MHz spur causes false 1699 * detects in OFDM, causing Tx Hangs. Decrease weak signal 1700 * sensitivity for this card. 1701 */ 1702 falseDectectBackoff = NO_FALSE_DETECT_BACKOFF; 1703 if (ee->ee_version < AR_EEPROM_VER3_3) { 1704 /* XXX magic number */ 1705 if (AH_PRIVATE(ah)->ah_subvendorid == 0x1022 && 1706 IEEE80211_IS_CHAN_OFDM(chan)) 1707 falseDectectBackoff += CB22_FALSE_DETECT_BACKOFF; 1708 } else { 1709 if (ar5212IsSpurChannel(ah, chan)) 1710 falseDectectBackoff += ee->ee_falseDetectBackoff[arrayMode]; 1711 } 1712 AR_PHY_BIS(ah, 73, 0xFFFFFF01, (falseDectectBackoff << 1) & 0xFE); 1713 1714 if (ichan->privFlags & CHANNEL_IQVALID) { 1715 iCoff = ichan->iCoff; 1716 qCoff = ichan->qCoff; 1717 } else { 1718 iCoff = ee->ee_iqCalI[is2GHz]; 1719 qCoff = ee->ee_iqCalQ[is2GHz]; 1720 } 1721 1722 /* write previous IQ results */ 1723 OS_REG_RMW_FIELD(ah, AR_PHY_TIMING_CTRL4, 1724 AR_PHY_TIMING_CTRL4_IQCORR_Q_I_COFF, iCoff); 1725 OS_REG_RMW_FIELD(ah, AR_PHY_TIMING_CTRL4, 1726 AR_PHY_TIMING_CTRL4_IQCORR_Q_Q_COFF, qCoff); 1727 OS_REG_SET_BIT(ah, AR_PHY_TIMING_CTRL4, 1728 AR_PHY_TIMING_CTRL4_IQCORR_ENABLE); 1729 1730 if (ee->ee_version >= AR_EEPROM_VER4_1) { 1731 if (!IEEE80211_IS_CHAN_108G(chan) || ee->ee_version >= AR_EEPROM_VER5_0) 1732 OS_REG_RMW_FIELD(ah, AR_PHY_GAIN_2GHZ, 1733 AR_PHY_GAIN_2GHZ_RXTX_MARGIN, rxtxMargin); 1734 } 1735 if (ee->ee_version >= AR_EEPROM_VER5_1) { 1736 /* for now always disabled */ 1737 OS_REG_WRITE(ah, AR_PHY_HEAVY_CLIP_ENABLE, 0); 1738 } 1739 1740 return AH_TRUE; 1741 #undef AR_PHY_BIS 1742 #undef NO_FALSE_DETECT_BACKOFF 1743 #undef CB22_FALSE_DETECT_BACKOFF 1744 } 1745 1746 /* 1747 * Apply Spur Immunity to Boards that require it. 1748 * Applies only to OFDM RX operation. 1749 */ 1750 1751 void 1752 ar5212SetSpurMitigation(struct ath_hal *ah, 1753 const struct ieee80211_channel *chan) 1754 { 1755 uint32_t pilotMask[2] = {0, 0}, binMagMask[4] = {0, 0, 0 , 0}; 1756 uint16_t i, finalSpur, curChanAsSpur, binWidth = 0, spurDetectWidth, spurChan; 1757 int32_t spurDeltaPhase = 0, spurFreqSd = 0, spurOffset, binOffsetNumT16, curBinOffset; 1758 int16_t numBinOffsets; 1759 static const uint16_t magMapFor4[4] = {1, 2, 2, 1}; 1760 static const uint16_t magMapFor3[3] = {1, 2, 1}; 1761 const uint16_t *pMagMap; 1762 HAL_BOOL is2GHz = IEEE80211_IS_CHAN_2GHZ(chan); 1763 HAL_CHANNEL_INTERNAL *ichan = ath_hal_checkchannel(ah, chan); 1764 uint32_t val; 1765 1766 #define CHAN_TO_SPUR(_f, _freq) ( ((_freq) - ((_f) ? 2300 : 4900)) * 10 ) 1767 if (IS_2417(ah)) { 1768 HALDEBUG(ah, HAL_DEBUG_RFPARAM, "%s: no spur mitigation\n", 1769 __func__); 1770 return; 1771 } 1772 1773 curChanAsSpur = CHAN_TO_SPUR(is2GHz, ichan->channel); 1774 1775 if (ichan->mainSpur) { 1776 /* Pull out the saved spur value */ 1777 finalSpur = ichan->mainSpur; 1778 } else { 1779 /* 1780 * Check if spur immunity should be performed for this channel 1781 * Should only be performed once per channel and then saved 1782 */ 1783 finalSpur = AR_NO_SPUR; 1784 spurDetectWidth = HAL_SPUR_CHAN_WIDTH; 1785 if (IEEE80211_IS_CHAN_TURBO(chan)) 1786 spurDetectWidth *= 2; 1787 1788 /* Decide if any spur affects the current channel */ 1789 for (i = 0; i < AR_EEPROM_MODAL_SPURS; i++) { 1790 spurChan = ath_hal_getSpurChan(ah, i, is2GHz); 1791 if (spurChan == AR_NO_SPUR) { 1792 break; 1793 } 1794 if ((curChanAsSpur - spurDetectWidth <= (spurChan & HAL_SPUR_VAL_MASK)) && 1795 (curChanAsSpur + spurDetectWidth >= (spurChan & HAL_SPUR_VAL_MASK))) { 1796 finalSpur = spurChan & HAL_SPUR_VAL_MASK; 1797 break; 1798 } 1799 } 1800 /* Save detected spur (or no spur) for this channel */ 1801 ichan->mainSpur = finalSpur; 1802 } 1803 1804 /* Write spur immunity data */ 1805 if (finalSpur == AR_NO_SPUR) { 1806 /* Disable Spur Immunity Regs if they appear set */ 1807 if (OS_REG_READ(ah, AR_PHY_TIMING_CTRL4) & AR_PHY_TIMING_CTRL4_ENABLE_SPUR_FILTER) { 1808 /* Clear Spur Delta Phase, Spur Freq, and enable bits */ 1809 OS_REG_RMW_FIELD(ah, AR_PHY_MASK_CTL, AR_PHY_MASK_CTL_RATE, 0); 1810 val = OS_REG_READ(ah, AR_PHY_TIMING_CTRL4); 1811 val &= ~(AR_PHY_TIMING_CTRL4_ENABLE_SPUR_FILTER | 1812 AR_PHY_TIMING_CTRL4_ENABLE_CHAN_MASK | 1813 AR_PHY_TIMING_CTRL4_ENABLE_PILOT_MASK); 1814 OS_REG_WRITE(ah, AR_PHY_MASK_CTL, val); 1815 OS_REG_WRITE(ah, AR_PHY_TIMING11, 0); 1816 1817 /* Clear pilot masks */ 1818 OS_REG_WRITE(ah, AR_PHY_TIMING7, 0); 1819 OS_REG_RMW_FIELD(ah, AR_PHY_TIMING8, AR_PHY_TIMING8_PILOT_MASK_2, 0); 1820 OS_REG_WRITE(ah, AR_PHY_TIMING9, 0); 1821 OS_REG_RMW_FIELD(ah, AR_PHY_TIMING10, AR_PHY_TIMING10_PILOT_MASK_2, 0); 1822 1823 /* Clear magnitude masks */ 1824 OS_REG_WRITE(ah, AR_PHY_BIN_MASK_1, 0); 1825 OS_REG_WRITE(ah, AR_PHY_BIN_MASK_2, 0); 1826 OS_REG_WRITE(ah, AR_PHY_BIN_MASK_3, 0); 1827 OS_REG_RMW_FIELD(ah, AR_PHY_MASK_CTL, AR_PHY_MASK_CTL_MASK_4, 0); 1828 OS_REG_WRITE(ah, AR_PHY_BIN_MASK2_1, 0); 1829 OS_REG_WRITE(ah, AR_PHY_BIN_MASK2_2, 0); 1830 OS_REG_WRITE(ah, AR_PHY_BIN_MASK2_3, 0); 1831 OS_REG_RMW_FIELD(ah, AR_PHY_BIN_MASK2_4, AR_PHY_BIN_MASK2_4_MASK_4, 0); 1832 } 1833 } else { 1834 spurOffset = finalSpur - curChanAsSpur; 1835 /* 1836 * Spur calculations: 1837 * spurDeltaPhase is (spurOffsetIn100KHz / chipFrequencyIn100KHz) << 21 1838 * spurFreqSd is (spurOffsetIn100KHz / sampleFrequencyIn100KHz) << 11 1839 */ 1840 if (IEEE80211_IS_CHAN_TURBO(chan)) { 1841 /* Chip Frequency & sampleFrequency are 80 MHz */ 1842 spurDeltaPhase = (spurOffset << 16) / 25; 1843 spurFreqSd = spurDeltaPhase >> 10; 1844 binWidth = HAL_BIN_WIDTH_TURBO_100HZ; 1845 } else if (IEEE80211_IS_CHAN_G(chan)) { 1846 /* Chip Frequency is 44MHz, sampleFrequency is 40 MHz */ 1847 spurFreqSd = (spurOffset << 8) / 55; 1848 spurDeltaPhase = (spurOffset << 17) / 25; 1849 binWidth = HAL_BIN_WIDTH_BASE_100HZ; 1850 } else { 1851 HALASSERT(!IEEE80211_IS_CHAN_B(chan)); 1852 /* Chip Frequency & sampleFrequency are 40 MHz */ 1853 spurDeltaPhase = (spurOffset << 17) / 25; 1854 spurFreqSd = spurDeltaPhase >> 10; 1855 binWidth = HAL_BIN_WIDTH_BASE_100HZ; 1856 } 1857 1858 /* Compute Pilot Mask */ 1859 binOffsetNumT16 = ((spurOffset * 1000) << 4) / binWidth; 1860 /* The spur is on a bin if it's remainder at times 16 is 0 */ 1861 if (binOffsetNumT16 & 0xF) { 1862 numBinOffsets = 4; 1863 pMagMap = magMapFor4; 1864 } else { 1865 numBinOffsets = 3; 1866 pMagMap = magMapFor3; 1867 } 1868 for (i = 0; i < numBinOffsets; i++) { 1869 if ((binOffsetNumT16 >> 4) > HAL_MAX_BINS_ALLOWED) { 1870 HALDEBUG(ah, HAL_DEBUG_ANY, 1871 "Too man bins in spur mitigation\n"); 1872 return; 1873 } 1874 1875 /* Get Pilot Mask values */ 1876 curBinOffset = (binOffsetNumT16 >> 4) + i + 25; 1877 if ((curBinOffset >= 0) && (curBinOffset <= 32)) { 1878 if (curBinOffset <= 25) 1879 pilotMask[0] |= 1 << curBinOffset; 1880 else if (curBinOffset >= 27) 1881 pilotMask[0] |= 1 << (curBinOffset - 1); 1882 } else if ((curBinOffset >= 33) && (curBinOffset <= 52)) 1883 pilotMask[1] |= 1 << (curBinOffset - 33); 1884 1885 /* Get viterbi values */ 1886 if ((curBinOffset >= -1) && (curBinOffset <= 14)) 1887 binMagMask[0] |= pMagMap[i] << (curBinOffset + 1) * 2; 1888 else if ((curBinOffset >= 15) && (curBinOffset <= 30)) 1889 binMagMask[1] |= pMagMap[i] << (curBinOffset - 15) * 2; 1890 else if ((curBinOffset >= 31) && (curBinOffset <= 46)) 1891 binMagMask[2] |= pMagMap[i] << (curBinOffset -31) * 2; 1892 else if((curBinOffset >= 47) && (curBinOffset <= 53)) 1893 binMagMask[3] |= pMagMap[i] << (curBinOffset -47) * 2; 1894 } 1895 1896 /* Write Spur Delta Phase, Spur Freq, and enable bits */ 1897 OS_REG_RMW_FIELD(ah, AR_PHY_MASK_CTL, AR_PHY_MASK_CTL_RATE, 0xFF); 1898 val = OS_REG_READ(ah, AR_PHY_TIMING_CTRL4); 1899 val |= (AR_PHY_TIMING_CTRL4_ENABLE_SPUR_FILTER | 1900 AR_PHY_TIMING_CTRL4_ENABLE_CHAN_MASK | 1901 AR_PHY_TIMING_CTRL4_ENABLE_PILOT_MASK); 1902 OS_REG_WRITE(ah, AR_PHY_TIMING_CTRL4, val); 1903 OS_REG_WRITE(ah, AR_PHY_TIMING11, AR_PHY_TIMING11_USE_SPUR_IN_AGC | 1904 SM(spurFreqSd, AR_PHY_TIMING11_SPUR_FREQ_SD) | 1905 SM(spurDeltaPhase, AR_PHY_TIMING11_SPUR_DELTA_PHASE)); 1906 1907 /* Write pilot masks */ 1908 OS_REG_WRITE(ah, AR_PHY_TIMING7, pilotMask[0]); 1909 OS_REG_RMW_FIELD(ah, AR_PHY_TIMING8, AR_PHY_TIMING8_PILOT_MASK_2, pilotMask[1]); 1910 OS_REG_WRITE(ah, AR_PHY_TIMING9, pilotMask[0]); 1911 OS_REG_RMW_FIELD(ah, AR_PHY_TIMING10, AR_PHY_TIMING10_PILOT_MASK_2, pilotMask[1]); 1912 1913 /* Write magnitude masks */ 1914 OS_REG_WRITE(ah, AR_PHY_BIN_MASK_1, binMagMask[0]); 1915 OS_REG_WRITE(ah, AR_PHY_BIN_MASK_2, binMagMask[1]); 1916 OS_REG_WRITE(ah, AR_PHY_BIN_MASK_3, binMagMask[2]); 1917 OS_REG_RMW_FIELD(ah, AR_PHY_MASK_CTL, AR_PHY_MASK_CTL_MASK_4, binMagMask[3]); 1918 OS_REG_WRITE(ah, AR_PHY_BIN_MASK2_1, binMagMask[0]); 1919 OS_REG_WRITE(ah, AR_PHY_BIN_MASK2_2, binMagMask[1]); 1920 OS_REG_WRITE(ah, AR_PHY_BIN_MASK2_3, binMagMask[2]); 1921 OS_REG_RMW_FIELD(ah, AR_PHY_BIN_MASK2_4, AR_PHY_BIN_MASK2_4_MASK_4, binMagMask[3]); 1922 } 1923 #undef CHAN_TO_SPUR 1924 } 1925 1926 1927 /* 1928 * Delta slope coefficient computation. 1929 * Required for OFDM operation. 1930 */ 1931 void 1932 ar5212SetDeltaSlope(struct ath_hal *ah, const struct ieee80211_channel *chan) 1933 { 1934 #define COEF_SCALE_S 24 1935 #define INIT_CLOCKMHZSCALED 0x64000000 1936 uint16_t freq = ath_hal_gethwchannel(ah, chan); 1937 unsigned long coef_scaled, coef_exp, coef_man, ds_coef_exp, ds_coef_man; 1938 unsigned long clockMhzScaled = INIT_CLOCKMHZSCALED; 1939 1940 if (IEEE80211_IS_CHAN_TURBO(chan)) 1941 clockMhzScaled *= 2; 1942 /* half and quarter rate can divide the scaled clock by 2 or 4 respectively */ 1943 /* scale for selected channel bandwidth */ 1944 if (IEEE80211_IS_CHAN_HALF(chan)) { 1945 clockMhzScaled = clockMhzScaled >> 1; 1946 } else if (IEEE80211_IS_CHAN_QUARTER(chan)) { 1947 clockMhzScaled = clockMhzScaled >> 2; 1948 } 1949 1950 /* 1951 * ALGO -> coef = 1e8/fcarrier*fclock/40; 1952 * scaled coef to provide precision for this floating calculation 1953 */ 1954 coef_scaled = clockMhzScaled / freq; 1955 1956 /* 1957 * ALGO -> coef_exp = 14-floor(log2(coef)); 1958 * floor(log2(x)) is the highest set bit position 1959 */ 1960 for (coef_exp = 31; coef_exp > 0; coef_exp--) 1961 if ((coef_scaled >> coef_exp) & 0x1) 1962 break; 1963 /* A coef_exp of 0 is a legal bit position but an unexpected coef_exp */ 1964 HALASSERT(coef_exp); 1965 coef_exp = 14 - (coef_exp - COEF_SCALE_S); 1966 1967 /* 1968 * ALGO -> coef_man = floor(coef* 2^coef_exp+0.5); 1969 * The coefficient is already shifted up for scaling 1970 */ 1971 coef_man = coef_scaled + (1 << (COEF_SCALE_S - coef_exp - 1)); 1972 ds_coef_man = coef_man >> (COEF_SCALE_S - coef_exp); 1973 ds_coef_exp = coef_exp - 16; 1974 1975 OS_REG_RMW_FIELD(ah, AR_PHY_TIMING3, 1976 AR_PHY_TIMING3_DSC_MAN, ds_coef_man); 1977 OS_REG_RMW_FIELD(ah, AR_PHY_TIMING3, 1978 AR_PHY_TIMING3_DSC_EXP, ds_coef_exp); 1979 #undef INIT_CLOCKMHZSCALED 1980 #undef COEF_SCALE_S 1981 } 1982 1983 /* 1984 * Set a limit on the overall output power. Used for dynamic 1985 * transmit power control and the like. 1986 * 1987 * NB: limit is in units of 0.5 dbM. 1988 */ 1989 HAL_BOOL 1990 ar5212SetTxPowerLimit(struct ath_hal *ah, uint32_t limit) 1991 { 1992 /* XXX blech, construct local writable copy */ 1993 struct ieee80211_channel dummy = *AH_PRIVATE(ah)->ah_curchan; 1994 uint16_t dummyXpdGains[2]; 1995 HAL_BOOL isBmode; 1996 1997 SAVE_CCK(ah, &dummy, isBmode); 1998 AH_PRIVATE(ah)->ah_powerLimit = AH_MIN(limit, MAX_RATE_POWER); 1999 return ar5212SetTransmitPower(ah, &dummy, dummyXpdGains); 2000 } 2001 2002 /* 2003 * Set the transmit power in the baseband for the given 2004 * operating channel and mode. 2005 */ 2006 HAL_BOOL 2007 ar5212SetTransmitPower(struct ath_hal *ah, 2008 const struct ieee80211_channel *chan, uint16_t *rfXpdGain) 2009 { 2010 #define POW_OFDM(_r, _s) (((0 & 1)<< ((_s)+6)) | (((_r) & 0x3f) << (_s))) 2011 #define POW_CCK(_r, _s) (((_r) & 0x3f) << (_s)) 2012 #define N(a) (sizeof (a) / sizeof (a[0])) 2013 static const uint16_t tpcScaleReductionTable[5] = 2014 { 0, 3, 6, 9, MAX_RATE_POWER }; 2015 struct ath_hal_5212 *ahp = AH5212(ah); 2016 uint16_t freq = ath_hal_gethwchannel(ah, chan); 2017 const HAL_EEPROM *ee = AH_PRIVATE(ah)->ah_eeprom; 2018 int16_t minPower, maxPower, tpcInDb, powerLimit; 2019 int i; 2020 2021 HALASSERT(ah->ah_magic == AR5212_MAGIC); 2022 2023 OS_MEMZERO(ahp->ah_pcdacTable, ahp->ah_pcdacTableSize); 2024 OS_MEMZERO(ahp->ah_ratesArray, sizeof(ahp->ah_ratesArray)); 2025 2026 powerLimit = AH_MIN(MAX_RATE_POWER, AH_PRIVATE(ah)->ah_powerLimit); 2027 if (powerLimit >= MAX_RATE_POWER || powerLimit == 0) 2028 tpcInDb = tpcScaleReductionTable[AH_PRIVATE(ah)->ah_tpScale]; 2029 else 2030 tpcInDb = 0; 2031 if (!ar5212SetRateTable(ah, chan, tpcInDb, powerLimit, 2032 AH_TRUE, &minPower, &maxPower)) { 2033 HALDEBUG(ah, HAL_DEBUG_ANY, "%s: unable to set rate table\n", 2034 __func__); 2035 return AH_FALSE; 2036 } 2037 if (!ahp->ah_rfHal->setPowerTable(ah, 2038 &minPower, &maxPower, chan, rfXpdGain)) { 2039 HALDEBUG(ah, HAL_DEBUG_ANY, "%s: unable to set power table\n", 2040 __func__); 2041 return AH_FALSE; 2042 } 2043 2044 /* 2045 * Adjust XR power/rate up by 2 dB to account for greater peak 2046 * to avg ratio - except in newer avg power designs 2047 */ 2048 if (!IS_2413(ah) && !IS_5413(ah)) 2049 ahp->ah_ratesArray[15] += 4; 2050 /* 2051 * txPowerIndexOffset is set by the SetPowerTable() call - 2052 * adjust the rate table 2053 */ 2054 for (i = 0; i < N(ahp->ah_ratesArray); i++) { 2055 ahp->ah_ratesArray[i] += ahp->ah_txPowerIndexOffset; 2056 if (ahp->ah_ratesArray[i] > 63) 2057 ahp->ah_ratesArray[i] = 63; 2058 } 2059 2060 if (ee->ee_eepMap < 2) { 2061 /* 2062 * Correct gain deltas for 5212 G operation - 2063 * Removed with revised chipset 2064 */ 2065 if (AH_PRIVATE(ah)->ah_phyRev < AR_PHY_CHIP_ID_REV_2 && 2066 IEEE80211_IS_CHAN_G(chan)) { 2067 uint16_t cckOfdmPwrDelta; 2068 2069 if (freq == 2484) 2070 cckOfdmPwrDelta = SCALE_OC_DELTA( 2071 ee->ee_cckOfdmPwrDelta - 2072 ee->ee_scaledCh14FilterCckDelta); 2073 else 2074 cckOfdmPwrDelta = SCALE_OC_DELTA( 2075 ee->ee_cckOfdmPwrDelta); 2076 ar5212CorrectGainDelta(ah, cckOfdmPwrDelta); 2077 } 2078 /* 2079 * Finally, write the power values into the 2080 * baseband power table 2081 */ 2082 for (i = 0; i < (PWR_TABLE_SIZE/2); i++) { 2083 OS_REG_WRITE(ah, AR_PHY_PCDAC_TX_POWER(i), 2084 ((((ahp->ah_pcdacTable[2*i + 1] << 8) | 0xff) & 0xffff) << 16) 2085 | (((ahp->ah_pcdacTable[2*i] << 8) | 0xff) & 0xffff) 2086 ); 2087 } 2088 } 2089 2090 /* Write the OFDM power per rate set */ 2091 OS_REG_WRITE(ah, AR_PHY_POWER_TX_RATE1, 2092 POW_OFDM(ahp->ah_ratesArray[3], 24) 2093 | POW_OFDM(ahp->ah_ratesArray[2], 16) 2094 | POW_OFDM(ahp->ah_ratesArray[1], 8) 2095 | POW_OFDM(ahp->ah_ratesArray[0], 0) 2096 ); 2097 OS_REG_WRITE(ah, AR_PHY_POWER_TX_RATE2, 2098 POW_OFDM(ahp->ah_ratesArray[7], 24) 2099 | POW_OFDM(ahp->ah_ratesArray[6], 16) 2100 | POW_OFDM(ahp->ah_ratesArray[5], 8) 2101 | POW_OFDM(ahp->ah_ratesArray[4], 0) 2102 ); 2103 2104 /* Write the CCK power per rate set */ 2105 OS_REG_WRITE(ah, AR_PHY_POWER_TX_RATE3, 2106 POW_CCK(ahp->ah_ratesArray[10], 24) 2107 | POW_CCK(ahp->ah_ratesArray[9], 16) 2108 | POW_CCK(ahp->ah_ratesArray[15], 8) /* XR target power */ 2109 | POW_CCK(ahp->ah_ratesArray[8], 0) 2110 ); 2111 OS_REG_WRITE(ah, AR_PHY_POWER_TX_RATE4, 2112 POW_CCK(ahp->ah_ratesArray[14], 24) 2113 | POW_CCK(ahp->ah_ratesArray[13], 16) 2114 | POW_CCK(ahp->ah_ratesArray[12], 8) 2115 | POW_CCK(ahp->ah_ratesArray[11], 0) 2116 ); 2117 2118 /* 2119 * Set max power to 30 dBm and, optionally, 2120 * enable TPC in tx descriptors. 2121 */ 2122 OS_REG_WRITE(ah, AR_PHY_POWER_TX_RATE_MAX, MAX_RATE_POWER | 2123 (ahp->ah_tpcEnabled ? AR_PHY_POWER_TX_RATE_MAX_TPC_ENABLE : 0)); 2124 2125 return AH_TRUE; 2126 #undef N 2127 #undef POW_CCK 2128 #undef POW_OFDM 2129 } 2130 2131 /* 2132 * Sets the transmit power in the baseband for the given 2133 * operating channel and mode. 2134 */ 2135 static HAL_BOOL 2136 ar5212SetRateTable(struct ath_hal *ah, const struct ieee80211_channel *chan, 2137 int16_t tpcScaleReduction, int16_t powerLimit, HAL_BOOL commit, 2138 int16_t *pMinPower, int16_t *pMaxPower) 2139 { 2140 struct ath_hal_5212 *ahp = AH5212(ah); 2141 uint16_t freq = ath_hal_gethwchannel(ah, chan); 2142 const HAL_EEPROM *ee = AH_PRIVATE(ah)->ah_eeprom; 2143 uint16_t *rpow = ahp->ah_ratesArray; 2144 uint16_t twiceMaxEdgePower = MAX_RATE_POWER; 2145 uint16_t twiceMaxEdgePowerCck = MAX_RATE_POWER; 2146 uint16_t twiceMaxRDPower = MAX_RATE_POWER; 2147 int i; 2148 uint8_t cfgCtl; 2149 int8_t twiceAntennaGain, twiceAntennaReduction; 2150 const RD_EDGES_POWER *rep; 2151 TRGT_POWER_INFO targetPowerOfdm, targetPowerCck; 2152 int16_t scaledPower, maxAvailPower = 0; 2153 int16_t r13, r9, r7, r0; 2154 2155 HALASSERT(ah->ah_magic == AR5212_MAGIC); 2156 2157 twiceMaxRDPower = chan->ic_maxregpower * 2; 2158 *pMaxPower = -MAX_RATE_POWER; 2159 *pMinPower = MAX_RATE_POWER; 2160 2161 /* Get conformance test limit maximum for this channel */ 2162 cfgCtl = ath_hal_getctl(ah, chan); 2163 for (i = 0; i < ee->ee_numCtls; i++) { 2164 uint16_t twiceMinEdgePower; 2165 2166 if (ee->ee_ctl[i] == 0) 2167 continue; 2168 if (ee->ee_ctl[i] == cfgCtl || 2169 cfgCtl == ((ee->ee_ctl[i] & CTL_MODE_M) | SD_NO_CTL)) { 2170 rep = &ee->ee_rdEdgesPower[i * NUM_EDGES]; 2171 twiceMinEdgePower = ar5212GetMaxEdgePower(freq, rep); 2172 if ((cfgCtl & ~CTL_MODE_M) == SD_NO_CTL) { 2173 /* Find the minimum of all CTL edge powers that apply to this channel */ 2174 twiceMaxEdgePower = AH_MIN(twiceMaxEdgePower, twiceMinEdgePower); 2175 } else { 2176 twiceMaxEdgePower = twiceMinEdgePower; 2177 break; 2178 } 2179 } 2180 } 2181 2182 if (IEEE80211_IS_CHAN_G(chan)) { 2183 /* Check for a CCK CTL for 11G CCK powers */ 2184 cfgCtl = (cfgCtl & ~CTL_MODE_M) | CTL_11B; 2185 for (i = 0; i < ee->ee_numCtls; i++) { 2186 uint16_t twiceMinEdgePowerCck; 2187 2188 if (ee->ee_ctl[i] == 0) 2189 continue; 2190 if (ee->ee_ctl[i] == cfgCtl || 2191 cfgCtl == ((ee->ee_ctl[i] & CTL_MODE_M) | SD_NO_CTL)) { 2192 rep = &ee->ee_rdEdgesPower[i * NUM_EDGES]; 2193 twiceMinEdgePowerCck = ar5212GetMaxEdgePower(freq, rep); 2194 if ((cfgCtl & ~CTL_MODE_M) == SD_NO_CTL) { 2195 /* Find the minimum of all CTL edge powers that apply to this channel */ 2196 twiceMaxEdgePowerCck = AH_MIN(twiceMaxEdgePowerCck, twiceMinEdgePowerCck); 2197 } else { 2198 twiceMaxEdgePowerCck = twiceMinEdgePowerCck; 2199 break; 2200 } 2201 } 2202 } 2203 } else { 2204 /* Set the 11B cck edge power to the one found before */ 2205 twiceMaxEdgePowerCck = twiceMaxEdgePower; 2206 } 2207 2208 /* Get Antenna Gain reduction */ 2209 if (IEEE80211_IS_CHAN_5GHZ(chan)) { 2210 ath_hal_eepromGet(ah, AR_EEP_ANTGAINMAX_5, &twiceAntennaGain); 2211 } else { 2212 ath_hal_eepromGet(ah, AR_EEP_ANTGAINMAX_2, &twiceAntennaGain); 2213 } 2214 twiceAntennaReduction = 2215 ath_hal_getantennareduction(ah, chan, twiceAntennaGain); 2216 2217 if (IEEE80211_IS_CHAN_OFDM(chan)) { 2218 /* Get final OFDM target powers */ 2219 if (IEEE80211_IS_CHAN_2GHZ(chan)) { 2220 ar5212GetTargetPowers(ah, chan, ee->ee_trgtPwr_11g, 2221 ee->ee_numTargetPwr_11g, &targetPowerOfdm); 2222 } else { 2223 ar5212GetTargetPowers(ah, chan, ee->ee_trgtPwr_11a, 2224 ee->ee_numTargetPwr_11a, &targetPowerOfdm); 2225 } 2226 2227 /* Get Maximum OFDM power */ 2228 /* Minimum of target and edge powers */ 2229 scaledPower = AH_MIN(twiceMaxEdgePower, 2230 twiceMaxRDPower - twiceAntennaReduction); 2231 2232 /* 2233 * If turbo is set, reduce power to keep power 2234 * consumption under 2 Watts. Note that we always do 2235 * this unless specially configured. Then we limit 2236 * power only for non-AP operation. 2237 */ 2238 if (IEEE80211_IS_CHAN_TURBO(chan) 2239 #ifdef AH_ENABLE_AP_SUPPORT 2240 && AH_PRIVATE(ah)->ah_opmode != HAL_M_HOSTAP 2241 #endif 2242 ) { 2243 /* 2244 * If turbo is set, reduce power to keep power 2245 * consumption under 2 Watts 2246 */ 2247 if (ee->ee_version >= AR_EEPROM_VER3_1) 2248 scaledPower = AH_MIN(scaledPower, 2249 ee->ee_turbo2WMaxPower5); 2250 /* 2251 * EEPROM version 4.0 added an additional 2252 * constraint on 2.4GHz channels. 2253 */ 2254 if (ee->ee_version >= AR_EEPROM_VER4_0 && 2255 IEEE80211_IS_CHAN_2GHZ(chan)) 2256 scaledPower = AH_MIN(scaledPower, 2257 ee->ee_turbo2WMaxPower2); 2258 } 2259 2260 maxAvailPower = AH_MIN(scaledPower, 2261 targetPowerOfdm.twicePwr6_24); 2262 2263 /* Reduce power by max regulatory domain allowed restrictions */ 2264 scaledPower = maxAvailPower - (tpcScaleReduction * 2); 2265 scaledPower = (scaledPower < 0) ? 0 : scaledPower; 2266 scaledPower = AH_MIN(scaledPower, powerLimit); 2267 2268 if (commit) { 2269 /* Set OFDM rates 9, 12, 18, 24 */ 2270 r0 = rpow[0] = rpow[1] = rpow[2] = rpow[3] = rpow[4] = scaledPower; 2271 2272 /* Set OFDM rates 36, 48, 54, XR */ 2273 rpow[5] = AH_MIN(rpow[0], targetPowerOfdm.twicePwr36); 2274 rpow[6] = AH_MIN(rpow[0], targetPowerOfdm.twicePwr48); 2275 r7 = rpow[7] = AH_MIN(rpow[0], targetPowerOfdm.twicePwr54); 2276 2277 if (ee->ee_version >= AR_EEPROM_VER4_0) { 2278 /* Setup XR target power from EEPROM */ 2279 rpow[15] = AH_MIN(scaledPower, IEEE80211_IS_CHAN_2GHZ(chan) ? 2280 ee->ee_xrTargetPower2 : ee->ee_xrTargetPower5); 2281 } else { 2282 /* XR uses 6mb power */ 2283 rpow[15] = rpow[0]; 2284 } 2285 ahp->ah_ofdmTxPower = *pMaxPower; 2286 2287 } else { 2288 r0 = scaledPower; 2289 r7 = AH_MIN(r0, targetPowerOfdm.twicePwr54); 2290 } 2291 *pMinPower = r7; 2292 *pMaxPower = r0; 2293 2294 HALDEBUG(ah, HAL_DEBUG_RFPARAM, 2295 "%s: MaxRD: %d TurboMax: %d MaxCTL: %d " 2296 "TPC_Reduction %d chan=%d (0x%x) maxAvailPower=%d pwr6_24=%d, maxPower=%d\n", 2297 __func__, twiceMaxRDPower, ee->ee_turbo2WMaxPower5, 2298 twiceMaxEdgePower, tpcScaleReduction * 2, 2299 chan->ic_freq, chan->ic_flags, 2300 maxAvailPower, targetPowerOfdm.twicePwr6_24, *pMaxPower); 2301 } 2302 2303 if (IEEE80211_IS_CHAN_CCK(chan)) { 2304 /* Get final CCK target powers */ 2305 ar5212GetTargetPowers(ah, chan, ee->ee_trgtPwr_11b, 2306 ee->ee_numTargetPwr_11b, &targetPowerCck); 2307 2308 /* Reduce power by max regulatory domain allowed restrictions */ 2309 scaledPower = AH_MIN(twiceMaxEdgePowerCck, 2310 twiceMaxRDPower - twiceAntennaReduction); 2311 if (maxAvailPower < AH_MIN(scaledPower, targetPowerCck.twicePwr6_24)) 2312 maxAvailPower = AH_MIN(scaledPower, targetPowerCck.twicePwr6_24); 2313 2314 /* Reduce power by user selection */ 2315 scaledPower = AH_MIN(scaledPower, targetPowerCck.twicePwr6_24) - (tpcScaleReduction * 2); 2316 scaledPower = (scaledPower < 0) ? 0 : scaledPower; 2317 scaledPower = AH_MIN(scaledPower, powerLimit); 2318 2319 if (commit) { 2320 /* Set CCK rates 2L, 2S, 5.5L, 5.5S, 11L, 11S */ 2321 rpow[8] = AH_MIN(scaledPower, targetPowerCck.twicePwr6_24); 2322 r9 = rpow[9] = AH_MIN(scaledPower, targetPowerCck.twicePwr36); 2323 rpow[10] = rpow[9]; 2324 rpow[11] = AH_MIN(scaledPower, targetPowerCck.twicePwr48); 2325 rpow[12] = rpow[11]; 2326 r13 = rpow[13] = AH_MIN(scaledPower, targetPowerCck.twicePwr54); 2327 rpow[14] = rpow[13]; 2328 } else { 2329 r9 = AH_MIN(scaledPower, targetPowerCck.twicePwr36); 2330 r13 = AH_MIN(scaledPower, targetPowerCck.twicePwr54); 2331 } 2332 2333 /* Set min/max power based off OFDM values or initialization */ 2334 if (r13 < *pMinPower) 2335 *pMinPower = r13; 2336 if (r9 > *pMaxPower) 2337 *pMaxPower = r9; 2338 2339 HALDEBUG(ah, HAL_DEBUG_RFPARAM, 2340 "%s: cck: MaxRD: %d MaxCTL: %d " 2341 "TPC_Reduction %d chan=%d (0x%x) maxAvailPower=%d pwr6_24=%d, maxPower=%d\n", 2342 __func__, twiceMaxRDPower, twiceMaxEdgePowerCck, 2343 tpcScaleReduction * 2, chan->ic_freq, chan->ic_flags, 2344 maxAvailPower, targetPowerCck.twicePwr6_24, *pMaxPower); 2345 } 2346 if (commit) { 2347 ahp->ah_tx6PowerInHalfDbm = *pMaxPower; 2348 AH_PRIVATE(ah)->ah_maxPowerLevel = ahp->ah_tx6PowerInHalfDbm; 2349 } 2350 return AH_TRUE; 2351 } 2352 2353 HAL_BOOL 2354 ar5212GetChipPowerLimits(struct ath_hal *ah, struct ieee80211_channel *chan) 2355 { 2356 struct ath_hal_5212 *ahp = AH5212(ah); 2357 #if 0 2358 static const uint16_t tpcScaleReductionTable[5] = 2359 { 0, 3, 6, 9, MAX_RATE_POWER }; 2360 int16_t tpcInDb, powerLimit; 2361 #endif 2362 int16_t minPower, maxPower; 2363 2364 /* 2365 * Get Pier table max and min powers. 2366 */ 2367 if (ahp->ah_rfHal->getChannelMaxMinPower(ah, chan, &maxPower, &minPower)) { 2368 /* NB: rf code returns 1/4 dBm units, convert */ 2369 chan->ic_maxpower = maxPower / 2; 2370 chan->ic_minpower = minPower / 2; 2371 } else { 2372 HALDEBUG(ah, HAL_DEBUG_ANY, 2373 "%s: no min/max power for %u/0x%x\n", 2374 __func__, chan->ic_freq, chan->ic_flags); 2375 chan->ic_maxpower = MAX_RATE_POWER; 2376 chan->ic_minpower = 0; 2377 } 2378 #if 0 2379 /* 2380 * Now adjust to reflect any global scale and/or CTL's. 2381 * (XXX is that correct?) 2382 */ 2383 powerLimit = AH_MIN(MAX_RATE_POWER, AH_PRIVATE(ah)->ah_powerLimit); 2384 if (powerLimit >= MAX_RATE_POWER || powerLimit == 0) 2385 tpcInDb = tpcScaleReductionTable[AH_PRIVATE(ah)->ah_tpScale]; 2386 else 2387 tpcInDb = 0; 2388 if (!ar5212SetRateTable(ah, chan, tpcInDb, powerLimit, 2389 AH_FALSE, &minPower, &maxPower)) { 2390 HALDEBUG(ah, HAL_DEBUG_ANY, 2391 "%s: unable to find max/min power\n",__func__); 2392 return AH_FALSE; 2393 } 2394 if (maxPower < chan->ic_maxpower) 2395 chan->ic_maxpower = maxPower; 2396 if (minPower < chan->ic_minpower) 2397 chan->ic_minpower = minPower; 2398 HALDEBUG(ah, HAL_DEBUG_RESET, 2399 "Chan %d: MaxPow = %d MinPow = %d\n", 2400 chan->ic_freq, chan->ic_maxpower, chans->ic_minpower); 2401 #endif 2402 return AH_TRUE; 2403 } 2404 2405 /* 2406 * Correct for the gain-delta between ofdm and cck mode target 2407 * powers. Write the results to the rate table and the power table. 2408 * 2409 * Conventions : 2410 * 1. rpow[ii] is the integer value of 2*(desired power 2411 * for the rate ii in dBm) to provide 0.5dB resolution. rate 2412 * mapping is as following : 2413 * [0..7] --> ofdm 6, 9, .. 48, 54 2414 * [8..14] --> cck 1L, 2L, 2S, .. 11L, 11S 2415 * [15] --> XR (all rates get the same power) 2416 * 2. powv[ii] is the pcdac corresponding to ii/2 dBm. 2417 */ 2418 static void 2419 ar5212CorrectGainDelta(struct ath_hal *ah, int twiceOfdmCckDelta) 2420 { 2421 #define N(_a) (sizeof(_a) / sizeof(_a[0])) 2422 struct ath_hal_5212 *ahp = AH5212(ah); 2423 const HAL_EEPROM *ee = AH_PRIVATE(ah)->ah_eeprom; 2424 int16_t ratesIndex[N(ahp->ah_ratesArray)]; 2425 uint16_t ii, jj, iter; 2426 int32_t cckIndex; 2427 int16_t gainDeltaAdjust; 2428 2429 HALASSERT(ah->ah_magic == AR5212_MAGIC); 2430 2431 gainDeltaAdjust = ee->ee_cckOfdmGainDelta; 2432 2433 /* make a local copy of desired powers as initial indices */ 2434 OS_MEMCPY(ratesIndex, ahp->ah_ratesArray, sizeof(ratesIndex)); 2435 2436 /* fix only the CCK indices */ 2437 for (ii = 8; ii < 15; ii++) { 2438 /* apply a gain_delta correction of -15 for CCK */ 2439 ratesIndex[ii] -= gainDeltaAdjust; 2440 2441 /* Now check for contention with all ofdm target powers */ 2442 jj = 0; 2443 iter = 0; 2444 /* indicates not all ofdm rates checked forcontention yet */ 2445 while (jj < 16) { 2446 if (ratesIndex[ii] < 0) 2447 ratesIndex[ii] = 0; 2448 if (jj == 8) { /* skip CCK rates */ 2449 jj = 15; 2450 continue; 2451 } 2452 if (ratesIndex[ii] == ahp->ah_ratesArray[jj]) { 2453 if (ahp->ah_ratesArray[jj] == 0) 2454 ratesIndex[ii]++; 2455 else if (iter > 50) { 2456 /* 2457 * To avoid pathological case of of 2458 * dm target powers 0 and 0.5dBm 2459 */ 2460 ratesIndex[ii]++; 2461 } else 2462 ratesIndex[ii]--; 2463 /* check with all rates again */ 2464 jj = 0; 2465 iter++; 2466 } else 2467 jj++; 2468 } 2469 if (ratesIndex[ii] >= PWR_TABLE_SIZE) 2470 ratesIndex[ii] = PWR_TABLE_SIZE -1; 2471 cckIndex = ahp->ah_ratesArray[ii] - twiceOfdmCckDelta; 2472 if (cckIndex < 0) 2473 cckIndex = 0; 2474 2475 /* 2476 * Validate that the indexes for the powv are not 2477 * out of bounds. 2478 */ 2479 HALASSERT(cckIndex < PWR_TABLE_SIZE); 2480 HALASSERT(ratesIndex[ii] < PWR_TABLE_SIZE); 2481 ahp->ah_pcdacTable[ratesIndex[ii]] = 2482 ahp->ah_pcdacTable[cckIndex]; 2483 } 2484 /* Override rate per power table with new values */ 2485 for (ii = 8; ii < 15; ii++) 2486 ahp->ah_ratesArray[ii] = ratesIndex[ii]; 2487 #undef N 2488 } 2489 2490 /* 2491 * Find the maximum conformance test limit for the given channel and CTL info 2492 */ 2493 static uint16_t 2494 ar5212GetMaxEdgePower(uint16_t channel, const RD_EDGES_POWER *pRdEdgesPower) 2495 { 2496 /* temp array for holding edge channels */ 2497 uint16_t tempChannelList[NUM_EDGES]; 2498 uint16_t clo, chi, twiceMaxEdgePower; 2499 int i, numEdges; 2500 2501 /* Get the edge power */ 2502 for (i = 0; i < NUM_EDGES; i++) { 2503 if (pRdEdgesPower[i].rdEdge == 0) 2504 break; 2505 tempChannelList[i] = pRdEdgesPower[i].rdEdge; 2506 } 2507 numEdges = i; 2508 2509 ar5212GetLowerUpperValues(channel, tempChannelList, 2510 numEdges, &clo, &chi); 2511 /* Get the index for the lower channel */ 2512 for (i = 0; i < numEdges && clo != tempChannelList[i]; i++) 2513 ; 2514 /* Is lower channel ever outside the rdEdge? */ 2515 HALASSERT(i != numEdges); 2516 2517 if ((clo == chi && clo == channel) || (pRdEdgesPower[i].flag)) { 2518 /* 2519 * If there's an exact channel match or an inband flag set 2520 * on the lower channel use the given rdEdgePower 2521 */ 2522 twiceMaxEdgePower = pRdEdgesPower[i].twice_rdEdgePower; 2523 HALASSERT(twiceMaxEdgePower > 0); 2524 } else 2525 twiceMaxEdgePower = MAX_RATE_POWER; 2526 return twiceMaxEdgePower; 2527 } 2528 2529 /* 2530 * Returns interpolated or the scaled up interpolated value 2531 */ 2532 static uint16_t 2533 interpolate(uint16_t target, uint16_t srcLeft, uint16_t srcRight, 2534 uint16_t targetLeft, uint16_t targetRight) 2535 { 2536 uint16_t rv; 2537 int16_t lRatio; 2538 2539 /* to get an accurate ratio, always scale, if want to scale, then don't scale back down */ 2540 if ((targetLeft * targetRight) == 0) 2541 return 0; 2542 2543 if (srcRight != srcLeft) { 2544 /* 2545 * Note the ratio always need to be scaled, 2546 * since it will be a fraction. 2547 */ 2548 lRatio = (target - srcLeft) * EEP_SCALE / (srcRight - srcLeft); 2549 if (lRatio < 0) { 2550 /* Return as Left target if value would be negative */ 2551 rv = targetLeft; 2552 } else if (lRatio > EEP_SCALE) { 2553 /* Return as Right target if Ratio is greater than 100% (SCALE) */ 2554 rv = targetRight; 2555 } else { 2556 rv = (lRatio * targetRight + (EEP_SCALE - lRatio) * 2557 targetLeft) / EEP_SCALE; 2558 } 2559 } else { 2560 rv = targetLeft; 2561 } 2562 return rv; 2563 } 2564 2565 /* 2566 * Return the four rates of target power for the given target power table 2567 * channel, and number of channels 2568 */ 2569 static void 2570 ar5212GetTargetPowers(struct ath_hal *ah, const struct ieee80211_channel *chan, 2571 const TRGT_POWER_INFO *powInfo, 2572 uint16_t numChannels, TRGT_POWER_INFO *pNewPower) 2573 { 2574 uint16_t freq = ath_hal_gethwchannel(ah, chan); 2575 /* temp array for holding target power channels */ 2576 uint16_t tempChannelList[NUM_TEST_FREQUENCIES]; 2577 uint16_t clo, chi, ixlo, ixhi; 2578 int i; 2579 2580 /* Copy the target powers into the temp channel list */ 2581 for (i = 0; i < numChannels; i++) 2582 tempChannelList[i] = powInfo[i].testChannel; 2583 2584 ar5212GetLowerUpperValues(freq, tempChannelList, 2585 numChannels, &clo, &chi); 2586 2587 /* Get the indices for the channel */ 2588 ixlo = ixhi = 0; 2589 for (i = 0; i < numChannels; i++) { 2590 if (clo == tempChannelList[i]) { 2591 ixlo = i; 2592 } 2593 if (chi == tempChannelList[i]) { 2594 ixhi = i; 2595 break; 2596 } 2597 } 2598 2599 /* 2600 * Get the lower and upper channels, target powers, 2601 * and interpolate between them. 2602 */ 2603 pNewPower->twicePwr6_24 = interpolate(freq, clo, chi, 2604 powInfo[ixlo].twicePwr6_24, powInfo[ixhi].twicePwr6_24); 2605 pNewPower->twicePwr36 = interpolate(freq, clo, chi, 2606 powInfo[ixlo].twicePwr36, powInfo[ixhi].twicePwr36); 2607 pNewPower->twicePwr48 = interpolate(freq, clo, chi, 2608 powInfo[ixlo].twicePwr48, powInfo[ixhi].twicePwr48); 2609 pNewPower->twicePwr54 = interpolate(freq, clo, chi, 2610 powInfo[ixlo].twicePwr54, powInfo[ixhi].twicePwr54); 2611 } 2612 2613 static uint32_t 2614 udiff(uint32_t u, uint32_t v) 2615 { 2616 return (u >= v ? u - v : v - u); 2617 } 2618 2619 /* 2620 * Search a list for a specified value v that is within 2621 * EEP_DELTA of the search values. Return the closest 2622 * values in the list above and below the desired value. 2623 * EEP_DELTA is a factional value; everything is scaled 2624 * so only integer arithmetic is used. 2625 * 2626 * NB: the input list is assumed to be sorted in ascending order 2627 */ 2628 void 2629 ar5212GetLowerUpperValues(uint16_t v, uint16_t *lp, uint16_t listSize, 2630 uint16_t *vlo, uint16_t *vhi) 2631 { 2632 uint32_t target = v * EEP_SCALE; 2633 uint16_t *ep = lp+listSize; 2634 2635 /* 2636 * Check first and last elements for out-of-bounds conditions. 2637 */ 2638 if (target < (uint32_t)(lp[0] * EEP_SCALE - EEP_DELTA)) { 2639 *vlo = *vhi = lp[0]; 2640 return; 2641 } 2642 if (target > (uint32_t)(ep[-1] * EEP_SCALE + EEP_DELTA)) { 2643 *vlo = *vhi = ep[-1]; 2644 return; 2645 } 2646 2647 /* look for value being near or between 2 values in list */ 2648 for (; lp < ep; lp++) { 2649 /* 2650 * If value is close to the current value of the list 2651 * then target is not between values, it is one of the values 2652 */ 2653 if (udiff(lp[0] * EEP_SCALE, target) < EEP_DELTA) { 2654 *vlo = *vhi = lp[0]; 2655 return; 2656 } 2657 /* 2658 * Look for value being between current value and next value 2659 * if so return these 2 values 2660 */ 2661 if (target < (uint32_t)(lp[1] * EEP_SCALE - EEP_DELTA)) { 2662 *vlo = lp[0]; 2663 *vhi = lp[1]; 2664 return; 2665 } 2666 } 2667 HALASSERT(AH_FALSE); /* should not reach here */ 2668 } 2669 2670 /* 2671 * Perform analog "swizzling" of parameters into their location 2672 * 2673 * NB: used by RF backends 2674 */ 2675 void 2676 ar5212ModifyRfBuffer(uint32_t *rfBuf, uint32_t reg32, uint32_t numBits, 2677 uint32_t firstBit, uint32_t column) 2678 { 2679 #define MAX_ANALOG_START 319 /* XXX */ 2680 uint32_t tmp32, mask, arrayEntry, lastBit; 2681 int32_t bitPosition, bitsLeft; 2682 2683 HALASSERT(column <= 3); 2684 HALASSERT(numBits <= 32); 2685 HALASSERT(firstBit + numBits <= MAX_ANALOG_START); 2686 2687 tmp32 = ath_hal_reverseBits(reg32, numBits); 2688 arrayEntry = (firstBit - 1) / 8; 2689 bitPosition = (firstBit - 1) % 8; 2690 bitsLeft = numBits; 2691 while (bitsLeft > 0) { 2692 lastBit = (bitPosition + bitsLeft > 8) ? 2693 8 : bitPosition + bitsLeft; 2694 mask = (((1 << lastBit) - 1) ^ ((1 << bitPosition) - 1)) << 2695 (column * 8); 2696 rfBuf[arrayEntry] &= ~mask; 2697 rfBuf[arrayEntry] |= ((tmp32 << bitPosition) << 2698 (column * 8)) & mask; 2699 bitsLeft -= 8 - bitPosition; 2700 tmp32 = tmp32 >> (8 - bitPosition); 2701 bitPosition = 0; 2702 arrayEntry++; 2703 } 2704 #undef MAX_ANALOG_START 2705 } 2706 2707 /* 2708 * Sets the rate to duration values in MAC - used for multi- 2709 * rate retry. 2710 * The rate duration table needs to cover all valid rate codes; 2711 * the 11g table covers all ofdm rates, while the 11b table 2712 * covers all cck rates => all valid rates get covered between 2713 * these two mode's ratetables! 2714 * But if we're turbo, the ofdm phy is replaced by the turbo phy 2715 * and cck is not valid with turbo => all rates get covered 2716 * by the turbo ratetable only 2717 */ 2718 void 2719 ar5212SetRateDurationTable(struct ath_hal *ah, 2720 const struct ieee80211_channel *chan) 2721 { 2722 const HAL_RATE_TABLE *rt; 2723 int i; 2724 2725 /* NB: band doesn't matter for 1/2 and 1/4 rate */ 2726 if (IEEE80211_IS_CHAN_HALF(chan)) { 2727 rt = ar5212GetRateTable(ah, HAL_MODE_11A_HALF_RATE); 2728 } else if (IEEE80211_IS_CHAN_QUARTER(chan)) { 2729 rt = ar5212GetRateTable(ah, HAL_MODE_11A_QUARTER_RATE); 2730 } else { 2731 rt = ar5212GetRateTable(ah, 2732 IEEE80211_IS_CHAN_TURBO(chan) ? HAL_MODE_TURBO : HAL_MODE_11G); 2733 } 2734 2735 for (i = 0; i < rt->rateCount; ++i) 2736 OS_REG_WRITE(ah, 2737 AR_RATE_DURATION(rt->info[i].rateCode), 2738 ath_hal_computetxtime(ah, rt, 2739 WLAN_CTRL_FRAME_SIZE, 2740 rt->info[i].controlRate, AH_FALSE, AH_TRUE)); 2741 if (!IEEE80211_IS_CHAN_TURBO(chan)) { 2742 /* 11g Table is used to cover the CCK rates. */ 2743 rt = ar5212GetRateTable(ah, HAL_MODE_11G); 2744 for (i = 0; i < rt->rateCount; ++i) { 2745 uint32_t reg = AR_RATE_DURATION(rt->info[i].rateCode); 2746 2747 if (rt->info[i].phy != IEEE80211_T_CCK) 2748 continue; 2749 2750 OS_REG_WRITE(ah, reg, 2751 ath_hal_computetxtime(ah, rt, 2752 WLAN_CTRL_FRAME_SIZE, 2753 rt->info[i].controlRate, AH_FALSE, 2754 AH_TRUE)); 2755 /* cck rates have short preamble option also */ 2756 if (rt->info[i].shortPreamble) { 2757 reg += rt->info[i].shortPreamble << 2; 2758 OS_REG_WRITE(ah, reg, 2759 ath_hal_computetxtime(ah, rt, 2760 WLAN_CTRL_FRAME_SIZE, 2761 rt->info[i].controlRate, 2762 AH_TRUE, AH_TRUE)); 2763 } 2764 } 2765 } 2766 } 2767 2768 /* Adjust various register settings based on half/quarter rate clock setting. 2769 * This includes: +USEC, TX/RX latency, 2770 * + IFS params: slot, eifs, misc etc. 2771 */ 2772 void 2773 ar5212SetIFSTiming(struct ath_hal *ah, const struct ieee80211_channel *chan) 2774 { 2775 uint32_t txLat, rxLat, usec, slot, refClock, eifs, init_usec; 2776 2777 HALASSERT(IEEE80211_IS_CHAN_HALF(chan) || 2778 IEEE80211_IS_CHAN_QUARTER(chan)); 2779 2780 refClock = OS_REG_READ(ah, AR_USEC) & AR_USEC_USEC32; 2781 if (IEEE80211_IS_CHAN_HALF(chan)) { 2782 slot = IFS_SLOT_HALF_RATE; 2783 rxLat = RX_NON_FULL_RATE_LATENCY << AR5212_USEC_RX_LAT_S; 2784 txLat = TX_HALF_RATE_LATENCY << AR5212_USEC_TX_LAT_S; 2785 usec = HALF_RATE_USEC; 2786 eifs = IFS_EIFS_HALF_RATE; 2787 init_usec = INIT_USEC >> 1; 2788 } else { /* quarter rate */ 2789 slot = IFS_SLOT_QUARTER_RATE; 2790 rxLat = RX_NON_FULL_RATE_LATENCY << AR5212_USEC_RX_LAT_S; 2791 txLat = TX_QUARTER_RATE_LATENCY << AR5212_USEC_TX_LAT_S; 2792 usec = QUARTER_RATE_USEC; 2793 eifs = IFS_EIFS_QUARTER_RATE; 2794 init_usec = INIT_USEC >> 2; 2795 } 2796 2797 OS_REG_WRITE(ah, AR_USEC, (usec | refClock | txLat | rxLat)); 2798 OS_REG_WRITE(ah, AR_D_GBL_IFS_SLOT, slot); 2799 OS_REG_WRITE(ah, AR_D_GBL_IFS_EIFS, eifs); 2800 OS_REG_RMW_FIELD(ah, AR_D_GBL_IFS_MISC, 2801 AR_D_GBL_IFS_MISC_USEC_DURATION, init_usec); 2802 } 2803