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 #include "ah_desc.h" /* NB: for HAL_PHYERR* */ 27 28 #include "ar5212/ar5212.h" 29 #include "ar5212/ar5212reg.h" 30 #include "ar5212/ar5212phy.h" 31 32 #include "ah_eeprom_v3.h" 33 34 #define AR_NUM_GPIO 6 /* 6 GPIO pins */ 35 #define AR_GPIOD_MASK 0x0000002F /* GPIO data reg r/w mask */ 36 37 void 38 ar5212GetMacAddress(struct ath_hal *ah, uint8_t *mac) 39 { 40 struct ath_hal_5212 *ahp = AH5212(ah); 41 42 OS_MEMCPY(mac, ahp->ah_macaddr, IEEE80211_ADDR_LEN); 43 } 44 45 HAL_BOOL 46 ar5212SetMacAddress(struct ath_hal *ah, const uint8_t *mac) 47 { 48 struct ath_hal_5212 *ahp = AH5212(ah); 49 50 OS_MEMCPY(ahp->ah_macaddr, mac, IEEE80211_ADDR_LEN); 51 return AH_TRUE; 52 } 53 54 void 55 ar5212GetBssIdMask(struct ath_hal *ah, uint8_t *mask) 56 { 57 struct ath_hal_5212 *ahp = AH5212(ah); 58 59 OS_MEMCPY(mask, ahp->ah_bssidmask, IEEE80211_ADDR_LEN); 60 } 61 62 HAL_BOOL 63 ar5212SetBssIdMask(struct ath_hal *ah, const uint8_t *mask) 64 { 65 struct ath_hal_5212 *ahp = AH5212(ah); 66 67 /* save it since it must be rewritten on reset */ 68 OS_MEMCPY(ahp->ah_bssidmask, mask, IEEE80211_ADDR_LEN); 69 70 OS_REG_WRITE(ah, AR_BSSMSKL, LE_READ_4(ahp->ah_bssidmask)); 71 OS_REG_WRITE(ah, AR_BSSMSKU, LE_READ_2(ahp->ah_bssidmask + 4)); 72 return AH_TRUE; 73 } 74 75 /* 76 * Attempt to change the cards operating regulatory domain to the given value 77 */ 78 HAL_BOOL 79 ar5212SetRegulatoryDomain(struct ath_hal *ah, 80 uint16_t regDomain, HAL_STATUS *status) 81 { 82 HAL_STATUS ecode; 83 84 if (AH_PRIVATE(ah)->ah_currentRD == regDomain) { 85 ecode = HAL_EINVAL; 86 goto bad; 87 } 88 if (ath_hal_eepromGetFlag(ah, AR_EEP_WRITEPROTECT)) { 89 ecode = HAL_EEWRITE; 90 goto bad; 91 } 92 #ifdef AH_SUPPORT_WRITE_REGDOMAIN 93 if (ath_hal_eepromWrite(ah, AR_EEPROM_REG_DOMAIN, regDomain)) { 94 HALDEBUG(ah, HAL_DEBUG_ANY, 95 "%s: set regulatory domain to %u (0x%x)\n", 96 __func__, regDomain, regDomain); 97 AH_PRIVATE(ah)->ah_currentRD = regDomain; 98 return AH_TRUE; 99 } 100 #endif 101 ecode = HAL_EIO; 102 bad: 103 if (status) 104 *status = ecode; 105 return AH_FALSE; 106 } 107 108 /* 109 * Return the wireless modes (a,b,g,t) supported by hardware. 110 * 111 * This value is what is actually supported by the hardware 112 * and is unaffected by regulatory/country code settings. 113 */ 114 u_int 115 ar5212GetWirelessModes(struct ath_hal *ah) 116 { 117 u_int mode = 0; 118 119 if (ath_hal_eepromGetFlag(ah, AR_EEP_AMODE)) { 120 mode = HAL_MODE_11A; 121 if (!ath_hal_eepromGetFlag(ah, AR_EEP_TURBO5DISABLE)) 122 mode |= HAL_MODE_TURBO | HAL_MODE_108A; 123 if (AH_PRIVATE(ah)->ah_caps.halChanHalfRate) 124 mode |= HAL_MODE_11A_HALF_RATE; 125 if (AH_PRIVATE(ah)->ah_caps.halChanQuarterRate) 126 mode |= HAL_MODE_11A_QUARTER_RATE; 127 } 128 if (ath_hal_eepromGetFlag(ah, AR_EEP_BMODE)) 129 mode |= HAL_MODE_11B; 130 if (ath_hal_eepromGetFlag(ah, AR_EEP_GMODE) && 131 AH_PRIVATE(ah)->ah_subvendorid != AR_SUBVENDOR_ID_NOG) { 132 mode |= HAL_MODE_11G; 133 if (!ath_hal_eepromGetFlag(ah, AR_EEP_TURBO2DISABLE)) 134 mode |= HAL_MODE_108G; 135 if (AH_PRIVATE(ah)->ah_caps.halChanHalfRate) 136 mode |= HAL_MODE_11G_HALF_RATE; 137 if (AH_PRIVATE(ah)->ah_caps.halChanQuarterRate) 138 mode |= HAL_MODE_11G_QUARTER_RATE; 139 } 140 return mode; 141 } 142 143 /* 144 * Set the interrupt and GPIO values so the ISR can disable RF 145 * on a switch signal. Assumes GPIO port and interrupt polarity 146 * are set prior to call. 147 */ 148 void 149 ar5212EnableRfKill(struct ath_hal *ah) 150 { 151 uint16_t rfsilent = AH_PRIVATE(ah)->ah_rfsilent; 152 int select = MS(rfsilent, AR_EEPROM_RFSILENT_GPIO_SEL); 153 int polarity = MS(rfsilent, AR_EEPROM_RFSILENT_POLARITY); 154 155 /* 156 * Configure the desired GPIO port for input 157 * and enable baseband rf silence. 158 */ 159 ath_hal_gpioCfgInput(ah, select); 160 OS_REG_SET_BIT(ah, AR_PHY(0), 0x00002000); 161 /* 162 * If radio disable switch connection to GPIO bit x is enabled 163 * program GPIO interrupt. 164 * If rfkill bit on eeprom is 1, setupeeprommap routine has already 165 * verified that it is a later version of eeprom, it has a place for 166 * rfkill bit and it is set to 1, indicating that GPIO bit x hardware 167 * connection is present. 168 */ 169 ath_hal_gpioSetIntr(ah, select, 170 (ath_hal_gpioGet(ah, select) == polarity ? !polarity : polarity)); 171 } 172 173 /* 174 * Change the LED blinking pattern to correspond to the connectivity 175 */ 176 void 177 ar5212SetLedState(struct ath_hal *ah, HAL_LED_STATE state) 178 { 179 static const uint32_t ledbits[8] = { 180 AR_PCICFG_LEDCTL_NONE, /* HAL_LED_INIT */ 181 AR_PCICFG_LEDCTL_PEND, /* HAL_LED_SCAN */ 182 AR_PCICFG_LEDCTL_PEND, /* HAL_LED_AUTH */ 183 AR_PCICFG_LEDCTL_ASSOC, /* HAL_LED_ASSOC*/ 184 AR_PCICFG_LEDCTL_ASSOC, /* HAL_LED_RUN */ 185 AR_PCICFG_LEDCTL_NONE, 186 AR_PCICFG_LEDCTL_NONE, 187 AR_PCICFG_LEDCTL_NONE, 188 }; 189 uint32_t bits; 190 191 bits = OS_REG_READ(ah, AR_PCICFG); 192 if (IS_2417(ah)) { 193 /* 194 * Enable LED for Nala. There is a bit marked reserved 195 * that must be set and we also turn on the power led. 196 * Because we mark s/w LED control setting the control 197 * status bits below is meangless (the driver must flash 198 * the LED(s) using the GPIO lines). 199 */ 200 bits = (bits &~ AR_PCICFG_LEDMODE) 201 | SM(AR_PCICFG_LEDMODE_POWON, AR_PCICFG_LEDMODE) 202 #if 0 203 | SM(AR_PCICFG_LEDMODE_NETON, AR_PCICFG_LEDMODE) 204 #endif 205 | 0x08000000; 206 } 207 bits = (bits &~ AR_PCICFG_LEDCTL) 208 | SM(ledbits[state & 0x7], AR_PCICFG_LEDCTL); 209 OS_REG_WRITE(ah, AR_PCICFG, bits); 210 } 211 212 /* 213 * Change association related fields programmed into the hardware. 214 * Writing a valid BSSID to the hardware effectively enables the hardware 215 * to synchronize its TSF to the correct beacons and receive frames coming 216 * from that BSSID. It is called by the SME JOIN operation. 217 */ 218 void 219 ar5212WriteAssocid(struct ath_hal *ah, const uint8_t *bssid, uint16_t assocId) 220 { 221 struct ath_hal_5212 *ahp = AH5212(ah); 222 223 /* save bssid for possible re-use on reset */ 224 OS_MEMCPY(ahp->ah_bssid, bssid, IEEE80211_ADDR_LEN); 225 ahp->ah_assocId = assocId; 226 OS_REG_WRITE(ah, AR_BSS_ID0, LE_READ_4(ahp->ah_bssid)); 227 OS_REG_WRITE(ah, AR_BSS_ID1, LE_READ_2(ahp->ah_bssid+4) | 228 ((assocId & 0x3fff)<<AR_BSS_ID1_AID_S)); 229 } 230 231 /* 232 * Get the current hardware tsf for stamlme 233 */ 234 uint64_t 235 ar5212GetTsf64(struct ath_hal *ah) 236 { 237 uint32_t low1, low2, u32; 238 239 /* sync multi-word read */ 240 low1 = OS_REG_READ(ah, AR_TSF_L32); 241 u32 = OS_REG_READ(ah, AR_TSF_U32); 242 low2 = OS_REG_READ(ah, AR_TSF_L32); 243 if (low2 < low1) { /* roll over */ 244 /* 245 * If we are not preempted this will work. If we are 246 * then we re-reading AR_TSF_U32 does no good as the 247 * low bits will be meaningless. Likewise reading 248 * L32, U32, U32, then comparing the last two reads 249 * to check for rollover doesn't help if preempted--so 250 * we take this approach as it costs one less PCI read 251 * which can be noticeable when doing things like 252 * timestamping packets in monitor mode. 253 */ 254 u32++; 255 } 256 return (((uint64_t) u32) << 32) | ((uint64_t) low2); 257 } 258 259 /* 260 * Get the current hardware tsf for stamlme 261 */ 262 uint32_t 263 ar5212GetTsf32(struct ath_hal *ah) 264 { 265 return OS_REG_READ(ah, AR_TSF_L32); 266 } 267 268 void 269 ar5212SetTsf64(struct ath_hal *ah, uint64_t tsf64) 270 { 271 OS_REG_WRITE(ah, AR_TSF_L32, tsf64 & 0xffffffff); 272 OS_REG_WRITE(ah, AR_TSF_U32, (tsf64 >> 32) & 0xffffffff); 273 } 274 275 /* 276 * Reset the current hardware tsf for stamlme. 277 */ 278 void 279 ar5212ResetTsf(struct ath_hal *ah) 280 { 281 282 uint32_t val = OS_REG_READ(ah, AR_BEACON); 283 284 OS_REG_WRITE(ah, AR_BEACON, val | AR_BEACON_RESET_TSF); 285 /* 286 * When resetting the TSF, write twice to the 287 * corresponding register; each write to the RESET_TSF bit toggles 288 * the internal signal to cause a reset of the TSF - but if the signal 289 * is left high, it will reset the TSF on the next chip reset also! 290 * writing the bit an even number of times fixes this issue 291 */ 292 OS_REG_WRITE(ah, AR_BEACON, val | AR_BEACON_RESET_TSF); 293 } 294 295 /* 296 * Set or clear hardware basic rate bit 297 * Set hardware basic rate set if basic rate is found 298 * and basic rate is equal or less than 2Mbps 299 */ 300 void 301 ar5212SetBasicRate(struct ath_hal *ah, HAL_RATE_SET *rs) 302 { 303 const struct ieee80211_channel *chan = AH_PRIVATE(ah)->ah_curchan; 304 uint32_t reg; 305 uint8_t xset; 306 int i; 307 308 if (chan == AH_NULL || !IEEE80211_IS_CHAN_CCK(chan)) 309 return; 310 xset = 0; 311 for (i = 0; i < rs->rs_count; i++) { 312 uint8_t rset = rs->rs_rates[i]; 313 /* Basic rate defined? */ 314 if ((rset & 0x80) && (rset &= 0x7f) >= xset) 315 xset = rset; 316 } 317 /* 318 * Set the h/w bit to reflect whether or not the basic 319 * rate is found to be equal or less than 2Mbps. 320 */ 321 reg = OS_REG_READ(ah, AR_STA_ID1); 322 if (xset && xset/2 <= 2) 323 OS_REG_WRITE(ah, AR_STA_ID1, reg | AR_STA_ID1_BASE_RATE_11B); 324 else 325 OS_REG_WRITE(ah, AR_STA_ID1, reg &~ AR_STA_ID1_BASE_RATE_11B); 326 } 327 328 /* 329 * Grab a semi-random value from hardware registers - may not 330 * change often 331 */ 332 uint32_t 333 ar5212GetRandomSeed(struct ath_hal *ah) 334 { 335 uint32_t nf; 336 337 nf = (OS_REG_READ(ah, AR_PHY(25)) >> 19) & 0x1ff; 338 if (nf & 0x100) 339 nf = 0 - ((nf ^ 0x1ff) + 1); 340 return (OS_REG_READ(ah, AR_TSF_U32) ^ 341 OS_REG_READ(ah, AR_TSF_L32) ^ nf); 342 } 343 344 /* 345 * Detect if our card is present 346 */ 347 HAL_BOOL 348 ar5212DetectCardPresent(struct ath_hal *ah) 349 { 350 uint16_t macVersion, macRev; 351 uint32_t v; 352 353 /* 354 * Read the Silicon Revision register and compare that 355 * to what we read at attach time. If the same, we say 356 * a card/device is present. 357 */ 358 v = OS_REG_READ(ah, AR_SREV) & AR_SREV_ID; 359 macVersion = v >> AR_SREV_ID_S; 360 macRev = v & AR_SREV_REVISION; 361 return (AH_PRIVATE(ah)->ah_macVersion == macVersion && 362 AH_PRIVATE(ah)->ah_macRev == macRev); 363 } 364 365 void 366 ar5212EnableMibCounters(struct ath_hal *ah) 367 { 368 /* NB: this just resets the mib counter machinery */ 369 OS_REG_WRITE(ah, AR_MIBC, 370 ~(AR_MIBC_COW | AR_MIBC_FMC | AR_MIBC_CMC | AR_MIBC_MCS) & 0x0f); 371 } 372 373 void 374 ar5212DisableMibCounters(struct ath_hal *ah) 375 { 376 OS_REG_WRITE(ah, AR_MIBC, AR_MIBC | AR_MIBC_CMC); 377 } 378 379 /* 380 * Update MIB Counters 381 */ 382 void 383 ar5212UpdateMibCounters(struct ath_hal *ah, HAL_MIB_STATS* stats) 384 { 385 stats->ackrcv_bad += OS_REG_READ(ah, AR_ACK_FAIL); 386 stats->rts_bad += OS_REG_READ(ah, AR_RTS_FAIL); 387 stats->fcs_bad += OS_REG_READ(ah, AR_FCS_FAIL); 388 stats->rts_good += OS_REG_READ(ah, AR_RTS_OK); 389 stats->beacons += OS_REG_READ(ah, AR_BEACON_CNT); 390 } 391 392 /* 393 * Detect if the HW supports spreading a CCK signal on channel 14 394 */ 395 HAL_BOOL 396 ar5212IsJapanChannelSpreadSupported(struct ath_hal *ah) 397 { 398 return AH_TRUE; 399 } 400 401 /* 402 * Get the rssi of frame curently being received. 403 */ 404 uint32_t 405 ar5212GetCurRssi(struct ath_hal *ah) 406 { 407 return (OS_REG_READ(ah, AR_PHY_CURRENT_RSSI) & 0xff); 408 } 409 410 u_int 411 ar5212GetDefAntenna(struct ath_hal *ah) 412 { 413 return (OS_REG_READ(ah, AR_DEF_ANTENNA) & 0x7); 414 } 415 416 void 417 ar5212SetDefAntenna(struct ath_hal *ah, u_int antenna) 418 { 419 OS_REG_WRITE(ah, AR_DEF_ANTENNA, (antenna & 0x7)); 420 } 421 422 HAL_ANT_SETTING 423 ar5212GetAntennaSwitch(struct ath_hal *ah) 424 { 425 return AH5212(ah)->ah_antControl; 426 } 427 428 HAL_BOOL 429 ar5212SetAntennaSwitch(struct ath_hal *ah, HAL_ANT_SETTING setting) 430 { 431 struct ath_hal_5212 *ahp = AH5212(ah); 432 const struct ieee80211_channel *chan = AH_PRIVATE(ah)->ah_curchan; 433 434 if (!ahp->ah_phyPowerOn || chan == AH_NULL) { 435 /* PHY powered off, just stash settings */ 436 ahp->ah_antControl = setting; 437 ahp->ah_diversity = (setting == HAL_ANT_VARIABLE); 438 return AH_TRUE; 439 } 440 return ar5212SetAntennaSwitchInternal(ah, setting, chan); 441 } 442 443 HAL_BOOL 444 ar5212IsSleepAfterBeaconBroken(struct ath_hal *ah) 445 { 446 return AH_TRUE; 447 } 448 449 HAL_BOOL 450 ar5212SetSifsTime(struct ath_hal *ah, u_int us) 451 { 452 struct ath_hal_5212 *ahp = AH5212(ah); 453 454 if (us > ath_hal_mac_usec(ah, 0xffff)) { 455 HALDEBUG(ah, HAL_DEBUG_ANY, "%s: bad SIFS time %u\n", 456 __func__, us); 457 ahp->ah_sifstime = (u_int) -1; /* restore default handling */ 458 return AH_FALSE; 459 } else { 460 /* convert to system clocks */ 461 OS_REG_WRITE(ah, AR_D_GBL_IFS_SIFS, ath_hal_mac_clks(ah, us-2)); 462 ahp->ah_sifstime = us; 463 return AH_TRUE; 464 } 465 } 466 467 u_int 468 ar5212GetSifsTime(struct ath_hal *ah) 469 { 470 u_int clks = OS_REG_READ(ah, AR_D_GBL_IFS_SIFS) & 0xffff; 471 return ath_hal_mac_usec(ah, clks)+2; /* convert from system clocks */ 472 } 473 474 HAL_BOOL 475 ar5212SetSlotTime(struct ath_hal *ah, u_int us) 476 { 477 struct ath_hal_5212 *ahp = AH5212(ah); 478 479 if (us < HAL_SLOT_TIME_6 || us > ath_hal_mac_usec(ah, 0xffff)) { 480 HALDEBUG(ah, HAL_DEBUG_ANY, "%s: bad slot time %u\n", 481 __func__, us); 482 ahp->ah_slottime = (u_int) -1; /* restore default handling */ 483 return AH_FALSE; 484 } else { 485 /* convert to system clocks */ 486 OS_REG_WRITE(ah, AR_D_GBL_IFS_SLOT, ath_hal_mac_clks(ah, us)); 487 ahp->ah_slottime = us; 488 return AH_TRUE; 489 } 490 } 491 492 u_int 493 ar5212GetSlotTime(struct ath_hal *ah) 494 { 495 u_int clks = OS_REG_READ(ah, AR_D_GBL_IFS_SLOT) & 0xffff; 496 return ath_hal_mac_usec(ah, clks); /* convert from system clocks */ 497 } 498 499 HAL_BOOL 500 ar5212SetAckTimeout(struct ath_hal *ah, u_int us) 501 { 502 struct ath_hal_5212 *ahp = AH5212(ah); 503 504 if (us > ath_hal_mac_usec(ah, MS(0xffffffff, AR_TIME_OUT_ACK))) { 505 HALDEBUG(ah, HAL_DEBUG_ANY, "%s: bad ack timeout %u\n", 506 __func__, us); 507 ahp->ah_acktimeout = (u_int) -1; /* restore default handling */ 508 return AH_FALSE; 509 } else { 510 /* convert to system clocks */ 511 OS_REG_RMW_FIELD(ah, AR_TIME_OUT, 512 AR_TIME_OUT_ACK, ath_hal_mac_clks(ah, us)); 513 ahp->ah_acktimeout = us; 514 return AH_TRUE; 515 } 516 } 517 518 u_int 519 ar5212GetAckTimeout(struct ath_hal *ah) 520 { 521 u_int clks = MS(OS_REG_READ(ah, AR_TIME_OUT), AR_TIME_OUT_ACK); 522 return ath_hal_mac_usec(ah, clks); /* convert from system clocks */ 523 } 524 525 u_int 526 ar5212GetAckCTSRate(struct ath_hal *ah) 527 { 528 return ((AH5212(ah)->ah_staId1Defaults & AR_STA_ID1_ACKCTS_6MB) == 0); 529 } 530 531 HAL_BOOL 532 ar5212SetAckCTSRate(struct ath_hal *ah, u_int high) 533 { 534 struct ath_hal_5212 *ahp = AH5212(ah); 535 536 if (high) { 537 OS_REG_CLR_BIT(ah, AR_STA_ID1, AR_STA_ID1_ACKCTS_6MB); 538 ahp->ah_staId1Defaults &= ~AR_STA_ID1_ACKCTS_6MB; 539 } else { 540 OS_REG_SET_BIT(ah, AR_STA_ID1, AR_STA_ID1_ACKCTS_6MB); 541 ahp->ah_staId1Defaults |= AR_STA_ID1_ACKCTS_6MB; 542 } 543 return AH_TRUE; 544 } 545 546 HAL_BOOL 547 ar5212SetCTSTimeout(struct ath_hal *ah, u_int us) 548 { 549 struct ath_hal_5212 *ahp = AH5212(ah); 550 551 if (us > ath_hal_mac_usec(ah, MS(0xffffffff, AR_TIME_OUT_CTS))) { 552 HALDEBUG(ah, HAL_DEBUG_ANY, "%s: bad cts timeout %u\n", 553 __func__, us); 554 ahp->ah_ctstimeout = (u_int) -1; /* restore default handling */ 555 return AH_FALSE; 556 } else { 557 /* convert to system clocks */ 558 OS_REG_RMW_FIELD(ah, AR_TIME_OUT, 559 AR_TIME_OUT_CTS, ath_hal_mac_clks(ah, us)); 560 ahp->ah_ctstimeout = us; 561 return AH_TRUE; 562 } 563 } 564 565 u_int 566 ar5212GetCTSTimeout(struct ath_hal *ah) 567 { 568 u_int clks = MS(OS_REG_READ(ah, AR_TIME_OUT), AR_TIME_OUT_CTS); 569 return ath_hal_mac_usec(ah, clks); /* convert from system clocks */ 570 } 571 572 /* Setup decompression for given key index */ 573 HAL_BOOL 574 ar5212SetDecompMask(struct ath_hal *ah, uint16_t keyidx, int en) 575 { 576 struct ath_hal_5212 *ahp = AH5212(ah); 577 578 if (keyidx >= HAL_DECOMP_MASK_SIZE) 579 return AH_FALSE; 580 OS_REG_WRITE(ah, AR_DCM_A, keyidx); 581 OS_REG_WRITE(ah, AR_DCM_D, en ? AR_DCM_D_EN : 0); 582 ahp->ah_decompMask[keyidx] = en; 583 584 return AH_TRUE; 585 } 586 587 /* Setup coverage class */ 588 void 589 ar5212SetCoverageClass(struct ath_hal *ah, uint8_t coverageclass, int now) 590 { 591 uint32_t slot, timeout, eifs; 592 u_int clkRate; 593 594 AH_PRIVATE(ah)->ah_coverageClass = coverageclass; 595 596 if (now) { 597 if (AH_PRIVATE(ah)->ah_coverageClass == 0) 598 return; 599 600 /* Don't apply coverage class to non A channels */ 601 if (!IEEE80211_IS_CHAN_A(AH_PRIVATE(ah)->ah_curchan)) 602 return; 603 604 /* Get core clock rate */ 605 clkRate = ath_hal_mac_clks(ah, 1); 606 607 /* Compute EIFS */ 608 slot = coverageclass * 3 * clkRate; 609 eifs = coverageclass * 6 * clkRate; 610 if (IEEE80211_IS_CHAN_HALF(AH_PRIVATE(ah)->ah_curchan)) { 611 slot += IFS_SLOT_HALF_RATE; 612 eifs += IFS_EIFS_HALF_RATE; 613 } else if (IEEE80211_IS_CHAN_QUARTER(AH_PRIVATE(ah)->ah_curchan)) { 614 slot += IFS_SLOT_QUARTER_RATE; 615 eifs += IFS_EIFS_QUARTER_RATE; 616 } else { /* full rate */ 617 slot += IFS_SLOT_FULL_RATE; 618 eifs += IFS_EIFS_FULL_RATE; 619 } 620 621 /* 622 * Add additional time for air propagation for ACK and CTS 623 * timeouts. This value is in core clocks. 624 */ 625 timeout = ACK_CTS_TIMEOUT_11A + (coverageclass * 3 * clkRate); 626 627 /* 628 * Write the values: slot, eifs, ack/cts timeouts. 629 */ 630 OS_REG_WRITE(ah, AR_D_GBL_IFS_SLOT, slot); 631 OS_REG_WRITE(ah, AR_D_GBL_IFS_EIFS, eifs); 632 OS_REG_WRITE(ah, AR_TIME_OUT, 633 SM(timeout, AR_TIME_OUT_CTS) 634 | SM(timeout, AR_TIME_OUT_ACK)); 635 } 636 } 637 638 HAL_STATUS 639 ar5212SetQuiet(struct ath_hal *ah, uint32_t period, uint32_t duration, 640 uint32_t nextStart, HAL_QUIET_FLAG flag) 641 { 642 OS_REG_WRITE(ah, AR_QUIET2, period | (duration << AR_QUIET2_QUIET_DUR_S)); 643 if (flag & HAL_QUIET_ENABLE) { 644 OS_REG_WRITE(ah, AR_QUIET1, nextStart | (1 << 16)); 645 } 646 else { 647 OS_REG_WRITE(ah, AR_QUIET1, nextStart); 648 } 649 return HAL_OK; 650 } 651 652 void 653 ar5212SetPCUConfig(struct ath_hal *ah) 654 { 655 ar5212SetOperatingMode(ah, AH_PRIVATE(ah)->ah_opmode); 656 } 657 658 /* 659 * Return whether an external 32KHz crystal should be used 660 * to reduce power consumption when sleeping. We do so if 661 * the crystal is present (obtained from EEPROM) and if we 662 * are not running as an AP and are configured to use it. 663 */ 664 HAL_BOOL 665 ar5212Use32KHzclock(struct ath_hal *ah, HAL_OPMODE opmode) 666 { 667 if (opmode != HAL_M_HOSTAP) { 668 struct ath_hal_5212 *ahp = AH5212(ah); 669 return ath_hal_eepromGetFlag(ah, AR_EEP_32KHZCRYSTAL) && 670 (ahp->ah_enable32kHzClock == USE_32KHZ || 671 ahp->ah_enable32kHzClock == AUTO_32KHZ); 672 } else 673 return AH_FALSE; 674 } 675 676 /* 677 * If 32KHz clock exists, use it to lower power consumption during sleep 678 * 679 * Note: If clock is set to 32 KHz, delays on accessing certain 680 * baseband registers (27-31, 124-127) are required. 681 */ 682 void 683 ar5212SetupClock(struct ath_hal *ah, HAL_OPMODE opmode) 684 { 685 if (ar5212Use32KHzclock(ah, opmode)) { 686 /* 687 * Enable clocks to be turned OFF in BB during sleep 688 * and also enable turning OFF 32MHz/40MHz Refclk 689 * from A2. 690 */ 691 OS_REG_WRITE(ah, AR_PHY_SLEEP_CTR_CONTROL, 0x1f); 692 OS_REG_WRITE(ah, AR_PHY_REFCLKPD, 693 IS_RAD5112_ANY(ah) || IS_5413(ah) ? 0x14 : 0x18); 694 OS_REG_RMW_FIELD(ah, AR_USEC, AR_USEC_USEC32, 1); 695 OS_REG_WRITE(ah, AR_TSF_PARM, 61); /* 32 KHz TSF incr */ 696 OS_REG_RMW_FIELD(ah, AR_PCICFG, AR_PCICFG_SCLK_SEL, 1); 697 698 if (IS_2413(ah) || IS_5413(ah) || IS_2417(ah)) { 699 OS_REG_WRITE(ah, AR_PHY_SLEEP_CTR_LIMIT, 0x26); 700 OS_REG_WRITE(ah, AR_PHY_SLEEP_SCAL, 0x0d); 701 OS_REG_WRITE(ah, AR_PHY_M_SLEEP, 0x07); 702 OS_REG_WRITE(ah, AR_PHY_REFCLKDLY, 0x3f); 703 /* # Set sleep clock rate to 32 KHz. */ 704 OS_REG_RMW_FIELD(ah, AR_PCICFG, AR_PCICFG_SCLK_RATE_IND, 0x2); 705 } else { 706 OS_REG_WRITE(ah, AR_PHY_SLEEP_CTR_LIMIT, 0x0a); 707 OS_REG_WRITE(ah, AR_PHY_SLEEP_SCAL, 0x0c); 708 OS_REG_WRITE(ah, AR_PHY_M_SLEEP, 0x03); 709 OS_REG_WRITE(ah, AR_PHY_REFCLKDLY, 0x20); 710 OS_REG_RMW_FIELD(ah, AR_PCICFG, AR_PCICFG_SCLK_RATE_IND, 0x3); 711 } 712 } else { 713 OS_REG_RMW_FIELD(ah, AR_PCICFG, AR_PCICFG_SCLK_RATE_IND, 0x0); 714 OS_REG_RMW_FIELD(ah, AR_PCICFG, AR_PCICFG_SCLK_SEL, 0); 715 716 OS_REG_WRITE(ah, AR_TSF_PARM, 1); /* 32MHz TSF inc */ 717 718 OS_REG_WRITE(ah, AR_PHY_SLEEP_CTR_CONTROL, 0x1f); 719 OS_REG_WRITE(ah, AR_PHY_SLEEP_CTR_LIMIT, 0x7f); 720 721 if (IS_2417(ah)) 722 OS_REG_WRITE(ah, AR_PHY_SLEEP_SCAL, 0x0a); 723 else if (IS_HB63(ah)) 724 OS_REG_WRITE(ah, AR_PHY_SLEEP_SCAL, 0x32); 725 else 726 OS_REG_WRITE(ah, AR_PHY_SLEEP_SCAL, 0x0e); 727 OS_REG_WRITE(ah, AR_PHY_M_SLEEP, 0x0c); 728 OS_REG_WRITE(ah, AR_PHY_REFCLKDLY, 0xff); 729 OS_REG_WRITE(ah, AR_PHY_REFCLKPD, 730 IS_RAD5112_ANY(ah) || IS_5413(ah) || IS_2417(ah) ? 0x14 : 0x18); 731 OS_REG_RMW_FIELD(ah, AR_USEC, AR_USEC_USEC32, 732 IS_RAD5112_ANY(ah) || IS_5413(ah) ? 39 : 31); 733 } 734 } 735 736 /* 737 * If 32KHz clock exists, turn it off and turn back on the 32Mhz 738 */ 739 void 740 ar5212RestoreClock(struct ath_hal *ah, HAL_OPMODE opmode) 741 { 742 if (ar5212Use32KHzclock(ah, opmode)) { 743 /* # Set sleep clock rate back to 32 MHz. */ 744 OS_REG_RMW_FIELD(ah, AR_PCICFG, AR_PCICFG_SCLK_RATE_IND, 0); 745 OS_REG_RMW_FIELD(ah, AR_PCICFG, AR_PCICFG_SCLK_SEL, 0); 746 747 OS_REG_WRITE(ah, AR_TSF_PARM, 1); /* 32 MHz TSF incr */ 748 OS_REG_RMW_FIELD(ah, AR_USEC, AR_USEC_USEC32, 749 IS_RAD5112_ANY(ah) || IS_5413(ah) ? 39 : 31); 750 751 /* 752 * Restore BB registers to power-on defaults 753 */ 754 OS_REG_WRITE(ah, AR_PHY_SLEEP_CTR_CONTROL, 0x1f); 755 OS_REG_WRITE(ah, AR_PHY_SLEEP_CTR_LIMIT, 0x7f); 756 OS_REG_WRITE(ah, AR_PHY_SLEEP_SCAL, 0x0e); 757 OS_REG_WRITE(ah, AR_PHY_M_SLEEP, 0x0c); 758 OS_REG_WRITE(ah, AR_PHY_REFCLKDLY, 0xff); 759 OS_REG_WRITE(ah, AR_PHY_REFCLKPD, 760 IS_RAD5112_ANY(ah) || IS_5413(ah) ? 0x14 : 0x18); 761 } 762 } 763 764 /* 765 * Adjust NF based on statistical values for 5GHz frequencies. 766 * Default method: this may be overridden by the rf backend. 767 */ 768 int16_t 769 ar5212GetNfAdjust(struct ath_hal *ah, const HAL_CHANNEL_INTERNAL *c) 770 { 771 static const struct { 772 uint16_t freqLow; 773 int16_t adjust; 774 } adjustDef[] = { 775 { 5790, 11 }, /* NB: ordered high -> low */ 776 { 5730, 10 }, 777 { 5690, 9 }, 778 { 5660, 8 }, 779 { 5610, 7 }, 780 { 5530, 5 }, 781 { 5450, 4 }, 782 { 5379, 2 }, 783 { 5209, 0 }, 784 { 3000, 1 }, 785 { 0, 0 }, 786 }; 787 int i; 788 789 for (i = 0; c->channel <= adjustDef[i].freqLow; i++) 790 ; 791 return adjustDef[i].adjust; 792 } 793 794 HAL_STATUS 795 ar5212GetCapability(struct ath_hal *ah, HAL_CAPABILITY_TYPE type, 796 uint32_t capability, uint32_t *result) 797 { 798 #define MACVERSION(ah) AH_PRIVATE(ah)->ah_macVersion 799 struct ath_hal_5212 *ahp = AH5212(ah); 800 const HAL_CAPABILITIES *pCap = &AH_PRIVATE(ah)->ah_caps; 801 const struct ar5212AniState *ani; 802 803 switch (type) { 804 case HAL_CAP_CIPHER: /* cipher handled in hardware */ 805 switch (capability) { 806 case HAL_CIPHER_AES_CCM: 807 return pCap->halCipherAesCcmSupport ? 808 HAL_OK : HAL_ENOTSUPP; 809 case HAL_CIPHER_AES_OCB: 810 case HAL_CIPHER_TKIP: 811 case HAL_CIPHER_WEP: 812 case HAL_CIPHER_MIC: 813 case HAL_CIPHER_CLR: 814 return HAL_OK; 815 default: 816 return HAL_ENOTSUPP; 817 } 818 case HAL_CAP_TKIP_MIC: /* handle TKIP MIC in hardware */ 819 switch (capability) { 820 case 0: /* hardware capability */ 821 return HAL_OK; 822 case 1: 823 return (ahp->ah_staId1Defaults & 824 AR_STA_ID1_CRPT_MIC_ENABLE) ? HAL_OK : HAL_ENXIO; 825 } 826 return HAL_EINVAL; 827 case HAL_CAP_TKIP_SPLIT: /* hardware TKIP uses split keys */ 828 switch (capability) { 829 case 0: /* hardware capability */ 830 return pCap->halTkipMicTxRxKeySupport ? 831 HAL_ENXIO : HAL_OK; 832 case 1: /* current setting */ 833 return (ahp->ah_miscMode & 834 AR_MISC_MODE_MIC_NEW_LOC_ENABLE) ? HAL_ENXIO : HAL_OK; 835 } 836 return HAL_EINVAL; 837 case HAL_CAP_WME_TKIPMIC: /* hardware can do TKIP MIC w/ WMM */ 838 /* XXX move to capability bit */ 839 return MACVERSION(ah) > AR_SREV_VERSION_VENICE || 840 (MACVERSION(ah) == AR_SREV_VERSION_VENICE && 841 AH_PRIVATE(ah)->ah_macRev >= 8) ? HAL_OK : HAL_ENOTSUPP; 842 case HAL_CAP_DIVERSITY: /* hardware supports fast diversity */ 843 switch (capability) { 844 case 0: /* hardware capability */ 845 return HAL_OK; 846 case 1: /* current setting */ 847 return ahp->ah_diversity ? HAL_OK : HAL_ENXIO; 848 case HAL_CAP_STRONG_DIV: 849 *result = OS_REG_READ(ah, AR_PHY_RESTART); 850 *result = MS(*result, AR_PHY_RESTART_DIV_GC); 851 return HAL_OK; 852 } 853 return HAL_EINVAL; 854 case HAL_CAP_DIAG: 855 *result = AH_PRIVATE(ah)->ah_diagreg; 856 return HAL_OK; 857 case HAL_CAP_TPC: 858 switch (capability) { 859 case 0: /* hardware capability */ 860 return HAL_OK; 861 case 1: 862 return ahp->ah_tpcEnabled ? HAL_OK : HAL_ENXIO; 863 } 864 return HAL_OK; 865 case HAL_CAP_PHYDIAG: /* radar pulse detection capability */ 866 switch (capability) { 867 case HAL_CAP_RADAR: 868 return ath_hal_eepromGetFlag(ah, AR_EEP_AMODE) ? 869 HAL_OK: HAL_ENXIO; 870 case HAL_CAP_AR: 871 return (ath_hal_eepromGetFlag(ah, AR_EEP_GMODE) || 872 ath_hal_eepromGetFlag(ah, AR_EEP_BMODE)) ? 873 HAL_OK: HAL_ENXIO; 874 } 875 return HAL_ENXIO; 876 case HAL_CAP_MCAST_KEYSRCH: /* multicast frame keycache search */ 877 switch (capability) { 878 case 0: /* hardware capability */ 879 return pCap->halMcastKeySrchSupport ? HAL_OK : HAL_ENXIO; 880 case 1: 881 return (ahp->ah_staId1Defaults & 882 AR_STA_ID1_MCAST_KSRCH) ? HAL_OK : HAL_ENXIO; 883 } 884 return HAL_EINVAL; 885 case HAL_CAP_TSF_ADJUST: /* hardware has beacon tsf adjust */ 886 switch (capability) { 887 case 0: /* hardware capability */ 888 return pCap->halTsfAddSupport ? HAL_OK : HAL_ENOTSUPP; 889 case 1: 890 return (ahp->ah_miscMode & AR_MISC_MODE_TX_ADD_TSF) ? 891 HAL_OK : HAL_ENXIO; 892 } 893 return HAL_EINVAL; 894 case HAL_CAP_TPC_ACK: 895 *result = MS(ahp->ah_macTPC, AR_TPC_ACK); 896 return HAL_OK; 897 case HAL_CAP_TPC_CTS: 898 *result = MS(ahp->ah_macTPC, AR_TPC_CTS); 899 return HAL_OK; 900 case HAL_CAP_INTMIT: /* interference mitigation */ 901 switch (capability) { 902 case HAL_CAP_INTMIT_PRESENT: /* hardware capability */ 903 return HAL_OK; 904 case HAL_CAP_INTMIT_ENABLE: 905 return (ahp->ah_procPhyErr & HAL_ANI_ENA) ? 906 HAL_OK : HAL_ENXIO; 907 case HAL_CAP_INTMIT_NOISE_IMMUNITY_LEVEL: 908 case HAL_CAP_INTMIT_OFDM_WEAK_SIGNAL_LEVEL: 909 case HAL_CAP_INTMIT_CCK_WEAK_SIGNAL_THR: 910 case HAL_CAP_INTMIT_FIRSTEP_LEVEL: 911 case HAL_CAP_INTMIT_SPUR_IMMUNITY_LEVEL: 912 ani = ar5212AniGetCurrentState(ah); 913 if (ani == AH_NULL) 914 return HAL_ENXIO; 915 switch (capability) { 916 case 2: *result = ani->noiseImmunityLevel; break; 917 case 3: *result = !ani->ofdmWeakSigDetectOff; break; 918 case 4: *result = ani->cckWeakSigThreshold; break; 919 case 5: *result = ani->firstepLevel; break; 920 case 6: *result = ani->spurImmunityLevel; break; 921 } 922 return HAL_OK; 923 } 924 return HAL_EINVAL; 925 default: 926 return ath_hal_getcapability(ah, type, capability, result); 927 } 928 #undef MACVERSION 929 } 930 931 HAL_BOOL 932 ar5212SetCapability(struct ath_hal *ah, HAL_CAPABILITY_TYPE type, 933 uint32_t capability, uint32_t setting, HAL_STATUS *status) 934 { 935 #define N(a) (sizeof(a)/sizeof(a[0])) 936 struct ath_hal_5212 *ahp = AH5212(ah); 937 const HAL_CAPABILITIES *pCap = &AH_PRIVATE(ah)->ah_caps; 938 uint32_t v; 939 940 switch (type) { 941 case HAL_CAP_TKIP_MIC: /* handle TKIP MIC in hardware */ 942 if (setting) 943 ahp->ah_staId1Defaults |= AR_STA_ID1_CRPT_MIC_ENABLE; 944 else 945 ahp->ah_staId1Defaults &= ~AR_STA_ID1_CRPT_MIC_ENABLE; 946 return AH_TRUE; 947 case HAL_CAP_TKIP_SPLIT: /* hardware TKIP uses split keys */ 948 if (!pCap->halTkipMicTxRxKeySupport) 949 return AH_FALSE; 950 /* NB: true =>'s use split key cache layout */ 951 if (setting) 952 ahp->ah_miscMode &= ~AR_MISC_MODE_MIC_NEW_LOC_ENABLE; 953 else 954 ahp->ah_miscMode |= AR_MISC_MODE_MIC_NEW_LOC_ENABLE; 955 /* NB: write here so keys can be setup w/o a reset */ 956 OS_REG_WRITE(ah, AR_MISC_MODE, OS_REG_READ(ah, AR_MISC_MODE) | ahp->ah_miscMode); 957 return AH_TRUE; 958 case HAL_CAP_DIVERSITY: 959 switch (capability) { 960 case 0: 961 return AH_FALSE; 962 case 1: /* setting */ 963 if (ahp->ah_phyPowerOn) { 964 if (capability == HAL_CAP_STRONG_DIV) { 965 v = OS_REG_READ(ah, AR_PHY_CCK_DETECT); 966 if (setting) 967 v |= AR_PHY_CCK_DETECT_BB_ENABLE_ANT_FAST_DIV; 968 else 969 v &= ~AR_PHY_CCK_DETECT_BB_ENABLE_ANT_FAST_DIV; 970 OS_REG_WRITE(ah, AR_PHY_CCK_DETECT, v); 971 } 972 } 973 ahp->ah_diversity = (setting != 0); 974 return AH_TRUE; 975 976 case HAL_CAP_STRONG_DIV: 977 if (! ahp->ah_phyPowerOn) 978 return AH_FALSE; 979 v = OS_REG_READ(ah, AR_PHY_RESTART); 980 v &= ~AR_PHY_RESTART_DIV_GC; 981 v |= SM(setting, AR_PHY_RESTART_DIV_GC); 982 OS_REG_WRITE(ah, AR_PHY_RESTART, v); 983 return AH_TRUE; 984 default: 985 return AH_FALSE; 986 } 987 case HAL_CAP_DIAG: /* hardware diagnostic support */ 988 /* 989 * NB: could split this up into virtual capabilities, 990 * (e.g. 1 => ACK, 2 => CTS, etc.) but it hardly 991 * seems worth the additional complexity. 992 */ 993 AH_PRIVATE(ah)->ah_diagreg = setting; 994 OS_REG_WRITE(ah, AR_DIAG_SW, AH_PRIVATE(ah)->ah_diagreg); 995 return AH_TRUE; 996 case HAL_CAP_TPC: 997 ahp->ah_tpcEnabled = (setting != 0); 998 return AH_TRUE; 999 case HAL_CAP_MCAST_KEYSRCH: /* multicast frame keycache search */ 1000 if (setting) 1001 ahp->ah_staId1Defaults |= AR_STA_ID1_MCAST_KSRCH; 1002 else 1003 ahp->ah_staId1Defaults &= ~AR_STA_ID1_MCAST_KSRCH; 1004 return AH_TRUE; 1005 case HAL_CAP_TPC_ACK: 1006 case HAL_CAP_TPC_CTS: 1007 setting += ahp->ah_txPowerIndexOffset; 1008 if (setting > 63) 1009 setting = 63; 1010 if (type == HAL_CAP_TPC_ACK) { 1011 ahp->ah_macTPC &= AR_TPC_ACK; 1012 ahp->ah_macTPC |= MS(setting, AR_TPC_ACK); 1013 } else { 1014 ahp->ah_macTPC &= AR_TPC_CTS; 1015 ahp->ah_macTPC |= MS(setting, AR_TPC_CTS); 1016 } 1017 OS_REG_WRITE(ah, AR_TPC, ahp->ah_macTPC); 1018 return AH_TRUE; 1019 case HAL_CAP_INTMIT: { /* interference mitigation */ 1020 /* This maps the public ANI commands to the internal ANI commands */ 1021 /* Private: HAL_ANI_CMD; Public: HAL_CAP_INTMIT_CMD */ 1022 static const HAL_ANI_CMD cmds[] = { 1023 HAL_ANI_PRESENT, 1024 HAL_ANI_MODE, 1025 HAL_ANI_NOISE_IMMUNITY_LEVEL, 1026 HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION, 1027 HAL_ANI_CCK_WEAK_SIGNAL_THR, 1028 HAL_ANI_FIRSTEP_LEVEL, 1029 HAL_ANI_SPUR_IMMUNITY_LEVEL, 1030 }; 1031 return capability < N(cmds) ? 1032 AH5212(ah)->ah_aniControl(ah, cmds[capability], setting) : 1033 AH_FALSE; 1034 } 1035 case HAL_CAP_TSF_ADJUST: /* hardware has beacon tsf adjust */ 1036 if (pCap->halTsfAddSupport) { 1037 if (setting) 1038 ahp->ah_miscMode |= AR_MISC_MODE_TX_ADD_TSF; 1039 else 1040 ahp->ah_miscMode &= ~AR_MISC_MODE_TX_ADD_TSF; 1041 return AH_TRUE; 1042 } 1043 /* fall thru... */ 1044 default: 1045 return ath_hal_setcapability(ah, type, capability, 1046 setting, status); 1047 } 1048 #undef N 1049 } 1050 1051 HAL_BOOL 1052 ar5212GetDiagState(struct ath_hal *ah, int request, 1053 const void *args, uint32_t argsize, 1054 void **result, uint32_t *resultsize) 1055 { 1056 struct ath_hal_5212 *ahp = AH5212(ah); 1057 HAL_ANI_STATS *astats; 1058 1059 (void) ahp; 1060 if (ath_hal_getdiagstate(ah, request, args, argsize, result, resultsize)) 1061 return AH_TRUE; 1062 switch (request) { 1063 case HAL_DIAG_EEPROM: 1064 case HAL_DIAG_EEPROM_EXP_11A: 1065 case HAL_DIAG_EEPROM_EXP_11B: 1066 case HAL_DIAG_EEPROM_EXP_11G: 1067 case HAL_DIAG_RFGAIN: 1068 return ath_hal_eepromDiag(ah, request, 1069 args, argsize, result, resultsize); 1070 case HAL_DIAG_RFGAIN_CURSTEP: 1071 *result = __DECONST(void *, ahp->ah_gainValues.currStep); 1072 *resultsize = (*result == AH_NULL) ? 1073 0 : sizeof(GAIN_OPTIMIZATION_STEP); 1074 return AH_TRUE; 1075 case HAL_DIAG_PCDAC: 1076 *result = ahp->ah_pcdacTable; 1077 *resultsize = ahp->ah_pcdacTableSize; 1078 return AH_TRUE; 1079 case HAL_DIAG_TXRATES: 1080 *result = &ahp->ah_ratesArray[0]; 1081 *resultsize = sizeof(ahp->ah_ratesArray); 1082 return AH_TRUE; 1083 case HAL_DIAG_ANI_CURRENT: 1084 *result = ar5212AniGetCurrentState(ah); 1085 *resultsize = (*result == AH_NULL) ? 1086 0 : sizeof(struct ar5212AniState); 1087 return AH_TRUE; 1088 case HAL_DIAG_ANI_STATS: 1089 OS_MEMZERO(&ahp->ext_ani_stats, sizeof(ahp->ext_ani_stats)); 1090 astats = ar5212AniGetCurrentStats(ah); 1091 if (astats == NULL) { 1092 *result = NULL; 1093 *resultsize = 0; 1094 } else { 1095 OS_MEMCPY(&ahp->ext_ani_stats, astats, sizeof(HAL_ANI_STATS)); 1096 *result = &ahp->ext_ani_stats; 1097 *resultsize = sizeof(ahp->ext_ani_stats); 1098 } 1099 return AH_TRUE; 1100 case HAL_DIAG_ANI_CMD: 1101 if (argsize != 2*sizeof(uint32_t)) 1102 return AH_FALSE; 1103 AH5212(ah)->ah_aniControl(ah, ((const uint32_t *)args)[0], 1104 ((const uint32_t *)args)[1]); 1105 return AH_TRUE; 1106 case HAL_DIAG_ANI_PARAMS: 1107 /* 1108 * NB: We assume struct ar5212AniParams is identical 1109 * to HAL_ANI_PARAMS; if they diverge then we'll need 1110 * to handle it here 1111 */ 1112 if (argsize == 0 && args == AH_NULL) { 1113 struct ar5212AniState *aniState = 1114 ar5212AniGetCurrentState(ah); 1115 if (aniState == AH_NULL) 1116 return AH_FALSE; 1117 *result = __DECONST(void *, aniState->params); 1118 *resultsize = sizeof(struct ar5212AniParams); 1119 return AH_TRUE; 1120 } else { 1121 if (argsize != sizeof(struct ar5212AniParams)) 1122 return AH_FALSE; 1123 return ar5212AniSetParams(ah, args, args); 1124 } 1125 break; 1126 } 1127 return AH_FALSE; 1128 } 1129 1130 /* 1131 * Check whether there's an in-progress NF completion. 1132 * 1133 * Returns AH_TRUE if there's a in-progress NF calibration, AH_FALSE 1134 * otherwise. 1135 */ 1136 HAL_BOOL 1137 ar5212IsNFCalInProgress(struct ath_hal *ah) 1138 { 1139 if (OS_REG_READ(ah, AR_PHY_AGC_CONTROL) & AR_PHY_AGC_CONTROL_NF) 1140 return AH_TRUE; 1141 return AH_FALSE; 1142 } 1143 1144 /* 1145 * Wait for an in-progress NF calibration to complete. 1146 * 1147 * The completion function waits "i" times 10uS. 1148 * It returns AH_TRUE if the NF calibration completed (or was never 1149 * in progress); AH_FALSE if it was still in progress after "i" checks. 1150 */ 1151 HAL_BOOL 1152 ar5212WaitNFCalComplete(struct ath_hal *ah, int i) 1153 { 1154 int j; 1155 if (i <= 0) 1156 i = 1; /* it should run at least once */ 1157 for (j = 0; j < i; j++) { 1158 if (! ar5212IsNFCalInProgress(ah)) 1159 return AH_TRUE; 1160 OS_DELAY(10); 1161 } 1162 return AH_FALSE; 1163 } 1164 1165 void 1166 ar5212EnableDfs(struct ath_hal *ah, HAL_PHYERR_PARAM *pe) 1167 { 1168 uint32_t val; 1169 val = OS_REG_READ(ah, AR_PHY_RADAR_0); 1170 1171 if (pe->pe_firpwr != HAL_PHYERR_PARAM_NOVAL) { 1172 val &= ~AR_PHY_RADAR_0_FIRPWR; 1173 val |= SM(pe->pe_firpwr, AR_PHY_RADAR_0_FIRPWR); 1174 } 1175 if (pe->pe_rrssi != HAL_PHYERR_PARAM_NOVAL) { 1176 val &= ~AR_PHY_RADAR_0_RRSSI; 1177 val |= SM(pe->pe_rrssi, AR_PHY_RADAR_0_RRSSI); 1178 } 1179 if (pe->pe_height != HAL_PHYERR_PARAM_NOVAL) { 1180 val &= ~AR_PHY_RADAR_0_HEIGHT; 1181 val |= SM(pe->pe_height, AR_PHY_RADAR_0_HEIGHT); 1182 } 1183 if (pe->pe_prssi != HAL_PHYERR_PARAM_NOVAL) { 1184 val &= ~AR_PHY_RADAR_0_PRSSI; 1185 val |= SM(pe->pe_prssi, AR_PHY_RADAR_0_PRSSI); 1186 } 1187 if (pe->pe_inband != HAL_PHYERR_PARAM_NOVAL) { 1188 val &= ~AR_PHY_RADAR_0_INBAND; 1189 val |= SM(pe->pe_inband, AR_PHY_RADAR_0_INBAND); 1190 } 1191 if (pe->pe_enabled) 1192 val |= AR_PHY_RADAR_0_ENA; 1193 else 1194 val &= ~ AR_PHY_RADAR_0_ENA; 1195 1196 if (IS_5413(ah)) { 1197 1198 if (pe->pe_blockradar == 1) 1199 OS_REG_SET_BIT(ah, AR_PHY_RADAR_2, 1200 AR_PHY_RADAR_2_BLOCKOFDMWEAK); 1201 else 1202 OS_REG_CLR_BIT(ah, AR_PHY_RADAR_2, 1203 AR_PHY_RADAR_2_BLOCKOFDMWEAK); 1204 1205 if (pe->pe_en_relstep_check == 1) 1206 OS_REG_SET_BIT(ah, AR_PHY_RADAR_2, 1207 AR_PHY_RADAR_2_ENRELSTEPCHK); 1208 else 1209 OS_REG_CLR_BIT(ah, AR_PHY_RADAR_2, 1210 AR_PHY_RADAR_2_ENRELSTEPCHK); 1211 1212 if (pe->pe_usefir128 == 1) 1213 OS_REG_SET_BIT(ah, AR_PHY_RADAR_2, 1214 AR_PHY_RADAR_2_USEFIR128); 1215 else 1216 OS_REG_CLR_BIT(ah, AR_PHY_RADAR_2, 1217 AR_PHY_RADAR_2_USEFIR128); 1218 1219 if (pe->pe_enmaxrssi == 1) 1220 OS_REG_SET_BIT(ah, AR_PHY_RADAR_2, 1221 AR_PHY_RADAR_2_ENMAXRSSI); 1222 else 1223 OS_REG_CLR_BIT(ah, AR_PHY_RADAR_2, 1224 AR_PHY_RADAR_2_ENMAXRSSI); 1225 1226 if (pe->pe_enrelpwr == 1) 1227 OS_REG_SET_BIT(ah, AR_PHY_RADAR_2, 1228 AR_PHY_RADAR_2_ENRELPWRCHK); 1229 else 1230 OS_REG_CLR_BIT(ah, AR_PHY_RADAR_2, 1231 AR_PHY_RADAR_2_ENRELPWRCHK); 1232 1233 if (pe->pe_relpwr != HAL_PHYERR_PARAM_NOVAL) 1234 OS_REG_RMW_FIELD(ah, AR_PHY_RADAR_2, 1235 AR_PHY_RADAR_2_RELPWR, pe->pe_relpwr); 1236 1237 if (pe->pe_relstep != HAL_PHYERR_PARAM_NOVAL) 1238 OS_REG_RMW_FIELD(ah, AR_PHY_RADAR_2, 1239 AR_PHY_RADAR_2_RELSTEP, pe->pe_relstep); 1240 1241 if (pe->pe_maxlen != HAL_PHYERR_PARAM_NOVAL) 1242 OS_REG_RMW_FIELD(ah, AR_PHY_RADAR_2, 1243 AR_PHY_RADAR_2_MAXLEN, pe->pe_maxlen); 1244 } 1245 1246 OS_REG_WRITE(ah, AR_PHY_RADAR_0, val); 1247 } 1248 1249 /* 1250 * Parameters for the AR5212 PHY. 1251 */ 1252 #define AR5212_DFS_FIRPWR -35 1253 #define AR5212_DFS_RRSSI 20 1254 #define AR5212_DFS_HEIGHT 14 1255 #define AR5212_DFS_PRSSI 6 1256 #define AR5212_DFS_INBAND 4 1257 1258 /* 1259 * Default parameters for the AR5413 PHY. 1260 */ 1261 #define AR5413_DFS_FIRPWR -34 1262 #define AR5413_DFS_RRSSI 20 1263 #define AR5413_DFS_HEIGHT 10 1264 #define AR5413_DFS_PRSSI 15 1265 #define AR5413_DFS_INBAND 6 1266 #define AR5413_DFS_RELPWR 8 1267 #define AR5413_DFS_RELSTEP 31 1268 #define AR5413_DFS_MAXLEN 255 1269 1270 HAL_BOOL 1271 ar5212GetDfsDefaultThresh(struct ath_hal *ah, HAL_PHYERR_PARAM *pe) 1272 { 1273 1274 if (IS_5413(ah)) { 1275 pe->pe_firpwr = AR5413_DFS_FIRPWR; 1276 pe->pe_rrssi = AR5413_DFS_RRSSI; 1277 pe->pe_height = AR5413_DFS_HEIGHT; 1278 pe->pe_prssi = AR5413_DFS_PRSSI; 1279 pe->pe_inband = AR5413_DFS_INBAND; 1280 pe->pe_relpwr = AR5413_DFS_RELPWR; 1281 pe->pe_relstep = AR5413_DFS_RELSTEP; 1282 pe->pe_maxlen = AR5413_DFS_MAXLEN; 1283 pe->pe_usefir128 = 0; 1284 pe->pe_blockradar = 1; 1285 pe->pe_enmaxrssi = 1; 1286 pe->pe_enrelpwr = 1; 1287 pe->pe_en_relstep_check = 0; 1288 } else { 1289 pe->pe_firpwr = AR5212_DFS_FIRPWR; 1290 pe->pe_rrssi = AR5212_DFS_RRSSI; 1291 pe->pe_height = AR5212_DFS_HEIGHT; 1292 pe->pe_prssi = AR5212_DFS_PRSSI; 1293 pe->pe_inband = AR5212_DFS_INBAND; 1294 pe->pe_relpwr = 0; 1295 pe->pe_relstep = 0; 1296 pe->pe_maxlen = 0; 1297 pe->pe_usefir128 = 0; 1298 pe->pe_blockradar = 0; 1299 pe->pe_enmaxrssi = 0; 1300 pe->pe_enrelpwr = 0; 1301 pe->pe_en_relstep_check = 0; 1302 } 1303 1304 return (AH_TRUE); 1305 } 1306 1307 void 1308 ar5212GetDfsThresh(struct ath_hal *ah, HAL_PHYERR_PARAM *pe) 1309 { 1310 uint32_t val,temp; 1311 1312 val = OS_REG_READ(ah, AR_PHY_RADAR_0); 1313 1314 temp = MS(val,AR_PHY_RADAR_0_FIRPWR); 1315 temp |= 0xFFFFFF80; 1316 pe->pe_firpwr = temp; 1317 pe->pe_rrssi = MS(val, AR_PHY_RADAR_0_RRSSI); 1318 pe->pe_height = MS(val, AR_PHY_RADAR_0_HEIGHT); 1319 pe->pe_prssi = MS(val, AR_PHY_RADAR_0_PRSSI); 1320 pe->pe_inband = MS(val, AR_PHY_RADAR_0_INBAND); 1321 pe->pe_enabled = !! (val & AR_PHY_RADAR_0_ENA); 1322 1323 pe->pe_relpwr = 0; 1324 pe->pe_relstep = 0; 1325 pe->pe_maxlen = 0; 1326 pe->pe_usefir128 = 0; 1327 pe->pe_blockradar = 0; 1328 pe->pe_enmaxrssi = 0; 1329 pe->pe_enrelpwr = 0; 1330 pe->pe_en_relstep_check = 0; 1331 pe->pe_extchannel = AH_FALSE; 1332 1333 if (IS_5413(ah)) { 1334 val = OS_REG_READ(ah, AR_PHY_RADAR_2); 1335 pe->pe_relpwr = !! MS(val, AR_PHY_RADAR_2_RELPWR); 1336 pe->pe_relstep = !! MS(val, AR_PHY_RADAR_2_RELSTEP); 1337 pe->pe_maxlen = !! MS(val, AR_PHY_RADAR_2_MAXLEN); 1338 1339 pe->pe_usefir128 = !! (val & AR_PHY_RADAR_2_USEFIR128); 1340 pe->pe_blockradar = !! (val & AR_PHY_RADAR_2_BLOCKOFDMWEAK); 1341 pe->pe_enmaxrssi = !! (val & AR_PHY_RADAR_2_ENMAXRSSI); 1342 pe->pe_enrelpwr = !! (val & AR_PHY_RADAR_2_ENRELPWRCHK); 1343 pe->pe_en_relstep_check = 1344 !! (val & AR_PHY_RADAR_2_ENRELSTEPCHK); 1345 } 1346 } 1347 1348 /* 1349 * Process the radar phy error and extract the pulse duration. 1350 */ 1351 HAL_BOOL 1352 ar5212ProcessRadarEvent(struct ath_hal *ah, struct ath_rx_status *rxs, 1353 uint64_t fulltsf, const char *buf, HAL_DFS_EVENT *event) 1354 { 1355 uint8_t dur; 1356 uint8_t rssi; 1357 1358 /* Check whether the given phy error is a radar event */ 1359 if ((rxs->rs_phyerr != HAL_PHYERR_RADAR) && 1360 (rxs->rs_phyerr != HAL_PHYERR_FALSE_RADAR_EXT)) 1361 return AH_FALSE; 1362 1363 /* 1364 * The first byte is the pulse width - if there's 1365 * no data, simply set the duration to 0 1366 */ 1367 if (rxs->rs_datalen >= 1) 1368 /* The pulse width is byte 0 of the data */ 1369 dur = ((uint8_t) buf[0]) & 0xff; 1370 else 1371 dur = 0; 1372 1373 /* Pulse RSSI is the normal reported RSSI */ 1374 rssi = (uint8_t) rxs->rs_rssi; 1375 1376 /* 0 duration/rssi is not a valid radar event */ 1377 if (dur == 0 && rssi == 0) 1378 return AH_FALSE; 1379 1380 HALDEBUG(ah, HAL_DEBUG_DFS, "%s: rssi=%d, dur=%d\n", 1381 __func__, rssi, dur); 1382 1383 /* Record the event */ 1384 event->re_full_ts = fulltsf; 1385 event->re_ts = rxs->rs_tstamp; 1386 event->re_rssi = rssi; 1387 event->re_dur = dur; 1388 event->re_flags = HAL_DFS_EVENT_PRICH; 1389 1390 return AH_TRUE; 1391 } 1392 1393 /* 1394 * Return whether 5GHz fast-clock (44MHz) is enabled. 1395 * It's always disabled for AR5212 series NICs. 1396 */ 1397 HAL_BOOL 1398 ar5212IsFastClockEnabled(struct ath_hal *ah) 1399 { 1400 return AH_FALSE; 1401 } 1402 1403 /* 1404 * Return what percentage of the extension channel is busy. 1405 * This is always disabled for AR5212 series NICs. 1406 */ 1407 uint32_t 1408 ar5212Get11nExtBusy(struct ath_hal *ah) 1409 { 1410 return 0; 1411 } 1412 1413 /* 1414 * Channel survey support. 1415 */ 1416 HAL_BOOL 1417 ar5212GetMibCycleCounts(struct ath_hal *ah, HAL_SURVEY_SAMPLE *hsample) 1418 { 1419 struct ath_hal_5212 *ahp = AH5212(ah); 1420 u_int32_t good = AH_TRUE; 1421 1422 /* XXX freeze/unfreeze mib counters */ 1423 uint32_t rc = OS_REG_READ(ah, AR_RCCNT); 1424 uint32_t rf = OS_REG_READ(ah, AR_RFCNT); 1425 uint32_t tf = OS_REG_READ(ah, AR_TFCNT); 1426 uint32_t cc = OS_REG_READ(ah, AR_CCCNT); /* read cycles last */ 1427 1428 if (ahp->ah_cycleCount == 0 || ahp->ah_cycleCount > cc) { 1429 /* 1430 * Cycle counter wrap (or initial call); it's not possible 1431 * to accurately calculate a value because the registers 1432 * right shift rather than wrap--so punt and return 0. 1433 */ 1434 HALDEBUG(ah, HAL_DEBUG_ANY, 1435 "%s: cycle counter wrap. ExtBusy = 0\n", __func__); 1436 good = AH_FALSE; 1437 } else { 1438 hsample->cycle_count = cc - ahp->ah_cycleCount; 1439 hsample->chan_busy = rc - ahp->ah_ctlBusy; 1440 hsample->ext_chan_busy = 0; 1441 hsample->rx_busy = rf - ahp->ah_rxBusy; 1442 hsample->tx_busy = tf - ahp->ah_txBusy; 1443 } 1444 1445 /* 1446 * Keep a copy of the MIB results so the next sample has something 1447 * to work from. 1448 */ 1449 ahp->ah_cycleCount = cc; 1450 ahp->ah_rxBusy = rf; 1451 ahp->ah_ctlBusy = rc; 1452 ahp->ah_txBusy = tf; 1453 1454 return (good); 1455 } 1456 1457 void 1458 ar5212SetChainMasks(struct ath_hal *ah, uint32_t tx_chainmask, 1459 uint32_t rx_chainmask) 1460 { 1461 } 1462