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 /* 24 * XXX this is virtually the same code as for 5212; we reuse 25 * storage in the 5212 state block; need to refactor. 26 */ 27 #include "ah.h" 28 #include "ah_internal.h" 29 #include "ah_desc.h" 30 31 #include "ar5416/ar5416.h" 32 #include "ar5416/ar5416reg.h" 33 #include "ar5416/ar5416phy.h" 34 35 /* 36 * Anti noise immunity support. We track phy errors and react 37 * to excessive errors by adjusting the noise immunity parameters. 38 */ 39 40 #define HAL_EP_RND(x, mul) \ 41 ((((x)%(mul)) >= ((mul)/2)) ? ((x) + ((mul) - 1)) / (mul) : (x)/(mul)) 42 #define BEACON_RSSI(ahp) \ 43 HAL_EP_RND(ahp->ah_stats.ast_nodestats.ns_avgbrssi, \ 44 HAL_RSSI_EP_MULTIPLIER) 45 46 /* 47 * ANI processing tunes radio parameters according to PHY errors 48 * and related information. This is done for noise and spur 49 * immunity in all operating modes if the device indicates it's 50 * capable at attach time. In addition, when there is a reference 51 * rssi value (e.g. beacon frames from an ap in station mode) 52 * further tuning is done. 53 * 54 * ANI_ENA indicates whether any ANI processing should be done; 55 * this is specified at attach time. 56 * 57 * ANI_ENA_RSSI indicates whether rssi-based processing should 58 * done, this is enabled based on operating mode and is meaningful 59 * only if ANI_ENA is true. 60 * 61 * ANI parameters are typically controlled only by the hal. The 62 * AniControl interface however permits manual tuning through the 63 * diagnostic api. 64 */ 65 #define ANI_ENA(ah) \ 66 (AH5212(ah)->ah_procPhyErr & HAL_ANI_ENA) 67 #define ANI_ENA_RSSI(ah) \ 68 (AH5212(ah)->ah_procPhyErr & HAL_RSSI_ANI_ENA) 69 70 #define ah_mibStats ah_stats.ast_mibstats 71 72 static void 73 enableAniMIBCounters(struct ath_hal *ah, const struct ar5212AniParams *params) 74 { 75 struct ath_hal_5212 *ahp = AH5212(ah); 76 77 HALDEBUG(ah, HAL_DEBUG_ANI, "%s: Enable mib counters: " 78 "OfdmPhyErrBase 0x%x cckPhyErrBase 0x%x\n", 79 __func__, params->ofdmPhyErrBase, params->cckPhyErrBase); 80 81 OS_REG_WRITE(ah, AR_FILTOFDM, 0); 82 OS_REG_WRITE(ah, AR_FILTCCK, 0); 83 84 OS_REG_WRITE(ah, AR_PHYCNT1, params->ofdmPhyErrBase); 85 OS_REG_WRITE(ah, AR_PHYCNT2, params->cckPhyErrBase); 86 OS_REG_WRITE(ah, AR_PHY_ERR_MASK_1, AR_PHY_ERR_OFDM_TIMING); 87 OS_REG_WRITE(ah, AR_PHY_ERR_MASK_2, AR_PHY_ERR_CCK_TIMING); 88 89 ar5212UpdateMibCounters(ah, &ahp->ah_mibStats); /* save+clear counters*/ 90 ar5212EnableMibCounters(ah); /* enable everything */ 91 } 92 93 static void 94 disableAniMIBCounters(struct ath_hal *ah) 95 { 96 struct ath_hal_5212 *ahp = AH5212(ah); 97 98 HALDEBUG(ah, HAL_DEBUG_ANI, "Disable MIB counters\n"); 99 100 ar5212UpdateMibCounters(ah, &ahp->ah_mibStats); /* save stats */ 101 ar5212DisableMibCounters(ah); /* disable everything */ 102 103 OS_REG_WRITE(ah, AR_PHY_ERR_MASK_1, 0); 104 OS_REG_WRITE(ah, AR_PHY_ERR_MASK_2, 0); 105 } 106 107 static void 108 setPhyErrBase(struct ath_hal *ah, struct ar5212AniParams *params) 109 { 110 if (params->ofdmTrigHigh >= AR_PHY_COUNTMAX) { 111 HALDEBUG(ah, HAL_DEBUG_ANY, 112 "OFDM Trigger %d is too high for hw counters, using max\n", 113 params->ofdmTrigHigh); 114 params->ofdmPhyErrBase = 0; 115 } else 116 params->ofdmPhyErrBase = AR_PHY_COUNTMAX - params->ofdmTrigHigh; 117 if (params->cckTrigHigh >= AR_PHY_COUNTMAX) { 118 HALDEBUG(ah, HAL_DEBUG_ANY, 119 "CCK Trigger %d is too high for hw counters, using max\n", 120 params->cckTrigHigh); 121 params->cckPhyErrBase = 0; 122 } else 123 params->cckPhyErrBase = AR_PHY_COUNTMAX - params->cckTrigHigh; 124 } 125 126 /* 127 * Setup ANI handling. Sets all thresholds and reset the 128 * channel statistics. Note that ar5416AniReset should be 129 * called by ar5416Reset before anything else happens and 130 * that's where we force initial settings. 131 */ 132 void 133 ar5416AniAttach(struct ath_hal *ah, const struct ar5212AniParams *params24, 134 const struct ar5212AniParams *params5, HAL_BOOL enable) 135 { 136 struct ath_hal_5212 *ahp = AH5212(ah); 137 138 if (params24 != AH_NULL) { 139 OS_MEMCPY(&ahp->ah_aniParams24, params24, sizeof(*params24)); 140 setPhyErrBase(ah, &ahp->ah_aniParams24); 141 } 142 if (params5 != AH_NULL) { 143 OS_MEMCPY(&ahp->ah_aniParams5, params5, sizeof(*params5)); 144 setPhyErrBase(ah, &ahp->ah_aniParams5); 145 } 146 147 OS_MEMZERO(ahp->ah_ani, sizeof(ahp->ah_ani)); 148 /* Enable MIB Counters */ 149 enableAniMIBCounters(ah, &ahp->ah_aniParams24 /*XXX*/); 150 151 if (enable) { /* Enable ani now */ 152 HALASSERT(params24 != AH_NULL && params5 != AH_NULL); 153 ahp->ah_procPhyErr |= HAL_ANI_ENA; 154 } else { 155 ahp->ah_procPhyErr &= ~HAL_ANI_ENA; 156 } 157 } 158 159 /* 160 * Cleanup any ANI state setup. 161 * 162 * This doesn't restore registers to their default settings! 163 */ 164 void 165 ar5416AniDetach(struct ath_hal *ah) 166 { 167 HALDEBUG(ah, HAL_DEBUG_ANI, "Detaching Ani\n"); 168 disableAniMIBCounters(ah); 169 } 170 171 /* 172 * Control Adaptive Noise Immunity Parameters 173 */ 174 HAL_BOOL 175 ar5416AniControl(struct ath_hal *ah, HAL_ANI_CMD cmd, int param) 176 { 177 typedef int TABLE[]; 178 struct ath_hal_5212 *ahp = AH5212(ah); 179 struct ar5212AniState *aniState = ahp->ah_curani; 180 const struct ar5212AniParams *params = AH_NULL; 181 182 /* 183 * This function may be called before there's a current 184 * channel (eg to disable ANI.) 185 */ 186 if (aniState != AH_NULL) 187 params = aniState->params; 188 189 OS_MARK(ah, AH_MARK_ANI_CONTROL, cmd); 190 191 /* These commands can't be disabled */ 192 if (cmd == HAL_ANI_PRESENT) 193 return AH_TRUE; 194 195 if (cmd == HAL_ANI_MODE) { 196 if (param == 0) { 197 ahp->ah_procPhyErr &= ~HAL_ANI_ENA; 198 /* Turn off HW counters if we have them */ 199 ar5416AniDetach(ah); 200 } else { /* normal/auto mode */ 201 /* don't mess with state if already enabled */ 202 if (! (ahp->ah_procPhyErr & HAL_ANI_ENA)) { 203 /* Enable MIB Counters */ 204 /* 205 * XXX use 2.4ghz params if no channel is 206 * available 207 */ 208 enableAniMIBCounters(ah, 209 ahp->ah_curani != AH_NULL ? 210 ahp->ah_curani->params: 211 &ahp->ah_aniParams24); 212 ahp->ah_procPhyErr |= HAL_ANI_ENA; 213 } 214 } 215 return AH_TRUE; 216 } 217 218 /* Check whether the particular function is enabled */ 219 if (((1 << cmd) & AH5416(ah)->ah_ani_function) == 0) { 220 HALDEBUG(ah, HAL_DEBUG_ANI, "%s: command %d disabled\n", 221 __func__, cmd); 222 HALDEBUG(ah, HAL_DEBUG_ANI, "%s: cmd %d; mask %x\n", __func__, cmd, AH5416(ah)->ah_ani_function); 223 return AH_FALSE; 224 } 225 226 switch (cmd) { 227 case HAL_ANI_NOISE_IMMUNITY_LEVEL: { 228 u_int level = param; 229 230 HALDEBUG(ah, HAL_DEBUG_ANI, "%s: HAL_ANI_NOISE_IMMUNITY_LEVEL: set level = %d\n", __func__, level); 231 if (level > params->maxNoiseImmunityLevel) { 232 HALDEBUG(ah, HAL_DEBUG_ANI, 233 "%s: immunity level out of range (%u > %u)\n", 234 __func__, level, params->maxNoiseImmunityLevel); 235 return AH_FALSE; 236 } 237 238 OS_REG_RMW_FIELD(ah, AR_PHY_DESIRED_SZ, 239 AR_PHY_DESIRED_SZ_TOT_DES, params->totalSizeDesired[level]); 240 OS_REG_RMW_FIELD(ah, AR_PHY_AGC_CTL1, 241 AR_PHY_AGC_CTL1_COARSE_LOW, params->coarseLow[level]); 242 OS_REG_RMW_FIELD(ah, AR_PHY_AGC_CTL1, 243 AR_PHY_AGC_CTL1_COARSE_HIGH, params->coarseHigh[level]); 244 OS_REG_RMW_FIELD(ah, AR_PHY_FIND_SIG, 245 AR_PHY_FIND_SIG_FIRPWR, params->firpwr[level]); 246 247 if (level > aniState->noiseImmunityLevel) 248 ahp->ah_stats.ast_ani_niup++; 249 else if (level < aniState->noiseImmunityLevel) 250 ahp->ah_stats.ast_ani_nidown++; 251 aniState->noiseImmunityLevel = level; 252 break; 253 } 254 case HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION: { 255 static const TABLE m1ThreshLow = { 127, 50 }; 256 static const TABLE m2ThreshLow = { 127, 40 }; 257 static const TABLE m1Thresh = { 127, 0x4d }; 258 static const TABLE m2Thresh = { 127, 0x40 }; 259 static const TABLE m2CountThr = { 31, 16 }; 260 static const TABLE m2CountThrLow = { 63, 48 }; 261 u_int on = param ? 1 : 0; 262 263 HALDEBUG(ah, HAL_DEBUG_ANI, "%s: HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION: %s\n", __func__, on ? "enabled" : "disabled"); 264 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR_LOW, 265 AR_PHY_SFCORR_LOW_M1_THRESH_LOW, m1ThreshLow[on]); 266 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR_LOW, 267 AR_PHY_SFCORR_LOW_M2_THRESH_LOW, m2ThreshLow[on]); 268 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR, 269 AR_PHY_SFCORR_M1_THRESH, m1Thresh[on]); 270 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR, 271 AR_PHY_SFCORR_M2_THRESH, m2Thresh[on]); 272 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR, 273 AR_PHY_SFCORR_M2COUNT_THR, m2CountThr[on]); 274 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR_LOW, 275 AR_PHY_SFCORR_LOW_M2COUNT_THR_LOW, m2CountThrLow[on]); 276 277 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR_EXT, 278 AR_PHY_SFCORR_EXT_M1_THRESH_LOW, m1ThreshLow[on]); 279 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR_EXT, 280 AR_PHY_SFCORR_EXT_M2_THRESH_LOW, m2ThreshLow[on]); 281 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR_EXT, 282 AR_PHY_SFCORR_EXT_M1_THRESH, m1Thresh[on]); 283 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR_EXT, 284 AR_PHY_SFCORR_EXT_M2_THRESH, m2Thresh[on]); 285 286 if (on) { 287 OS_REG_SET_BIT(ah, AR_PHY_SFCORR_LOW, 288 AR_PHY_SFCORR_LOW_USE_SELF_CORR_LOW); 289 } else { 290 OS_REG_CLR_BIT(ah, AR_PHY_SFCORR_LOW, 291 AR_PHY_SFCORR_LOW_USE_SELF_CORR_LOW); 292 } 293 if (on) 294 ahp->ah_stats.ast_ani_ofdmon++; 295 else 296 ahp->ah_stats.ast_ani_ofdmoff++; 297 aniState->ofdmWeakSigDetectOff = !on; 298 break; 299 } 300 case HAL_ANI_CCK_WEAK_SIGNAL_THR: { 301 static const TABLE weakSigThrCck = { 8, 6 }; 302 u_int high = param ? 1 : 0; 303 304 HALDEBUG(ah, HAL_DEBUG_ANI, "%s: HAL_ANI_CCK_WEAK_SIGNAL_THR: %s\n", __func__, high ? "high" : "low"); 305 OS_REG_RMW_FIELD(ah, AR_PHY_CCK_DETECT, 306 AR_PHY_CCK_DETECT_WEAK_SIG_THR_CCK, weakSigThrCck[high]); 307 if (high) 308 ahp->ah_stats.ast_ani_cckhigh++; 309 else 310 ahp->ah_stats.ast_ani_ccklow++; 311 aniState->cckWeakSigThreshold = high; 312 break; 313 } 314 case HAL_ANI_FIRSTEP_LEVEL: { 315 u_int level = param; 316 317 HALDEBUG(ah, HAL_DEBUG_ANI, "%s: HAL_ANI_FIRSTEP_LEVEL: level = %d\n", __func__, level); 318 if (level > params->maxFirstepLevel) { 319 HALDEBUG(ah, HAL_DEBUG_ANI, 320 "%s: firstep level out of range (%u > %u)\n", 321 __func__, level, params->maxFirstepLevel); 322 return AH_FALSE; 323 } 324 OS_REG_RMW_FIELD(ah, AR_PHY_FIND_SIG, 325 AR_PHY_FIND_SIG_FIRSTEP, params->firstep[level]); 326 if (level > aniState->firstepLevel) 327 ahp->ah_stats.ast_ani_stepup++; 328 else if (level < aniState->firstepLevel) 329 ahp->ah_stats.ast_ani_stepdown++; 330 aniState->firstepLevel = level; 331 break; 332 } 333 case HAL_ANI_SPUR_IMMUNITY_LEVEL: { 334 u_int level = param; 335 336 HALDEBUG(ah, HAL_DEBUG_ANI, "%s: HAL_ANI_SPUR_IMMUNITY_LEVEL: level = %d\n", __func__, level); 337 if (level > params->maxSpurImmunityLevel) { 338 HALDEBUG(ah, HAL_DEBUG_ANI, 339 "%s: spur immunity level out of range (%u > %u)\n", 340 __func__, level, params->maxSpurImmunityLevel); 341 return AH_FALSE; 342 } 343 OS_REG_RMW_FIELD(ah, AR_PHY_TIMING5, 344 AR_PHY_TIMING5_CYCPWR_THR1, params->cycPwrThr1[level]); 345 346 if (level > aniState->spurImmunityLevel) 347 ahp->ah_stats.ast_ani_spurup++; 348 else if (level < aniState->spurImmunityLevel) 349 ahp->ah_stats.ast_ani_spurdown++; 350 aniState->spurImmunityLevel = level; 351 break; 352 } 353 #ifdef AH_PRIVATE_DIAG 354 case HAL_ANI_PHYERR_RESET: 355 ahp->ah_stats.ast_ani_ofdmerrs = 0; 356 ahp->ah_stats.ast_ani_cckerrs = 0; 357 break; 358 #endif /* AH_PRIVATE_DIAG */ 359 default: 360 HALDEBUG(ah, HAL_DEBUG_ANI, "%s: invalid cmd %u\n", 361 __func__, cmd); 362 return AH_FALSE; 363 } 364 return AH_TRUE; 365 } 366 367 static void 368 ar5416AniOfdmErrTrigger(struct ath_hal *ah) 369 { 370 struct ath_hal_5212 *ahp = AH5212(ah); 371 const struct ieee80211_channel *chan = AH_PRIVATE(ah)->ah_curchan; 372 struct ar5212AniState *aniState; 373 const struct ar5212AniParams *params; 374 375 HALASSERT(chan != AH_NULL); 376 377 if (!ANI_ENA(ah)) 378 return; 379 380 aniState = ahp->ah_curani; 381 params = aniState->params; 382 /* First, raise noise immunity level, up to max */ 383 if (aniState->noiseImmunityLevel+1 < params->maxNoiseImmunityLevel) { 384 if (ar5416AniControl(ah, HAL_ANI_NOISE_IMMUNITY_LEVEL, 385 aniState->noiseImmunityLevel + 1)) 386 return; 387 } 388 /* then, raise spur immunity level, up to max */ 389 if (aniState->spurImmunityLevel+1 < params->maxSpurImmunityLevel) { 390 if (ar5416AniControl(ah, HAL_ANI_SPUR_IMMUNITY_LEVEL, 391 aniState->spurImmunityLevel + 1)) 392 return; 393 } 394 395 /* 396 * In the case of AP mode operation, we cannot bucketize beacons 397 * according to RSSI. Instead, raise Firstep level, up to max, and 398 * simply return. 399 */ 400 if (AH_PRIVATE(ah)->ah_opmode == HAL_M_HOSTAP) { 401 if (aniState->firstepLevel < params->maxFirstepLevel) { 402 if (ar5416AniControl(ah, HAL_ANI_FIRSTEP_LEVEL, 403 aniState->firstepLevel + 1)) 404 return; 405 } 406 } 407 if (ANI_ENA_RSSI(ah)) { 408 int32_t rssi = BEACON_RSSI(ahp); 409 if (rssi > params->rssiThrHigh) { 410 /* 411 * Beacon rssi is high, can turn off ofdm 412 * weak sig detect. 413 */ 414 if (!aniState->ofdmWeakSigDetectOff) { 415 ar5416AniControl(ah, 416 HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION, 417 AH_FALSE); 418 ar5416AniControl(ah, 419 HAL_ANI_SPUR_IMMUNITY_LEVEL, 0); 420 return; 421 } 422 /* 423 * If weak sig detect is already off, as last resort, 424 * raise firstep level 425 */ 426 if (aniState->firstepLevel < params->maxFirstepLevel) { 427 if (ar5416AniControl(ah, HAL_ANI_FIRSTEP_LEVEL, 428 aniState->firstepLevel + 1)) 429 return; 430 } 431 } else if (rssi > params->rssiThrLow) { 432 /* 433 * Beacon rssi in mid range, need ofdm weak signal 434 * detect, but we can raise firststepLevel. 435 */ 436 if (aniState->ofdmWeakSigDetectOff) 437 ar5416AniControl(ah, 438 HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION, 439 AH_TRUE); 440 if (aniState->firstepLevel < params->maxFirstepLevel) 441 if (ar5416AniControl(ah, HAL_ANI_FIRSTEP_LEVEL, 442 aniState->firstepLevel + 1)) 443 return; 444 } else { 445 /* 446 * Beacon rssi is low, if in 11b/g mode, turn off ofdm 447 * weak signal detection and zero firstepLevel to 448 * maximize CCK sensitivity 449 */ 450 if (IEEE80211_IS_CHAN_CCK(chan)) { 451 if (!aniState->ofdmWeakSigDetectOff) 452 ar5416AniControl(ah, 453 HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION, 454 AH_FALSE); 455 if (aniState->firstepLevel > 0) 456 if (ar5416AniControl(ah, 457 HAL_ANI_FIRSTEP_LEVEL, 0)) 458 return; 459 } 460 } 461 } 462 } 463 464 static void 465 ar5416AniCckErrTrigger(struct ath_hal *ah) 466 { 467 struct ath_hal_5212 *ahp = AH5212(ah); 468 const struct ieee80211_channel *chan = AH_PRIVATE(ah)->ah_curchan; 469 struct ar5212AniState *aniState; 470 const struct ar5212AniParams *params; 471 472 HALASSERT(chan != AH_NULL); 473 474 if (!ANI_ENA(ah)) 475 return; 476 477 /* first, raise noise immunity level, up to max */ 478 aniState = ahp->ah_curani; 479 params = aniState->params; 480 if ((AH5416(ah)->ah_ani_function & (1 << HAL_ANI_NOISE_IMMUNITY_LEVEL) && 481 aniState->noiseImmunityLevel+1 < params->maxNoiseImmunityLevel)) { 482 ar5416AniControl(ah, HAL_ANI_NOISE_IMMUNITY_LEVEL, 483 aniState->noiseImmunityLevel + 1); 484 return; 485 } 486 487 if (ANI_ENA_RSSI(ah)) { 488 int32_t rssi = BEACON_RSSI(ahp); 489 if (rssi > params->rssiThrLow) { 490 /* 491 * Beacon signal in mid and high range, 492 * raise firstep level. 493 */ 494 if (aniState->firstepLevel < params->maxFirstepLevel) 495 ar5416AniControl(ah, HAL_ANI_FIRSTEP_LEVEL, 496 aniState->firstepLevel + 1); 497 } else { 498 /* 499 * Beacon rssi is low, zero firstep level to maximize 500 * CCK sensitivity in 11b/g mode. 501 */ 502 if (IEEE80211_IS_CHAN_CCK(chan)) { 503 if (aniState->firstepLevel > 0) 504 ar5416AniControl(ah, 505 HAL_ANI_FIRSTEP_LEVEL, 0); 506 } 507 } 508 } 509 } 510 511 static void 512 ar5416AniRestart(struct ath_hal *ah, struct ar5212AniState *aniState) 513 { 514 struct ath_hal_5212 *ahp = AH5212(ah); 515 const struct ar5212AniParams *params = aniState->params; 516 517 aniState->listenTime = 0; 518 /* 519 * NB: these are written on reset based on the 520 * ini so we must re-write them! 521 */ 522 HALDEBUG(ah, HAL_DEBUG_ANI, 523 "%s: Writing ofdmbase=%u cckbase=%u\n", __func__, 524 params->ofdmPhyErrBase, params->cckPhyErrBase); 525 OS_REG_WRITE(ah, AR_PHY_ERR_1, params->ofdmPhyErrBase); 526 OS_REG_WRITE(ah, AR_PHY_ERR_2, params->cckPhyErrBase); 527 OS_REG_WRITE(ah, AR_PHY_ERR_MASK_1, AR_PHY_ERR_OFDM_TIMING); 528 OS_REG_WRITE(ah, AR_PHY_ERR_MASK_2, AR_PHY_ERR_CCK_TIMING); 529 530 /* Clear the mib counters and save them in the stats */ 531 ar5212UpdateMibCounters(ah, &ahp->ah_mibStats); 532 aniState->ofdmPhyErrCount = 0; 533 aniState->cckPhyErrCount = 0; 534 } 535 536 /* 537 * Restore/reset the ANI parameters and reset the statistics. 538 * This routine must be called for every channel change. 539 * 540 * NOTE: This is where ah_curani is set; other ani code assumes 541 * it is setup to reflect the current channel. 542 */ 543 void 544 ar5416AniReset(struct ath_hal *ah, const struct ieee80211_channel *chan, 545 HAL_OPMODE opmode, int restore) 546 { 547 struct ath_hal_5212 *ahp = AH5212(ah); 548 HAL_CHANNEL_INTERNAL *ichan = ath_hal_checkchannel(ah, chan); 549 /* XXX bounds check ic_devdata */ 550 struct ar5212AniState *aniState = &ahp->ah_ani[chan->ic_devdata]; 551 uint32_t rxfilter; 552 553 if ((ichan->privFlags & CHANNEL_ANI_INIT) == 0) { 554 OS_MEMZERO(aniState, sizeof(*aniState)); 555 if (IEEE80211_IS_CHAN_2GHZ(chan)) 556 aniState->params = &ahp->ah_aniParams24; 557 else 558 aniState->params = &ahp->ah_aniParams5; 559 ichan->privFlags |= CHANNEL_ANI_INIT; 560 HALASSERT((ichan->privFlags & CHANNEL_ANI_SETUP) == 0); 561 } 562 ahp->ah_curani = aniState; 563 #if 0 564 ath_hal_printf(ah,"%s: chan %u/0x%x restore %d opmode %u%s\n", 565 __func__, chan->ic_freq, chan->ic_flags, restore, opmode, 566 ichan->privFlags & CHANNEL_ANI_SETUP ? " setup" : ""); 567 #else 568 HALDEBUG(ah, HAL_DEBUG_ANI, "%s: chan %u/0x%x restore %d opmode %u%s\n", 569 __func__, chan->ic_freq, chan->ic_flags, restore, opmode, 570 ichan->privFlags & CHANNEL_ANI_SETUP ? " setup" : ""); 571 #endif 572 OS_MARK(ah, AH_MARK_ANI_RESET, opmode); 573 574 /* 575 * Turn off PHY error frame delivery while we futz with settings. 576 */ 577 rxfilter = ah->ah_getRxFilter(ah); 578 ah->ah_setRxFilter(ah, rxfilter &~ HAL_RX_FILTER_PHYERR); 579 580 /* 581 * If ANI is disabled at this point, don't set the default 582 * ANI parameter settings - leave the HAL settings there. 583 * This is (currently) needed for reliable radar detection. 584 */ 585 if (! ANI_ENA(ah)) { 586 HALDEBUG(ah, HAL_DEBUG_ANI, "%s: ANI disabled\n", 587 __func__); 588 goto finish; 589 } 590 591 /* 592 * Use a restrictive set of ANI parameters for hostap mode. 593 */ 594 if (opmode == HAL_M_HOSTAP) { 595 if (IEEE80211_IS_CHAN_2GHZ(chan)) 596 AH5416(ah)->ah_ani_function = 597 HAL_ANI_SPUR_IMMUNITY_LEVEL | HAL_ANI_FIRSTEP_LEVEL; 598 else 599 AH5416(ah)->ah_ani_function = 0; 600 } 601 602 /* 603 * Automatic processing is done only in station mode right now. 604 */ 605 if (opmode == HAL_M_STA) 606 ahp->ah_procPhyErr |= HAL_RSSI_ANI_ENA; 607 else 608 ahp->ah_procPhyErr &= ~HAL_RSSI_ANI_ENA; 609 /* 610 * Set all ani parameters. We either set them to initial 611 * values or restore the previous ones for the channel. 612 * XXX if ANI follows hardware, we don't care what mode we're 613 * XXX in, we should keep the ani parameters 614 */ 615 if (restore && (ichan->privFlags & CHANNEL_ANI_SETUP)) { 616 ar5416AniControl(ah, HAL_ANI_NOISE_IMMUNITY_LEVEL, 617 aniState->noiseImmunityLevel); 618 ar5416AniControl(ah, HAL_ANI_SPUR_IMMUNITY_LEVEL, 619 aniState->spurImmunityLevel); 620 ar5416AniControl(ah, HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION, 621 !aniState->ofdmWeakSigDetectOff); 622 ar5416AniControl(ah, HAL_ANI_CCK_WEAK_SIGNAL_THR, 623 aniState->cckWeakSigThreshold); 624 ar5416AniControl(ah, HAL_ANI_FIRSTEP_LEVEL, 625 aniState->firstepLevel); 626 } else { 627 ar5416AniControl(ah, HAL_ANI_NOISE_IMMUNITY_LEVEL, 0); 628 ar5416AniControl(ah, HAL_ANI_SPUR_IMMUNITY_LEVEL, 0); 629 ar5416AniControl(ah, HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION, 630 AH_FALSE); 631 ar5416AniControl(ah, HAL_ANI_CCK_WEAK_SIGNAL_THR, AH_FALSE); 632 ar5416AniControl(ah, HAL_ANI_FIRSTEP_LEVEL, 0); 633 ichan->privFlags |= CHANNEL_ANI_SETUP; 634 } 635 636 /* 637 * In case the counters haven't yet been setup; set them up. 638 */ 639 enableAniMIBCounters(ah, aniState->params); 640 ar5416AniRestart(ah, aniState); 641 642 finish: 643 /* restore RX filter mask */ 644 ah->ah_setRxFilter(ah, rxfilter); 645 } 646 647 /* 648 * Process a MIB interrupt. We may potentially be invoked because 649 * any of the MIB counters overflow/trigger so don't assume we're 650 * here because a PHY error counter triggered. 651 */ 652 void 653 ar5416ProcessMibIntr(struct ath_hal *ah, const HAL_NODE_STATS *stats) 654 { 655 struct ath_hal_5212 *ahp = AH5212(ah); 656 uint32_t phyCnt1, phyCnt2; 657 658 HALDEBUG(ah, HAL_DEBUG_ANI, "%s: mibc 0x%x phyCnt1 0x%x phyCnt2 0x%x " 659 "filtofdm 0x%x filtcck 0x%x\n", 660 __func__, OS_REG_READ(ah, AR_MIBC), 661 OS_REG_READ(ah, AR_PHYCNT1), OS_REG_READ(ah, AR_PHYCNT2), 662 OS_REG_READ(ah, AR_FILTOFDM), OS_REG_READ(ah, AR_FILTCCK)); 663 664 /* 665 * First order of business is to clear whatever caused 666 * the interrupt so we don't keep getting interrupted. 667 * We have the usual mib counters that are reset-on-read 668 * and the additional counters that appeared starting in 669 * Hainan. We collect the mib counters and explicitly 670 * zero additional counters we are not using. Anything 671 * else is reset only if it caused the interrupt. 672 */ 673 /* NB: these are not reset-on-read */ 674 phyCnt1 = OS_REG_READ(ah, AR_PHY_ERR_1); 675 phyCnt2 = OS_REG_READ(ah, AR_PHY_ERR_2); 676 /* not used, always reset them in case they are the cause */ 677 OS_REG_WRITE(ah, AR_FILTOFDM, 0); 678 OS_REG_WRITE(ah, AR_FILTCCK, 0); 679 if ((OS_REG_READ(ah, AR_SLP_MIB_CTRL) & AR_SLP_MIB_PENDING) == 0) 680 OS_REG_WRITE(ah, AR_SLP_MIB_CTRL, AR_SLP_MIB_CLEAR); 681 682 /* Clear the mib counters and save them in the stats */ 683 ar5212UpdateMibCounters(ah, &ahp->ah_mibStats); 684 ahp->ah_stats.ast_nodestats = *stats; 685 686 /* 687 * Check for an ani stat hitting the trigger threshold. 688 * When this happens we get a MIB interrupt and the top 689 * 2 bits of the counter register will be 0b11, hence 690 * the mask check of phyCnt?. 691 */ 692 if (((phyCnt1 & AR_MIBCNT_INTRMASK) == AR_MIBCNT_INTRMASK) || 693 ((phyCnt2 & AR_MIBCNT_INTRMASK) == AR_MIBCNT_INTRMASK)) { 694 struct ar5212AniState *aniState = ahp->ah_curani; 695 const struct ar5212AniParams *params = aniState->params; 696 uint32_t ofdmPhyErrCnt, cckPhyErrCnt; 697 698 ofdmPhyErrCnt = phyCnt1 - params->ofdmPhyErrBase; 699 ahp->ah_stats.ast_ani_ofdmerrs += 700 ofdmPhyErrCnt - aniState->ofdmPhyErrCount; 701 aniState->ofdmPhyErrCount = ofdmPhyErrCnt; 702 703 cckPhyErrCnt = phyCnt2 - params->cckPhyErrBase; 704 ahp->ah_stats.ast_ani_cckerrs += 705 cckPhyErrCnt - aniState->cckPhyErrCount; 706 aniState->cckPhyErrCount = cckPhyErrCnt; 707 708 /* 709 * NB: figure out which counter triggered. If both 710 * trigger we'll only deal with one as the processing 711 * clobbers the error counter so the trigger threshold 712 * check will never be true. 713 */ 714 if (aniState->ofdmPhyErrCount > params->ofdmTrigHigh) 715 ar5416AniOfdmErrTrigger(ah); 716 if (aniState->cckPhyErrCount > params->cckTrigHigh) 717 ar5416AniCckErrTrigger(ah); 718 /* NB: always restart to insure the h/w counters are reset */ 719 ar5416AniRestart(ah, aniState); 720 } 721 } 722 723 static void 724 ar5416AniLowerImmunity(struct ath_hal *ah) 725 { 726 struct ath_hal_5212 *ahp = AH5212(ah); 727 struct ar5212AniState *aniState; 728 const struct ar5212AniParams *params; 729 730 HALASSERT(ANI_ENA(ah)); 731 732 aniState = ahp->ah_curani; 733 params = aniState->params; 734 735 /* 736 * In the case of AP mode operation, we cannot bucketize beacons 737 * according to RSSI. Instead, lower Firstep level, down to min, and 738 * simply return. 739 */ 740 if (AH_PRIVATE(ah)->ah_opmode == HAL_M_HOSTAP) { 741 if (aniState->firstepLevel > 0) { 742 if (ar5416AniControl(ah, HAL_ANI_FIRSTEP_LEVEL, 743 aniState->firstepLevel - 1)) 744 return; 745 } 746 } 747 if (ANI_ENA_RSSI(ah)) { 748 int32_t rssi = BEACON_RSSI(ahp); 749 if (rssi > params->rssiThrHigh) { 750 /* 751 * Beacon signal is high, leave ofdm weak signal 752 * detection off or it may oscillate. Let it fall 753 * through. 754 */ 755 } else if (rssi > params->rssiThrLow) { 756 /* 757 * Beacon rssi in mid range, turn on ofdm weak signal 758 * detection or lower firstep level. 759 */ 760 if (aniState->ofdmWeakSigDetectOff) { 761 if (ar5416AniControl(ah, 762 HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION, 763 AH_TRUE)) 764 return; 765 } 766 if (aniState->firstepLevel > 0) { 767 if (ar5416AniControl(ah, HAL_ANI_FIRSTEP_LEVEL, 768 aniState->firstepLevel - 1)) 769 return; 770 } 771 } else { 772 /* 773 * Beacon rssi is low, reduce firstep level. 774 */ 775 if (aniState->firstepLevel > 0) { 776 if (ar5416AniControl(ah, HAL_ANI_FIRSTEP_LEVEL, 777 aniState->firstepLevel - 1)) 778 return; 779 } 780 } 781 } 782 /* then lower spur immunity level, down to zero */ 783 if (aniState->spurImmunityLevel > 0) { 784 if (ar5416AniControl(ah, HAL_ANI_SPUR_IMMUNITY_LEVEL, 785 aniState->spurImmunityLevel - 1)) 786 return; 787 } 788 /* 789 * if all else fails, lower noise immunity level down to a min value 790 * zero for now 791 */ 792 if (aniState->noiseImmunityLevel > 0) { 793 if (ar5416AniControl(ah, HAL_ANI_NOISE_IMMUNITY_LEVEL, 794 aniState->noiseImmunityLevel - 1)) 795 return; 796 } 797 } 798 799 #define CLOCK_RATE 44000 /* XXX use mac_usec or similar */ 800 /* convert HW counter values to ms using 11g clock rate, goo9d enough 801 for 11a and Turbo */ 802 803 /* 804 * Return an approximation of the time spent ``listening'' by 805 * deducting the cycles spent tx'ing and rx'ing from the total 806 * cycle count since our last call. A return value <0 indicates 807 * an invalid/inconsistent time. 808 * 809 * This may be called with ANI disabled; in which case simply keep 810 * the statistics and don't write to the aniState pointer. 811 * 812 * XXX TODO: Make this cleaner! 813 */ 814 static int32_t 815 ar5416AniGetListenTime(struct ath_hal *ah) 816 { 817 struct ath_hal_5212 *ahp = AH5212(ah); 818 struct ar5212AniState *aniState = NULL; 819 int32_t listenTime = 0; 820 int good; 821 HAL_SURVEY_SAMPLE hs; 822 823 /* 824 * We shouldn't see ah_curchan be NULL, but just in case.. 825 */ 826 if (AH_PRIVATE(ah)->ah_curchan == AH_NULL) { 827 ath_hal_printf(ah, "%s: ah_curchan = NULL?\n", __func__); 828 return (0); 829 } 830 831 /* 832 * Fetch the current statistics, squirrel away the current 833 * sample. 834 */ 835 OS_MEMZERO(&hs, sizeof(hs)); 836 good = ar5416GetMibCycleCounts(ah, &hs); 837 ath_hal_survey_add_sample(ah, &hs); 838 839 if (ANI_ENA(ah)) 840 aniState = ahp->ah_curani; 841 842 if (good == AH_FALSE) { 843 /* 844 * Cycle counter wrap (or initial call); it's not possible 845 * to accurately calculate a value because the registers 846 * right shift rather than wrap--so punt and return 0. 847 */ 848 listenTime = 0; 849 ahp->ah_stats.ast_ani_lzero++; 850 } else if (ANI_ENA(ah)) { 851 /* 852 * Only calculate and update the cycle count if we have 853 * an ANI state. 854 */ 855 int32_t ccdelta = 856 AH5416(ah)->ah_cycleCount - aniState->cycleCount; 857 int32_t rfdelta = 858 AH5416(ah)->ah_rxBusy - aniState->rxFrameCount; 859 int32_t tfdelta = 860 AH5416(ah)->ah_txBusy - aniState->txFrameCount; 861 listenTime = (ccdelta - rfdelta - tfdelta) / CLOCK_RATE; 862 } 863 864 /* 865 * Again, only update ANI state if we have it. 866 */ 867 if (ANI_ENA(ah)) { 868 aniState->cycleCount = AH5416(ah)->ah_cycleCount; 869 aniState->rxFrameCount = AH5416(ah)->ah_rxBusy; 870 aniState->txFrameCount = AH5416(ah)->ah_txBusy; 871 } 872 873 return listenTime; 874 } 875 876 /* 877 * Update ani stats in preparation for listen time processing. 878 */ 879 static void 880 updateMIBStats(struct ath_hal *ah, struct ar5212AniState *aniState) 881 { 882 struct ath_hal_5212 *ahp = AH5212(ah); 883 const struct ar5212AniParams *params = aniState->params; 884 uint32_t phyCnt1, phyCnt2; 885 int32_t ofdmPhyErrCnt, cckPhyErrCnt; 886 887 /* Clear the mib counters and save them in the stats */ 888 ar5212UpdateMibCounters(ah, &ahp->ah_mibStats); 889 890 /* NB: these are not reset-on-read */ 891 phyCnt1 = OS_REG_READ(ah, AR_PHY_ERR_1); 892 phyCnt2 = OS_REG_READ(ah, AR_PHY_ERR_2); 893 894 /* NB: these are spec'd to never roll-over */ 895 ofdmPhyErrCnt = phyCnt1 - params->ofdmPhyErrBase; 896 if (ofdmPhyErrCnt < 0) { 897 HALDEBUG(ah, HAL_DEBUG_ANI, "OFDM phyErrCnt %d phyCnt1 0x%x\n", 898 ofdmPhyErrCnt, phyCnt1); 899 ofdmPhyErrCnt = AR_PHY_COUNTMAX; 900 } 901 ahp->ah_stats.ast_ani_ofdmerrs += 902 ofdmPhyErrCnt - aniState->ofdmPhyErrCount; 903 aniState->ofdmPhyErrCount = ofdmPhyErrCnt; 904 905 cckPhyErrCnt = phyCnt2 - params->cckPhyErrBase; 906 if (cckPhyErrCnt < 0) { 907 HALDEBUG(ah, HAL_DEBUG_ANI, "CCK phyErrCnt %d phyCnt2 0x%x\n", 908 cckPhyErrCnt, phyCnt2); 909 cckPhyErrCnt = AR_PHY_COUNTMAX; 910 } 911 ahp->ah_stats.ast_ani_cckerrs += 912 cckPhyErrCnt - aniState->cckPhyErrCount; 913 aniState->cckPhyErrCount = cckPhyErrCnt; 914 } 915 916 void 917 ar5416RxMonitor(struct ath_hal *ah, const HAL_NODE_STATS *stats, 918 const struct ieee80211_channel *chan) 919 { 920 struct ath_hal_5212 *ahp = AH5212(ah); 921 ahp->ah_stats.ast_nodestats.ns_avgbrssi = stats->ns_avgbrssi; 922 } 923 924 /* 925 * Do periodic processing. This routine is called from the 926 * driver's rx interrupt handler after processing frames. 927 */ 928 void 929 ar5416AniPoll(struct ath_hal *ah, const struct ieee80211_channel *chan) 930 { 931 struct ath_hal_5212 *ahp = AH5212(ah); 932 struct ar5212AniState *aniState = ahp->ah_curani; 933 const struct ar5212AniParams *params; 934 int32_t listenTime; 935 936 /* Always update from the MIB, for statistics gathering */ 937 listenTime = ar5416AniGetListenTime(ah); 938 939 /* XXX can aniState be null? */ 940 if (aniState == AH_NULL) 941 return; 942 943 if (!ANI_ENA(ah)) 944 return; 945 946 if (listenTime < 0) { 947 ahp->ah_stats.ast_ani_lneg++; 948 /* restart ANI period if listenTime is invalid */ 949 HALDEBUG(ah, HAL_DEBUG_ANI, "%s: invalid listenTime\n", 950 __func__); 951 ar5416AniRestart(ah, aniState); 952 953 /* Don't do any further processing */ 954 return; 955 } 956 /* XXX beware of overflow? */ 957 aniState->listenTime += listenTime; 958 959 OS_MARK(ah, AH_MARK_ANI_POLL, aniState->listenTime); 960 961 params = aniState->params; 962 if (aniState->listenTime > 5*params->period) { 963 /* 964 * Check to see if need to lower immunity if 965 * 5 aniPeriods have passed 966 */ 967 updateMIBStats(ah, aniState); 968 if (aniState->ofdmPhyErrCount <= aniState->listenTime * 969 params->ofdmTrigLow/1000 && 970 aniState->cckPhyErrCount <= aniState->listenTime * 971 params->cckTrigLow/1000) 972 ar5416AniLowerImmunity(ah); 973 HALDEBUG(ah, HAL_DEBUG_ANI, "%s: lower immunity\n", 974 __func__); 975 ar5416AniRestart(ah, aniState); 976 } else if (aniState->listenTime > params->period) { 977 updateMIBStats(ah, aniState); 978 /* check to see if need to raise immunity */ 979 if (aniState->ofdmPhyErrCount > aniState->listenTime * 980 params->ofdmTrigHigh / 1000) { 981 HALDEBUG(ah, HAL_DEBUG_ANI, 982 "%s: OFDM err %u listenTime %u\n", __func__, 983 aniState->ofdmPhyErrCount, aniState->listenTime); 984 ar5416AniOfdmErrTrigger(ah); 985 ar5416AniRestart(ah, aniState); 986 } else if (aniState->cckPhyErrCount > aniState->listenTime * 987 params->cckTrigHigh / 1000) { 988 HALDEBUG(ah, HAL_DEBUG_ANI, 989 "%s: CCK err %u listenTime %u\n", __func__, 990 aniState->cckPhyErrCount, aniState->listenTime); 991 ar5416AniCckErrTrigger(ah); 992 ar5416AniRestart(ah, aniState); 993 } 994 } 995 } 996