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_eeprom.h" /* for 5ghz fast clock flag */ 27 28 #include "ar5416/ar5416reg.h" /* NB: includes ar5212reg.h */ 29 #include "ar9003/ar9300_devid.h" 30 31 /* linker set of registered chips */ 32 OS_SET_DECLARE(ah_chips, struct ath_hal_chip); 33 TAILQ_HEAD(, ath_hal_chip) ah_chip_list = TAILQ_HEAD_INITIALIZER(ah_chip_list); 34 35 int 36 ath_hal_add_chip(struct ath_hal_chip *ahc) 37 { 38 39 TAILQ_INSERT_TAIL(&ah_chip_list, ahc, node); 40 return (0); 41 } 42 43 int 44 ath_hal_remove_chip(struct ath_hal_chip *ahc) 45 { 46 47 TAILQ_REMOVE(&ah_chip_list, ahc, node); 48 return (0); 49 } 50 51 /* 52 * Check the set of registered chips to see if any recognize 53 * the device as one they can support. 54 */ 55 const char* 56 ath_hal_probe(uint16_t vendorid, uint16_t devid) 57 { 58 struct ath_hal_chip * const *pchip; 59 struct ath_hal_chip *pc; 60 61 /* Linker set */ 62 OS_SET_FOREACH(pchip, ah_chips) { 63 const char *name = (*pchip)->probe(vendorid, devid); 64 if (name != AH_NULL) 65 return name; 66 } 67 68 /* List */ 69 TAILQ_FOREACH(pc, &ah_chip_list, node) { 70 const char *name = pc->probe(vendorid, devid); 71 if (name != AH_NULL) 72 return name; 73 } 74 75 return AH_NULL; 76 } 77 78 /* 79 * Attach detects device chip revisions, initializes the hwLayer 80 * function list, reads EEPROM information, 81 * selects reset vectors, and performs a short self test. 82 * Any failures will return an error that should cause a hardware 83 * disable. 84 */ 85 struct ath_hal* 86 ath_hal_attach(uint16_t devid, HAL_SOFTC sc, 87 HAL_BUS_TAG st, HAL_BUS_HANDLE sh, uint16_t *eepromdata, 88 HAL_OPS_CONFIG *ah_config, 89 HAL_STATUS *error) 90 { 91 struct ath_hal_chip * const *pchip; 92 struct ath_hal_chip *pc; 93 94 OS_SET_FOREACH(pchip, ah_chips) { 95 struct ath_hal_chip *chip = *pchip; 96 struct ath_hal *ah; 97 98 /* XXX don't have vendorid, assume atheros one works */ 99 if (chip->probe(ATHEROS_VENDOR_ID, devid) == AH_NULL) 100 continue; 101 ah = chip->attach(devid, sc, st, sh, eepromdata, ah_config, 102 error); 103 if (ah != AH_NULL) { 104 /* copy back private state to public area */ 105 ah->ah_devid = AH_PRIVATE(ah)->ah_devid; 106 ah->ah_subvendorid = AH_PRIVATE(ah)->ah_subvendorid; 107 ah->ah_macVersion = AH_PRIVATE(ah)->ah_macVersion; 108 ah->ah_macRev = AH_PRIVATE(ah)->ah_macRev; 109 ah->ah_phyRev = AH_PRIVATE(ah)->ah_phyRev; 110 ah->ah_analog5GhzRev = AH_PRIVATE(ah)->ah_analog5GhzRev; 111 ah->ah_analog2GhzRev = AH_PRIVATE(ah)->ah_analog2GhzRev; 112 return ah; 113 } 114 } 115 116 /* List */ 117 TAILQ_FOREACH(pc, &ah_chip_list, node) { 118 struct ath_hal_chip *chip = pc; 119 struct ath_hal *ah; 120 121 /* XXX don't have vendorid, assume atheros one works */ 122 if (chip->probe(ATHEROS_VENDOR_ID, devid) == AH_NULL) 123 continue; 124 ah = chip->attach(devid, sc, st, sh, eepromdata, ah_config, 125 error); 126 if (ah != AH_NULL) { 127 /* copy back private state to public area */ 128 ah->ah_devid = AH_PRIVATE(ah)->ah_devid; 129 ah->ah_subvendorid = AH_PRIVATE(ah)->ah_subvendorid; 130 ah->ah_macVersion = AH_PRIVATE(ah)->ah_macVersion; 131 ah->ah_macRev = AH_PRIVATE(ah)->ah_macRev; 132 ah->ah_phyRev = AH_PRIVATE(ah)->ah_phyRev; 133 ah->ah_analog5GhzRev = AH_PRIVATE(ah)->ah_analog5GhzRev; 134 ah->ah_analog2GhzRev = AH_PRIVATE(ah)->ah_analog2GhzRev; 135 return ah; 136 } 137 } 138 139 return AH_NULL; 140 } 141 142 const char * 143 ath_hal_mac_name(struct ath_hal *ah) 144 { 145 switch (ah->ah_macVersion) { 146 case AR_SREV_VERSION_CRETE: 147 case AR_SREV_VERSION_MAUI_1: 148 return "AR5210"; 149 case AR_SREV_VERSION_MAUI_2: 150 case AR_SREV_VERSION_OAHU: 151 return "AR5211"; 152 case AR_SREV_VERSION_VENICE: 153 return "AR5212"; 154 case AR_SREV_VERSION_GRIFFIN: 155 return "AR2413"; 156 case AR_SREV_VERSION_CONDOR: 157 return "AR5424"; 158 case AR_SREV_VERSION_EAGLE: 159 return "AR5413"; 160 case AR_SREV_VERSION_COBRA: 161 return "AR2415"; 162 case AR_SREV_2425: /* Swan */ 163 return "AR2425"; 164 case AR_SREV_2417: /* Nala */ 165 return "AR2417"; 166 case AR_XSREV_VERSION_OWL_PCI: 167 return "AR5416"; 168 case AR_XSREV_VERSION_OWL_PCIE: 169 return "AR5418"; 170 case AR_XSREV_VERSION_HOWL: 171 return "AR9130"; 172 case AR_XSREV_VERSION_SOWL: 173 return "AR9160"; 174 case AR_XSREV_VERSION_MERLIN: 175 if (AH_PRIVATE(ah)->ah_ispcie) 176 return "AR9280"; 177 return "AR9220"; 178 case AR_XSREV_VERSION_KITE: 179 return "AR9285"; 180 case AR_XSREV_VERSION_KIWI: 181 if (AH_PRIVATE(ah)->ah_ispcie) 182 return "AR9287"; 183 return "AR9227"; 184 case AR_SREV_VERSION_AR9380: 185 if (ah->ah_macRev >= AR_SREV_REVISION_AR9580_10) 186 return "AR9580"; 187 return "AR9380"; 188 case AR_SREV_VERSION_AR9460: 189 return "AR9460"; 190 case AR_SREV_VERSION_AR9330: 191 return "AR9330"; 192 case AR_SREV_VERSION_AR9340: 193 return "AR9340"; 194 case AR_SREV_VERSION_QCA9550: 195 return "QCA9550"; 196 case AR_SREV_VERSION_AR9485: 197 return "AR9485"; 198 case AR_SREV_VERSION_QCA9565: 199 return "QCA9565"; 200 case AR_SREV_VERSION_QCA9530: 201 return "QCA9530"; 202 } 203 return "????"; 204 } 205 206 /* 207 * Return the mask of available modes based on the hardware capabilities. 208 */ 209 u_int 210 ath_hal_getwirelessmodes(struct ath_hal*ah) 211 { 212 return ath_hal_getWirelessModes(ah); 213 } 214 215 /* linker set of registered RF backends */ 216 OS_SET_DECLARE(ah_rfs, struct ath_hal_rf); 217 TAILQ_HEAD(, ath_hal_rf) ah_rf_list = TAILQ_HEAD_INITIALIZER(ah_rf_list); 218 219 int 220 ath_hal_add_rf(struct ath_hal_rf *arf) 221 { 222 223 TAILQ_INSERT_TAIL(&ah_rf_list, arf, node); 224 return (0); 225 } 226 227 int 228 ath_hal_remove_rf(struct ath_hal_rf *arf) 229 { 230 231 TAILQ_REMOVE(&ah_rf_list, arf, node); 232 return (0); 233 } 234 235 /* 236 * Check the set of registered RF backends to see if 237 * any recognize the device as one they can support. 238 */ 239 struct ath_hal_rf * 240 ath_hal_rfprobe(struct ath_hal *ah, HAL_STATUS *ecode) 241 { 242 struct ath_hal_rf * const *prf; 243 struct ath_hal_rf * rf; 244 245 OS_SET_FOREACH(prf, ah_rfs) { 246 struct ath_hal_rf *rf = *prf; 247 if (rf->probe(ah)) 248 return rf; 249 } 250 251 TAILQ_FOREACH(rf, &ah_rf_list, node) { 252 if (rf->probe(ah)) 253 return rf; 254 } 255 *ecode = HAL_ENOTSUPP; 256 return AH_NULL; 257 } 258 259 const char * 260 ath_hal_rf_name(struct ath_hal *ah) 261 { 262 switch (ah->ah_analog5GhzRev & AR_RADIO_SREV_MAJOR) { 263 case 0: /* 5210 */ 264 return "5110"; /* NB: made up */ 265 case AR_RAD5111_SREV_MAJOR: 266 case AR_RAD5111_SREV_PROD: 267 return "5111"; 268 case AR_RAD2111_SREV_MAJOR: 269 return "2111"; 270 case AR_RAD5112_SREV_MAJOR: 271 case AR_RAD5112_SREV_2_0: 272 case AR_RAD5112_SREV_2_1: 273 return "5112"; 274 case AR_RAD2112_SREV_MAJOR: 275 case AR_RAD2112_SREV_2_0: 276 case AR_RAD2112_SREV_2_1: 277 return "2112"; 278 case AR_RAD2413_SREV_MAJOR: 279 return "2413"; 280 case AR_RAD5413_SREV_MAJOR: 281 return "5413"; 282 case AR_RAD2316_SREV_MAJOR: 283 return "2316"; 284 case AR_RAD2317_SREV_MAJOR: 285 return "2317"; 286 case AR_RAD5424_SREV_MAJOR: 287 return "5424"; 288 289 case AR_RAD5133_SREV_MAJOR: 290 return "5133"; 291 case AR_RAD2133_SREV_MAJOR: 292 return "2133"; 293 case AR_RAD5122_SREV_MAJOR: 294 return "5122"; 295 case AR_RAD2122_SREV_MAJOR: 296 return "2122"; 297 } 298 return "????"; 299 } 300 301 /* 302 * Poll the register looking for a specific value. 303 */ 304 HAL_BOOL 305 ath_hal_wait(struct ath_hal *ah, u_int reg, uint32_t mask, uint32_t val) 306 { 307 #define AH_TIMEOUT 5000 308 return ath_hal_waitfor(ah, reg, mask, val, AH_TIMEOUT); 309 #undef AH_TIMEOUT 310 } 311 312 HAL_BOOL 313 ath_hal_waitfor(struct ath_hal *ah, u_int reg, uint32_t mask, uint32_t val, uint32_t timeout) 314 { 315 int i; 316 317 for (i = 0; i < timeout; i++) { 318 if ((OS_REG_READ(ah, reg) & mask) == val) 319 return AH_TRUE; 320 OS_DELAY(10); 321 } 322 HALDEBUG(ah, HAL_DEBUG_REGIO | HAL_DEBUG_PHYIO, 323 "%s: timeout on reg 0x%x: 0x%08x & 0x%08x != 0x%08x\n", 324 __func__, reg, OS_REG_READ(ah, reg), mask, val); 325 return AH_FALSE; 326 } 327 328 /* 329 * Reverse the bits starting at the low bit for a value of 330 * bit_count in size 331 */ 332 uint32_t 333 ath_hal_reverseBits(uint32_t val, uint32_t n) 334 { 335 uint32_t retval; 336 int i; 337 338 for (i = 0, retval = 0; i < n; i++) { 339 retval = (retval << 1) | (val & 1); 340 val >>= 1; 341 } 342 return retval; 343 } 344 345 /* 802.11n related timing definitions */ 346 347 #define OFDM_PLCP_BITS 22 348 #define HT_L_STF 8 349 #define HT_L_LTF 8 350 #define HT_L_SIG 4 351 #define HT_SIG 8 352 #define HT_STF 4 353 #define HT_LTF(n) ((n) * 4) 354 355 #define HT_RC_2_MCS(_rc) ((_rc) & 0x1f) 356 #define HT_RC_2_STREAMS(_rc) ((((_rc) & 0x78) >> 3) + 1) 357 #define IS_HT_RATE(_rc) ( (_rc) & IEEE80211_RATE_MCS) 358 359 /* 360 * Calculate the duration of a packet whether it is 11n or legacy. 361 */ 362 uint32_t 363 ath_hal_pkt_txtime(struct ath_hal *ah, const HAL_RATE_TABLE *rates, uint32_t frameLen, 364 uint16_t rateix, HAL_BOOL isht40, HAL_BOOL shortPreamble, 365 HAL_BOOL includeSifs) 366 { 367 uint8_t rc; 368 int numStreams; 369 370 rc = rates->info[rateix].rateCode; 371 372 /* Legacy rate? Return the old way */ 373 if (! IS_HT_RATE(rc)) 374 return ath_hal_computetxtime(ah, rates, frameLen, rateix, 375 shortPreamble, includeSifs); 376 377 /* 11n frame - extract out the number of spatial streams */ 378 numStreams = HT_RC_2_STREAMS(rc); 379 KASSERT(numStreams > 0 && numStreams <= 4, 380 ("number of spatial streams needs to be 1..3: MCS rate 0x%x!", 381 rateix)); 382 383 /* XXX TODO: Add SIFS */ 384 return ath_computedur_ht(frameLen, rc, numStreams, isht40, 385 shortPreamble); 386 } 387 388 static const uint16_t ht20_bps[32] = { 389 26, 52, 78, 104, 156, 208, 234, 260, 390 52, 104, 156, 208, 312, 416, 468, 520, 391 78, 156, 234, 312, 468, 624, 702, 780, 392 104, 208, 312, 416, 624, 832, 936, 1040 393 }; 394 static const uint16_t ht40_bps[32] = { 395 54, 108, 162, 216, 324, 432, 486, 540, 396 108, 216, 324, 432, 648, 864, 972, 1080, 397 162, 324, 486, 648, 972, 1296, 1458, 1620, 398 216, 432, 648, 864, 1296, 1728, 1944, 2160 399 }; 400 401 /* 402 * Calculate the transmit duration of an 11n frame. 403 */ 404 uint32_t 405 ath_computedur_ht(uint32_t frameLen, uint16_t rate, int streams, 406 HAL_BOOL isht40, HAL_BOOL isShortGI) 407 { 408 uint32_t bitsPerSymbol, numBits, numSymbols, txTime; 409 410 KASSERT(rate & IEEE80211_RATE_MCS, ("not mcs %d", rate)); 411 KASSERT((rate &~ IEEE80211_RATE_MCS) < 31, ("bad mcs 0x%x", rate)); 412 413 if (isht40) 414 bitsPerSymbol = ht40_bps[HT_RC_2_MCS(rate)]; 415 else 416 bitsPerSymbol = ht20_bps[HT_RC_2_MCS(rate)]; 417 numBits = OFDM_PLCP_BITS + (frameLen << 3); 418 numSymbols = howmany(numBits, bitsPerSymbol); 419 if (isShortGI) 420 txTime = ((numSymbols * 18) + 4) / 5; /* 3.6us */ 421 else 422 txTime = numSymbols * 4; /* 4us */ 423 return txTime + HT_L_STF + HT_L_LTF + 424 HT_L_SIG + HT_SIG + HT_STF + HT_LTF(streams); 425 } 426 427 /* 428 * Compute the time to transmit a frame of length frameLen bytes 429 * using the specified rate, phy, and short preamble setting. 430 */ 431 uint16_t 432 ath_hal_computetxtime(struct ath_hal *ah, 433 const HAL_RATE_TABLE *rates, uint32_t frameLen, uint16_t rateix, 434 HAL_BOOL shortPreamble, HAL_BOOL includeSifs) 435 { 436 uint32_t bitsPerSymbol, numBits, numSymbols, phyTime, txTime; 437 uint32_t kbps; 438 439 /* Warn if this function is called for 11n rates; it should not be! */ 440 if (IS_HT_RATE(rates->info[rateix].rateCode)) 441 ath_hal_printf(ah, "%s: MCS rate? (index %d; hwrate 0x%x)\n", 442 __func__, rateix, rates->info[rateix].rateCode); 443 444 kbps = rates->info[rateix].rateKbps; 445 /* 446 * index can be invalid during dynamic Turbo transitions. 447 * XXX 448 */ 449 if (kbps == 0) 450 return 0; 451 switch (rates->info[rateix].phy) { 452 case IEEE80211_T_CCK: 453 phyTime = CCK_PREAMBLE_BITS + CCK_PLCP_BITS; 454 if (shortPreamble && rates->info[rateix].shortPreamble) 455 phyTime >>= 1; 456 numBits = frameLen << 3; 457 txTime = phyTime 458 + ((numBits * 1000)/kbps); 459 if (includeSifs) 460 txTime += CCK_SIFS_TIME; 461 break; 462 case IEEE80211_T_OFDM: 463 bitsPerSymbol = (kbps * OFDM_SYMBOL_TIME) / 1000; 464 HALASSERT(bitsPerSymbol != 0); 465 466 numBits = OFDM_PLCP_BITS + (frameLen << 3); 467 numSymbols = howmany(numBits, bitsPerSymbol); 468 txTime = OFDM_PREAMBLE_TIME 469 + (numSymbols * OFDM_SYMBOL_TIME); 470 if (includeSifs) 471 txTime += OFDM_SIFS_TIME; 472 break; 473 case IEEE80211_T_OFDM_HALF: 474 bitsPerSymbol = (kbps * OFDM_HALF_SYMBOL_TIME) / 1000; 475 HALASSERT(bitsPerSymbol != 0); 476 477 numBits = OFDM_HALF_PLCP_BITS + (frameLen << 3); 478 numSymbols = howmany(numBits, bitsPerSymbol); 479 txTime = OFDM_HALF_PREAMBLE_TIME 480 + (numSymbols * OFDM_HALF_SYMBOL_TIME); 481 if (includeSifs) 482 txTime += OFDM_HALF_SIFS_TIME; 483 break; 484 case IEEE80211_T_OFDM_QUARTER: 485 bitsPerSymbol = (kbps * OFDM_QUARTER_SYMBOL_TIME) / 1000; 486 HALASSERT(bitsPerSymbol != 0); 487 488 numBits = OFDM_QUARTER_PLCP_BITS + (frameLen << 3); 489 numSymbols = howmany(numBits, bitsPerSymbol); 490 txTime = OFDM_QUARTER_PREAMBLE_TIME 491 + (numSymbols * OFDM_QUARTER_SYMBOL_TIME); 492 if (includeSifs) 493 txTime += OFDM_QUARTER_SIFS_TIME; 494 break; 495 case IEEE80211_T_TURBO: 496 bitsPerSymbol = (kbps * TURBO_SYMBOL_TIME) / 1000; 497 HALASSERT(bitsPerSymbol != 0); 498 499 numBits = TURBO_PLCP_BITS + (frameLen << 3); 500 numSymbols = howmany(numBits, bitsPerSymbol); 501 txTime = TURBO_PREAMBLE_TIME 502 + (numSymbols * TURBO_SYMBOL_TIME); 503 if (includeSifs) 504 txTime += TURBO_SIFS_TIME; 505 break; 506 default: 507 HALDEBUG(ah, HAL_DEBUG_PHYIO, 508 "%s: unknown phy %u (rate ix %u)\n", 509 __func__, rates->info[rateix].phy, rateix); 510 txTime = 0; 511 break; 512 } 513 return txTime; 514 } 515 516 int 517 ath_hal_get_curmode(struct ath_hal *ah, const struct ieee80211_channel *chan) 518 { 519 /* 520 * Pick a default mode at bootup. A channel change is inevitable. 521 */ 522 if (!chan) 523 return HAL_MODE_11NG_HT20; 524 525 if (IEEE80211_IS_CHAN_TURBO(chan)) 526 return HAL_MODE_TURBO; 527 528 /* check for NA_HT before plain A, since IS_CHAN_A includes NA_HT */ 529 if (IEEE80211_IS_CHAN_5GHZ(chan) && IEEE80211_IS_CHAN_HT20(chan)) 530 return HAL_MODE_11NA_HT20; 531 if (IEEE80211_IS_CHAN_5GHZ(chan) && IEEE80211_IS_CHAN_HT40U(chan)) 532 return HAL_MODE_11NA_HT40PLUS; 533 if (IEEE80211_IS_CHAN_5GHZ(chan) && IEEE80211_IS_CHAN_HT40D(chan)) 534 return HAL_MODE_11NA_HT40MINUS; 535 if (IEEE80211_IS_CHAN_A(chan)) 536 return HAL_MODE_11A; 537 538 /* check for NG_HT before plain G, since IS_CHAN_G includes NG_HT */ 539 if (IEEE80211_IS_CHAN_2GHZ(chan) && IEEE80211_IS_CHAN_HT20(chan)) 540 return HAL_MODE_11NG_HT20; 541 if (IEEE80211_IS_CHAN_2GHZ(chan) && IEEE80211_IS_CHAN_HT40U(chan)) 542 return HAL_MODE_11NG_HT40PLUS; 543 if (IEEE80211_IS_CHAN_2GHZ(chan) && IEEE80211_IS_CHAN_HT40D(chan)) 544 return HAL_MODE_11NG_HT40MINUS; 545 546 /* 547 * XXX For FreeBSD, will this work correctly given the DYN 548 * chan mode (OFDM+CCK dynamic) ? We have pure-G versions DYN-BG.. 549 */ 550 if (IEEE80211_IS_CHAN_G(chan)) 551 return HAL_MODE_11G; 552 if (IEEE80211_IS_CHAN_B(chan)) 553 return HAL_MODE_11B; 554 555 HALASSERT(0); 556 return HAL_MODE_11NG_HT20; 557 } 558 559 560 typedef enum { 561 WIRELESS_MODE_11a = 0, 562 WIRELESS_MODE_TURBO = 1, 563 WIRELESS_MODE_11b = 2, 564 WIRELESS_MODE_11g = 3, 565 WIRELESS_MODE_108g = 4, 566 567 WIRELESS_MODE_MAX 568 } WIRELESS_MODE; 569 570 /* 571 * XXX TODO: for some (?) chips, an 11b mode still runs at 11bg. 572 * Maybe AR5211 has separate 11b and 11g only modes, so 11b is 22MHz 573 * and 11g is 44MHz, but AR5416 and later run 11b in 11bg mode, right? 574 */ 575 static WIRELESS_MODE 576 ath_hal_chan2wmode(struct ath_hal *ah, const struct ieee80211_channel *chan) 577 { 578 if (IEEE80211_IS_CHAN_B(chan)) 579 return WIRELESS_MODE_11b; 580 if (IEEE80211_IS_CHAN_G(chan)) 581 return WIRELESS_MODE_11g; 582 if (IEEE80211_IS_CHAN_108G(chan)) 583 return WIRELESS_MODE_108g; 584 if (IEEE80211_IS_CHAN_TURBO(chan)) 585 return WIRELESS_MODE_TURBO; 586 return WIRELESS_MODE_11a; 587 } 588 589 /* 590 * Convert between microseconds and core system clocks. 591 */ 592 /* 11a Turbo 11b 11g 108g */ 593 static const uint8_t CLOCK_RATE[] = { 40, 80, 22, 44, 88 }; 594 595 #define CLOCK_FAST_RATE_5GHZ_OFDM 44 596 597 u_int 598 ath_hal_mac_clks(struct ath_hal *ah, u_int usecs) 599 { 600 const struct ieee80211_channel *c = AH_PRIVATE(ah)->ah_curchan; 601 u_int clks; 602 603 /* NB: ah_curchan may be null when called attach time */ 604 /* XXX merlin and later specific workaround - 5ghz fast clock is 44 */ 605 if (c != AH_NULL && IS_5GHZ_FAST_CLOCK_EN(ah, c)) { 606 clks = usecs * CLOCK_FAST_RATE_5GHZ_OFDM; 607 if (IEEE80211_IS_CHAN_HT40(c)) 608 clks <<= 1; 609 } else if (c != AH_NULL) { 610 clks = usecs * CLOCK_RATE[ath_hal_chan2wmode(ah, c)]; 611 if (IEEE80211_IS_CHAN_HT40(c)) 612 clks <<= 1; 613 } else 614 clks = usecs * CLOCK_RATE[WIRELESS_MODE_11b]; 615 616 /* Compensate for half/quarter rate */ 617 if (c != AH_NULL && IEEE80211_IS_CHAN_HALF(c)) 618 clks = clks / 2; 619 else if (c != AH_NULL && IEEE80211_IS_CHAN_QUARTER(c)) 620 clks = clks / 4; 621 622 return clks; 623 } 624 625 u_int 626 ath_hal_mac_usec(struct ath_hal *ah, u_int clks) 627 { 628 uint64_t psec; 629 630 psec = ath_hal_mac_psec(ah, clks); 631 return (psec / 1000000); 632 } 633 634 /* 635 * XXX TODO: half, quarter rates. 636 */ 637 uint64_t 638 ath_hal_mac_psec(struct ath_hal *ah, u_int clks) 639 { 640 const struct ieee80211_channel *c = AH_PRIVATE(ah)->ah_curchan; 641 uint64_t psec; 642 643 /* NB: ah_curchan may be null when called attach time */ 644 /* XXX merlin and later specific workaround - 5ghz fast clock is 44 */ 645 if (c != AH_NULL && IS_5GHZ_FAST_CLOCK_EN(ah, c)) { 646 psec = (clks * 1000000ULL) / CLOCK_FAST_RATE_5GHZ_OFDM; 647 if (IEEE80211_IS_CHAN_HT40(c)) 648 psec >>= 1; 649 } else if (c != AH_NULL) { 650 psec = (clks * 1000000ULL) / CLOCK_RATE[ath_hal_chan2wmode(ah, c)]; 651 if (IEEE80211_IS_CHAN_HT40(c)) 652 psec >>= 1; 653 } else 654 psec = (clks * 1000000ULL) / CLOCK_RATE[WIRELESS_MODE_11b]; 655 return psec; 656 } 657 658 /* 659 * Setup a h/w rate table's reverse lookup table and 660 * fill in ack durations. This routine is called for 661 * each rate table returned through the ah_getRateTable 662 * method. The reverse lookup tables are assumed to be 663 * initialized to zero (or at least the first entry). 664 * We use this as a key that indicates whether or not 665 * we've previously setup the reverse lookup table. 666 * 667 * XXX not reentrant, but shouldn't matter 668 */ 669 void 670 ath_hal_setupratetable(struct ath_hal *ah, HAL_RATE_TABLE *rt) 671 { 672 #define N(a) (sizeof(a)/sizeof(a[0])) 673 int i; 674 675 if (rt->rateCodeToIndex[0] != 0) /* already setup */ 676 return; 677 for (i = 0; i < N(rt->rateCodeToIndex); i++) 678 rt->rateCodeToIndex[i] = (uint8_t) -1; 679 for (i = 0; i < rt->rateCount; i++) { 680 uint8_t code = rt->info[i].rateCode; 681 uint8_t cix = rt->info[i].controlRate; 682 683 HALASSERT(code < N(rt->rateCodeToIndex)); 684 rt->rateCodeToIndex[code] = i; 685 HALASSERT((code | rt->info[i].shortPreamble) < 686 N(rt->rateCodeToIndex)); 687 rt->rateCodeToIndex[code | rt->info[i].shortPreamble] = i; 688 /* 689 * XXX for 11g the control rate to use for 5.5 and 11 Mb/s 690 * depends on whether they are marked as basic rates; 691 * the static tables are setup with an 11b-compatible 692 * 2Mb/s rate which will work but is suboptimal 693 */ 694 rt->info[i].lpAckDuration = ath_hal_computetxtime(ah, rt, 695 WLAN_CTRL_FRAME_SIZE, cix, AH_FALSE, AH_TRUE); 696 rt->info[i].spAckDuration = ath_hal_computetxtime(ah, rt, 697 WLAN_CTRL_FRAME_SIZE, cix, AH_TRUE, AH_TRUE); 698 } 699 #undef N 700 } 701 702 HAL_STATUS 703 ath_hal_getcapability(struct ath_hal *ah, HAL_CAPABILITY_TYPE type, 704 uint32_t capability, uint32_t *result) 705 { 706 const HAL_CAPABILITIES *pCap = &AH_PRIVATE(ah)->ah_caps; 707 708 switch (type) { 709 case HAL_CAP_REG_DMN: /* regulatory domain */ 710 *result = AH_PRIVATE(ah)->ah_currentRD; 711 return HAL_OK; 712 case HAL_CAP_DFS_DMN: /* DFS Domain */ 713 *result = AH_PRIVATE(ah)->ah_dfsDomain; 714 return HAL_OK; 715 case HAL_CAP_CIPHER: /* cipher handled in hardware */ 716 case HAL_CAP_TKIP_MIC: /* handle TKIP MIC in hardware */ 717 return HAL_ENOTSUPP; 718 case HAL_CAP_TKIP_SPLIT: /* hardware TKIP uses split keys */ 719 return HAL_ENOTSUPP; 720 case HAL_CAP_PHYCOUNTERS: /* hardware PHY error counters */ 721 return pCap->halHwPhyCounterSupport ? HAL_OK : HAL_ENXIO; 722 case HAL_CAP_WME_TKIPMIC: /* hardware can do TKIP MIC when WMM is turned on */ 723 return HAL_ENOTSUPP; 724 case HAL_CAP_DIVERSITY: /* hardware supports fast diversity */ 725 return HAL_ENOTSUPP; 726 case HAL_CAP_KEYCACHE_SIZE: /* hardware key cache size */ 727 *result = pCap->halKeyCacheSize; 728 return HAL_OK; 729 case HAL_CAP_NUM_TXQUEUES: /* number of hardware tx queues */ 730 *result = pCap->halTotalQueues; 731 return HAL_OK; 732 case HAL_CAP_VEOL: /* hardware supports virtual EOL */ 733 return pCap->halVEOLSupport ? HAL_OK : HAL_ENOTSUPP; 734 case HAL_CAP_PSPOLL: /* hardware PS-Poll support works */ 735 return pCap->halPSPollBroken ? HAL_ENOTSUPP : HAL_OK; 736 case HAL_CAP_COMPRESSION: 737 return pCap->halCompressSupport ? HAL_OK : HAL_ENOTSUPP; 738 case HAL_CAP_BURST: 739 return pCap->halBurstSupport ? HAL_OK : HAL_ENOTSUPP; 740 case HAL_CAP_FASTFRAME: 741 return pCap->halFastFramesSupport ? HAL_OK : HAL_ENOTSUPP; 742 case HAL_CAP_DIAG: /* hardware diagnostic support */ 743 *result = AH_PRIVATE(ah)->ah_diagreg; 744 return HAL_OK; 745 case HAL_CAP_TXPOW: /* global tx power limit */ 746 switch (capability) { 747 case 0: /* facility is supported */ 748 return HAL_OK; 749 case 1: /* current limit */ 750 *result = AH_PRIVATE(ah)->ah_powerLimit; 751 return HAL_OK; 752 case 2: /* current max tx power */ 753 *result = AH_PRIVATE(ah)->ah_maxPowerLevel; 754 return HAL_OK; 755 case 3: /* scale factor */ 756 *result = AH_PRIVATE(ah)->ah_tpScale; 757 return HAL_OK; 758 } 759 return HAL_ENOTSUPP; 760 case HAL_CAP_BSSIDMASK: /* hardware supports bssid mask */ 761 return pCap->halBssIdMaskSupport ? HAL_OK : HAL_ENOTSUPP; 762 case HAL_CAP_MCAST_KEYSRCH: /* multicast frame keycache search */ 763 return pCap->halMcastKeySrchSupport ? HAL_OK : HAL_ENOTSUPP; 764 case HAL_CAP_TSF_ADJUST: /* hardware has beacon tsf adjust */ 765 return HAL_ENOTSUPP; 766 case HAL_CAP_RFSILENT: /* rfsilent support */ 767 switch (capability) { 768 case 0: /* facility is supported */ 769 return pCap->halRfSilentSupport ? HAL_OK : HAL_ENOTSUPP; 770 case 1: /* current setting */ 771 return AH_PRIVATE(ah)->ah_rfkillEnabled ? 772 HAL_OK : HAL_ENOTSUPP; 773 case 2: /* rfsilent config */ 774 *result = AH_PRIVATE(ah)->ah_rfsilent; 775 return HAL_OK; 776 } 777 return HAL_ENOTSUPP; 778 case HAL_CAP_11D: 779 return HAL_OK; 780 781 case HAL_CAP_HT: 782 return pCap->halHTSupport ? HAL_OK : HAL_ENOTSUPP; 783 case HAL_CAP_GTXTO: 784 return pCap->halGTTSupport ? HAL_OK : HAL_ENOTSUPP; 785 case HAL_CAP_FAST_CC: 786 return pCap->halFastCCSupport ? HAL_OK : HAL_ENOTSUPP; 787 case HAL_CAP_TX_CHAINMASK: /* mask of TX chains supported */ 788 *result = pCap->halTxChainMask; 789 return HAL_OK; 790 case HAL_CAP_RX_CHAINMASK: /* mask of RX chains supported */ 791 *result = pCap->halRxChainMask; 792 return HAL_OK; 793 case HAL_CAP_NUM_GPIO_PINS: 794 *result = pCap->halNumGpioPins; 795 return HAL_OK; 796 case HAL_CAP_CST: 797 return pCap->halCSTSupport ? HAL_OK : HAL_ENOTSUPP; 798 case HAL_CAP_RTS_AGGR_LIMIT: 799 *result = pCap->halRtsAggrLimit; 800 return HAL_OK; 801 case HAL_CAP_4ADDR_AGGR: 802 return pCap->hal4AddrAggrSupport ? HAL_OK : HAL_ENOTSUPP; 803 case HAL_CAP_EXT_CHAN_DFS: 804 return pCap->halExtChanDfsSupport ? HAL_OK : HAL_ENOTSUPP; 805 case HAL_CAP_RX_STBC: 806 return pCap->halRxStbcSupport ? HAL_OK : HAL_ENOTSUPP; 807 case HAL_CAP_TX_STBC: 808 return pCap->halTxStbcSupport ? HAL_OK : HAL_ENOTSUPP; 809 case HAL_CAP_COMBINED_RADAR_RSSI: 810 return pCap->halUseCombinedRadarRssi ? HAL_OK : HAL_ENOTSUPP; 811 case HAL_CAP_AUTO_SLEEP: 812 return pCap->halAutoSleepSupport ? HAL_OK : HAL_ENOTSUPP; 813 case HAL_CAP_MBSSID_AGGR_SUPPORT: 814 return pCap->halMbssidAggrSupport ? HAL_OK : HAL_ENOTSUPP; 815 case HAL_CAP_SPLIT_4KB_TRANS: /* hardware handles descriptors straddling 4k page boundary */ 816 return pCap->hal4kbSplitTransSupport ? HAL_OK : HAL_ENOTSUPP; 817 case HAL_CAP_REG_FLAG: 818 *result = AH_PRIVATE(ah)->ah_currentRDext; 819 return HAL_OK; 820 case HAL_CAP_ENHANCED_DMA_SUPPORT: 821 return pCap->halEnhancedDmaSupport ? HAL_OK : HAL_ENOTSUPP; 822 case HAL_CAP_NUM_TXMAPS: 823 *result = pCap->halNumTxMaps; 824 return HAL_OK; 825 case HAL_CAP_TXDESCLEN: 826 *result = pCap->halTxDescLen; 827 return HAL_OK; 828 case HAL_CAP_TXSTATUSLEN: 829 *result = pCap->halTxStatusLen; 830 return HAL_OK; 831 case HAL_CAP_RXSTATUSLEN: 832 *result = pCap->halRxStatusLen; 833 return HAL_OK; 834 case HAL_CAP_RXFIFODEPTH: 835 switch (capability) { 836 case HAL_RX_QUEUE_HP: 837 *result = pCap->halRxHpFifoDepth; 838 return HAL_OK; 839 case HAL_RX_QUEUE_LP: 840 *result = pCap->halRxLpFifoDepth; 841 return HAL_OK; 842 default: 843 return HAL_ENOTSUPP; 844 } 845 case HAL_CAP_RXBUFSIZE: 846 case HAL_CAP_NUM_MR_RETRIES: 847 *result = pCap->halNumMRRetries; 848 return HAL_OK; 849 case HAL_CAP_BT_COEX: 850 return pCap->halBtCoexSupport ? HAL_OK : HAL_ENOTSUPP; 851 case HAL_CAP_SPECTRAL_SCAN: 852 return pCap->halSpectralScanSupport ? HAL_OK : HAL_ENOTSUPP; 853 case HAL_CAP_HT20_SGI: 854 return pCap->halHTSGI20Support ? HAL_OK : HAL_ENOTSUPP; 855 case HAL_CAP_RXTSTAMP_PREC: /* rx desc tstamp precision (bits) */ 856 *result = pCap->halRxTstampPrecision; 857 return HAL_OK; 858 case HAL_CAP_ANT_DIV_COMB: /* AR9285/AR9485 LNA diversity */ 859 return pCap->halAntDivCombSupport ? HAL_OK : HAL_ENOTSUPP; 860 861 case HAL_CAP_ENHANCED_DFS_SUPPORT: 862 return pCap->halEnhancedDfsSupport ? HAL_OK : HAL_ENOTSUPP; 863 864 /* FreeBSD-specific entries for now */ 865 case HAL_CAP_RXORN_FATAL: /* HAL_INT_RXORN treated as fatal */ 866 return AH_PRIVATE(ah)->ah_rxornIsFatal ? HAL_OK : HAL_ENOTSUPP; 867 case HAL_CAP_INTRMASK: /* mask of supported interrupts */ 868 *result = pCap->halIntrMask; 869 return HAL_OK; 870 case HAL_CAP_BSSIDMATCH: /* hardware has disable bssid match */ 871 return pCap->halBssidMatchSupport ? HAL_OK : HAL_ENOTSUPP; 872 case HAL_CAP_STREAMS: /* number of 11n spatial streams */ 873 switch (capability) { 874 case 0: /* TX */ 875 *result = pCap->halTxStreams; 876 return HAL_OK; 877 case 1: /* RX */ 878 *result = pCap->halRxStreams; 879 return HAL_OK; 880 default: 881 return HAL_ENOTSUPP; 882 } 883 case HAL_CAP_RXDESC_SELFLINK: /* hardware supports self-linked final RX descriptors correctly */ 884 return pCap->halHasRxSelfLinkedTail ? HAL_OK : HAL_ENOTSUPP; 885 case HAL_CAP_BB_READ_WAR: /* Baseband read WAR */ 886 return pCap->halHasBBReadWar? HAL_OK : HAL_ENOTSUPP; 887 case HAL_CAP_SERIALISE_WAR: /* PCI register serialisation */ 888 return pCap->halSerialiseRegWar ? HAL_OK : HAL_ENOTSUPP; 889 case HAL_CAP_MFP: /* Management frame protection setting */ 890 *result = pCap->halMfpSupport; 891 return HAL_OK; 892 case HAL_CAP_RX_LNA_MIXING: /* Hardware uses an RX LNA mixer to map 2 antennas to a 1 stream receiver */ 893 return pCap->halRxUsingLnaMixing ? HAL_OK : HAL_ENOTSUPP; 894 case HAL_CAP_DO_MYBEACON: /* Hardware supports filtering my-beacons */ 895 return pCap->halRxDoMyBeacon ? HAL_OK : HAL_ENOTSUPP; 896 case HAL_CAP_TXTSTAMP_PREC: /* tx desc tstamp precision (bits) */ 897 *result = pCap->halTxTstampPrecision; 898 return HAL_OK; 899 default: 900 return HAL_EINVAL; 901 } 902 } 903 904 HAL_BOOL 905 ath_hal_setcapability(struct ath_hal *ah, HAL_CAPABILITY_TYPE type, 906 uint32_t capability, uint32_t setting, HAL_STATUS *status) 907 { 908 909 switch (type) { 910 case HAL_CAP_TXPOW: 911 switch (capability) { 912 case 3: 913 if (setting <= HAL_TP_SCALE_MIN) { 914 AH_PRIVATE(ah)->ah_tpScale = setting; 915 return AH_TRUE; 916 } 917 break; 918 } 919 break; 920 case HAL_CAP_RFSILENT: /* rfsilent support */ 921 /* 922 * NB: allow even if halRfSilentSupport is false 923 * in case the EEPROM is misprogrammed. 924 */ 925 switch (capability) { 926 case 1: /* current setting */ 927 AH_PRIVATE(ah)->ah_rfkillEnabled = (setting != 0); 928 return AH_TRUE; 929 case 2: /* rfsilent config */ 930 /* XXX better done per-chip for validation? */ 931 AH_PRIVATE(ah)->ah_rfsilent = setting; 932 return AH_TRUE; 933 } 934 break; 935 case HAL_CAP_REG_DMN: /* regulatory domain */ 936 AH_PRIVATE(ah)->ah_currentRD = setting; 937 return AH_TRUE; 938 case HAL_CAP_RXORN_FATAL: /* HAL_INT_RXORN treated as fatal */ 939 AH_PRIVATE(ah)->ah_rxornIsFatal = setting; 940 return AH_TRUE; 941 default: 942 break; 943 } 944 if (status) 945 *status = HAL_EINVAL; 946 return AH_FALSE; 947 } 948 949 /* 950 * Common support for getDiagState method. 951 */ 952 953 static u_int 954 ath_hal_getregdump(struct ath_hal *ah, const HAL_REGRANGE *regs, 955 void *dstbuf, int space) 956 { 957 uint32_t *dp = dstbuf; 958 int i; 959 960 for (i = 0; space >= 2*sizeof(uint32_t); i++) { 961 uint32_t r = regs[i].start; 962 uint32_t e = regs[i].end; 963 *dp++ = r; 964 *dp++ = e; 965 space -= 2*sizeof(uint32_t); 966 do { 967 *dp++ = OS_REG_READ(ah, r); 968 r += sizeof(uint32_t); 969 space -= sizeof(uint32_t); 970 } while (r <= e && space >= sizeof(uint32_t)); 971 } 972 return (char *) dp - (char *) dstbuf; 973 } 974 975 static void 976 ath_hal_setregs(struct ath_hal *ah, const HAL_REGWRITE *regs, int space) 977 { 978 while (space >= sizeof(HAL_REGWRITE)) { 979 OS_REG_WRITE(ah, regs->addr, regs->value); 980 regs++, space -= sizeof(HAL_REGWRITE); 981 } 982 } 983 984 HAL_BOOL 985 ath_hal_getdiagstate(struct ath_hal *ah, int request, 986 const void *args, uint32_t argsize, 987 void **result, uint32_t *resultsize) 988 { 989 990 switch (request) { 991 case HAL_DIAG_REVS: 992 *result = &AH_PRIVATE(ah)->ah_devid; 993 *resultsize = sizeof(HAL_REVS); 994 return AH_TRUE; 995 case HAL_DIAG_REGS: 996 *resultsize = ath_hal_getregdump(ah, args, *result,*resultsize); 997 return AH_TRUE; 998 case HAL_DIAG_SETREGS: 999 ath_hal_setregs(ah, args, argsize); 1000 *resultsize = 0; 1001 return AH_TRUE; 1002 case HAL_DIAG_FATALERR: 1003 *result = &AH_PRIVATE(ah)->ah_fatalState[0]; 1004 *resultsize = sizeof(AH_PRIVATE(ah)->ah_fatalState); 1005 return AH_TRUE; 1006 case HAL_DIAG_EEREAD: 1007 if (argsize != sizeof(uint16_t)) 1008 return AH_FALSE; 1009 if (!ath_hal_eepromRead(ah, *(const uint16_t *)args, *result)) 1010 return AH_FALSE; 1011 *resultsize = sizeof(uint16_t); 1012 return AH_TRUE; 1013 #ifdef AH_PRIVATE_DIAG 1014 case HAL_DIAG_SETKEY: { 1015 const HAL_DIAG_KEYVAL *dk; 1016 1017 if (argsize != sizeof(HAL_DIAG_KEYVAL)) 1018 return AH_FALSE; 1019 dk = (const HAL_DIAG_KEYVAL *)args; 1020 return ah->ah_setKeyCacheEntry(ah, dk->dk_keyix, 1021 &dk->dk_keyval, dk->dk_mac, dk->dk_xor); 1022 } 1023 case HAL_DIAG_RESETKEY: 1024 if (argsize != sizeof(uint16_t)) 1025 return AH_FALSE; 1026 return ah->ah_resetKeyCacheEntry(ah, *(const uint16_t *)args); 1027 #ifdef AH_SUPPORT_WRITE_EEPROM 1028 case HAL_DIAG_EEWRITE: { 1029 const HAL_DIAG_EEVAL *ee; 1030 if (argsize != sizeof(HAL_DIAG_EEVAL)) 1031 return AH_FALSE; 1032 ee = (const HAL_DIAG_EEVAL *)args; 1033 return ath_hal_eepromWrite(ah, ee->ee_off, ee->ee_data); 1034 } 1035 #endif /* AH_SUPPORT_WRITE_EEPROM */ 1036 #endif /* AH_PRIVATE_DIAG */ 1037 case HAL_DIAG_11NCOMPAT: 1038 if (argsize == 0) { 1039 *resultsize = sizeof(uint32_t); 1040 *((uint32_t *)(*result)) = 1041 AH_PRIVATE(ah)->ah_11nCompat; 1042 } else if (argsize == sizeof(uint32_t)) { 1043 AH_PRIVATE(ah)->ah_11nCompat = *(const uint32_t *)args; 1044 } else 1045 return AH_FALSE; 1046 return AH_TRUE; 1047 case HAL_DIAG_CHANSURVEY: 1048 *result = &AH_PRIVATE(ah)->ah_chansurvey; 1049 *resultsize = sizeof(HAL_CHANNEL_SURVEY); 1050 return AH_TRUE; 1051 } 1052 return AH_FALSE; 1053 } 1054 1055 /* 1056 * Set the properties of the tx queue with the parameters 1057 * from qInfo. 1058 */ 1059 HAL_BOOL 1060 ath_hal_setTxQProps(struct ath_hal *ah, 1061 HAL_TX_QUEUE_INFO *qi, const HAL_TXQ_INFO *qInfo) 1062 { 1063 uint32_t cw; 1064 1065 if (qi->tqi_type == HAL_TX_QUEUE_INACTIVE) { 1066 HALDEBUG(ah, HAL_DEBUG_TXQUEUE, 1067 "%s: inactive queue\n", __func__); 1068 return AH_FALSE; 1069 } 1070 /* XXX validate parameters */ 1071 qi->tqi_ver = qInfo->tqi_ver; 1072 qi->tqi_subtype = qInfo->tqi_subtype; 1073 qi->tqi_qflags = qInfo->tqi_qflags; 1074 qi->tqi_priority = qInfo->tqi_priority; 1075 if (qInfo->tqi_aifs != HAL_TXQ_USEDEFAULT) 1076 qi->tqi_aifs = AH_MIN(qInfo->tqi_aifs, 255); 1077 else 1078 qi->tqi_aifs = INIT_AIFS; 1079 if (qInfo->tqi_cwmin != HAL_TXQ_USEDEFAULT) { 1080 cw = AH_MIN(qInfo->tqi_cwmin, 1024); 1081 /* make sure that the CWmin is of the form (2^n - 1) */ 1082 qi->tqi_cwmin = 1; 1083 while (qi->tqi_cwmin < cw) 1084 qi->tqi_cwmin = (qi->tqi_cwmin << 1) | 1; 1085 } else 1086 qi->tqi_cwmin = qInfo->tqi_cwmin; 1087 if (qInfo->tqi_cwmax != HAL_TXQ_USEDEFAULT) { 1088 cw = AH_MIN(qInfo->tqi_cwmax, 1024); 1089 /* make sure that the CWmax is of the form (2^n - 1) */ 1090 qi->tqi_cwmax = 1; 1091 while (qi->tqi_cwmax < cw) 1092 qi->tqi_cwmax = (qi->tqi_cwmax << 1) | 1; 1093 } else 1094 qi->tqi_cwmax = INIT_CWMAX; 1095 /* Set retry limit values */ 1096 if (qInfo->tqi_shretry != 0) 1097 qi->tqi_shretry = AH_MIN(qInfo->tqi_shretry, 15); 1098 else 1099 qi->tqi_shretry = INIT_SH_RETRY; 1100 if (qInfo->tqi_lgretry != 0) 1101 qi->tqi_lgretry = AH_MIN(qInfo->tqi_lgretry, 15); 1102 else 1103 qi->tqi_lgretry = INIT_LG_RETRY; 1104 qi->tqi_cbrPeriod = qInfo->tqi_cbrPeriod; 1105 qi->tqi_cbrOverflowLimit = qInfo->tqi_cbrOverflowLimit; 1106 qi->tqi_burstTime = qInfo->tqi_burstTime; 1107 qi->tqi_readyTime = qInfo->tqi_readyTime; 1108 1109 switch (qInfo->tqi_subtype) { 1110 case HAL_WME_UPSD: 1111 if (qi->tqi_type == HAL_TX_QUEUE_DATA) 1112 qi->tqi_intFlags = HAL_TXQ_USE_LOCKOUT_BKOFF_DIS; 1113 break; 1114 default: 1115 break; /* NB: silence compiler */ 1116 } 1117 return AH_TRUE; 1118 } 1119 1120 HAL_BOOL 1121 ath_hal_getTxQProps(struct ath_hal *ah, 1122 HAL_TXQ_INFO *qInfo, const HAL_TX_QUEUE_INFO *qi) 1123 { 1124 if (qi->tqi_type == HAL_TX_QUEUE_INACTIVE) { 1125 HALDEBUG(ah, HAL_DEBUG_TXQUEUE, 1126 "%s: inactive queue\n", __func__); 1127 return AH_FALSE; 1128 } 1129 1130 qInfo->tqi_ver = qi->tqi_ver; 1131 qInfo->tqi_subtype = qi->tqi_subtype; 1132 qInfo->tqi_qflags = qi->tqi_qflags; 1133 qInfo->tqi_priority = qi->tqi_priority; 1134 qInfo->tqi_aifs = qi->tqi_aifs; 1135 qInfo->tqi_cwmin = qi->tqi_cwmin; 1136 qInfo->tqi_cwmax = qi->tqi_cwmax; 1137 qInfo->tqi_shretry = qi->tqi_shretry; 1138 qInfo->tqi_lgretry = qi->tqi_lgretry; 1139 qInfo->tqi_cbrPeriod = qi->tqi_cbrPeriod; 1140 qInfo->tqi_cbrOverflowLimit = qi->tqi_cbrOverflowLimit; 1141 qInfo->tqi_burstTime = qi->tqi_burstTime; 1142 qInfo->tqi_readyTime = qi->tqi_readyTime; 1143 qInfo->tqi_compBuf = qi->tqi_physCompBuf; 1144 return AH_TRUE; 1145 } 1146 1147 /* 11a Turbo 11b 11g 108g */ 1148 static const int16_t NOISE_FLOOR[] = { -96, -93, -98, -96, -93 }; 1149 1150 /* 1151 * Read the current channel noise floor and return. 1152 * If nf cal hasn't finished, channel noise floor should be 0 1153 * and we return a nominal value based on band and frequency. 1154 * 1155 * NB: This is a private routine used by per-chip code to 1156 * implement the ah_getChanNoise method. 1157 */ 1158 int16_t 1159 ath_hal_getChanNoise(struct ath_hal *ah, const struct ieee80211_channel *chan) 1160 { 1161 HAL_CHANNEL_INTERNAL *ichan; 1162 1163 ichan = ath_hal_checkchannel(ah, chan); 1164 if (ichan == AH_NULL) { 1165 HALDEBUG(ah, HAL_DEBUG_NFCAL, 1166 "%s: invalid channel %u/0x%x; no mapping\n", 1167 __func__, chan->ic_freq, chan->ic_flags); 1168 return 0; 1169 } 1170 if (ichan->rawNoiseFloor == 0) { 1171 WIRELESS_MODE mode = ath_hal_chan2wmode(ah, chan); 1172 1173 HALASSERT(mode < WIRELESS_MODE_MAX); 1174 return NOISE_FLOOR[mode] + ath_hal_getNfAdjust(ah, ichan); 1175 } else 1176 return ichan->rawNoiseFloor + ichan->noiseFloorAdjust; 1177 } 1178 1179 /* 1180 * Fetch the current setup of ctl/ext noise floor values. 1181 * 1182 * If the CHANNEL_MIMO_NF_VALID flag isn't set, the array is simply 1183 * populated with values from NOISE_FLOOR[] + ath_hal_getNfAdjust(). 1184 * 1185 * The caller must supply ctl/ext NF arrays which are at least 1186 * AH_MAX_CHAINS entries long. 1187 */ 1188 int 1189 ath_hal_get_mimo_chan_noise(struct ath_hal *ah, 1190 const struct ieee80211_channel *chan, int16_t *nf_ctl, 1191 int16_t *nf_ext) 1192 { 1193 HAL_CHANNEL_INTERNAL *ichan; 1194 int i; 1195 1196 ichan = ath_hal_checkchannel(ah, chan); 1197 if (ichan == AH_NULL) { 1198 HALDEBUG(ah, HAL_DEBUG_NFCAL, 1199 "%s: invalid channel %u/0x%x; no mapping\n", 1200 __func__, chan->ic_freq, chan->ic_flags); 1201 for (i = 0; i < AH_MAX_CHAINS; i++) { 1202 nf_ctl[i] = nf_ext[i] = 0; 1203 } 1204 return 0; 1205 } 1206 1207 /* Return 0 if there's no valid MIMO values (yet) */ 1208 if (! (ichan->privFlags & CHANNEL_MIMO_NF_VALID)) { 1209 for (i = 0; i < AH_MAX_CHAINS; i++) { 1210 nf_ctl[i] = nf_ext[i] = 0; 1211 } 1212 return 0; 1213 } 1214 if (ichan->rawNoiseFloor == 0) { 1215 WIRELESS_MODE mode = ath_hal_chan2wmode(ah, chan); 1216 HALASSERT(mode < WIRELESS_MODE_MAX); 1217 /* 1218 * See the comment below - this could cause issues for 1219 * stations which have a very low RSSI, below the 1220 * 'normalised' NF values in NOISE_FLOOR[]. 1221 */ 1222 for (i = 0; i < AH_MAX_CHAINS; i++) { 1223 nf_ctl[i] = nf_ext[i] = NOISE_FLOOR[mode] + 1224 ath_hal_getNfAdjust(ah, ichan); 1225 } 1226 return 1; 1227 } else { 1228 /* 1229 * The value returned here from a MIMO radio is presumed to be 1230 * "good enough" as a NF calculation. As RSSI values are calculated 1231 * against this, an adjusted NF may be higher than the RSSI value 1232 * returned from a vary weak station, resulting in an obscenely 1233 * high signal strength calculation being returned. 1234 * 1235 * This should be re-evaluated at a later date, along with any 1236 * signal strength calculations which are made. Quite likely the 1237 * RSSI values will need to be adjusted to ensure the calculations 1238 * don't "wrap" when RSSI is less than the "adjusted" NF value. 1239 * ("Adjust" here is via ichan->noiseFloorAdjust.) 1240 */ 1241 for (i = 0; i < AH_MAX_CHAINS; i++) { 1242 nf_ctl[i] = ichan->noiseFloorCtl[i] + ath_hal_getNfAdjust(ah, ichan); 1243 nf_ext[i] = ichan->noiseFloorExt[i] + ath_hal_getNfAdjust(ah, ichan); 1244 } 1245 return 1; 1246 } 1247 } 1248 1249 /* 1250 * Process all valid raw noise floors into the dBm noise floor values. 1251 * Though our device has no reference for a dBm noise floor, we perform 1252 * a relative minimization of NF's based on the lowest NF found across a 1253 * channel scan. 1254 */ 1255 void 1256 ath_hal_process_noisefloor(struct ath_hal *ah) 1257 { 1258 HAL_CHANNEL_INTERNAL *c; 1259 int16_t correct2, correct5; 1260 int16_t lowest2, lowest5; 1261 int i; 1262 1263 /* 1264 * Find the lowest 2GHz and 5GHz noise floor values after adjusting 1265 * for statistically recorded NF/channel deviation. 1266 */ 1267 correct2 = lowest2 = 0; 1268 correct5 = lowest5 = 0; 1269 for (i = 0; i < AH_PRIVATE(ah)->ah_nchan; i++) { 1270 WIRELESS_MODE mode; 1271 int16_t nf; 1272 1273 c = &AH_PRIVATE(ah)->ah_channels[i]; 1274 if (c->rawNoiseFloor >= 0) 1275 continue; 1276 /* XXX can't identify proper mode */ 1277 mode = IS_CHAN_5GHZ(c) ? WIRELESS_MODE_11a : WIRELESS_MODE_11g; 1278 nf = c->rawNoiseFloor + NOISE_FLOOR[mode] + 1279 ath_hal_getNfAdjust(ah, c); 1280 if (IS_CHAN_5GHZ(c)) { 1281 if (nf < lowest5) { 1282 lowest5 = nf; 1283 correct5 = NOISE_FLOOR[mode] - 1284 (c->rawNoiseFloor + ath_hal_getNfAdjust(ah, c)); 1285 } 1286 } else { 1287 if (nf < lowest2) { 1288 lowest2 = nf; 1289 correct2 = NOISE_FLOOR[mode] - 1290 (c->rawNoiseFloor + ath_hal_getNfAdjust(ah, c)); 1291 } 1292 } 1293 } 1294 1295 /* Correct the channels to reach the expected NF value */ 1296 for (i = 0; i < AH_PRIVATE(ah)->ah_nchan; i++) { 1297 c = &AH_PRIVATE(ah)->ah_channels[i]; 1298 if (c->rawNoiseFloor >= 0) 1299 continue; 1300 /* Apply correction factor */ 1301 c->noiseFloorAdjust = ath_hal_getNfAdjust(ah, c) + 1302 (IS_CHAN_5GHZ(c) ? correct5 : correct2); 1303 HALDEBUG(ah, HAL_DEBUG_NFCAL, "%u raw nf %d adjust %d\n", 1304 c->channel, c->rawNoiseFloor, c->noiseFloorAdjust); 1305 } 1306 } 1307 1308 /* 1309 * INI support routines. 1310 */ 1311 1312 int 1313 ath_hal_ini_write(struct ath_hal *ah, const HAL_INI_ARRAY *ia, 1314 int col, int regWr) 1315 { 1316 int r; 1317 1318 HALASSERT(col < ia->cols); 1319 for (r = 0; r < ia->rows; r++) { 1320 OS_REG_WRITE(ah, HAL_INI_VAL(ia, r, 0), 1321 HAL_INI_VAL(ia, r, col)); 1322 1323 /* Analog shift register delay seems needed for Merlin - PR kern/154220 */ 1324 if (HAL_INI_VAL(ia, r, 0) >= 0x7800 && HAL_INI_VAL(ia, r, 0) < 0x7900) 1325 OS_DELAY(100); 1326 1327 DMA_YIELD(regWr); 1328 } 1329 return regWr; 1330 } 1331 1332 void 1333 ath_hal_ini_bank_setup(uint32_t data[], const HAL_INI_ARRAY *ia, int col) 1334 { 1335 int r; 1336 1337 HALASSERT(col < ia->cols); 1338 for (r = 0; r < ia->rows; r++) 1339 data[r] = HAL_INI_VAL(ia, r, col); 1340 } 1341 1342 int 1343 ath_hal_ini_bank_write(struct ath_hal *ah, const HAL_INI_ARRAY *ia, 1344 const uint32_t data[], int regWr) 1345 { 1346 int r; 1347 1348 for (r = 0; r < ia->rows; r++) { 1349 OS_REG_WRITE(ah, HAL_INI_VAL(ia, r, 0), data[r]); 1350 DMA_YIELD(regWr); 1351 } 1352 return regWr; 1353 } 1354 1355 /* 1356 * These are EEPROM board related routines which should likely live in 1357 * a helper library of some sort. 1358 */ 1359 1360 /************************************************************** 1361 * ath_ee_getLowerUppderIndex 1362 * 1363 * Return indices surrounding the value in sorted integer lists. 1364 * Requirement: the input list must be monotonically increasing 1365 * and populated up to the list size 1366 * Returns: match is set if an index in the array matches exactly 1367 * or a the target is before or after the range of the array. 1368 */ 1369 HAL_BOOL 1370 ath_ee_getLowerUpperIndex(uint8_t target, uint8_t *pList, uint16_t listSize, 1371 uint16_t *indexL, uint16_t *indexR) 1372 { 1373 uint16_t i; 1374 1375 /* 1376 * Check first and last elements for beyond ordered array cases. 1377 */ 1378 if (target <= pList[0]) { 1379 *indexL = *indexR = 0; 1380 return AH_TRUE; 1381 } 1382 if (target >= pList[listSize-1]) { 1383 *indexL = *indexR = (uint16_t)(listSize - 1); 1384 return AH_TRUE; 1385 } 1386 1387 /* look for value being near or between 2 values in list */ 1388 for (i = 0; i < listSize - 1; i++) { 1389 /* 1390 * If value is close to the current value of the list 1391 * then target is not between values, it is one of the values 1392 */ 1393 if (pList[i] == target) { 1394 *indexL = *indexR = i; 1395 return AH_TRUE; 1396 } 1397 /* 1398 * Look for value being between current value and next value 1399 * if so return these 2 values 1400 */ 1401 if (target < pList[i + 1]) { 1402 *indexL = i; 1403 *indexR = (uint16_t)(i + 1); 1404 return AH_FALSE; 1405 } 1406 } 1407 HALASSERT(0); 1408 *indexL = *indexR = 0; 1409 return AH_FALSE; 1410 } 1411 1412 /************************************************************** 1413 * ath_ee_FillVpdTable 1414 * 1415 * Fill the Vpdlist for indices Pmax-Pmin 1416 * Note: pwrMin, pwrMax and Vpdlist are all in dBm * 4 1417 */ 1418 HAL_BOOL 1419 ath_ee_FillVpdTable(uint8_t pwrMin, uint8_t pwrMax, uint8_t *pPwrList, 1420 uint8_t *pVpdList, uint16_t numIntercepts, uint8_t *pRetVpdList) 1421 { 1422 uint16_t i, k; 1423 uint8_t currPwr = pwrMin; 1424 uint16_t idxL, idxR; 1425 1426 HALASSERT(pwrMax > pwrMin); 1427 for (i = 0; i <= (pwrMax - pwrMin) / 2; i++) { 1428 ath_ee_getLowerUpperIndex(currPwr, pPwrList, numIntercepts, 1429 &(idxL), &(idxR)); 1430 if (idxR < 1) 1431 idxR = 1; /* extrapolate below */ 1432 if (idxL == numIntercepts - 1) 1433 idxL = (uint16_t)(numIntercepts - 2); /* extrapolate above */ 1434 if (pPwrList[idxL] == pPwrList[idxR]) 1435 k = pVpdList[idxL]; 1436 else 1437 k = (uint16_t)( ((currPwr - pPwrList[idxL]) * pVpdList[idxR] + (pPwrList[idxR] - currPwr) * pVpdList[idxL]) / 1438 (pPwrList[idxR] - pPwrList[idxL]) ); 1439 HALASSERT(k < 256); 1440 pRetVpdList[i] = (uint8_t)k; 1441 currPwr += 2; /* half dB steps */ 1442 } 1443 1444 return AH_TRUE; 1445 } 1446 1447 /************************************************************************** 1448 * ath_ee_interpolate 1449 * 1450 * Returns signed interpolated or the scaled up interpolated value 1451 */ 1452 int16_t 1453 ath_ee_interpolate(uint16_t target, uint16_t srcLeft, uint16_t srcRight, 1454 int16_t targetLeft, int16_t targetRight) 1455 { 1456 int16_t rv; 1457 1458 if (srcRight == srcLeft) { 1459 rv = targetLeft; 1460 } else { 1461 rv = (int16_t)( ((target - srcLeft) * targetRight + 1462 (srcRight - target) * targetLeft) / (srcRight - srcLeft) ); 1463 } 1464 return rv; 1465 } 1466 1467 /* 1468 * Adjust the TSF. 1469 */ 1470 void 1471 ath_hal_adjusttsf(struct ath_hal *ah, int32_t tsfdelta) 1472 { 1473 /* XXX handle wrap/overflow */ 1474 OS_REG_WRITE(ah, AR_TSF_L32, OS_REG_READ(ah, AR_TSF_L32) + tsfdelta); 1475 } 1476 1477 /* 1478 * Enable or disable CCA. 1479 */ 1480 void 1481 ath_hal_setcca(struct ath_hal *ah, int ena) 1482 { 1483 /* 1484 * NB: fill me in; this is not provided by default because disabling 1485 * CCA in most locales violates regulatory. 1486 */ 1487 } 1488 1489 /* 1490 * Get CCA setting. 1491 * 1492 * XXX TODO: turn this and the above function into methods 1493 * in case there are chipset differences in handling CCA. 1494 */ 1495 int 1496 ath_hal_getcca(struct ath_hal *ah) 1497 { 1498 u_int32_t diag; 1499 if (ath_hal_getcapability(ah, HAL_CAP_DIAG, 0, &diag) != HAL_OK) 1500 return 1; 1501 return ((diag & 0x500000) == 0); 1502 } 1503 1504 /* 1505 * Set the current state of self-generated ACK and RTS/CTS frames. 1506 * 1507 * For correct DFS operation, the device should not even /ACK/ frames 1508 * that are sent to it during CAC or CSA. 1509 */ 1510 void 1511 ath_hal_set_dfs_cac_tx_quiet(struct ath_hal *ah, HAL_BOOL ena) 1512 { 1513 1514 if (ah->ah_setDfsCacTxQuiet == NULL) 1515 return; 1516 ah->ah_setDfsCacTxQuiet(ah, ena); 1517 } 1518 1519 /* 1520 * This routine is only needed when supporting EEPROM-in-RAM setups 1521 * (eg embedded SoCs and on-board PCI/PCIe devices.) 1522 */ 1523 /* NB: This is in 16 bit words; not bytes */ 1524 /* XXX This doesn't belong here! */ 1525 #define ATH_DATA_EEPROM_SIZE 2048 1526 1527 HAL_BOOL 1528 ath_hal_EepromDataRead(struct ath_hal *ah, u_int off, uint16_t *data) 1529 { 1530 if (ah->ah_eepromdata == AH_NULL) { 1531 HALDEBUG(ah, HAL_DEBUG_ANY, "%s: no eeprom data!\n", __func__); 1532 return AH_FALSE; 1533 } 1534 if (off > ATH_DATA_EEPROM_SIZE) { 1535 HALDEBUG(ah, HAL_DEBUG_ANY, "%s: offset %x > %x\n", 1536 __func__, off, ATH_DATA_EEPROM_SIZE); 1537 return AH_FALSE; 1538 } 1539 (*data) = ah->ah_eepromdata[off]; 1540 return AH_TRUE; 1541 } 1542 1543 /* 1544 * Do a 2GHz specific MHz->IEEE based on the hardware 1545 * frequency. 1546 * 1547 * This is the unmapped frequency which is programmed into the hardware. 1548 */ 1549 int 1550 ath_hal_mhz2ieee_2ghz(struct ath_hal *ah, int freq) 1551 { 1552 1553 if (freq == 2484) 1554 return 14; 1555 if (freq < 2484) 1556 return ((int) freq - 2407) / 5; 1557 else 1558 return 15 + ((freq - 2512) / 20); 1559 } 1560 1561 /* 1562 * Clear the current survey data. 1563 * 1564 * This should be done during a channel change. 1565 */ 1566 void 1567 ath_hal_survey_clear(struct ath_hal *ah) 1568 { 1569 1570 OS_MEMZERO(&AH_PRIVATE(ah)->ah_chansurvey, 1571 sizeof(AH_PRIVATE(ah)->ah_chansurvey)); 1572 } 1573 1574 /* 1575 * Add a sample to the channel survey. 1576 */ 1577 void 1578 ath_hal_survey_add_sample(struct ath_hal *ah, HAL_SURVEY_SAMPLE *hs) 1579 { 1580 HAL_CHANNEL_SURVEY *cs; 1581 1582 cs = &AH_PRIVATE(ah)->ah_chansurvey; 1583 1584 OS_MEMCPY(&cs->samples[cs->cur_sample], hs, sizeof(*hs)); 1585 cs->samples[cs->cur_sample].seq_num = cs->cur_seq; 1586 cs->cur_sample = (cs->cur_sample + 1) % CHANNEL_SURVEY_SAMPLE_COUNT; 1587 cs->cur_seq++; 1588 } 1589