1 /* 2 * Copyright (c) 2004-2007 Reyk Floeter <reyk@openbsd.org> 3 * Copyright (c) 2006-2009 Nick Kossifidis <mickflemm@gmail.com> 4 * Copyright (c) 2007-2008 Jiri Slaby <jirislaby@gmail.com> 5 * Copyright (c) 2008-2009 Felix Fietkau <nbd@openwrt.org> 6 * 7 * Permission to use, copy, modify, and 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 */ 20 21 /***********************\ 22 * PHY related functions * 23 \***********************/ 24 25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 26 27 #include <linux/delay.h> 28 #include <linux/slab.h> 29 #include <asm/unaligned.h> 30 31 #include "ath5k.h" 32 #include "reg.h" 33 #include "rfbuffer.h" 34 #include "rfgain.h" 35 #include "../regd.h" 36 37 38 /** 39 * DOC: PHY related functions 40 * 41 * Here we handle the low-level functions related to baseband 42 * and analog frontend (RF) parts. This is by far the most complex 43 * part of the hw code so make sure you know what you are doing. 44 * 45 * Here is a list of what this is all about: 46 * 47 * - Channel setting/switching 48 * 49 * - Automatic Gain Control (AGC) calibration 50 * 51 * - Noise Floor calibration 52 * 53 * - I/Q imbalance calibration (QAM correction) 54 * 55 * - Calibration due to thermal changes (gain_F) 56 * 57 * - Spur noise mitigation 58 * 59 * - RF/PHY initialization for the various operating modes and bwmodes 60 * 61 * - Antenna control 62 * 63 * - TX power control per channel/rate/packet type 64 * 65 * Also have in mind we never got documentation for most of these 66 * functions, what we have comes mostly from Atheros's code, reverse 67 * engineering and patent docs/presentations etc. 68 */ 69 70 71 /******************\ 72 * Helper functions * 73 \******************/ 74 75 /** 76 * ath5k_hw_radio_revision() - Get the PHY Chip revision 77 * @ah: The &struct ath5k_hw 78 * @band: One of enum ieee80211_band 79 * 80 * Returns the revision number of a 2GHz, 5GHz or single chip 81 * radio. 82 */ 83 u16 84 ath5k_hw_radio_revision(struct ath5k_hw *ah, enum ieee80211_band band) 85 { 86 unsigned int i; 87 u32 srev; 88 u16 ret; 89 90 /* 91 * Set the radio chip access register 92 */ 93 switch (band) { 94 case IEEE80211_BAND_2GHZ: 95 ath5k_hw_reg_write(ah, AR5K_PHY_SHIFT_2GHZ, AR5K_PHY(0)); 96 break; 97 case IEEE80211_BAND_5GHZ: 98 ath5k_hw_reg_write(ah, AR5K_PHY_SHIFT_5GHZ, AR5K_PHY(0)); 99 break; 100 default: 101 return 0; 102 } 103 104 usleep_range(2000, 2500); 105 106 /* ...wait until PHY is ready and read the selected radio revision */ 107 ath5k_hw_reg_write(ah, 0x00001c16, AR5K_PHY(0x34)); 108 109 for (i = 0; i < 8; i++) 110 ath5k_hw_reg_write(ah, 0x00010000, AR5K_PHY(0x20)); 111 112 if (ah->ah_version == AR5K_AR5210) { 113 srev = ath5k_hw_reg_read(ah, AR5K_PHY(256) >> 28) & 0xf; 114 ret = (u16)ath5k_hw_bitswap(srev, 4) + 1; 115 } else { 116 srev = (ath5k_hw_reg_read(ah, AR5K_PHY(0x100)) >> 24) & 0xff; 117 ret = (u16)ath5k_hw_bitswap(((srev & 0xf0) >> 4) | 118 ((srev & 0x0f) << 4), 8); 119 } 120 121 /* Reset to the 5GHz mode */ 122 ath5k_hw_reg_write(ah, AR5K_PHY_SHIFT_5GHZ, AR5K_PHY(0)); 123 124 return ret; 125 } 126 127 /** 128 * ath5k_channel_ok() - Check if a channel is supported by the hw 129 * @ah: The &struct ath5k_hw 130 * @channel: The &struct ieee80211_channel 131 * 132 * Note: We don't do any regulatory domain checks here, it's just 133 * a sanity check. 134 */ 135 bool 136 ath5k_channel_ok(struct ath5k_hw *ah, struct ieee80211_channel *channel) 137 { 138 u16 freq = channel->center_freq; 139 140 /* Check if the channel is in our supported range */ 141 if (channel->band == IEEE80211_BAND_2GHZ) { 142 if ((freq >= ah->ah_capabilities.cap_range.range_2ghz_min) && 143 (freq <= ah->ah_capabilities.cap_range.range_2ghz_max)) 144 return true; 145 } else if (channel->band == IEEE80211_BAND_5GHZ) 146 if ((freq >= ah->ah_capabilities.cap_range.range_5ghz_min) && 147 (freq <= ah->ah_capabilities.cap_range.range_5ghz_max)) 148 return true; 149 150 return false; 151 } 152 153 /** 154 * ath5k_hw_chan_has_spur_noise() - Check if channel is sensitive to spur noise 155 * @ah: The &struct ath5k_hw 156 * @channel: The &struct ieee80211_channel 157 */ 158 bool 159 ath5k_hw_chan_has_spur_noise(struct ath5k_hw *ah, 160 struct ieee80211_channel *channel) 161 { 162 u8 refclk_freq; 163 164 if ((ah->ah_radio == AR5K_RF5112) || 165 (ah->ah_radio == AR5K_RF5413) || 166 (ah->ah_radio == AR5K_RF2413) || 167 (ah->ah_mac_version == (AR5K_SREV_AR2417 >> 4))) 168 refclk_freq = 40; 169 else 170 refclk_freq = 32; 171 172 if ((channel->center_freq % refclk_freq != 0) && 173 ((channel->center_freq % refclk_freq < 10) || 174 (channel->center_freq % refclk_freq > 22))) 175 return true; 176 else 177 return false; 178 } 179 180 /** 181 * ath5k_hw_rfb_op() - Perform an operation on the given RF Buffer 182 * @ah: The &struct ath5k_hw 183 * @rf_regs: The struct ath5k_rf_reg 184 * @val: New value 185 * @reg_id: RF register ID 186 * @set: Indicate we need to swap data 187 * 188 * This is an internal function used to modify RF Banks before 189 * writing them to AR5K_RF_BUFFER. Check out rfbuffer.h for more 190 * infos. 191 */ 192 static unsigned int 193 ath5k_hw_rfb_op(struct ath5k_hw *ah, const struct ath5k_rf_reg *rf_regs, 194 u32 val, u8 reg_id, bool set) 195 { 196 const struct ath5k_rf_reg *rfreg = NULL; 197 u8 offset, bank, num_bits, col, position; 198 u16 entry; 199 u32 mask, data, last_bit, bits_shifted, first_bit; 200 u32 *rfb; 201 s32 bits_left; 202 int i; 203 204 data = 0; 205 rfb = ah->ah_rf_banks; 206 207 for (i = 0; i < ah->ah_rf_regs_count; i++) { 208 if (rf_regs[i].index == reg_id) { 209 rfreg = &rf_regs[i]; 210 break; 211 } 212 } 213 214 if (rfb == NULL || rfreg == NULL) { 215 ATH5K_PRINTF("Rf register not found!\n"); 216 /* should not happen */ 217 return 0; 218 } 219 220 bank = rfreg->bank; 221 num_bits = rfreg->field.len; 222 first_bit = rfreg->field.pos; 223 col = rfreg->field.col; 224 225 /* first_bit is an offset from bank's 226 * start. Since we have all banks on 227 * the same array, we use this offset 228 * to mark each bank's start */ 229 offset = ah->ah_offset[bank]; 230 231 /* Boundary check */ 232 if (!(col <= 3 && num_bits <= 32 && first_bit + num_bits <= 319)) { 233 ATH5K_PRINTF("invalid values at offset %u\n", offset); 234 return 0; 235 } 236 237 entry = ((first_bit - 1) / 8) + offset; 238 position = (first_bit - 1) % 8; 239 240 if (set) 241 data = ath5k_hw_bitswap(val, num_bits); 242 243 for (bits_shifted = 0, bits_left = num_bits; bits_left > 0; 244 position = 0, entry++) { 245 246 last_bit = (position + bits_left > 8) ? 8 : 247 position + bits_left; 248 249 mask = (((1 << last_bit) - 1) ^ ((1 << position) - 1)) << 250 (col * 8); 251 252 if (set) { 253 rfb[entry] &= ~mask; 254 rfb[entry] |= ((data << position) << (col * 8)) & mask; 255 data >>= (8 - position); 256 } else { 257 data |= (((rfb[entry] & mask) >> (col * 8)) >> position) 258 << bits_shifted; 259 bits_shifted += last_bit - position; 260 } 261 262 bits_left -= 8 - position; 263 } 264 265 data = set ? 1 : ath5k_hw_bitswap(data, num_bits); 266 267 return data; 268 } 269 270 /** 271 * ath5k_hw_write_ofdm_timings() - set OFDM timings on AR5212 272 * @ah: the &struct ath5k_hw 273 * @channel: the currently set channel upon reset 274 * 275 * Write the delta slope coefficient (used on pilot tracking ?) for OFDM 276 * operation on the AR5212 upon reset. This is a helper for ath5k_hw_phy_init. 277 * 278 * Since delta slope is floating point we split it on its exponent and 279 * mantissa and provide these values on hw. 280 * 281 * For more infos i think this patent is related 282 * "http://www.freepatentsonline.com/7184495.html" 283 */ 284 static inline int 285 ath5k_hw_write_ofdm_timings(struct ath5k_hw *ah, 286 struct ieee80211_channel *channel) 287 { 288 /* Get exponent and mantissa and set it */ 289 u32 coef_scaled, coef_exp, coef_man, 290 ds_coef_exp, ds_coef_man, clock; 291 292 BUG_ON(!(ah->ah_version == AR5K_AR5212) || 293 (channel->hw_value == AR5K_MODE_11B)); 294 295 /* Get coefficient 296 * ALGO: coef = (5 * clock / carrier_freq) / 2 297 * we scale coef by shifting clock value by 24 for 298 * better precision since we use integers */ 299 switch (ah->ah_bwmode) { 300 case AR5K_BWMODE_40MHZ: 301 clock = 40 * 2; 302 break; 303 case AR5K_BWMODE_10MHZ: 304 clock = 40 / 2; 305 break; 306 case AR5K_BWMODE_5MHZ: 307 clock = 40 / 4; 308 break; 309 default: 310 clock = 40; 311 break; 312 } 313 coef_scaled = ((5 * (clock << 24)) / 2) / channel->center_freq; 314 315 /* Get exponent 316 * ALGO: coef_exp = 14 - highest set bit position */ 317 coef_exp = ilog2(coef_scaled); 318 319 /* Doesn't make sense if it's zero*/ 320 if (!coef_scaled || !coef_exp) 321 return -EINVAL; 322 323 /* Note: we've shifted coef_scaled by 24 */ 324 coef_exp = 14 - (coef_exp - 24); 325 326 327 /* Get mantissa (significant digits) 328 * ALGO: coef_mant = floor(coef_scaled* 2^coef_exp+0.5) */ 329 coef_man = coef_scaled + 330 (1 << (24 - coef_exp - 1)); 331 332 /* Calculate delta slope coefficient exponent 333 * and mantissa (remove scaling) and set them on hw */ 334 ds_coef_man = coef_man >> (24 - coef_exp); 335 ds_coef_exp = coef_exp - 16; 336 337 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_TIMING_3, 338 AR5K_PHY_TIMING_3_DSC_MAN, ds_coef_man); 339 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_TIMING_3, 340 AR5K_PHY_TIMING_3_DSC_EXP, ds_coef_exp); 341 342 return 0; 343 } 344 345 /** 346 * ath5k_hw_phy_disable() - Disable PHY 347 * @ah: The &struct ath5k_hw 348 */ 349 int ath5k_hw_phy_disable(struct ath5k_hw *ah) 350 { 351 /*Just a try M.F.*/ 352 ath5k_hw_reg_write(ah, AR5K_PHY_ACT_DISABLE, AR5K_PHY_ACT); 353 354 return 0; 355 } 356 357 /** 358 * ath5k_hw_wait_for_synth() - Wait for synth to settle 359 * @ah: The &struct ath5k_hw 360 * @channel: The &struct ieee80211_channel 361 */ 362 static void 363 ath5k_hw_wait_for_synth(struct ath5k_hw *ah, 364 struct ieee80211_channel *channel) 365 { 366 /* 367 * On 5211+ read activation -> rx delay 368 * and use it (100ns steps). 369 */ 370 if (ah->ah_version != AR5K_AR5210) { 371 u32 delay; 372 delay = ath5k_hw_reg_read(ah, AR5K_PHY_RX_DELAY) & 373 AR5K_PHY_RX_DELAY_M; 374 delay = (channel->hw_value == AR5K_MODE_11B) ? 375 ((delay << 2) / 22) : (delay / 10); 376 if (ah->ah_bwmode == AR5K_BWMODE_10MHZ) 377 delay = delay << 1; 378 if (ah->ah_bwmode == AR5K_BWMODE_5MHZ) 379 delay = delay << 2; 380 /* XXX: /2 on turbo ? Let's be safe 381 * for now */ 382 usleep_range(100 + delay, 100 + (2 * delay)); 383 } else { 384 usleep_range(1000, 1500); 385 } 386 } 387 388 389 /**********************\ 390 * RF Gain optimization * 391 \**********************/ 392 393 /** 394 * DOC: RF Gain optimization 395 * 396 * This code is used to optimize RF gain on different environments 397 * (temperature mostly) based on feedback from a power detector. 398 * 399 * It's only used on RF5111 and RF5112, later RF chips seem to have 400 * auto adjustment on hw -notice they have a much smaller BANK 7 and 401 * no gain optimization ladder-. 402 * 403 * For more infos check out this patent doc 404 * "http://www.freepatentsonline.com/7400691.html" 405 * 406 * This paper describes power drops as seen on the receiver due to 407 * probe packets 408 * "http://www.cnri.dit.ie/publications/ICT08%20-%20Practical%20Issues 409 * %20of%20Power%20Control.pdf" 410 * 411 * And this is the MadWiFi bug entry related to the above 412 * "http://madwifi-project.org/ticket/1659" 413 * with various measurements and diagrams 414 */ 415 416 /** 417 * ath5k_hw_rfgain_opt_init() - Initialize ah_gain during attach 418 * @ah: The &struct ath5k_hw 419 */ 420 int ath5k_hw_rfgain_opt_init(struct ath5k_hw *ah) 421 { 422 /* Initialize the gain optimization values */ 423 switch (ah->ah_radio) { 424 case AR5K_RF5111: 425 ah->ah_gain.g_step_idx = rfgain_opt_5111.go_default; 426 ah->ah_gain.g_low = 20; 427 ah->ah_gain.g_high = 35; 428 ah->ah_gain.g_state = AR5K_RFGAIN_ACTIVE; 429 break; 430 case AR5K_RF5112: 431 ah->ah_gain.g_step_idx = rfgain_opt_5112.go_default; 432 ah->ah_gain.g_low = 20; 433 ah->ah_gain.g_high = 85; 434 ah->ah_gain.g_state = AR5K_RFGAIN_ACTIVE; 435 break; 436 default: 437 return -EINVAL; 438 } 439 440 return 0; 441 } 442 443 /** 444 * ath5k_hw_request_rfgain_probe() - Request a PAPD probe packet 445 * @ah: The &struct ath5k_hw 446 * 447 * Schedules a gain probe check on the next transmitted packet. 448 * That means our next packet is going to be sent with lower 449 * tx power and a Peak to Average Power Detector (PAPD) will try 450 * to measure the gain. 451 * 452 * TODO: Force a tx packet (bypassing PCU arbitrator etc) 453 * just after we enable the probe so that we don't mess with 454 * standard traffic. 455 */ 456 static void 457 ath5k_hw_request_rfgain_probe(struct ath5k_hw *ah) 458 { 459 460 /* Skip if gain calibration is inactive or 461 * we already handle a probe request */ 462 if (ah->ah_gain.g_state != AR5K_RFGAIN_ACTIVE) 463 return; 464 465 /* Send the packet with 2dB below max power as 466 * patent doc suggest */ 467 ath5k_hw_reg_write(ah, AR5K_REG_SM(ah->ah_txpower.txp_ofdm - 4, 468 AR5K_PHY_PAPD_PROBE_TXPOWER) | 469 AR5K_PHY_PAPD_PROBE_TX_NEXT, AR5K_PHY_PAPD_PROBE); 470 471 ah->ah_gain.g_state = AR5K_RFGAIN_READ_REQUESTED; 472 473 } 474 475 /** 476 * ath5k_hw_rf_gainf_corr() - Calculate Gain_F measurement correction 477 * @ah: The &struct ath5k_hw 478 * 479 * Calculate Gain_F measurement correction 480 * based on the current step for RF5112 rev. 2 481 */ 482 static u32 483 ath5k_hw_rf_gainf_corr(struct ath5k_hw *ah) 484 { 485 u32 mix, step; 486 u32 *rf; 487 const struct ath5k_gain_opt *go; 488 const struct ath5k_gain_opt_step *g_step; 489 const struct ath5k_rf_reg *rf_regs; 490 491 /* Only RF5112 Rev. 2 supports it */ 492 if ((ah->ah_radio != AR5K_RF5112) || 493 (ah->ah_radio_5ghz_revision <= AR5K_SREV_RAD_5112A)) 494 return 0; 495 496 go = &rfgain_opt_5112; 497 rf_regs = rf_regs_5112a; 498 ah->ah_rf_regs_count = ARRAY_SIZE(rf_regs_5112a); 499 500 g_step = &go->go_step[ah->ah_gain.g_step_idx]; 501 502 if (ah->ah_rf_banks == NULL) 503 return 0; 504 505 rf = ah->ah_rf_banks; 506 ah->ah_gain.g_f_corr = 0; 507 508 /* No VGA (Variable Gain Amplifier) override, skip */ 509 if (ath5k_hw_rfb_op(ah, rf_regs, 0, AR5K_RF_MIXVGA_OVR, false) != 1) 510 return 0; 511 512 /* Mix gain stepping */ 513 step = ath5k_hw_rfb_op(ah, rf_regs, 0, AR5K_RF_MIXGAIN_STEP, false); 514 515 /* Mix gain override */ 516 mix = g_step->gos_param[0]; 517 518 switch (mix) { 519 case 3: 520 ah->ah_gain.g_f_corr = step * 2; 521 break; 522 case 2: 523 ah->ah_gain.g_f_corr = (step - 5) * 2; 524 break; 525 case 1: 526 ah->ah_gain.g_f_corr = step; 527 break; 528 default: 529 ah->ah_gain.g_f_corr = 0; 530 break; 531 } 532 533 return ah->ah_gain.g_f_corr; 534 } 535 536 /** 537 * ath5k_hw_rf_check_gainf_readback() - Validate Gain_F feedback from detector 538 * @ah: The &struct ath5k_hw 539 * 540 * Check if current gain_F measurement is in the range of our 541 * power detector windows. If we get a measurement outside range 542 * we know it's not accurate (detectors can't measure anything outside 543 * their detection window) so we must ignore it. 544 * 545 * Returns true if readback was O.K. or false on failure 546 */ 547 static bool 548 ath5k_hw_rf_check_gainf_readback(struct ath5k_hw *ah) 549 { 550 const struct ath5k_rf_reg *rf_regs; 551 u32 step, mix_ovr, level[4]; 552 u32 *rf; 553 554 if (ah->ah_rf_banks == NULL) 555 return false; 556 557 rf = ah->ah_rf_banks; 558 559 if (ah->ah_radio == AR5K_RF5111) { 560 561 rf_regs = rf_regs_5111; 562 ah->ah_rf_regs_count = ARRAY_SIZE(rf_regs_5111); 563 564 step = ath5k_hw_rfb_op(ah, rf_regs, 0, AR5K_RF_RFGAIN_STEP, 565 false); 566 567 level[0] = 0; 568 level[1] = (step == 63) ? 50 : step + 4; 569 level[2] = (step != 63) ? 64 : level[0]; 570 level[3] = level[2] + 50; 571 572 ah->ah_gain.g_high = level[3] - 573 (step == 63 ? AR5K_GAIN_DYN_ADJUST_HI_MARGIN : -5); 574 ah->ah_gain.g_low = level[0] + 575 (step == 63 ? AR5K_GAIN_DYN_ADJUST_LO_MARGIN : 0); 576 } else { 577 578 rf_regs = rf_regs_5112; 579 ah->ah_rf_regs_count = ARRAY_SIZE(rf_regs_5112); 580 581 mix_ovr = ath5k_hw_rfb_op(ah, rf_regs, 0, AR5K_RF_MIXVGA_OVR, 582 false); 583 584 level[0] = level[2] = 0; 585 586 if (mix_ovr == 1) { 587 level[1] = level[3] = 83; 588 } else { 589 level[1] = level[3] = 107; 590 ah->ah_gain.g_high = 55; 591 } 592 } 593 594 return (ah->ah_gain.g_current >= level[0] && 595 ah->ah_gain.g_current <= level[1]) || 596 (ah->ah_gain.g_current >= level[2] && 597 ah->ah_gain.g_current <= level[3]); 598 } 599 600 /** 601 * ath5k_hw_rf_gainf_adjust() - Perform Gain_F adjustment 602 * @ah: The &struct ath5k_hw 603 * 604 * Choose the right target gain based on current gain 605 * and RF gain optimization ladder 606 */ 607 static s8 608 ath5k_hw_rf_gainf_adjust(struct ath5k_hw *ah) 609 { 610 const struct ath5k_gain_opt *go; 611 const struct ath5k_gain_opt_step *g_step; 612 int ret = 0; 613 614 switch (ah->ah_radio) { 615 case AR5K_RF5111: 616 go = &rfgain_opt_5111; 617 break; 618 case AR5K_RF5112: 619 go = &rfgain_opt_5112; 620 break; 621 default: 622 return 0; 623 } 624 625 g_step = &go->go_step[ah->ah_gain.g_step_idx]; 626 627 if (ah->ah_gain.g_current >= ah->ah_gain.g_high) { 628 629 /* Reached maximum */ 630 if (ah->ah_gain.g_step_idx == 0) 631 return -1; 632 633 for (ah->ah_gain.g_target = ah->ah_gain.g_current; 634 ah->ah_gain.g_target >= ah->ah_gain.g_high && 635 ah->ah_gain.g_step_idx > 0; 636 g_step = &go->go_step[ah->ah_gain.g_step_idx]) 637 ah->ah_gain.g_target -= 2 * 638 (go->go_step[--(ah->ah_gain.g_step_idx)].gos_gain - 639 g_step->gos_gain); 640 641 ret = 1; 642 goto done; 643 } 644 645 if (ah->ah_gain.g_current <= ah->ah_gain.g_low) { 646 647 /* Reached minimum */ 648 if (ah->ah_gain.g_step_idx == (go->go_steps_count - 1)) 649 return -2; 650 651 for (ah->ah_gain.g_target = ah->ah_gain.g_current; 652 ah->ah_gain.g_target <= ah->ah_gain.g_low && 653 ah->ah_gain.g_step_idx < go->go_steps_count - 1; 654 g_step = &go->go_step[ah->ah_gain.g_step_idx]) 655 ah->ah_gain.g_target -= 2 * 656 (go->go_step[++ah->ah_gain.g_step_idx].gos_gain - 657 g_step->gos_gain); 658 659 ret = 2; 660 goto done; 661 } 662 663 done: 664 ATH5K_DBG(ah, ATH5K_DEBUG_CALIBRATE, 665 "ret %d, gain step %u, current gain %u, target gain %u\n", 666 ret, ah->ah_gain.g_step_idx, ah->ah_gain.g_current, 667 ah->ah_gain.g_target); 668 669 return ret; 670 } 671 672 /** 673 * ath5k_hw_gainf_calibrate() - Do a gain_F calibration 674 * @ah: The &struct ath5k_hw 675 * 676 * Main callback for thermal RF gain calibration engine 677 * Check for a new gain reading and schedule an adjustment 678 * if needed. 679 * 680 * Returns one of enum ath5k_rfgain codes 681 */ 682 enum ath5k_rfgain 683 ath5k_hw_gainf_calibrate(struct ath5k_hw *ah) 684 { 685 u32 data, type; 686 struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom; 687 688 if (ah->ah_rf_banks == NULL || 689 ah->ah_gain.g_state == AR5K_RFGAIN_INACTIVE) 690 return AR5K_RFGAIN_INACTIVE; 691 692 /* No check requested, either engine is inactive 693 * or an adjustment is already requested */ 694 if (ah->ah_gain.g_state != AR5K_RFGAIN_READ_REQUESTED) 695 goto done; 696 697 /* Read the PAPD (Peak to Average Power Detector) 698 * register */ 699 data = ath5k_hw_reg_read(ah, AR5K_PHY_PAPD_PROBE); 700 701 /* No probe is scheduled, read gain_F measurement */ 702 if (!(data & AR5K_PHY_PAPD_PROBE_TX_NEXT)) { 703 ah->ah_gain.g_current = data >> AR5K_PHY_PAPD_PROBE_GAINF_S; 704 type = AR5K_REG_MS(data, AR5K_PHY_PAPD_PROBE_TYPE); 705 706 /* If tx packet is CCK correct the gain_F measurement 707 * by cck ofdm gain delta */ 708 if (type == AR5K_PHY_PAPD_PROBE_TYPE_CCK) { 709 if (ah->ah_radio_5ghz_revision >= AR5K_SREV_RAD_5112A) 710 ah->ah_gain.g_current += 711 ee->ee_cck_ofdm_gain_delta; 712 else 713 ah->ah_gain.g_current += 714 AR5K_GAIN_CCK_PROBE_CORR; 715 } 716 717 /* Further correct gain_F measurement for 718 * RF5112A radios */ 719 if (ah->ah_radio_5ghz_revision >= AR5K_SREV_RAD_5112A) { 720 ath5k_hw_rf_gainf_corr(ah); 721 ah->ah_gain.g_current = 722 ah->ah_gain.g_current >= ah->ah_gain.g_f_corr ? 723 (ah->ah_gain.g_current - ah->ah_gain.g_f_corr) : 724 0; 725 } 726 727 /* Check if measurement is ok and if we need 728 * to adjust gain, schedule a gain adjustment, 729 * else switch back to the active state */ 730 if (ath5k_hw_rf_check_gainf_readback(ah) && 731 AR5K_GAIN_CHECK_ADJUST(&ah->ah_gain) && 732 ath5k_hw_rf_gainf_adjust(ah)) { 733 ah->ah_gain.g_state = AR5K_RFGAIN_NEED_CHANGE; 734 } else { 735 ah->ah_gain.g_state = AR5K_RFGAIN_ACTIVE; 736 } 737 } 738 739 done: 740 return ah->ah_gain.g_state; 741 } 742 743 /** 744 * ath5k_hw_rfgain_init() - Write initial RF gain settings to hw 745 * @ah: The &struct ath5k_hw 746 * @band: One of enum ieee80211_band 747 * 748 * Write initial RF gain table to set the RF sensitivity. 749 * 750 * NOTE: This one works on all RF chips and has nothing to do 751 * with Gain_F calibration 752 */ 753 static int 754 ath5k_hw_rfgain_init(struct ath5k_hw *ah, enum ieee80211_band band) 755 { 756 const struct ath5k_ini_rfgain *ath5k_rfg; 757 unsigned int i, size, index; 758 759 switch (ah->ah_radio) { 760 case AR5K_RF5111: 761 ath5k_rfg = rfgain_5111; 762 size = ARRAY_SIZE(rfgain_5111); 763 break; 764 case AR5K_RF5112: 765 ath5k_rfg = rfgain_5112; 766 size = ARRAY_SIZE(rfgain_5112); 767 break; 768 case AR5K_RF2413: 769 ath5k_rfg = rfgain_2413; 770 size = ARRAY_SIZE(rfgain_2413); 771 break; 772 case AR5K_RF2316: 773 ath5k_rfg = rfgain_2316; 774 size = ARRAY_SIZE(rfgain_2316); 775 break; 776 case AR5K_RF5413: 777 ath5k_rfg = rfgain_5413; 778 size = ARRAY_SIZE(rfgain_5413); 779 break; 780 case AR5K_RF2317: 781 case AR5K_RF2425: 782 ath5k_rfg = rfgain_2425; 783 size = ARRAY_SIZE(rfgain_2425); 784 break; 785 default: 786 return -EINVAL; 787 } 788 789 index = (band == IEEE80211_BAND_2GHZ) ? 1 : 0; 790 791 for (i = 0; i < size; i++) { 792 AR5K_REG_WAIT(i); 793 ath5k_hw_reg_write(ah, ath5k_rfg[i].rfg_value[index], 794 (u32)ath5k_rfg[i].rfg_register); 795 } 796 797 return 0; 798 } 799 800 801 /********************\ 802 * RF Registers setup * 803 \********************/ 804 805 /** 806 * ath5k_hw_rfregs_init() - Initialize RF register settings 807 * @ah: The &struct ath5k_hw 808 * @channel: The &struct ieee80211_channel 809 * @mode: One of enum ath5k_driver_mode 810 * 811 * Setup RF registers by writing RF buffer on hw. For 812 * more infos on this, check out rfbuffer.h 813 */ 814 static int 815 ath5k_hw_rfregs_init(struct ath5k_hw *ah, 816 struct ieee80211_channel *channel, 817 unsigned int mode) 818 { 819 const struct ath5k_rf_reg *rf_regs; 820 const struct ath5k_ini_rfbuffer *ini_rfb; 821 const struct ath5k_gain_opt *go = NULL; 822 const struct ath5k_gain_opt_step *g_step; 823 struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom; 824 u8 ee_mode = 0; 825 u32 *rfb; 826 int i, obdb = -1, bank = -1; 827 828 switch (ah->ah_radio) { 829 case AR5K_RF5111: 830 rf_regs = rf_regs_5111; 831 ah->ah_rf_regs_count = ARRAY_SIZE(rf_regs_5111); 832 ini_rfb = rfb_5111; 833 ah->ah_rf_banks_size = ARRAY_SIZE(rfb_5111); 834 go = &rfgain_opt_5111; 835 break; 836 case AR5K_RF5112: 837 if (ah->ah_radio_5ghz_revision >= AR5K_SREV_RAD_5112A) { 838 rf_regs = rf_regs_5112a; 839 ah->ah_rf_regs_count = ARRAY_SIZE(rf_regs_5112a); 840 ini_rfb = rfb_5112a; 841 ah->ah_rf_banks_size = ARRAY_SIZE(rfb_5112a); 842 } else { 843 rf_regs = rf_regs_5112; 844 ah->ah_rf_regs_count = ARRAY_SIZE(rf_regs_5112); 845 ini_rfb = rfb_5112; 846 ah->ah_rf_banks_size = ARRAY_SIZE(rfb_5112); 847 } 848 go = &rfgain_opt_5112; 849 break; 850 case AR5K_RF2413: 851 rf_regs = rf_regs_2413; 852 ah->ah_rf_regs_count = ARRAY_SIZE(rf_regs_2413); 853 ini_rfb = rfb_2413; 854 ah->ah_rf_banks_size = ARRAY_SIZE(rfb_2413); 855 break; 856 case AR5K_RF2316: 857 rf_regs = rf_regs_2316; 858 ah->ah_rf_regs_count = ARRAY_SIZE(rf_regs_2316); 859 ini_rfb = rfb_2316; 860 ah->ah_rf_banks_size = ARRAY_SIZE(rfb_2316); 861 break; 862 case AR5K_RF5413: 863 rf_regs = rf_regs_5413; 864 ah->ah_rf_regs_count = ARRAY_SIZE(rf_regs_5413); 865 ini_rfb = rfb_5413; 866 ah->ah_rf_banks_size = ARRAY_SIZE(rfb_5413); 867 break; 868 case AR5K_RF2317: 869 rf_regs = rf_regs_2425; 870 ah->ah_rf_regs_count = ARRAY_SIZE(rf_regs_2425); 871 ini_rfb = rfb_2317; 872 ah->ah_rf_banks_size = ARRAY_SIZE(rfb_2317); 873 break; 874 case AR5K_RF2425: 875 rf_regs = rf_regs_2425; 876 ah->ah_rf_regs_count = ARRAY_SIZE(rf_regs_2425); 877 if (ah->ah_mac_srev < AR5K_SREV_AR2417) { 878 ini_rfb = rfb_2425; 879 ah->ah_rf_banks_size = ARRAY_SIZE(rfb_2425); 880 } else { 881 ini_rfb = rfb_2417; 882 ah->ah_rf_banks_size = ARRAY_SIZE(rfb_2417); 883 } 884 break; 885 default: 886 return -EINVAL; 887 } 888 889 /* If it's the first time we set RF buffer, allocate 890 * ah->ah_rf_banks based on ah->ah_rf_banks_size 891 * we set above */ 892 if (ah->ah_rf_banks == NULL) { 893 ah->ah_rf_banks = kmalloc(sizeof(u32) * ah->ah_rf_banks_size, 894 GFP_KERNEL); 895 if (ah->ah_rf_banks == NULL) { 896 ATH5K_ERR(ah, "out of memory\n"); 897 return -ENOMEM; 898 } 899 } 900 901 /* Copy values to modify them */ 902 rfb = ah->ah_rf_banks; 903 904 for (i = 0; i < ah->ah_rf_banks_size; i++) { 905 if (ini_rfb[i].rfb_bank >= AR5K_MAX_RF_BANKS) { 906 ATH5K_ERR(ah, "invalid bank\n"); 907 return -EINVAL; 908 } 909 910 /* Bank changed, write down the offset */ 911 if (bank != ini_rfb[i].rfb_bank) { 912 bank = ini_rfb[i].rfb_bank; 913 ah->ah_offset[bank] = i; 914 } 915 916 rfb[i] = ini_rfb[i].rfb_mode_data[mode]; 917 } 918 919 /* Set Output and Driver bias current (OB/DB) */ 920 if (channel->band == IEEE80211_BAND_2GHZ) { 921 922 if (channel->hw_value == AR5K_MODE_11B) 923 ee_mode = AR5K_EEPROM_MODE_11B; 924 else 925 ee_mode = AR5K_EEPROM_MODE_11G; 926 927 /* For RF511X/RF211X combination we 928 * use b_OB and b_DB parameters stored 929 * in eeprom on ee->ee_ob[ee_mode][0] 930 * 931 * For all other chips we use OB/DB for 2GHz 932 * stored in the b/g modal section just like 933 * 802.11a on ee->ee_ob[ee_mode][1] */ 934 if ((ah->ah_radio == AR5K_RF5111) || 935 (ah->ah_radio == AR5K_RF5112)) 936 obdb = 0; 937 else 938 obdb = 1; 939 940 ath5k_hw_rfb_op(ah, rf_regs, ee->ee_ob[ee_mode][obdb], 941 AR5K_RF_OB_2GHZ, true); 942 943 ath5k_hw_rfb_op(ah, rf_regs, ee->ee_db[ee_mode][obdb], 944 AR5K_RF_DB_2GHZ, true); 945 946 /* RF5111 always needs OB/DB for 5GHz, even if we use 2GHz */ 947 } else if ((channel->band == IEEE80211_BAND_5GHZ) || 948 (ah->ah_radio == AR5K_RF5111)) { 949 950 /* For 11a, Turbo and XR we need to choose 951 * OB/DB based on frequency range */ 952 ee_mode = AR5K_EEPROM_MODE_11A; 953 obdb = channel->center_freq >= 5725 ? 3 : 954 (channel->center_freq >= 5500 ? 2 : 955 (channel->center_freq >= 5260 ? 1 : 956 (channel->center_freq > 4000 ? 0 : -1))); 957 958 if (obdb < 0) 959 return -EINVAL; 960 961 ath5k_hw_rfb_op(ah, rf_regs, ee->ee_ob[ee_mode][obdb], 962 AR5K_RF_OB_5GHZ, true); 963 964 ath5k_hw_rfb_op(ah, rf_regs, ee->ee_db[ee_mode][obdb], 965 AR5K_RF_DB_5GHZ, true); 966 } 967 968 g_step = &go->go_step[ah->ah_gain.g_step_idx]; 969 970 /* Set turbo mode (N/A on RF5413) */ 971 if ((ah->ah_bwmode == AR5K_BWMODE_40MHZ) && 972 (ah->ah_radio != AR5K_RF5413)) 973 ath5k_hw_rfb_op(ah, rf_regs, 1, AR5K_RF_TURBO, false); 974 975 /* Bank Modifications (chip-specific) */ 976 if (ah->ah_radio == AR5K_RF5111) { 977 978 /* Set gain_F settings according to current step */ 979 if (channel->hw_value != AR5K_MODE_11B) { 980 981 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_FRAME_CTL, 982 AR5K_PHY_FRAME_CTL_TX_CLIP, 983 g_step->gos_param[0]); 984 985 ath5k_hw_rfb_op(ah, rf_regs, g_step->gos_param[1], 986 AR5K_RF_PWD_90, true); 987 988 ath5k_hw_rfb_op(ah, rf_regs, g_step->gos_param[2], 989 AR5K_RF_PWD_84, true); 990 991 ath5k_hw_rfb_op(ah, rf_regs, g_step->gos_param[3], 992 AR5K_RF_RFGAIN_SEL, true); 993 994 /* We programmed gain_F parameters, switch back 995 * to active state */ 996 ah->ah_gain.g_state = AR5K_RFGAIN_ACTIVE; 997 998 } 999 1000 /* Bank 6/7 setup */ 1001 1002 ath5k_hw_rfb_op(ah, rf_regs, !ee->ee_xpd[ee_mode], 1003 AR5K_RF_PWD_XPD, true); 1004 1005 ath5k_hw_rfb_op(ah, rf_regs, ee->ee_x_gain[ee_mode], 1006 AR5K_RF_XPD_GAIN, true); 1007 1008 ath5k_hw_rfb_op(ah, rf_regs, ee->ee_i_gain[ee_mode], 1009 AR5K_RF_GAIN_I, true); 1010 1011 ath5k_hw_rfb_op(ah, rf_regs, ee->ee_xpd[ee_mode], 1012 AR5K_RF_PLO_SEL, true); 1013 1014 /* Tweak power detectors for half/quarter rate support */ 1015 if (ah->ah_bwmode == AR5K_BWMODE_5MHZ || 1016 ah->ah_bwmode == AR5K_BWMODE_10MHZ) { 1017 u8 wait_i; 1018 1019 ath5k_hw_rfb_op(ah, rf_regs, 0x1f, 1020 AR5K_RF_WAIT_S, true); 1021 1022 wait_i = (ah->ah_bwmode == AR5K_BWMODE_5MHZ) ? 1023 0x1f : 0x10; 1024 1025 ath5k_hw_rfb_op(ah, rf_regs, wait_i, 1026 AR5K_RF_WAIT_I, true); 1027 ath5k_hw_rfb_op(ah, rf_regs, 3, 1028 AR5K_RF_MAX_TIME, true); 1029 1030 } 1031 } 1032 1033 if (ah->ah_radio == AR5K_RF5112) { 1034 1035 /* Set gain_F settings according to current step */ 1036 if (channel->hw_value != AR5K_MODE_11B) { 1037 1038 ath5k_hw_rfb_op(ah, rf_regs, g_step->gos_param[0], 1039 AR5K_RF_MIXGAIN_OVR, true); 1040 1041 ath5k_hw_rfb_op(ah, rf_regs, g_step->gos_param[1], 1042 AR5K_RF_PWD_138, true); 1043 1044 ath5k_hw_rfb_op(ah, rf_regs, g_step->gos_param[2], 1045 AR5K_RF_PWD_137, true); 1046 1047 ath5k_hw_rfb_op(ah, rf_regs, g_step->gos_param[3], 1048 AR5K_RF_PWD_136, true); 1049 1050 ath5k_hw_rfb_op(ah, rf_regs, g_step->gos_param[4], 1051 AR5K_RF_PWD_132, true); 1052 1053 ath5k_hw_rfb_op(ah, rf_regs, g_step->gos_param[5], 1054 AR5K_RF_PWD_131, true); 1055 1056 ath5k_hw_rfb_op(ah, rf_regs, g_step->gos_param[6], 1057 AR5K_RF_PWD_130, true); 1058 1059 /* We programmed gain_F parameters, switch back 1060 * to active state */ 1061 ah->ah_gain.g_state = AR5K_RFGAIN_ACTIVE; 1062 } 1063 1064 /* Bank 6/7 setup */ 1065 1066 ath5k_hw_rfb_op(ah, rf_regs, ee->ee_xpd[ee_mode], 1067 AR5K_RF_XPD_SEL, true); 1068 1069 if (ah->ah_radio_5ghz_revision < AR5K_SREV_RAD_5112A) { 1070 /* Rev. 1 supports only one xpd */ 1071 ath5k_hw_rfb_op(ah, rf_regs, 1072 ee->ee_x_gain[ee_mode], 1073 AR5K_RF_XPD_GAIN, true); 1074 1075 } else { 1076 u8 *pdg_curve_to_idx = ee->ee_pdc_to_idx[ee_mode]; 1077 if (ee->ee_pd_gains[ee_mode] > 1) { 1078 ath5k_hw_rfb_op(ah, rf_regs, 1079 pdg_curve_to_idx[0], 1080 AR5K_RF_PD_GAIN_LO, true); 1081 ath5k_hw_rfb_op(ah, rf_regs, 1082 pdg_curve_to_idx[1], 1083 AR5K_RF_PD_GAIN_HI, true); 1084 } else { 1085 ath5k_hw_rfb_op(ah, rf_regs, 1086 pdg_curve_to_idx[0], 1087 AR5K_RF_PD_GAIN_LO, true); 1088 ath5k_hw_rfb_op(ah, rf_regs, 1089 pdg_curve_to_idx[0], 1090 AR5K_RF_PD_GAIN_HI, true); 1091 } 1092 1093 /* Lower synth voltage on Rev 2 */ 1094 if (ah->ah_radio == AR5K_RF5112 && 1095 (ah->ah_radio_5ghz_revision & AR5K_SREV_REV) > 0) { 1096 ath5k_hw_rfb_op(ah, rf_regs, 2, 1097 AR5K_RF_HIGH_VC_CP, true); 1098 1099 ath5k_hw_rfb_op(ah, rf_regs, 2, 1100 AR5K_RF_MID_VC_CP, true); 1101 1102 ath5k_hw_rfb_op(ah, rf_regs, 2, 1103 AR5K_RF_LOW_VC_CP, true); 1104 1105 ath5k_hw_rfb_op(ah, rf_regs, 2, 1106 AR5K_RF_PUSH_UP, true); 1107 } 1108 1109 /* Decrease power consumption on 5213+ BaseBand */ 1110 if (ah->ah_phy_revision >= AR5K_SREV_PHY_5212A) { 1111 ath5k_hw_rfb_op(ah, rf_regs, 1, 1112 AR5K_RF_PAD2GND, true); 1113 1114 ath5k_hw_rfb_op(ah, rf_regs, 1, 1115 AR5K_RF_XB2_LVL, true); 1116 1117 ath5k_hw_rfb_op(ah, rf_regs, 1, 1118 AR5K_RF_XB5_LVL, true); 1119 1120 ath5k_hw_rfb_op(ah, rf_regs, 1, 1121 AR5K_RF_PWD_167, true); 1122 1123 ath5k_hw_rfb_op(ah, rf_regs, 1, 1124 AR5K_RF_PWD_166, true); 1125 } 1126 } 1127 1128 ath5k_hw_rfb_op(ah, rf_regs, ee->ee_i_gain[ee_mode], 1129 AR5K_RF_GAIN_I, true); 1130 1131 /* Tweak power detector for half/quarter rates */ 1132 if (ah->ah_bwmode == AR5K_BWMODE_5MHZ || 1133 ah->ah_bwmode == AR5K_BWMODE_10MHZ) { 1134 u8 pd_delay; 1135 1136 pd_delay = (ah->ah_bwmode == AR5K_BWMODE_5MHZ) ? 1137 0xf : 0x8; 1138 1139 ath5k_hw_rfb_op(ah, rf_regs, pd_delay, 1140 AR5K_RF_PD_PERIOD_A, true); 1141 ath5k_hw_rfb_op(ah, rf_regs, 0xf, 1142 AR5K_RF_PD_DELAY_A, true); 1143 1144 } 1145 } 1146 1147 if (ah->ah_radio == AR5K_RF5413 && 1148 channel->band == IEEE80211_BAND_2GHZ) { 1149 1150 ath5k_hw_rfb_op(ah, rf_regs, 1, AR5K_RF_DERBY_CHAN_SEL_MODE, 1151 true); 1152 1153 /* Set optimum value for early revisions (on pci-e chips) */ 1154 if (ah->ah_mac_srev >= AR5K_SREV_AR5424 && 1155 ah->ah_mac_srev < AR5K_SREV_AR5413) 1156 ath5k_hw_rfb_op(ah, rf_regs, ath5k_hw_bitswap(6, 3), 1157 AR5K_RF_PWD_ICLOBUF_2G, true); 1158 1159 } 1160 1161 /* Write RF banks on hw */ 1162 for (i = 0; i < ah->ah_rf_banks_size; i++) { 1163 AR5K_REG_WAIT(i); 1164 ath5k_hw_reg_write(ah, rfb[i], ini_rfb[i].rfb_ctrl_register); 1165 } 1166 1167 return 0; 1168 } 1169 1170 1171 /**************************\ 1172 PHY/RF channel functions 1173 \**************************/ 1174 1175 /** 1176 * ath5k_hw_rf5110_chan2athchan() - Convert channel freq on RF5110 1177 * @channel: The &struct ieee80211_channel 1178 * 1179 * Map channel frequency to IEEE channel number and convert it 1180 * to an internal channel value used by the RF5110 chipset. 1181 */ 1182 static u32 1183 ath5k_hw_rf5110_chan2athchan(struct ieee80211_channel *channel) 1184 { 1185 u32 athchan; 1186 1187 athchan = (ath5k_hw_bitswap( 1188 (ieee80211_frequency_to_channel( 1189 channel->center_freq) - 24) / 2, 5) 1190 << 1) | (1 << 6) | 0x1; 1191 return athchan; 1192 } 1193 1194 /** 1195 * ath5k_hw_rf5110_channel() - Set channel frequency on RF5110 1196 * @ah: The &struct ath5k_hw 1197 * @channel: The &struct ieee80211_channel 1198 */ 1199 static int 1200 ath5k_hw_rf5110_channel(struct ath5k_hw *ah, 1201 struct ieee80211_channel *channel) 1202 { 1203 u32 data; 1204 1205 /* 1206 * Set the channel and wait 1207 */ 1208 data = ath5k_hw_rf5110_chan2athchan(channel); 1209 ath5k_hw_reg_write(ah, data, AR5K_RF_BUFFER); 1210 ath5k_hw_reg_write(ah, 0, AR5K_RF_BUFFER_CONTROL_0); 1211 usleep_range(1000, 1500); 1212 1213 return 0; 1214 } 1215 1216 /** 1217 * ath5k_hw_rf5111_chan2athchan() - Handle 2GHz channels on RF5111/2111 1218 * @ieee: IEEE channel number 1219 * @athchan: The &struct ath5k_athchan_2ghz 1220 * 1221 * In order to enable the RF2111 frequency converter on RF5111/2111 setups 1222 * we need to add some offsets and extra flags to the data values we pass 1223 * on to the PHY. So for every 2GHz channel this function gets called 1224 * to do the conversion. 1225 */ 1226 static int 1227 ath5k_hw_rf5111_chan2athchan(unsigned int ieee, 1228 struct ath5k_athchan_2ghz *athchan) 1229 { 1230 int channel; 1231 1232 /* Cast this value to catch negative channel numbers (>= -19) */ 1233 channel = (int)ieee; 1234 1235 /* 1236 * Map 2GHz IEEE channel to 5GHz Atheros channel 1237 */ 1238 if (channel <= 13) { 1239 athchan->a2_athchan = 115 + channel; 1240 athchan->a2_flags = 0x46; 1241 } else if (channel == 14) { 1242 athchan->a2_athchan = 124; 1243 athchan->a2_flags = 0x44; 1244 } else if (channel >= 15 && channel <= 26) { 1245 athchan->a2_athchan = ((channel - 14) * 4) + 132; 1246 athchan->a2_flags = 0x46; 1247 } else 1248 return -EINVAL; 1249 1250 return 0; 1251 } 1252 1253 /** 1254 * ath5k_hw_rf5111_channel() - Set channel frequency on RF5111/2111 1255 * @ah: The &struct ath5k_hw 1256 * @channel: The &struct ieee80211_channel 1257 */ 1258 static int 1259 ath5k_hw_rf5111_channel(struct ath5k_hw *ah, 1260 struct ieee80211_channel *channel) 1261 { 1262 struct ath5k_athchan_2ghz ath5k_channel_2ghz; 1263 unsigned int ath5k_channel = 1264 ieee80211_frequency_to_channel(channel->center_freq); 1265 u32 data0, data1, clock; 1266 int ret; 1267 1268 /* 1269 * Set the channel on the RF5111 radio 1270 */ 1271 data0 = data1 = 0; 1272 1273 if (channel->band == IEEE80211_BAND_2GHZ) { 1274 /* Map 2GHz channel to 5GHz Atheros channel ID */ 1275 ret = ath5k_hw_rf5111_chan2athchan( 1276 ieee80211_frequency_to_channel(channel->center_freq), 1277 &ath5k_channel_2ghz); 1278 if (ret) 1279 return ret; 1280 1281 ath5k_channel = ath5k_channel_2ghz.a2_athchan; 1282 data0 = ((ath5k_hw_bitswap(ath5k_channel_2ghz.a2_flags, 8) & 0xff) 1283 << 5) | (1 << 4); 1284 } 1285 1286 if (ath5k_channel < 145 || !(ath5k_channel & 1)) { 1287 clock = 1; 1288 data1 = ((ath5k_hw_bitswap(ath5k_channel - 24, 8) & 0xff) << 2) | 1289 (clock << 1) | (1 << 10) | 1; 1290 } else { 1291 clock = 0; 1292 data1 = ((ath5k_hw_bitswap((ath5k_channel - 24) / 2, 8) & 0xff) 1293 << 2) | (clock << 1) | (1 << 10) | 1; 1294 } 1295 1296 ath5k_hw_reg_write(ah, (data1 & 0xff) | ((data0 & 0xff) << 8), 1297 AR5K_RF_BUFFER); 1298 ath5k_hw_reg_write(ah, ((data1 >> 8) & 0xff) | (data0 & 0xff00), 1299 AR5K_RF_BUFFER_CONTROL_3); 1300 1301 return 0; 1302 } 1303 1304 /** 1305 * ath5k_hw_rf5112_channel() - Set channel frequency on 5112 and newer 1306 * @ah: The &struct ath5k_hw 1307 * @channel: The &struct ieee80211_channel 1308 * 1309 * On RF5112/2112 and newer we don't need to do any conversion. 1310 * We pass the frequency value after a few modifications to the 1311 * chip directly. 1312 * 1313 * NOTE: Make sure channel frequency given is within our range or else 1314 * we might damage the chip ! Use ath5k_channel_ok before calling this one. 1315 */ 1316 static int 1317 ath5k_hw_rf5112_channel(struct ath5k_hw *ah, 1318 struct ieee80211_channel *channel) 1319 { 1320 u32 data, data0, data1, data2; 1321 u16 c; 1322 1323 data = data0 = data1 = data2 = 0; 1324 c = channel->center_freq; 1325 1326 /* My guess based on code: 1327 * 2GHz RF has 2 synth modes, one with a Local Oscillator 1328 * at 2224Hz and one with a LO at 2192Hz. IF is 1520Hz 1329 * (3040/2). data0 is used to set the PLL divider and data1 1330 * selects synth mode. */ 1331 if (c < 4800) { 1332 /* Channel 14 and all frequencies with 2Hz spacing 1333 * below/above (non-standard channels) */ 1334 if (!((c - 2224) % 5)) { 1335 /* Same as (c - 2224) / 5 */ 1336 data0 = ((2 * (c - 704)) - 3040) / 10; 1337 data1 = 1; 1338 /* Channel 1 and all frequencies with 5Hz spacing 1339 * below/above (standard channels without channel 14) */ 1340 } else if (!((c - 2192) % 5)) { 1341 /* Same as (c - 2192) / 5 */ 1342 data0 = ((2 * (c - 672)) - 3040) / 10; 1343 data1 = 0; 1344 } else 1345 return -EINVAL; 1346 1347 data0 = ath5k_hw_bitswap((data0 << 2) & 0xff, 8); 1348 /* This is more complex, we have a single synthesizer with 1349 * 4 reference clock settings (?) based on frequency spacing 1350 * and set using data2. LO is at 4800Hz and data0 is again used 1351 * to set some divider. 1352 * 1353 * NOTE: There is an old atheros presentation at Stanford 1354 * that mentions a method called dual direct conversion 1355 * with 1GHz sliding IF for RF5110. Maybe that's what we 1356 * have here, or an updated version. */ 1357 } else if ((c % 5) != 2 || c > 5435) { 1358 if (!(c % 20) && c >= 5120) { 1359 data0 = ath5k_hw_bitswap(((c - 4800) / 20 << 2), 8); 1360 data2 = ath5k_hw_bitswap(3, 2); 1361 } else if (!(c % 10)) { 1362 data0 = ath5k_hw_bitswap(((c - 4800) / 10 << 1), 8); 1363 data2 = ath5k_hw_bitswap(2, 2); 1364 } else if (!(c % 5)) { 1365 data0 = ath5k_hw_bitswap((c - 4800) / 5, 8); 1366 data2 = ath5k_hw_bitswap(1, 2); 1367 } else 1368 return -EINVAL; 1369 } else { 1370 data0 = ath5k_hw_bitswap((10 * (c - 2 - 4800)) / 25 + 1, 8); 1371 data2 = ath5k_hw_bitswap(0, 2); 1372 } 1373 1374 data = (data0 << 4) | (data1 << 1) | (data2 << 2) | 0x1001; 1375 1376 ath5k_hw_reg_write(ah, data & 0xff, AR5K_RF_BUFFER); 1377 ath5k_hw_reg_write(ah, (data >> 8) & 0x7f, AR5K_RF_BUFFER_CONTROL_5); 1378 1379 return 0; 1380 } 1381 1382 /** 1383 * ath5k_hw_rf2425_channel() - Set channel frequency on RF2425 1384 * @ah: The &struct ath5k_hw 1385 * @channel: The &struct ieee80211_channel 1386 * 1387 * AR2425/2417 have a different 2GHz RF so code changes 1388 * a little bit from RF5112. 1389 */ 1390 static int 1391 ath5k_hw_rf2425_channel(struct ath5k_hw *ah, 1392 struct ieee80211_channel *channel) 1393 { 1394 u32 data, data0, data2; 1395 u16 c; 1396 1397 data = data0 = data2 = 0; 1398 c = channel->center_freq; 1399 1400 if (c < 4800) { 1401 data0 = ath5k_hw_bitswap((c - 2272), 8); 1402 data2 = 0; 1403 /* ? 5GHz ? */ 1404 } else if ((c % 5) != 2 || c > 5435) { 1405 if (!(c % 20) && c < 5120) 1406 data0 = ath5k_hw_bitswap(((c - 4800) / 20 << 2), 8); 1407 else if (!(c % 10)) 1408 data0 = ath5k_hw_bitswap(((c - 4800) / 10 << 1), 8); 1409 else if (!(c % 5)) 1410 data0 = ath5k_hw_bitswap((c - 4800) / 5, 8); 1411 else 1412 return -EINVAL; 1413 data2 = ath5k_hw_bitswap(1, 2); 1414 } else { 1415 data0 = ath5k_hw_bitswap((10 * (c - 2 - 4800)) / 25 + 1, 8); 1416 data2 = ath5k_hw_bitswap(0, 2); 1417 } 1418 1419 data = (data0 << 4) | data2 << 2 | 0x1001; 1420 1421 ath5k_hw_reg_write(ah, data & 0xff, AR5K_RF_BUFFER); 1422 ath5k_hw_reg_write(ah, (data >> 8) & 0x7f, AR5K_RF_BUFFER_CONTROL_5); 1423 1424 return 0; 1425 } 1426 1427 /** 1428 * ath5k_hw_channel() - Set a channel on the radio chip 1429 * @ah: The &struct ath5k_hw 1430 * @channel: The &struct ieee80211_channel 1431 * 1432 * This is the main function called to set a channel on the 1433 * radio chip based on the radio chip version. 1434 */ 1435 static int 1436 ath5k_hw_channel(struct ath5k_hw *ah, 1437 struct ieee80211_channel *channel) 1438 { 1439 int ret; 1440 /* 1441 * Check bounds supported by the PHY (we don't care about regulatory 1442 * restrictions at this point). 1443 */ 1444 if (!ath5k_channel_ok(ah, channel)) { 1445 ATH5K_ERR(ah, 1446 "channel frequency (%u MHz) out of supported " 1447 "band range\n", 1448 channel->center_freq); 1449 return -EINVAL; 1450 } 1451 1452 /* 1453 * Set the channel and wait 1454 */ 1455 switch (ah->ah_radio) { 1456 case AR5K_RF5110: 1457 ret = ath5k_hw_rf5110_channel(ah, channel); 1458 break; 1459 case AR5K_RF5111: 1460 ret = ath5k_hw_rf5111_channel(ah, channel); 1461 break; 1462 case AR5K_RF2317: 1463 case AR5K_RF2425: 1464 ret = ath5k_hw_rf2425_channel(ah, channel); 1465 break; 1466 default: 1467 ret = ath5k_hw_rf5112_channel(ah, channel); 1468 break; 1469 } 1470 1471 if (ret) 1472 return ret; 1473 1474 /* Set JAPAN setting for channel 14 */ 1475 if (channel->center_freq == 2484) { 1476 AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_CCKTXCTL, 1477 AR5K_PHY_CCKTXCTL_JAPAN); 1478 } else { 1479 AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_CCKTXCTL, 1480 AR5K_PHY_CCKTXCTL_WORLD); 1481 } 1482 1483 ah->ah_current_channel = channel; 1484 1485 return 0; 1486 } 1487 1488 1489 /*****************\ 1490 PHY calibration 1491 \*****************/ 1492 1493 /** 1494 * DOC: PHY Calibration routines 1495 * 1496 * Noise floor calibration: When we tell the hardware to 1497 * perform a noise floor calibration by setting the 1498 * AR5K_PHY_AGCCTL_NF bit on AR5K_PHY_AGCCTL, it will periodically 1499 * sample-and-hold the minimum noise level seen at the antennas. 1500 * This value is then stored in a ring buffer of recently measured 1501 * noise floor values so we have a moving window of the last few 1502 * samples. The median of the values in the history is then loaded 1503 * into the hardware for its own use for RSSI and CCA measurements. 1504 * This type of calibration doesn't interfere with traffic. 1505 * 1506 * AGC calibration: When we tell the hardware to perform 1507 * an AGC (Automatic Gain Control) calibration by setting the 1508 * AR5K_PHY_AGCCTL_CAL, hw disconnects the antennas and does 1509 * a calibration on the DC offsets of ADCs. During this period 1510 * rx/tx gets disabled so we have to deal with it on the driver 1511 * part. 1512 * 1513 * I/Q calibration: When we tell the hardware to perform 1514 * an I/Q calibration, it tries to correct I/Q imbalance and 1515 * fix QAM constellation by sampling data from rxed frames. 1516 * It doesn't interfere with traffic. 1517 * 1518 * For more infos on AGC and I/Q calibration check out patent doc 1519 * #03/094463. 1520 */ 1521 1522 /** 1523 * ath5k_hw_read_measured_noise_floor() - Read measured NF from hw 1524 * @ah: The &struct ath5k_hw 1525 */ 1526 static s32 1527 ath5k_hw_read_measured_noise_floor(struct ath5k_hw *ah) 1528 { 1529 s32 val; 1530 1531 val = ath5k_hw_reg_read(ah, AR5K_PHY_NF); 1532 return sign_extend32(AR5K_REG_MS(val, AR5K_PHY_NF_MINCCA_PWR), 8); 1533 } 1534 1535 /** 1536 * ath5k_hw_init_nfcal_hist() - Initialize NF calibration history buffer 1537 * @ah: The &struct ath5k_hw 1538 */ 1539 void 1540 ath5k_hw_init_nfcal_hist(struct ath5k_hw *ah) 1541 { 1542 int i; 1543 1544 ah->ah_nfcal_hist.index = 0; 1545 for (i = 0; i < ATH5K_NF_CAL_HIST_MAX; i++) 1546 ah->ah_nfcal_hist.nfval[i] = AR5K_TUNE_CCA_MAX_GOOD_VALUE; 1547 } 1548 1549 /** 1550 * ath5k_hw_update_nfcal_hist() - Update NF calibration history buffer 1551 * @ah: The &struct ath5k_hw 1552 * @noise_floor: The NF we got from hw 1553 */ 1554 static void ath5k_hw_update_nfcal_hist(struct ath5k_hw *ah, s16 noise_floor) 1555 { 1556 struct ath5k_nfcal_hist *hist = &ah->ah_nfcal_hist; 1557 hist->index = (hist->index + 1) & (ATH5K_NF_CAL_HIST_MAX - 1); 1558 hist->nfval[hist->index] = noise_floor; 1559 } 1560 1561 /** 1562 * ath5k_hw_get_median_noise_floor() - Get median NF from history buffer 1563 * @ah: The &struct ath5k_hw 1564 */ 1565 static s16 1566 ath5k_hw_get_median_noise_floor(struct ath5k_hw *ah) 1567 { 1568 s16 sort[ATH5K_NF_CAL_HIST_MAX]; 1569 s16 tmp; 1570 int i, j; 1571 1572 memcpy(sort, ah->ah_nfcal_hist.nfval, sizeof(sort)); 1573 for (i = 0; i < ATH5K_NF_CAL_HIST_MAX - 1; i++) { 1574 for (j = 1; j < ATH5K_NF_CAL_HIST_MAX - i; j++) { 1575 if (sort[j] > sort[j - 1]) { 1576 tmp = sort[j]; 1577 sort[j] = sort[j - 1]; 1578 sort[j - 1] = tmp; 1579 } 1580 } 1581 } 1582 for (i = 0; i < ATH5K_NF_CAL_HIST_MAX; i++) { 1583 ATH5K_DBG(ah, ATH5K_DEBUG_CALIBRATE, 1584 "cal %d:%d\n", i, sort[i]); 1585 } 1586 return sort[(ATH5K_NF_CAL_HIST_MAX - 1) / 2]; 1587 } 1588 1589 /** 1590 * ath5k_hw_update_noise_floor() - Update NF on hardware 1591 * @ah: The &struct ath5k_hw 1592 * 1593 * This is the main function we call to perform a NF calibration, 1594 * it reads NF from hardware, calculates the median and updates 1595 * NF on hw. 1596 */ 1597 void 1598 ath5k_hw_update_noise_floor(struct ath5k_hw *ah) 1599 { 1600 struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom; 1601 u32 val; 1602 s16 nf, threshold; 1603 u8 ee_mode; 1604 1605 /* keep last value if calibration hasn't completed */ 1606 if (ath5k_hw_reg_read(ah, AR5K_PHY_AGCCTL) & AR5K_PHY_AGCCTL_NF) { 1607 ATH5K_DBG(ah, ATH5K_DEBUG_CALIBRATE, 1608 "NF did not complete in calibration window\n"); 1609 1610 return; 1611 } 1612 1613 ah->ah_cal_mask |= AR5K_CALIBRATION_NF; 1614 1615 ee_mode = ath5k_eeprom_mode_from_channel(ah->ah_current_channel); 1616 if (WARN_ON(ee_mode < 0)) { 1617 ah->ah_cal_mask &= ~AR5K_CALIBRATION_NF; 1618 return; 1619 } 1620 1621 /* completed NF calibration, test threshold */ 1622 nf = ath5k_hw_read_measured_noise_floor(ah); 1623 threshold = ee->ee_noise_floor_thr[ee_mode]; 1624 1625 if (nf > threshold) { 1626 ATH5K_DBG(ah, ATH5K_DEBUG_CALIBRATE, 1627 "noise floor failure detected; " 1628 "read %d, threshold %d\n", 1629 nf, threshold); 1630 1631 nf = AR5K_TUNE_CCA_MAX_GOOD_VALUE; 1632 } 1633 1634 ath5k_hw_update_nfcal_hist(ah, nf); 1635 nf = ath5k_hw_get_median_noise_floor(ah); 1636 1637 /* load noise floor (in .5 dBm) so the hardware will use it */ 1638 val = ath5k_hw_reg_read(ah, AR5K_PHY_NF) & ~AR5K_PHY_NF_M; 1639 val |= (nf * 2) & AR5K_PHY_NF_M; 1640 ath5k_hw_reg_write(ah, val, AR5K_PHY_NF); 1641 1642 AR5K_REG_MASKED_BITS(ah, AR5K_PHY_AGCCTL, AR5K_PHY_AGCCTL_NF, 1643 ~(AR5K_PHY_AGCCTL_NF_EN | AR5K_PHY_AGCCTL_NF_NOUPDATE)); 1644 1645 ath5k_hw_register_timeout(ah, AR5K_PHY_AGCCTL, AR5K_PHY_AGCCTL_NF, 1646 0, false); 1647 1648 /* 1649 * Load a high max CCA Power value (-50 dBm in .5 dBm units) 1650 * so that we're not capped by the median we just loaded. 1651 * This will be used as the initial value for the next noise 1652 * floor calibration. 1653 */ 1654 val = (val & ~AR5K_PHY_NF_M) | ((-50 * 2) & AR5K_PHY_NF_M); 1655 ath5k_hw_reg_write(ah, val, AR5K_PHY_NF); 1656 AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_AGCCTL, 1657 AR5K_PHY_AGCCTL_NF_EN | 1658 AR5K_PHY_AGCCTL_NF_NOUPDATE | 1659 AR5K_PHY_AGCCTL_NF); 1660 1661 ah->ah_noise_floor = nf; 1662 1663 ah->ah_cal_mask &= ~AR5K_CALIBRATION_NF; 1664 1665 ATH5K_DBG(ah, ATH5K_DEBUG_CALIBRATE, 1666 "noise floor calibrated: %d\n", nf); 1667 } 1668 1669 /** 1670 * ath5k_hw_rf5110_calibrate() - Perform a PHY calibration on RF5110 1671 * @ah: The &struct ath5k_hw 1672 * @channel: The &struct ieee80211_channel 1673 * 1674 * Do a complete PHY calibration (AGC + NF + I/Q) on RF5110 1675 */ 1676 static int 1677 ath5k_hw_rf5110_calibrate(struct ath5k_hw *ah, 1678 struct ieee80211_channel *channel) 1679 { 1680 u32 phy_sig, phy_agc, phy_sat, beacon; 1681 int ret; 1682 1683 if (!(ah->ah_cal_mask & AR5K_CALIBRATION_FULL)) 1684 return 0; 1685 1686 /* 1687 * Disable beacons and RX/TX queues, wait 1688 */ 1689 AR5K_REG_ENABLE_BITS(ah, AR5K_DIAG_SW_5210, 1690 AR5K_DIAG_SW_DIS_TX_5210 | AR5K_DIAG_SW_DIS_RX_5210); 1691 beacon = ath5k_hw_reg_read(ah, AR5K_BEACON_5210); 1692 ath5k_hw_reg_write(ah, beacon & ~AR5K_BEACON_ENABLE, AR5K_BEACON_5210); 1693 1694 usleep_range(2000, 2500); 1695 1696 /* 1697 * Set the channel (with AGC turned off) 1698 */ 1699 AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_AGC, AR5K_PHY_AGC_DISABLE); 1700 udelay(10); 1701 ret = ath5k_hw_channel(ah, channel); 1702 1703 /* 1704 * Activate PHY and wait 1705 */ 1706 ath5k_hw_reg_write(ah, AR5K_PHY_ACT_ENABLE, AR5K_PHY_ACT); 1707 usleep_range(1000, 1500); 1708 1709 AR5K_REG_DISABLE_BITS(ah, AR5K_PHY_AGC, AR5K_PHY_AGC_DISABLE); 1710 1711 if (ret) 1712 return ret; 1713 1714 /* 1715 * Calibrate the radio chip 1716 */ 1717 1718 /* Remember normal state */ 1719 phy_sig = ath5k_hw_reg_read(ah, AR5K_PHY_SIG); 1720 phy_agc = ath5k_hw_reg_read(ah, AR5K_PHY_AGCCOARSE); 1721 phy_sat = ath5k_hw_reg_read(ah, AR5K_PHY_ADCSAT); 1722 1723 /* Update radio registers */ 1724 ath5k_hw_reg_write(ah, (phy_sig & ~(AR5K_PHY_SIG_FIRPWR)) | 1725 AR5K_REG_SM(-1, AR5K_PHY_SIG_FIRPWR), AR5K_PHY_SIG); 1726 1727 ath5k_hw_reg_write(ah, (phy_agc & ~(AR5K_PHY_AGCCOARSE_HI | 1728 AR5K_PHY_AGCCOARSE_LO)) | 1729 AR5K_REG_SM(-1, AR5K_PHY_AGCCOARSE_HI) | 1730 AR5K_REG_SM(-127, AR5K_PHY_AGCCOARSE_LO), AR5K_PHY_AGCCOARSE); 1731 1732 ath5k_hw_reg_write(ah, (phy_sat & ~(AR5K_PHY_ADCSAT_ICNT | 1733 AR5K_PHY_ADCSAT_THR)) | 1734 AR5K_REG_SM(2, AR5K_PHY_ADCSAT_ICNT) | 1735 AR5K_REG_SM(12, AR5K_PHY_ADCSAT_THR), AR5K_PHY_ADCSAT); 1736 1737 udelay(20); 1738 1739 AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_AGC, AR5K_PHY_AGC_DISABLE); 1740 udelay(10); 1741 ath5k_hw_reg_write(ah, AR5K_PHY_RFSTG_DISABLE, AR5K_PHY_RFSTG); 1742 AR5K_REG_DISABLE_BITS(ah, AR5K_PHY_AGC, AR5K_PHY_AGC_DISABLE); 1743 1744 usleep_range(1000, 1500); 1745 1746 /* 1747 * Enable calibration and wait until completion 1748 */ 1749 AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_AGCCTL, AR5K_PHY_AGCCTL_CAL); 1750 1751 ret = ath5k_hw_register_timeout(ah, AR5K_PHY_AGCCTL, 1752 AR5K_PHY_AGCCTL_CAL, 0, false); 1753 1754 /* Reset to normal state */ 1755 ath5k_hw_reg_write(ah, phy_sig, AR5K_PHY_SIG); 1756 ath5k_hw_reg_write(ah, phy_agc, AR5K_PHY_AGCCOARSE); 1757 ath5k_hw_reg_write(ah, phy_sat, AR5K_PHY_ADCSAT); 1758 1759 if (ret) { 1760 ATH5K_ERR(ah, "calibration timeout (%uMHz)\n", 1761 channel->center_freq); 1762 return ret; 1763 } 1764 1765 /* 1766 * Re-enable RX/TX and beacons 1767 */ 1768 AR5K_REG_DISABLE_BITS(ah, AR5K_DIAG_SW_5210, 1769 AR5K_DIAG_SW_DIS_TX_5210 | AR5K_DIAG_SW_DIS_RX_5210); 1770 ath5k_hw_reg_write(ah, beacon, AR5K_BEACON_5210); 1771 1772 return 0; 1773 } 1774 1775 /** 1776 * ath5k_hw_rf511x_iq_calibrate() - Perform I/Q calibration on RF5111 and newer 1777 * @ah: The &struct ath5k_hw 1778 */ 1779 static int 1780 ath5k_hw_rf511x_iq_calibrate(struct ath5k_hw *ah) 1781 { 1782 u32 i_pwr, q_pwr; 1783 s32 iq_corr, i_coff, i_coffd, q_coff, q_coffd; 1784 int i; 1785 1786 /* Skip if I/Q calibration is not needed or if it's still running */ 1787 if (!ah->ah_iq_cal_needed) 1788 return -EINVAL; 1789 else if (ath5k_hw_reg_read(ah, AR5K_PHY_IQ) & AR5K_PHY_IQ_RUN) { 1790 ATH5K_DBG_UNLIMIT(ah, ATH5K_DEBUG_CALIBRATE, 1791 "I/Q calibration still running"); 1792 return -EBUSY; 1793 } 1794 1795 /* Calibration has finished, get the results and re-run */ 1796 1797 /* Work around for empty results which can apparently happen on 5212: 1798 * Read registers up to 10 times until we get both i_pr and q_pwr */ 1799 for (i = 0; i <= 10; i++) { 1800 iq_corr = ath5k_hw_reg_read(ah, AR5K_PHY_IQRES_CAL_CORR); 1801 i_pwr = ath5k_hw_reg_read(ah, AR5K_PHY_IQRES_CAL_PWR_I); 1802 q_pwr = ath5k_hw_reg_read(ah, AR5K_PHY_IQRES_CAL_PWR_Q); 1803 ATH5K_DBG_UNLIMIT(ah, ATH5K_DEBUG_CALIBRATE, 1804 "iq_corr:%x i_pwr:%x q_pwr:%x", iq_corr, i_pwr, q_pwr); 1805 if (i_pwr && q_pwr) 1806 break; 1807 } 1808 1809 i_coffd = ((i_pwr >> 1) + (q_pwr >> 1)) >> 7; 1810 1811 if (ah->ah_version == AR5K_AR5211) 1812 q_coffd = q_pwr >> 6; 1813 else 1814 q_coffd = q_pwr >> 7; 1815 1816 /* In case i_coffd became zero, cancel calibration 1817 * not only it's too small, it'll also result a divide 1818 * by zero later on. */ 1819 if (i_coffd == 0 || q_coffd < 2) 1820 return -ECANCELED; 1821 1822 /* Protect against loss of sign bits */ 1823 1824 i_coff = (-iq_corr) / i_coffd; 1825 i_coff = clamp(i_coff, -32, 31); /* signed 6 bit */ 1826 1827 if (ah->ah_version == AR5K_AR5211) 1828 q_coff = (i_pwr / q_coffd) - 64; 1829 else 1830 q_coff = (i_pwr / q_coffd) - 128; 1831 q_coff = clamp(q_coff, -16, 15); /* signed 5 bit */ 1832 1833 ATH5K_DBG_UNLIMIT(ah, ATH5K_DEBUG_CALIBRATE, 1834 "new I:%d Q:%d (i_coffd:%x q_coffd:%x)", 1835 i_coff, q_coff, i_coffd, q_coffd); 1836 1837 /* Commit new I/Q values (set enable bit last to match HAL sources) */ 1838 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_IQ, AR5K_PHY_IQ_CORR_Q_I_COFF, i_coff); 1839 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_IQ, AR5K_PHY_IQ_CORR_Q_Q_COFF, q_coff); 1840 AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_IQ, AR5K_PHY_IQ_CORR_ENABLE); 1841 1842 /* Re-enable calibration -if we don't we'll commit 1843 * the same values again and again */ 1844 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_IQ, 1845 AR5K_PHY_IQ_CAL_NUM_LOG_MAX, 15); 1846 AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_IQ, AR5K_PHY_IQ_RUN); 1847 1848 return 0; 1849 } 1850 1851 /** 1852 * ath5k_hw_phy_calibrate() - Perform a PHY calibration 1853 * @ah: The &struct ath5k_hw 1854 * @channel: The &struct ieee80211_channel 1855 * 1856 * The main function we call from above to perform 1857 * a short or full PHY calibration based on RF chip 1858 * and current channel 1859 */ 1860 int 1861 ath5k_hw_phy_calibrate(struct ath5k_hw *ah, 1862 struct ieee80211_channel *channel) 1863 { 1864 int ret; 1865 1866 if (ah->ah_radio == AR5K_RF5110) 1867 return ath5k_hw_rf5110_calibrate(ah, channel); 1868 1869 ret = ath5k_hw_rf511x_iq_calibrate(ah); 1870 if (ret) { 1871 ATH5K_DBG_UNLIMIT(ah, ATH5K_DEBUG_CALIBRATE, 1872 "No I/Q correction performed (%uMHz)\n", 1873 channel->center_freq); 1874 1875 /* Happens all the time if there is not much 1876 * traffic, consider it normal behaviour. */ 1877 ret = 0; 1878 } 1879 1880 /* On full calibration request a PAPD probe for 1881 * gainf calibration if needed */ 1882 if ((ah->ah_cal_mask & AR5K_CALIBRATION_FULL) && 1883 (ah->ah_radio == AR5K_RF5111 || 1884 ah->ah_radio == AR5K_RF5112) && 1885 channel->hw_value != AR5K_MODE_11B) 1886 ath5k_hw_request_rfgain_probe(ah); 1887 1888 /* Update noise floor */ 1889 if (!(ah->ah_cal_mask & AR5K_CALIBRATION_NF)) 1890 ath5k_hw_update_noise_floor(ah); 1891 1892 return ret; 1893 } 1894 1895 1896 /***************************\ 1897 * Spur mitigation functions * 1898 \***************************/ 1899 1900 /** 1901 * ath5k_hw_set_spur_mitigation_filter() - Configure SPUR filter 1902 * @ah: The &struct ath5k_hw 1903 * @channel: The &struct ieee80211_channel 1904 * 1905 * This function gets called during PHY initialization to 1906 * configure the spur filter for the given channel. Spur is noise 1907 * generated due to "reflection" effects, for more information on this 1908 * method check out patent US7643810 1909 */ 1910 static void 1911 ath5k_hw_set_spur_mitigation_filter(struct ath5k_hw *ah, 1912 struct ieee80211_channel *channel) 1913 { 1914 struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom; 1915 u32 mag_mask[4] = {0, 0, 0, 0}; 1916 u32 pilot_mask[2] = {0, 0}; 1917 /* Note: fbin values are scaled up by 2 */ 1918 u16 spur_chan_fbin, chan_fbin, symbol_width, spur_detection_window; 1919 s32 spur_delta_phase, spur_freq_sigma_delta; 1920 s32 spur_offset, num_symbols_x16; 1921 u8 num_symbol_offsets, i, freq_band; 1922 1923 /* Convert current frequency to fbin value (the same way channels 1924 * are stored on EEPROM, check out ath5k_eeprom_bin2freq) and scale 1925 * up by 2 so we can compare it later */ 1926 if (channel->band == IEEE80211_BAND_2GHZ) { 1927 chan_fbin = (channel->center_freq - 2300) * 10; 1928 freq_band = AR5K_EEPROM_BAND_2GHZ; 1929 } else { 1930 chan_fbin = (channel->center_freq - 4900) * 10; 1931 freq_band = AR5K_EEPROM_BAND_5GHZ; 1932 } 1933 1934 /* Check if any spur_chan_fbin from EEPROM is 1935 * within our current channel's spur detection range */ 1936 spur_chan_fbin = AR5K_EEPROM_NO_SPUR; 1937 spur_detection_window = AR5K_SPUR_CHAN_WIDTH; 1938 /* XXX: Half/Quarter channels ?*/ 1939 if (ah->ah_bwmode == AR5K_BWMODE_40MHZ) 1940 spur_detection_window *= 2; 1941 1942 for (i = 0; i < AR5K_EEPROM_N_SPUR_CHANS; i++) { 1943 spur_chan_fbin = ee->ee_spur_chans[i][freq_band]; 1944 1945 /* Note: mask cleans AR5K_EEPROM_NO_SPUR flag 1946 * so it's zero if we got nothing from EEPROM */ 1947 if (spur_chan_fbin == AR5K_EEPROM_NO_SPUR) { 1948 spur_chan_fbin &= AR5K_EEPROM_SPUR_CHAN_MASK; 1949 break; 1950 } 1951 1952 if ((chan_fbin - spur_detection_window <= 1953 (spur_chan_fbin & AR5K_EEPROM_SPUR_CHAN_MASK)) && 1954 (chan_fbin + spur_detection_window >= 1955 (spur_chan_fbin & AR5K_EEPROM_SPUR_CHAN_MASK))) { 1956 spur_chan_fbin &= AR5K_EEPROM_SPUR_CHAN_MASK; 1957 break; 1958 } 1959 } 1960 1961 /* We need to enable spur filter for this channel */ 1962 if (spur_chan_fbin) { 1963 spur_offset = spur_chan_fbin - chan_fbin; 1964 /* 1965 * Calculate deltas: 1966 * spur_freq_sigma_delta -> spur_offset / sample_freq << 21 1967 * spur_delta_phase -> spur_offset / chip_freq << 11 1968 * Note: Both values have 100Hz resolution 1969 */ 1970 switch (ah->ah_bwmode) { 1971 case AR5K_BWMODE_40MHZ: 1972 /* Both sample_freq and chip_freq are 80MHz */ 1973 spur_delta_phase = (spur_offset << 16) / 25; 1974 spur_freq_sigma_delta = (spur_delta_phase >> 10); 1975 symbol_width = AR5K_SPUR_SYMBOL_WIDTH_BASE_100Hz * 2; 1976 break; 1977 case AR5K_BWMODE_10MHZ: 1978 /* Both sample_freq and chip_freq are 20MHz (?) */ 1979 spur_delta_phase = (spur_offset << 18) / 25; 1980 spur_freq_sigma_delta = (spur_delta_phase >> 10); 1981 symbol_width = AR5K_SPUR_SYMBOL_WIDTH_BASE_100Hz / 2; 1982 break; 1983 case AR5K_BWMODE_5MHZ: 1984 /* Both sample_freq and chip_freq are 10MHz (?) */ 1985 spur_delta_phase = (spur_offset << 19) / 25; 1986 spur_freq_sigma_delta = (spur_delta_phase >> 10); 1987 symbol_width = AR5K_SPUR_SYMBOL_WIDTH_BASE_100Hz / 4; 1988 break; 1989 default: 1990 if (channel->band == IEEE80211_BAND_5GHZ) { 1991 /* Both sample_freq and chip_freq are 40MHz */ 1992 spur_delta_phase = (spur_offset << 17) / 25; 1993 spur_freq_sigma_delta = 1994 (spur_delta_phase >> 10); 1995 symbol_width = 1996 AR5K_SPUR_SYMBOL_WIDTH_BASE_100Hz; 1997 } else { 1998 /* sample_freq -> 40MHz chip_freq -> 44MHz 1999 * (for b compatibility) */ 2000 spur_delta_phase = (spur_offset << 17) / 25; 2001 spur_freq_sigma_delta = 2002 (spur_offset << 8) / 55; 2003 symbol_width = 2004 AR5K_SPUR_SYMBOL_WIDTH_BASE_100Hz; 2005 } 2006 break; 2007 } 2008 2009 /* Calculate pilot and magnitude masks */ 2010 2011 /* Scale up spur_offset by 1000 to switch to 100HZ resolution 2012 * and divide by symbol_width to find how many symbols we have 2013 * Note: number of symbols is scaled up by 16 */ 2014 num_symbols_x16 = ((spur_offset * 1000) << 4) / symbol_width; 2015 2016 /* Spur is on a symbol if num_symbols_x16 % 16 is zero */ 2017 if (!(num_symbols_x16 & 0xF)) 2018 /* _X_ */ 2019 num_symbol_offsets = 3; 2020 else 2021 /* _xx_ */ 2022 num_symbol_offsets = 4; 2023 2024 for (i = 0; i < num_symbol_offsets; i++) { 2025 2026 /* Calculate pilot mask */ 2027 s32 curr_sym_off = 2028 (num_symbols_x16 / 16) + i + 25; 2029 2030 /* Pilot magnitude mask seems to be a way to 2031 * declare the boundaries for our detection 2032 * window or something, it's 2 for the middle 2033 * value(s) where the symbol is expected to be 2034 * and 1 on the boundary values */ 2035 u8 plt_mag_map = 2036 (i == 0 || i == (num_symbol_offsets - 1)) 2037 ? 1 : 2; 2038 2039 if (curr_sym_off >= 0 && curr_sym_off <= 32) { 2040 if (curr_sym_off <= 25) 2041 pilot_mask[0] |= 1 << curr_sym_off; 2042 else if (curr_sym_off >= 27) 2043 pilot_mask[0] |= 1 << (curr_sym_off - 1); 2044 } else if (curr_sym_off >= 33 && curr_sym_off <= 52) 2045 pilot_mask[1] |= 1 << (curr_sym_off - 33); 2046 2047 /* Calculate magnitude mask (for viterbi decoder) */ 2048 if (curr_sym_off >= -1 && curr_sym_off <= 14) 2049 mag_mask[0] |= 2050 plt_mag_map << (curr_sym_off + 1) * 2; 2051 else if (curr_sym_off >= 15 && curr_sym_off <= 30) 2052 mag_mask[1] |= 2053 plt_mag_map << (curr_sym_off - 15) * 2; 2054 else if (curr_sym_off >= 31 && curr_sym_off <= 46) 2055 mag_mask[2] |= 2056 plt_mag_map << (curr_sym_off - 31) * 2; 2057 else if (curr_sym_off >= 47 && curr_sym_off <= 53) 2058 mag_mask[3] |= 2059 plt_mag_map << (curr_sym_off - 47) * 2; 2060 2061 } 2062 2063 /* Write settings on hw to enable spur filter */ 2064 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_BIN_MASK_CTL, 2065 AR5K_PHY_BIN_MASK_CTL_RATE, 0xff); 2066 /* XXX: Self correlator also ? */ 2067 AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_IQ, 2068 AR5K_PHY_IQ_PILOT_MASK_EN | 2069 AR5K_PHY_IQ_CHAN_MASK_EN | 2070 AR5K_PHY_IQ_SPUR_FILT_EN); 2071 2072 /* Set delta phase and freq sigma delta */ 2073 ath5k_hw_reg_write(ah, 2074 AR5K_REG_SM(spur_delta_phase, 2075 AR5K_PHY_TIMING_11_SPUR_DELTA_PHASE) | 2076 AR5K_REG_SM(spur_freq_sigma_delta, 2077 AR5K_PHY_TIMING_11_SPUR_FREQ_SD) | 2078 AR5K_PHY_TIMING_11_USE_SPUR_IN_AGC, 2079 AR5K_PHY_TIMING_11); 2080 2081 /* Write pilot masks */ 2082 ath5k_hw_reg_write(ah, pilot_mask[0], AR5K_PHY_TIMING_7); 2083 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_TIMING_8, 2084 AR5K_PHY_TIMING_8_PILOT_MASK_2, 2085 pilot_mask[1]); 2086 2087 ath5k_hw_reg_write(ah, pilot_mask[0], AR5K_PHY_TIMING_9); 2088 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_TIMING_10, 2089 AR5K_PHY_TIMING_10_PILOT_MASK_2, 2090 pilot_mask[1]); 2091 2092 /* Write magnitude masks */ 2093 ath5k_hw_reg_write(ah, mag_mask[0], AR5K_PHY_BIN_MASK_1); 2094 ath5k_hw_reg_write(ah, mag_mask[1], AR5K_PHY_BIN_MASK_2); 2095 ath5k_hw_reg_write(ah, mag_mask[2], AR5K_PHY_BIN_MASK_3); 2096 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_BIN_MASK_CTL, 2097 AR5K_PHY_BIN_MASK_CTL_MASK_4, 2098 mag_mask[3]); 2099 2100 ath5k_hw_reg_write(ah, mag_mask[0], AR5K_PHY_BIN_MASK2_1); 2101 ath5k_hw_reg_write(ah, mag_mask[1], AR5K_PHY_BIN_MASK2_2); 2102 ath5k_hw_reg_write(ah, mag_mask[2], AR5K_PHY_BIN_MASK2_3); 2103 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_BIN_MASK2_4, 2104 AR5K_PHY_BIN_MASK2_4_MASK_4, 2105 mag_mask[3]); 2106 2107 } else if (ath5k_hw_reg_read(ah, AR5K_PHY_IQ) & 2108 AR5K_PHY_IQ_SPUR_FILT_EN) { 2109 /* Clean up spur mitigation settings and disable filter */ 2110 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_BIN_MASK_CTL, 2111 AR5K_PHY_BIN_MASK_CTL_RATE, 0); 2112 AR5K_REG_DISABLE_BITS(ah, AR5K_PHY_IQ, 2113 AR5K_PHY_IQ_PILOT_MASK_EN | 2114 AR5K_PHY_IQ_CHAN_MASK_EN | 2115 AR5K_PHY_IQ_SPUR_FILT_EN); 2116 ath5k_hw_reg_write(ah, 0, AR5K_PHY_TIMING_11); 2117 2118 /* Clear pilot masks */ 2119 ath5k_hw_reg_write(ah, 0, AR5K_PHY_TIMING_7); 2120 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_TIMING_8, 2121 AR5K_PHY_TIMING_8_PILOT_MASK_2, 2122 0); 2123 2124 ath5k_hw_reg_write(ah, 0, AR5K_PHY_TIMING_9); 2125 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_TIMING_10, 2126 AR5K_PHY_TIMING_10_PILOT_MASK_2, 2127 0); 2128 2129 /* Clear magnitude masks */ 2130 ath5k_hw_reg_write(ah, 0, AR5K_PHY_BIN_MASK_1); 2131 ath5k_hw_reg_write(ah, 0, AR5K_PHY_BIN_MASK_2); 2132 ath5k_hw_reg_write(ah, 0, AR5K_PHY_BIN_MASK_3); 2133 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_BIN_MASK_CTL, 2134 AR5K_PHY_BIN_MASK_CTL_MASK_4, 2135 0); 2136 2137 ath5k_hw_reg_write(ah, 0, AR5K_PHY_BIN_MASK2_1); 2138 ath5k_hw_reg_write(ah, 0, AR5K_PHY_BIN_MASK2_2); 2139 ath5k_hw_reg_write(ah, 0, AR5K_PHY_BIN_MASK2_3); 2140 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_BIN_MASK2_4, 2141 AR5K_PHY_BIN_MASK2_4_MASK_4, 2142 0); 2143 } 2144 } 2145 2146 2147 /*****************\ 2148 * Antenna control * 2149 \*****************/ 2150 2151 /** 2152 * DOC: Antenna control 2153 * 2154 * Hw supports up to 14 antennas ! I haven't found any card that implements 2155 * that. The maximum number of antennas I've seen is up to 4 (2 for 2GHz and 2 2156 * for 5GHz). Antenna 1 (MAIN) should be omnidirectional, 2 (AUX) 2157 * omnidirectional or sectorial and antennas 3-14 sectorial (or directional). 2158 * 2159 * We can have a single antenna for RX and multiple antennas for TX. 2160 * RX antenna is our "default" antenna (usually antenna 1) set on 2161 * DEFAULT_ANTENNA register and TX antenna is set on each TX control descriptor 2162 * (0 for automatic selection, 1 - 14 antenna number). 2163 * 2164 * We can let hw do all the work doing fast antenna diversity for both 2165 * tx and rx or we can do things manually. Here are the options we have 2166 * (all are bits of STA_ID1 register): 2167 * 2168 * AR5K_STA_ID1_DEFAULT_ANTENNA -> When 0 is set as the TX antenna on TX 2169 * control descriptor, use the default antenna to transmit or else use the last 2170 * antenna on which we received an ACK. 2171 * 2172 * AR5K_STA_ID1_DESC_ANTENNA -> Update default antenna after each TX frame to 2173 * the antenna on which we got the ACK for that frame. 2174 * 2175 * AR5K_STA_ID1_RTS_DEF_ANTENNA -> Use default antenna for RTS or else use the 2176 * one on the TX descriptor. 2177 * 2178 * AR5K_STA_ID1_SELFGEN_DEF_ANT -> Use default antenna for self generated frames 2179 * (ACKs etc), or else use current antenna (the one we just used for TX). 2180 * 2181 * Using the above we support the following scenarios: 2182 * 2183 * AR5K_ANTMODE_DEFAULT -> Hw handles antenna diversity etc automatically 2184 * 2185 * AR5K_ANTMODE_FIXED_A -> Only antenna A (MAIN) is present 2186 * 2187 * AR5K_ANTMODE_FIXED_B -> Only antenna B (AUX) is present 2188 * 2189 * AR5K_ANTMODE_SINGLE_AP -> Sta locked on a single ap 2190 * 2191 * AR5K_ANTMODE_SECTOR_AP -> AP with tx antenna set on tx desc 2192 * 2193 * AR5K_ANTMODE_SECTOR_STA -> STA with tx antenna set on tx desc 2194 * 2195 * AR5K_ANTMODE_DEBUG Debug mode -A -> Rx, B-> Tx- 2196 * 2197 * Also note that when setting antenna to F on tx descriptor card inverts 2198 * current tx antenna. 2199 */ 2200 2201 /** 2202 * ath5k_hw_set_def_antenna() - Set default rx antenna on AR5211/5212 and newer 2203 * @ah: The &struct ath5k_hw 2204 * @ant: Antenna number 2205 */ 2206 static void 2207 ath5k_hw_set_def_antenna(struct ath5k_hw *ah, u8 ant) 2208 { 2209 if (ah->ah_version != AR5K_AR5210) 2210 ath5k_hw_reg_write(ah, ant & 0x7, AR5K_DEFAULT_ANTENNA); 2211 } 2212 2213 /** 2214 * ath5k_hw_set_fast_div() - Enable/disable fast rx antenna diversity 2215 * @ah: The &struct ath5k_hw 2216 * @ee_mode: One of enum ath5k_driver_mode 2217 * @enable: True to enable, false to disable 2218 */ 2219 static void 2220 ath5k_hw_set_fast_div(struct ath5k_hw *ah, u8 ee_mode, bool enable) 2221 { 2222 switch (ee_mode) { 2223 case AR5K_EEPROM_MODE_11G: 2224 /* XXX: This is set to 2225 * disabled on initvals !!! */ 2226 case AR5K_EEPROM_MODE_11A: 2227 if (enable) 2228 AR5K_REG_DISABLE_BITS(ah, AR5K_PHY_AGCCTL, 2229 AR5K_PHY_AGCCTL_OFDM_DIV_DIS); 2230 else 2231 AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_AGCCTL, 2232 AR5K_PHY_AGCCTL_OFDM_DIV_DIS); 2233 break; 2234 case AR5K_EEPROM_MODE_11B: 2235 AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_AGCCTL, 2236 AR5K_PHY_AGCCTL_OFDM_DIV_DIS); 2237 break; 2238 default: 2239 return; 2240 } 2241 2242 if (enable) { 2243 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_RESTART, 2244 AR5K_PHY_RESTART_DIV_GC, 4); 2245 2246 AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_FAST_ANT_DIV, 2247 AR5K_PHY_FAST_ANT_DIV_EN); 2248 } else { 2249 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_RESTART, 2250 AR5K_PHY_RESTART_DIV_GC, 0); 2251 2252 AR5K_REG_DISABLE_BITS(ah, AR5K_PHY_FAST_ANT_DIV, 2253 AR5K_PHY_FAST_ANT_DIV_EN); 2254 } 2255 } 2256 2257 /** 2258 * ath5k_hw_set_antenna_switch() - Set up antenna switch table 2259 * @ah: The &struct ath5k_hw 2260 * @ee_mode: One of enum ath5k_driver_mode 2261 * 2262 * Switch table comes from EEPROM and includes information on controlling 2263 * the 2 antenna RX attenuators 2264 */ 2265 void 2266 ath5k_hw_set_antenna_switch(struct ath5k_hw *ah, u8 ee_mode) 2267 { 2268 u8 ant0, ant1; 2269 2270 /* 2271 * In case a fixed antenna was set as default 2272 * use the same switch table twice. 2273 */ 2274 if (ah->ah_ant_mode == AR5K_ANTMODE_FIXED_A) 2275 ant0 = ant1 = AR5K_ANT_SWTABLE_A; 2276 else if (ah->ah_ant_mode == AR5K_ANTMODE_FIXED_B) 2277 ant0 = ant1 = AR5K_ANT_SWTABLE_B; 2278 else { 2279 ant0 = AR5K_ANT_SWTABLE_A; 2280 ant1 = AR5K_ANT_SWTABLE_B; 2281 } 2282 2283 /* Set antenna idle switch table */ 2284 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_ANT_CTL, 2285 AR5K_PHY_ANT_CTL_SWTABLE_IDLE, 2286 (ah->ah_ant_ctl[ee_mode][AR5K_ANT_CTL] | 2287 AR5K_PHY_ANT_CTL_TXRX_EN)); 2288 2289 /* Set antenna switch tables */ 2290 ath5k_hw_reg_write(ah, ah->ah_ant_ctl[ee_mode][ant0], 2291 AR5K_PHY_ANT_SWITCH_TABLE_0); 2292 ath5k_hw_reg_write(ah, ah->ah_ant_ctl[ee_mode][ant1], 2293 AR5K_PHY_ANT_SWITCH_TABLE_1); 2294 } 2295 2296 /** 2297 * ath5k_hw_set_antenna_mode() - Set antenna operating mode 2298 * @ah: The &struct ath5k_hw 2299 * @ant_mode: One of enum ath5k_ant_mode 2300 */ 2301 void 2302 ath5k_hw_set_antenna_mode(struct ath5k_hw *ah, u8 ant_mode) 2303 { 2304 struct ieee80211_channel *channel = ah->ah_current_channel; 2305 bool use_def_for_tx, update_def_on_tx, use_def_for_rts, fast_div; 2306 bool use_def_for_sg; 2307 int ee_mode; 2308 u8 def_ant, tx_ant; 2309 u32 sta_id1 = 0; 2310 2311 /* if channel is not initialized yet we can't set the antennas 2312 * so just store the mode. it will be set on the next reset */ 2313 if (channel == NULL) { 2314 ah->ah_ant_mode = ant_mode; 2315 return; 2316 } 2317 2318 def_ant = ah->ah_def_ant; 2319 2320 ee_mode = ath5k_eeprom_mode_from_channel(channel); 2321 if (ee_mode < 0) { 2322 ATH5K_ERR(ah, 2323 "invalid channel: %d\n", channel->center_freq); 2324 return; 2325 } 2326 2327 switch (ant_mode) { 2328 case AR5K_ANTMODE_DEFAULT: 2329 tx_ant = 0; 2330 use_def_for_tx = false; 2331 update_def_on_tx = false; 2332 use_def_for_rts = false; 2333 use_def_for_sg = false; 2334 fast_div = true; 2335 break; 2336 case AR5K_ANTMODE_FIXED_A: 2337 def_ant = 1; 2338 tx_ant = 1; 2339 use_def_for_tx = true; 2340 update_def_on_tx = false; 2341 use_def_for_rts = true; 2342 use_def_for_sg = true; 2343 fast_div = false; 2344 break; 2345 case AR5K_ANTMODE_FIXED_B: 2346 def_ant = 2; 2347 tx_ant = 2; 2348 use_def_for_tx = true; 2349 update_def_on_tx = false; 2350 use_def_for_rts = true; 2351 use_def_for_sg = true; 2352 fast_div = false; 2353 break; 2354 case AR5K_ANTMODE_SINGLE_AP: 2355 def_ant = 1; /* updated on tx */ 2356 tx_ant = 0; 2357 use_def_for_tx = true; 2358 update_def_on_tx = true; 2359 use_def_for_rts = true; 2360 use_def_for_sg = true; 2361 fast_div = true; 2362 break; 2363 case AR5K_ANTMODE_SECTOR_AP: 2364 tx_ant = 1; /* variable */ 2365 use_def_for_tx = false; 2366 update_def_on_tx = false; 2367 use_def_for_rts = true; 2368 use_def_for_sg = false; 2369 fast_div = false; 2370 break; 2371 case AR5K_ANTMODE_SECTOR_STA: 2372 tx_ant = 1; /* variable */ 2373 use_def_for_tx = true; 2374 update_def_on_tx = false; 2375 use_def_for_rts = true; 2376 use_def_for_sg = false; 2377 fast_div = true; 2378 break; 2379 case AR5K_ANTMODE_DEBUG: 2380 def_ant = 1; 2381 tx_ant = 2; 2382 use_def_for_tx = false; 2383 update_def_on_tx = false; 2384 use_def_for_rts = false; 2385 use_def_for_sg = false; 2386 fast_div = false; 2387 break; 2388 default: 2389 return; 2390 } 2391 2392 ah->ah_tx_ant = tx_ant; 2393 ah->ah_ant_mode = ant_mode; 2394 ah->ah_def_ant = def_ant; 2395 2396 sta_id1 |= use_def_for_tx ? AR5K_STA_ID1_DEFAULT_ANTENNA : 0; 2397 sta_id1 |= update_def_on_tx ? AR5K_STA_ID1_DESC_ANTENNA : 0; 2398 sta_id1 |= use_def_for_rts ? AR5K_STA_ID1_RTS_DEF_ANTENNA : 0; 2399 sta_id1 |= use_def_for_sg ? AR5K_STA_ID1_SELFGEN_DEF_ANT : 0; 2400 2401 AR5K_REG_DISABLE_BITS(ah, AR5K_STA_ID1, AR5K_STA_ID1_ANTENNA_SETTINGS); 2402 2403 if (sta_id1) 2404 AR5K_REG_ENABLE_BITS(ah, AR5K_STA_ID1, sta_id1); 2405 2406 ath5k_hw_set_antenna_switch(ah, ee_mode); 2407 /* Note: set diversity before default antenna 2408 * because it won't work correctly */ 2409 ath5k_hw_set_fast_div(ah, ee_mode, fast_div); 2410 ath5k_hw_set_def_antenna(ah, def_ant); 2411 } 2412 2413 2414 /****************\ 2415 * TX power setup * 2416 \****************/ 2417 2418 /* 2419 * Helper functions 2420 */ 2421 2422 /** 2423 * ath5k_get_interpolated_value() - Get interpolated Y val between two points 2424 * @target: X value of the middle point 2425 * @x_left: X value of the left point 2426 * @x_right: X value of the right point 2427 * @y_left: Y value of the left point 2428 * @y_right: Y value of the right point 2429 */ 2430 static s16 2431 ath5k_get_interpolated_value(s16 target, s16 x_left, s16 x_right, 2432 s16 y_left, s16 y_right) 2433 { 2434 s16 ratio, result; 2435 2436 /* Avoid divide by zero and skip interpolation 2437 * if we have the same point */ 2438 if ((x_left == x_right) || (y_left == y_right)) 2439 return y_left; 2440 2441 /* 2442 * Since we use ints and not fps, we need to scale up in 2443 * order to get a sane ratio value (or else we 'll eg. get 2444 * always 1 instead of 1.25, 1.75 etc). We scale up by 100 2445 * to have some accuracy both for 0.5 and 0.25 steps. 2446 */ 2447 ratio = ((100 * y_right - 100 * y_left) / (x_right - x_left)); 2448 2449 /* Now scale down to be in range */ 2450 result = y_left + (ratio * (target - x_left) / 100); 2451 2452 return result; 2453 } 2454 2455 /** 2456 * ath5k_get_linear_pcdac_min() - Find vertical boundary (min pwr) for the 2457 * linear PCDAC curve 2458 * @stepL: Left array with y values (pcdac steps) 2459 * @stepR: Right array with y values (pcdac steps) 2460 * @pwrL: Left array with x values (power steps) 2461 * @pwrR: Right array with x values (power steps) 2462 * 2463 * Since we have the top of the curve and we draw the line below 2464 * until we reach 1 (1 pcdac step) we need to know which point 2465 * (x value) that is so that we don't go below x axis and have negative 2466 * pcdac values when creating the curve, or fill the table with zeros. 2467 */ 2468 static s16 2469 ath5k_get_linear_pcdac_min(const u8 *stepL, const u8 *stepR, 2470 const s16 *pwrL, const s16 *pwrR) 2471 { 2472 s8 tmp; 2473 s16 min_pwrL, min_pwrR; 2474 s16 pwr_i; 2475 2476 /* Some vendors write the same pcdac value twice !!! */ 2477 if (stepL[0] == stepL[1] || stepR[0] == stepR[1]) 2478 return max(pwrL[0], pwrR[0]); 2479 2480 if (pwrL[0] == pwrL[1]) 2481 min_pwrL = pwrL[0]; 2482 else { 2483 pwr_i = pwrL[0]; 2484 do { 2485 pwr_i--; 2486 tmp = (s8) ath5k_get_interpolated_value(pwr_i, 2487 pwrL[0], pwrL[1], 2488 stepL[0], stepL[1]); 2489 } while (tmp > 1); 2490 2491 min_pwrL = pwr_i; 2492 } 2493 2494 if (pwrR[0] == pwrR[1]) 2495 min_pwrR = pwrR[0]; 2496 else { 2497 pwr_i = pwrR[0]; 2498 do { 2499 pwr_i--; 2500 tmp = (s8) ath5k_get_interpolated_value(pwr_i, 2501 pwrR[0], pwrR[1], 2502 stepR[0], stepR[1]); 2503 } while (tmp > 1); 2504 2505 min_pwrR = pwr_i; 2506 } 2507 2508 /* Keep the right boundary so that it works for both curves */ 2509 return max(min_pwrL, min_pwrR); 2510 } 2511 2512 /** 2513 * ath5k_create_power_curve() - Create a Power to PDADC or PCDAC curve 2514 * @pmin: Minimum power value (xmin) 2515 * @pmax: Maximum power value (xmax) 2516 * @pwr: Array of power steps (x values) 2517 * @vpd: Array of matching PCDAC/PDADC steps (y values) 2518 * @num_points: Number of provided points 2519 * @vpd_table: Array to fill with the full PCDAC/PDADC values (y values) 2520 * @type: One of enum ath5k_powertable_type (eeprom.h) 2521 * 2522 * Interpolate (pwr,vpd) points to create a Power to PDADC or a 2523 * Power to PCDAC curve. 2524 * 2525 * Each curve has power on x axis (in 0.5dB units) and PCDAC/PDADC 2526 * steps (offsets) on y axis. Power can go up to 31.5dB and max 2527 * PCDAC/PDADC step for each curve is 64 but we can write more than 2528 * one curves on hw so we can go up to 128 (which is the max step we 2529 * can write on the final table). 2530 * 2531 * We write y values (PCDAC/PDADC steps) on hw. 2532 */ 2533 static void 2534 ath5k_create_power_curve(s16 pmin, s16 pmax, 2535 const s16 *pwr, const u8 *vpd, 2536 u8 num_points, 2537 u8 *vpd_table, u8 type) 2538 { 2539 u8 idx[2] = { 0, 1 }; 2540 s16 pwr_i = 2 * pmin; 2541 int i; 2542 2543 if (num_points < 2) 2544 return; 2545 2546 /* We want the whole line, so adjust boundaries 2547 * to cover the entire power range. Note that 2548 * power values are already 0.25dB so no need 2549 * to multiply pwr_i by 2 */ 2550 if (type == AR5K_PWRTABLE_LINEAR_PCDAC) { 2551 pwr_i = pmin; 2552 pmin = 0; 2553 pmax = 63; 2554 } 2555 2556 /* Find surrounding turning points (TPs) 2557 * and interpolate between them */ 2558 for (i = 0; (i <= (u16) (pmax - pmin)) && 2559 (i < AR5K_EEPROM_POWER_TABLE_SIZE); i++) { 2560 2561 /* We passed the right TP, move to the next set of TPs 2562 * if we pass the last TP, extrapolate above using the last 2563 * two TPs for ratio */ 2564 if ((pwr_i > pwr[idx[1]]) && (idx[1] < num_points - 1)) { 2565 idx[0]++; 2566 idx[1]++; 2567 } 2568 2569 vpd_table[i] = (u8) ath5k_get_interpolated_value(pwr_i, 2570 pwr[idx[0]], pwr[idx[1]], 2571 vpd[idx[0]], vpd[idx[1]]); 2572 2573 /* Increase by 0.5dB 2574 * (0.25 dB units) */ 2575 pwr_i += 2; 2576 } 2577 } 2578 2579 /** 2580 * ath5k_get_chan_pcal_surrounding_piers() - Get surrounding calibration piers 2581 * for a given channel. 2582 * @ah: The &struct ath5k_hw 2583 * @channel: The &struct ieee80211_channel 2584 * @pcinfo_l: The &struct ath5k_chan_pcal_info to put the left cal. pier 2585 * @pcinfo_r: The &struct ath5k_chan_pcal_info to put the right cal. pier 2586 * 2587 * Get the surrounding per-channel power calibration piers 2588 * for a given frequency so that we can interpolate between 2589 * them and come up with an appropriate dataset for our current 2590 * channel. 2591 */ 2592 static void 2593 ath5k_get_chan_pcal_surrounding_piers(struct ath5k_hw *ah, 2594 struct ieee80211_channel *channel, 2595 struct ath5k_chan_pcal_info **pcinfo_l, 2596 struct ath5k_chan_pcal_info **pcinfo_r) 2597 { 2598 struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom; 2599 struct ath5k_chan_pcal_info *pcinfo; 2600 u8 idx_l, idx_r; 2601 u8 mode, max, i; 2602 u32 target = channel->center_freq; 2603 2604 idx_l = 0; 2605 idx_r = 0; 2606 2607 switch (channel->hw_value) { 2608 case AR5K_EEPROM_MODE_11A: 2609 pcinfo = ee->ee_pwr_cal_a; 2610 mode = AR5K_EEPROM_MODE_11A; 2611 break; 2612 case AR5K_EEPROM_MODE_11B: 2613 pcinfo = ee->ee_pwr_cal_b; 2614 mode = AR5K_EEPROM_MODE_11B; 2615 break; 2616 case AR5K_EEPROM_MODE_11G: 2617 default: 2618 pcinfo = ee->ee_pwr_cal_g; 2619 mode = AR5K_EEPROM_MODE_11G; 2620 break; 2621 } 2622 max = ee->ee_n_piers[mode] - 1; 2623 2624 /* Frequency is below our calibrated 2625 * range. Use the lowest power curve 2626 * we have */ 2627 if (target < pcinfo[0].freq) { 2628 idx_l = idx_r = 0; 2629 goto done; 2630 } 2631 2632 /* Frequency is above our calibrated 2633 * range. Use the highest power curve 2634 * we have */ 2635 if (target > pcinfo[max].freq) { 2636 idx_l = idx_r = max; 2637 goto done; 2638 } 2639 2640 /* Frequency is inside our calibrated 2641 * channel range. Pick the surrounding 2642 * calibration piers so that we can 2643 * interpolate */ 2644 for (i = 0; i <= max; i++) { 2645 2646 /* Frequency matches one of our calibration 2647 * piers, no need to interpolate, just use 2648 * that calibration pier */ 2649 if (pcinfo[i].freq == target) { 2650 idx_l = idx_r = i; 2651 goto done; 2652 } 2653 2654 /* We found a calibration pier that's above 2655 * frequency, use this pier and the previous 2656 * one to interpolate */ 2657 if (target < pcinfo[i].freq) { 2658 idx_r = i; 2659 idx_l = idx_r - 1; 2660 goto done; 2661 } 2662 } 2663 2664 done: 2665 *pcinfo_l = &pcinfo[idx_l]; 2666 *pcinfo_r = &pcinfo[idx_r]; 2667 } 2668 2669 /** 2670 * ath5k_get_rate_pcal_data() - Get the interpolated per-rate power 2671 * calibration data 2672 * @ah: The &struct ath5k_hw *ah, 2673 * @channel: The &struct ieee80211_channel 2674 * @rates: The &struct ath5k_rate_pcal_info to fill 2675 * 2676 * Get the surrounding per-rate power calibration data 2677 * for a given frequency and interpolate between power 2678 * values to set max target power supported by hw for 2679 * each rate on this frequency. 2680 */ 2681 static void 2682 ath5k_get_rate_pcal_data(struct ath5k_hw *ah, 2683 struct ieee80211_channel *channel, 2684 struct ath5k_rate_pcal_info *rates) 2685 { 2686 struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom; 2687 struct ath5k_rate_pcal_info *rpinfo; 2688 u8 idx_l, idx_r; 2689 u8 mode, max, i; 2690 u32 target = channel->center_freq; 2691 2692 idx_l = 0; 2693 idx_r = 0; 2694 2695 switch (channel->hw_value) { 2696 case AR5K_MODE_11A: 2697 rpinfo = ee->ee_rate_tpwr_a; 2698 mode = AR5K_EEPROM_MODE_11A; 2699 break; 2700 case AR5K_MODE_11B: 2701 rpinfo = ee->ee_rate_tpwr_b; 2702 mode = AR5K_EEPROM_MODE_11B; 2703 break; 2704 case AR5K_MODE_11G: 2705 default: 2706 rpinfo = ee->ee_rate_tpwr_g; 2707 mode = AR5K_EEPROM_MODE_11G; 2708 break; 2709 } 2710 max = ee->ee_rate_target_pwr_num[mode] - 1; 2711 2712 /* Get the surrounding calibration 2713 * piers - same as above */ 2714 if (target < rpinfo[0].freq) { 2715 idx_l = idx_r = 0; 2716 goto done; 2717 } 2718 2719 if (target > rpinfo[max].freq) { 2720 idx_l = idx_r = max; 2721 goto done; 2722 } 2723 2724 for (i = 0; i <= max; i++) { 2725 2726 if (rpinfo[i].freq == target) { 2727 idx_l = idx_r = i; 2728 goto done; 2729 } 2730 2731 if (target < rpinfo[i].freq) { 2732 idx_r = i; 2733 idx_l = idx_r - 1; 2734 goto done; 2735 } 2736 } 2737 2738 done: 2739 /* Now interpolate power value, based on the frequency */ 2740 rates->freq = target; 2741 2742 rates->target_power_6to24 = 2743 ath5k_get_interpolated_value(target, rpinfo[idx_l].freq, 2744 rpinfo[idx_r].freq, 2745 rpinfo[idx_l].target_power_6to24, 2746 rpinfo[idx_r].target_power_6to24); 2747 2748 rates->target_power_36 = 2749 ath5k_get_interpolated_value(target, rpinfo[idx_l].freq, 2750 rpinfo[idx_r].freq, 2751 rpinfo[idx_l].target_power_36, 2752 rpinfo[idx_r].target_power_36); 2753 2754 rates->target_power_48 = 2755 ath5k_get_interpolated_value(target, rpinfo[idx_l].freq, 2756 rpinfo[idx_r].freq, 2757 rpinfo[idx_l].target_power_48, 2758 rpinfo[idx_r].target_power_48); 2759 2760 rates->target_power_54 = 2761 ath5k_get_interpolated_value(target, rpinfo[idx_l].freq, 2762 rpinfo[idx_r].freq, 2763 rpinfo[idx_l].target_power_54, 2764 rpinfo[idx_r].target_power_54); 2765 } 2766 2767 /** 2768 * ath5k_get_max_ctl_power() - Get max edge power for a given frequency 2769 * @ah: the &struct ath5k_hw 2770 * @channel: The &struct ieee80211_channel 2771 * 2772 * Get the max edge power for this channel if 2773 * we have such data from EEPROM's Conformance Test 2774 * Limits (CTL), and limit max power if needed. 2775 */ 2776 static void 2777 ath5k_get_max_ctl_power(struct ath5k_hw *ah, 2778 struct ieee80211_channel *channel) 2779 { 2780 struct ath_regulatory *regulatory = ath5k_hw_regulatory(ah); 2781 struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom; 2782 struct ath5k_edge_power *rep = ee->ee_ctl_pwr; 2783 u8 *ctl_val = ee->ee_ctl; 2784 s16 max_chan_pwr = ah->ah_txpower.txp_max_pwr / 4; 2785 s16 edge_pwr = 0; 2786 u8 rep_idx; 2787 u8 i, ctl_mode; 2788 u8 ctl_idx = 0xFF; 2789 u32 target = channel->center_freq; 2790 2791 ctl_mode = ath_regd_get_band_ctl(regulatory, channel->band); 2792 2793 switch (channel->hw_value) { 2794 case AR5K_MODE_11A: 2795 if (ah->ah_bwmode == AR5K_BWMODE_40MHZ) 2796 ctl_mode |= AR5K_CTL_TURBO; 2797 else 2798 ctl_mode |= AR5K_CTL_11A; 2799 break; 2800 case AR5K_MODE_11G: 2801 if (ah->ah_bwmode == AR5K_BWMODE_40MHZ) 2802 ctl_mode |= AR5K_CTL_TURBOG; 2803 else 2804 ctl_mode |= AR5K_CTL_11G; 2805 break; 2806 case AR5K_MODE_11B: 2807 ctl_mode |= AR5K_CTL_11B; 2808 break; 2809 default: 2810 return; 2811 } 2812 2813 for (i = 0; i < ee->ee_ctls; i++) { 2814 if (ctl_val[i] == ctl_mode) { 2815 ctl_idx = i; 2816 break; 2817 } 2818 } 2819 2820 /* If we have a CTL dataset available grab it and find the 2821 * edge power for our frequency */ 2822 if (ctl_idx == 0xFF) 2823 return; 2824 2825 /* Edge powers are sorted by frequency from lower 2826 * to higher. Each CTL corresponds to 8 edge power 2827 * measurements. */ 2828 rep_idx = ctl_idx * AR5K_EEPROM_N_EDGES; 2829 2830 /* Don't do boundaries check because we 2831 * might have more that one bands defined 2832 * for this mode */ 2833 2834 /* Get the edge power that's closer to our 2835 * frequency */ 2836 for (i = 0; i < AR5K_EEPROM_N_EDGES; i++) { 2837 rep_idx += i; 2838 if (target <= rep[rep_idx].freq) 2839 edge_pwr = (s16) rep[rep_idx].edge; 2840 } 2841 2842 if (edge_pwr) 2843 ah->ah_txpower.txp_max_pwr = 4 * min(edge_pwr, max_chan_pwr); 2844 } 2845 2846 2847 /* 2848 * Power to PCDAC table functions 2849 */ 2850 2851 /** 2852 * DOC: Power to PCDAC table functions 2853 * 2854 * For RF5111 we have an XPD -eXternal Power Detector- curve 2855 * for each calibrated channel. Each curve has 0,5dB Power steps 2856 * on x axis and PCDAC steps (offsets) on y axis and looks like an 2857 * exponential function. To recreate the curve we read 11 points 2858 * from eeprom (eeprom.c) and interpolate here. 2859 * 2860 * For RF5112 we have 4 XPD -eXternal Power Detector- curves 2861 * for each calibrated channel on 0, -6, -12 and -18dBm but we only 2862 * use the higher (3) and the lower (0) curves. Each curve again has 0.5dB 2863 * power steps on x axis and PCDAC steps on y axis and looks like a 2864 * linear function. To recreate the curve and pass the power values 2865 * on hw, we get 4 points for xpd 0 (lower gain -> max power) 2866 * and 3 points for xpd 3 (higher gain -> lower power) from eeprom (eeprom.c) 2867 * and interpolate here. 2868 * 2869 * For a given channel we get the calibrated points (piers) for it or 2870 * -if we don't have calibration data for this specific channel- from the 2871 * available surrounding channels we have calibration data for, after we do a 2872 * linear interpolation between them. Then since we have our calibrated points 2873 * for this channel, we do again a linear interpolation between them to get the 2874 * whole curve. 2875 * 2876 * We finally write the Y values of the curve(s) (the PCDAC values) on hw 2877 */ 2878 2879 /** 2880 * ath5k_fill_pwr_to_pcdac_table() - Fill Power to PCDAC table on RF5111 2881 * @ah: The &struct ath5k_hw 2882 * @table_min: Minimum power (x min) 2883 * @table_max: Maximum power (x max) 2884 * 2885 * No further processing is needed for RF5111, the only thing we have to 2886 * do is fill the values below and above calibration range since eeprom data 2887 * may not cover the entire PCDAC table. 2888 */ 2889 static void 2890 ath5k_fill_pwr_to_pcdac_table(struct ath5k_hw *ah, s16* table_min, 2891 s16 *table_max) 2892 { 2893 u8 *pcdac_out = ah->ah_txpower.txp_pd_table; 2894 u8 *pcdac_tmp = ah->ah_txpower.tmpL[0]; 2895 u8 pcdac_0, pcdac_n, pcdac_i, pwr_idx, i; 2896 s16 min_pwr, max_pwr; 2897 2898 /* Get table boundaries */ 2899 min_pwr = table_min[0]; 2900 pcdac_0 = pcdac_tmp[0]; 2901 2902 max_pwr = table_max[0]; 2903 pcdac_n = pcdac_tmp[table_max[0] - table_min[0]]; 2904 2905 /* Extrapolate below minimum using pcdac_0 */ 2906 pcdac_i = 0; 2907 for (i = 0; i < min_pwr; i++) 2908 pcdac_out[pcdac_i++] = pcdac_0; 2909 2910 /* Copy values from pcdac_tmp */ 2911 pwr_idx = min_pwr; 2912 for (i = 0; pwr_idx <= max_pwr && 2913 pcdac_i < AR5K_EEPROM_POWER_TABLE_SIZE; i++) { 2914 pcdac_out[pcdac_i++] = pcdac_tmp[i]; 2915 pwr_idx++; 2916 } 2917 2918 /* Extrapolate above maximum */ 2919 while (pcdac_i < AR5K_EEPROM_POWER_TABLE_SIZE) 2920 pcdac_out[pcdac_i++] = pcdac_n; 2921 2922 } 2923 2924 /** 2925 * ath5k_combine_linear_pcdac_curves() - Combine available PCDAC Curves 2926 * @ah: The &struct ath5k_hw 2927 * @table_min: Minimum power (x min) 2928 * @table_max: Maximum power (x max) 2929 * @pdcurves: Number of pd curves 2930 * 2931 * Combine available XPD Curves and fill Linear Power to PCDAC table on RF5112 2932 * RFX112 can have up to 2 curves (one for low txpower range and one for 2933 * higher txpower range). We need to put them both on pcdac_out and place 2934 * them in the correct location. In case we only have one curve available 2935 * just fit it on pcdac_out (it's supposed to cover the entire range of 2936 * available pwr levels since it's always the higher power curve). Extrapolate 2937 * below and above final table if needed. 2938 */ 2939 static void 2940 ath5k_combine_linear_pcdac_curves(struct ath5k_hw *ah, s16* table_min, 2941 s16 *table_max, u8 pdcurves) 2942 { 2943 u8 *pcdac_out = ah->ah_txpower.txp_pd_table; 2944 u8 *pcdac_low_pwr; 2945 u8 *pcdac_high_pwr; 2946 u8 *pcdac_tmp; 2947 u8 pwr; 2948 s16 max_pwr_idx; 2949 s16 min_pwr_idx; 2950 s16 mid_pwr_idx = 0; 2951 /* Edge flag turns on the 7nth bit on the PCDAC 2952 * to declare the higher power curve (force values 2953 * to be greater than 64). If we only have one curve 2954 * we don't need to set this, if we have 2 curves and 2955 * fill the table backwards this can also be used to 2956 * switch from higher power curve to lower power curve */ 2957 u8 edge_flag; 2958 int i; 2959 2960 /* When we have only one curve available 2961 * that's the higher power curve. If we have 2962 * two curves the first is the high power curve 2963 * and the next is the low power curve. */ 2964 if (pdcurves > 1) { 2965 pcdac_low_pwr = ah->ah_txpower.tmpL[1]; 2966 pcdac_high_pwr = ah->ah_txpower.tmpL[0]; 2967 mid_pwr_idx = table_max[1] - table_min[1] - 1; 2968 max_pwr_idx = (table_max[0] - table_min[0]) / 2; 2969 2970 /* If table size goes beyond 31.5dB, keep the 2971 * upper 31.5dB range when setting tx power. 2972 * Note: 126 = 31.5 dB in quarter dB steps */ 2973 if (table_max[0] - table_min[1] > 126) 2974 min_pwr_idx = table_max[0] - 126; 2975 else 2976 min_pwr_idx = table_min[1]; 2977 2978 /* Since we fill table backwards 2979 * start from high power curve */ 2980 pcdac_tmp = pcdac_high_pwr; 2981 2982 edge_flag = 0x40; 2983 } else { 2984 pcdac_low_pwr = ah->ah_txpower.tmpL[1]; /* Zeroed */ 2985 pcdac_high_pwr = ah->ah_txpower.tmpL[0]; 2986 min_pwr_idx = table_min[0]; 2987 max_pwr_idx = (table_max[0] - table_min[0]) / 2; 2988 pcdac_tmp = pcdac_high_pwr; 2989 edge_flag = 0; 2990 } 2991 2992 /* This is used when setting tx power*/ 2993 ah->ah_txpower.txp_min_idx = min_pwr_idx / 2; 2994 2995 /* Fill Power to PCDAC table backwards */ 2996 pwr = max_pwr_idx; 2997 for (i = 63; i >= 0; i--) { 2998 /* Entering lower power range, reset 2999 * edge flag and set pcdac_tmp to lower 3000 * power curve.*/ 3001 if (edge_flag == 0x40 && 3002 (2 * pwr <= (table_max[1] - table_min[0]) || pwr == 0)) { 3003 edge_flag = 0x00; 3004 pcdac_tmp = pcdac_low_pwr; 3005 pwr = mid_pwr_idx / 2; 3006 } 3007 3008 /* Don't go below 1, extrapolate below if we have 3009 * already switched to the lower power curve -or 3010 * we only have one curve and edge_flag is zero 3011 * anyway */ 3012 if (pcdac_tmp[pwr] < 1 && (edge_flag == 0x00)) { 3013 while (i >= 0) { 3014 pcdac_out[i] = pcdac_out[i + 1]; 3015 i--; 3016 } 3017 break; 3018 } 3019 3020 pcdac_out[i] = pcdac_tmp[pwr] | edge_flag; 3021 3022 /* Extrapolate above if pcdac is greater than 3023 * 126 -this can happen because we OR pcdac_out 3024 * value with edge_flag on high power curve */ 3025 if (pcdac_out[i] > 126) 3026 pcdac_out[i] = 126; 3027 3028 /* Decrease by a 0.5dB step */ 3029 pwr--; 3030 } 3031 } 3032 3033 /** 3034 * ath5k_write_pcdac_table() - Write the PCDAC values on hw 3035 * @ah: The &struct ath5k_hw 3036 */ 3037 static void 3038 ath5k_write_pcdac_table(struct ath5k_hw *ah) 3039 { 3040 u8 *pcdac_out = ah->ah_txpower.txp_pd_table; 3041 int i; 3042 3043 /* 3044 * Write TX power values 3045 */ 3046 for (i = 0; i < (AR5K_EEPROM_POWER_TABLE_SIZE / 2); i++) { 3047 ath5k_hw_reg_write(ah, 3048 (((pcdac_out[2 * i + 0] << 8 | 0xff) & 0xffff) << 0) | 3049 (((pcdac_out[2 * i + 1] << 8 | 0xff) & 0xffff) << 16), 3050 AR5K_PHY_PCDAC_TXPOWER(i)); 3051 } 3052 } 3053 3054 3055 /* 3056 * Power to PDADC table functions 3057 */ 3058 3059 /** 3060 * DOC: Power to PDADC table functions 3061 * 3062 * For RF2413 and later we have a Power to PDADC table (Power Detector) 3063 * instead of a PCDAC (Power Control) and 4 pd gain curves for each 3064 * calibrated channel. Each curve has power on x axis in 0.5 db steps and 3065 * PDADC steps on y axis and looks like an exponential function like the 3066 * RF5111 curve. 3067 * 3068 * To recreate the curves we read the points from eeprom (eeprom.c) 3069 * and interpolate here. Note that in most cases only 2 (higher and lower) 3070 * curves are used (like RF5112) but vendors have the opportunity to include 3071 * all 4 curves on eeprom. The final curve (higher power) has an extra 3072 * point for better accuracy like RF5112. 3073 * 3074 * The process is similar to what we do above for RF5111/5112 3075 */ 3076 3077 /** 3078 * ath5k_combine_pwr_to_pdadc_curves() - Combine the various PDADC curves 3079 * @ah: The &struct ath5k_hw 3080 * @pwr_min: Minimum power (x min) 3081 * @pwr_max: Maximum power (x max) 3082 * @pdcurves: Number of available curves 3083 * 3084 * Combine the various pd curves and create the final Power to PDADC table 3085 * We can have up to 4 pd curves, we need to do a similar process 3086 * as we do for RF5112. This time we don't have an edge_flag but we 3087 * set the gain boundaries on a separate register. 3088 */ 3089 static void 3090 ath5k_combine_pwr_to_pdadc_curves(struct ath5k_hw *ah, 3091 s16 *pwr_min, s16 *pwr_max, u8 pdcurves) 3092 { 3093 u8 gain_boundaries[AR5K_EEPROM_N_PD_GAINS]; 3094 u8 *pdadc_out = ah->ah_txpower.txp_pd_table; 3095 u8 *pdadc_tmp; 3096 s16 pdadc_0; 3097 u8 pdadc_i, pdadc_n, pwr_step, pdg, max_idx, table_size; 3098 u8 pd_gain_overlap; 3099 3100 /* Note: Register value is initialized on initvals 3101 * there is no feedback from hw. 3102 * XXX: What about pd_gain_overlap from EEPROM ? */ 3103 pd_gain_overlap = (u8) ath5k_hw_reg_read(ah, AR5K_PHY_TPC_RG5) & 3104 AR5K_PHY_TPC_RG5_PD_GAIN_OVERLAP; 3105 3106 /* Create final PDADC table */ 3107 for (pdg = 0, pdadc_i = 0; pdg < pdcurves; pdg++) { 3108 pdadc_tmp = ah->ah_txpower.tmpL[pdg]; 3109 3110 if (pdg == pdcurves - 1) 3111 /* 2 dB boundary stretch for last 3112 * (higher power) curve */ 3113 gain_boundaries[pdg] = pwr_max[pdg] + 4; 3114 else 3115 /* Set gain boundary in the middle 3116 * between this curve and the next one */ 3117 gain_boundaries[pdg] = 3118 (pwr_max[pdg] + pwr_min[pdg + 1]) / 2; 3119 3120 /* Sanity check in case our 2 db stretch got out of 3121 * range. */ 3122 if (gain_boundaries[pdg] > AR5K_TUNE_MAX_TXPOWER) 3123 gain_boundaries[pdg] = AR5K_TUNE_MAX_TXPOWER; 3124 3125 /* For the first curve (lower power) 3126 * start from 0 dB */ 3127 if (pdg == 0) 3128 pdadc_0 = 0; 3129 else 3130 /* For the other curves use the gain overlap */ 3131 pdadc_0 = (gain_boundaries[pdg - 1] - pwr_min[pdg]) - 3132 pd_gain_overlap; 3133 3134 /* Force each power step to be at least 0.5 dB */ 3135 if ((pdadc_tmp[1] - pdadc_tmp[0]) > 1) 3136 pwr_step = pdadc_tmp[1] - pdadc_tmp[0]; 3137 else 3138 pwr_step = 1; 3139 3140 /* If pdadc_0 is negative, we need to extrapolate 3141 * below this pdgain by a number of pwr_steps */ 3142 while ((pdadc_0 < 0) && (pdadc_i < 128)) { 3143 s16 tmp = pdadc_tmp[0] + pdadc_0 * pwr_step; 3144 pdadc_out[pdadc_i++] = (tmp < 0) ? 0 : (u8) tmp; 3145 pdadc_0++; 3146 } 3147 3148 /* Set last pwr level, using gain boundaries */ 3149 pdadc_n = gain_boundaries[pdg] + pd_gain_overlap - pwr_min[pdg]; 3150 /* Limit it to be inside pwr range */ 3151 table_size = pwr_max[pdg] - pwr_min[pdg]; 3152 max_idx = (pdadc_n < table_size) ? pdadc_n : table_size; 3153 3154 /* Fill pdadc_out table */ 3155 while (pdadc_0 < max_idx && pdadc_i < 128) 3156 pdadc_out[pdadc_i++] = pdadc_tmp[pdadc_0++]; 3157 3158 /* Need to extrapolate above this pdgain? */ 3159 if (pdadc_n <= max_idx) 3160 continue; 3161 3162 /* Force each power step to be at least 0.5 dB */ 3163 if ((pdadc_tmp[table_size - 1] - pdadc_tmp[table_size - 2]) > 1) 3164 pwr_step = pdadc_tmp[table_size - 1] - 3165 pdadc_tmp[table_size - 2]; 3166 else 3167 pwr_step = 1; 3168 3169 /* Extrapolate above */ 3170 while ((pdadc_0 < (s16) pdadc_n) && 3171 (pdadc_i < AR5K_EEPROM_POWER_TABLE_SIZE * 2)) { 3172 s16 tmp = pdadc_tmp[table_size - 1] + 3173 (pdadc_0 - max_idx) * pwr_step; 3174 pdadc_out[pdadc_i++] = (tmp > 127) ? 127 : (u8) tmp; 3175 pdadc_0++; 3176 } 3177 } 3178 3179 while (pdg < AR5K_EEPROM_N_PD_GAINS) { 3180 gain_boundaries[pdg] = gain_boundaries[pdg - 1]; 3181 pdg++; 3182 } 3183 3184 while (pdadc_i < AR5K_EEPROM_POWER_TABLE_SIZE * 2) { 3185 pdadc_out[pdadc_i] = pdadc_out[pdadc_i - 1]; 3186 pdadc_i++; 3187 } 3188 3189 /* Set gain boundaries */ 3190 ath5k_hw_reg_write(ah, 3191 AR5K_REG_SM(pd_gain_overlap, 3192 AR5K_PHY_TPC_RG5_PD_GAIN_OVERLAP) | 3193 AR5K_REG_SM(gain_boundaries[0], 3194 AR5K_PHY_TPC_RG5_PD_GAIN_BOUNDARY_1) | 3195 AR5K_REG_SM(gain_boundaries[1], 3196 AR5K_PHY_TPC_RG5_PD_GAIN_BOUNDARY_2) | 3197 AR5K_REG_SM(gain_boundaries[2], 3198 AR5K_PHY_TPC_RG5_PD_GAIN_BOUNDARY_3) | 3199 AR5K_REG_SM(gain_boundaries[3], 3200 AR5K_PHY_TPC_RG5_PD_GAIN_BOUNDARY_4), 3201 AR5K_PHY_TPC_RG5); 3202 3203 /* Used for setting rate power table */ 3204 ah->ah_txpower.txp_min_idx = pwr_min[0]; 3205 3206 } 3207 3208 /** 3209 * ath5k_write_pwr_to_pdadc_table() - Write the PDADC values on hw 3210 * @ah: The &struct ath5k_hw 3211 * @ee_mode: One of enum ath5k_driver_mode 3212 */ 3213 static void 3214 ath5k_write_pwr_to_pdadc_table(struct ath5k_hw *ah, u8 ee_mode) 3215 { 3216 struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom; 3217 u8 *pdadc_out = ah->ah_txpower.txp_pd_table; 3218 u8 *pdg_to_idx = ee->ee_pdc_to_idx[ee_mode]; 3219 u8 pdcurves = ee->ee_pd_gains[ee_mode]; 3220 u32 reg; 3221 u8 i; 3222 3223 /* Select the right pdgain curves */ 3224 3225 /* Clear current settings */ 3226 reg = ath5k_hw_reg_read(ah, AR5K_PHY_TPC_RG1); 3227 reg &= ~(AR5K_PHY_TPC_RG1_PDGAIN_1 | 3228 AR5K_PHY_TPC_RG1_PDGAIN_2 | 3229 AR5K_PHY_TPC_RG1_PDGAIN_3 | 3230 AR5K_PHY_TPC_RG1_NUM_PD_GAIN); 3231 3232 /* 3233 * Use pd_gains curve from eeprom 3234 * 3235 * This overrides the default setting from initvals 3236 * in case some vendors (e.g. Zcomax) don't use the default 3237 * curves. If we don't honor their settings we 'll get a 3238 * 5dB (1 * gain overlap ?) drop. 3239 */ 3240 reg |= AR5K_REG_SM(pdcurves, AR5K_PHY_TPC_RG1_NUM_PD_GAIN); 3241 3242 switch (pdcurves) { 3243 case 3: 3244 reg |= AR5K_REG_SM(pdg_to_idx[2], AR5K_PHY_TPC_RG1_PDGAIN_3); 3245 /* Fall through */ 3246 case 2: 3247 reg |= AR5K_REG_SM(pdg_to_idx[1], AR5K_PHY_TPC_RG1_PDGAIN_2); 3248 /* Fall through */ 3249 case 1: 3250 reg |= AR5K_REG_SM(pdg_to_idx[0], AR5K_PHY_TPC_RG1_PDGAIN_1); 3251 break; 3252 } 3253 ath5k_hw_reg_write(ah, reg, AR5K_PHY_TPC_RG1); 3254 3255 /* 3256 * Write TX power values 3257 */ 3258 for (i = 0; i < (AR5K_EEPROM_POWER_TABLE_SIZE / 2); i++) { 3259 u32 val = get_unaligned_le32(&pdadc_out[4 * i]); 3260 ath5k_hw_reg_write(ah, val, AR5K_PHY_PDADC_TXPOWER(i)); 3261 } 3262 } 3263 3264 3265 /* 3266 * Common code for PCDAC/PDADC tables 3267 */ 3268 3269 /** 3270 * ath5k_setup_channel_powertable() - Set up power table for this channel 3271 * @ah: The &struct ath5k_hw 3272 * @channel: The &struct ieee80211_channel 3273 * @ee_mode: One of enum ath5k_driver_mode 3274 * @type: One of enum ath5k_powertable_type (eeprom.h) 3275 * 3276 * This is the main function that uses all of the above 3277 * to set PCDAC/PDADC table on hw for the current channel. 3278 * This table is used for tx power calibration on the baseband, 3279 * without it we get weird tx power levels and in some cases 3280 * distorted spectral mask 3281 */ 3282 static int 3283 ath5k_setup_channel_powertable(struct ath5k_hw *ah, 3284 struct ieee80211_channel *channel, 3285 u8 ee_mode, u8 type) 3286 { 3287 struct ath5k_pdgain_info *pdg_L, *pdg_R; 3288 struct ath5k_chan_pcal_info *pcinfo_L; 3289 struct ath5k_chan_pcal_info *pcinfo_R; 3290 struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom; 3291 u8 *pdg_curve_to_idx = ee->ee_pdc_to_idx[ee_mode]; 3292 s16 table_min[AR5K_EEPROM_N_PD_GAINS]; 3293 s16 table_max[AR5K_EEPROM_N_PD_GAINS]; 3294 u8 *tmpL; 3295 u8 *tmpR; 3296 u32 target = channel->center_freq; 3297 int pdg, i; 3298 3299 /* Get surrounding freq piers for this channel */ 3300 ath5k_get_chan_pcal_surrounding_piers(ah, channel, 3301 &pcinfo_L, 3302 &pcinfo_R); 3303 3304 /* Loop over pd gain curves on 3305 * surrounding freq piers by index */ 3306 for (pdg = 0; pdg < ee->ee_pd_gains[ee_mode]; pdg++) { 3307 3308 /* Fill curves in reverse order 3309 * from lower power (max gain) 3310 * to higher power. Use curve -> idx 3311 * backmapping we did on eeprom init */ 3312 u8 idx = pdg_curve_to_idx[pdg]; 3313 3314 /* Grab the needed curves by index */ 3315 pdg_L = &pcinfo_L->pd_curves[idx]; 3316 pdg_R = &pcinfo_R->pd_curves[idx]; 3317 3318 /* Initialize the temp tables */ 3319 tmpL = ah->ah_txpower.tmpL[pdg]; 3320 tmpR = ah->ah_txpower.tmpR[pdg]; 3321 3322 /* Set curve's x boundaries and create 3323 * curves so that they cover the same 3324 * range (if we don't do that one table 3325 * will have values on some range and the 3326 * other one won't have any so interpolation 3327 * will fail) */ 3328 table_min[pdg] = min(pdg_L->pd_pwr[0], 3329 pdg_R->pd_pwr[0]) / 2; 3330 3331 table_max[pdg] = max(pdg_L->pd_pwr[pdg_L->pd_points - 1], 3332 pdg_R->pd_pwr[pdg_R->pd_points - 1]) / 2; 3333 3334 /* Now create the curves on surrounding channels 3335 * and interpolate if needed to get the final 3336 * curve for this gain on this channel */ 3337 switch (type) { 3338 case AR5K_PWRTABLE_LINEAR_PCDAC: 3339 /* Override min/max so that we don't loose 3340 * accuracy (don't divide by 2) */ 3341 table_min[pdg] = min(pdg_L->pd_pwr[0], 3342 pdg_R->pd_pwr[0]); 3343 3344 table_max[pdg] = 3345 max(pdg_L->pd_pwr[pdg_L->pd_points - 1], 3346 pdg_R->pd_pwr[pdg_R->pd_points - 1]); 3347 3348 /* Override minimum so that we don't get 3349 * out of bounds while extrapolating 3350 * below. Don't do this when we have 2 3351 * curves and we are on the high power curve 3352 * because table_min is ok in this case */ 3353 if (!(ee->ee_pd_gains[ee_mode] > 1 && pdg == 0)) { 3354 3355 table_min[pdg] = 3356 ath5k_get_linear_pcdac_min(pdg_L->pd_step, 3357 pdg_R->pd_step, 3358 pdg_L->pd_pwr, 3359 pdg_R->pd_pwr); 3360 3361 /* Don't go too low because we will 3362 * miss the upper part of the curve. 3363 * Note: 126 = 31.5dB (max power supported) 3364 * in 0.25dB units */ 3365 if (table_max[pdg] - table_min[pdg] > 126) 3366 table_min[pdg] = table_max[pdg] - 126; 3367 } 3368 3369 /* Fall through */ 3370 case AR5K_PWRTABLE_PWR_TO_PCDAC: 3371 case AR5K_PWRTABLE_PWR_TO_PDADC: 3372 3373 ath5k_create_power_curve(table_min[pdg], 3374 table_max[pdg], 3375 pdg_L->pd_pwr, 3376 pdg_L->pd_step, 3377 pdg_L->pd_points, tmpL, type); 3378 3379 /* We are in a calibration 3380 * pier, no need to interpolate 3381 * between freq piers */ 3382 if (pcinfo_L == pcinfo_R) 3383 continue; 3384 3385 ath5k_create_power_curve(table_min[pdg], 3386 table_max[pdg], 3387 pdg_R->pd_pwr, 3388 pdg_R->pd_step, 3389 pdg_R->pd_points, tmpR, type); 3390 break; 3391 default: 3392 return -EINVAL; 3393 } 3394 3395 /* Interpolate between curves 3396 * of surrounding freq piers to 3397 * get the final curve for this 3398 * pd gain. Re-use tmpL for interpolation 3399 * output */ 3400 for (i = 0; (i < (u16) (table_max[pdg] - table_min[pdg])) && 3401 (i < AR5K_EEPROM_POWER_TABLE_SIZE); i++) { 3402 tmpL[i] = (u8) ath5k_get_interpolated_value(target, 3403 (s16) pcinfo_L->freq, 3404 (s16) pcinfo_R->freq, 3405 (s16) tmpL[i], 3406 (s16) tmpR[i]); 3407 } 3408 } 3409 3410 /* Now we have a set of curves for this 3411 * channel on tmpL (x range is table_max - table_min 3412 * and y values are tmpL[pdg][]) sorted in the same 3413 * order as EEPROM (because we've used the backmapping). 3414 * So for RF5112 it's from higher power to lower power 3415 * and for RF2413 it's from lower power to higher power. 3416 * For RF5111 we only have one curve. */ 3417 3418 /* Fill min and max power levels for this 3419 * channel by interpolating the values on 3420 * surrounding channels to complete the dataset */ 3421 ah->ah_txpower.txp_min_pwr = ath5k_get_interpolated_value(target, 3422 (s16) pcinfo_L->freq, 3423 (s16) pcinfo_R->freq, 3424 pcinfo_L->min_pwr, pcinfo_R->min_pwr); 3425 3426 ah->ah_txpower.txp_max_pwr = ath5k_get_interpolated_value(target, 3427 (s16) pcinfo_L->freq, 3428 (s16) pcinfo_R->freq, 3429 pcinfo_L->max_pwr, pcinfo_R->max_pwr); 3430 3431 /* Fill PCDAC/PDADC table */ 3432 switch (type) { 3433 case AR5K_PWRTABLE_LINEAR_PCDAC: 3434 /* For RF5112 we can have one or two curves 3435 * and each curve covers a certain power lvl 3436 * range so we need to do some more processing */ 3437 ath5k_combine_linear_pcdac_curves(ah, table_min, table_max, 3438 ee->ee_pd_gains[ee_mode]); 3439 3440 /* Set txp.offset so that we can 3441 * match max power value with max 3442 * table index */ 3443 ah->ah_txpower.txp_offset = 64 - (table_max[0] / 2); 3444 break; 3445 case AR5K_PWRTABLE_PWR_TO_PCDAC: 3446 /* We are done for RF5111 since it has only 3447 * one curve, just fit the curve on the table */ 3448 ath5k_fill_pwr_to_pcdac_table(ah, table_min, table_max); 3449 3450 /* No rate powertable adjustment for RF5111 */ 3451 ah->ah_txpower.txp_min_idx = 0; 3452 ah->ah_txpower.txp_offset = 0; 3453 break; 3454 case AR5K_PWRTABLE_PWR_TO_PDADC: 3455 /* Set PDADC boundaries and fill 3456 * final PDADC table */ 3457 ath5k_combine_pwr_to_pdadc_curves(ah, table_min, table_max, 3458 ee->ee_pd_gains[ee_mode]); 3459 3460 /* Set txp.offset, note that table_min 3461 * can be negative */ 3462 ah->ah_txpower.txp_offset = table_min[0]; 3463 break; 3464 default: 3465 return -EINVAL; 3466 } 3467 3468 ah->ah_txpower.txp_setup = true; 3469 3470 return 0; 3471 } 3472 3473 /** 3474 * ath5k_write_channel_powertable() - Set power table for current channel on hw 3475 * @ah: The &struct ath5k_hw 3476 * @ee_mode: One of enum ath5k_driver_mode 3477 * @type: One of enum ath5k_powertable_type (eeprom.h) 3478 */ 3479 static void 3480 ath5k_write_channel_powertable(struct ath5k_hw *ah, u8 ee_mode, u8 type) 3481 { 3482 if (type == AR5K_PWRTABLE_PWR_TO_PDADC) 3483 ath5k_write_pwr_to_pdadc_table(ah, ee_mode); 3484 else 3485 ath5k_write_pcdac_table(ah); 3486 } 3487 3488 3489 /** 3490 * DOC: Per-rate tx power setting 3491 * 3492 * This is the code that sets the desired tx power limit (below 3493 * maximum) on hw for each rate (we also have TPC that sets 3494 * power per packet type). We do that by providing an index on the 3495 * PCDAC/PDADC table we set up above, for each rate. 3496 * 3497 * For now we only limit txpower based on maximum tx power 3498 * supported by hw (what's inside rate_info) + conformance test 3499 * limits. We need to limit this even more, based on regulatory domain 3500 * etc to be safe. Normally this is done from above so we don't care 3501 * here, all we care is that the tx power we set will be O.K. 3502 * for the hw (e.g. won't create noise on PA etc). 3503 * 3504 * Rate power table contains indices to PCDAC/PDADC table (0.5dB steps - 3505 * x values) and is indexed as follows: 3506 * rates[0] - rates[7] -> OFDM rates 3507 * rates[8] - rates[14] -> CCK rates 3508 * rates[15] -> XR rates (they all have the same power) 3509 */ 3510 3511 /** 3512 * ath5k_setup_rate_powertable() - Set up rate power table for a given tx power 3513 * @ah: The &struct ath5k_hw 3514 * @max_pwr: The maximum tx power requested in 0.5dB steps 3515 * @rate_info: The &struct ath5k_rate_pcal_info to fill 3516 * @ee_mode: One of enum ath5k_driver_mode 3517 */ 3518 static void 3519 ath5k_setup_rate_powertable(struct ath5k_hw *ah, u16 max_pwr, 3520 struct ath5k_rate_pcal_info *rate_info, 3521 u8 ee_mode) 3522 { 3523 unsigned int i; 3524 u16 *rates; 3525 s16 rate_idx_scaled = 0; 3526 3527 /* max_pwr is power level we got from driver/user in 0.5dB 3528 * units, switch to 0.25dB units so we can compare */ 3529 max_pwr *= 2; 3530 max_pwr = min(max_pwr, (u16) ah->ah_txpower.txp_max_pwr) / 2; 3531 3532 /* apply rate limits */ 3533 rates = ah->ah_txpower.txp_rates_power_table; 3534 3535 /* OFDM rates 6 to 24Mb/s */ 3536 for (i = 0; i < 5; i++) 3537 rates[i] = min(max_pwr, rate_info->target_power_6to24); 3538 3539 /* Rest OFDM rates */ 3540 rates[5] = min(rates[0], rate_info->target_power_36); 3541 rates[6] = min(rates[0], rate_info->target_power_48); 3542 rates[7] = min(rates[0], rate_info->target_power_54); 3543 3544 /* CCK rates */ 3545 /* 1L */ 3546 rates[8] = min(rates[0], rate_info->target_power_6to24); 3547 /* 2L */ 3548 rates[9] = min(rates[0], rate_info->target_power_36); 3549 /* 2S */ 3550 rates[10] = min(rates[0], rate_info->target_power_36); 3551 /* 5L */ 3552 rates[11] = min(rates[0], rate_info->target_power_48); 3553 /* 5S */ 3554 rates[12] = min(rates[0], rate_info->target_power_48); 3555 /* 11L */ 3556 rates[13] = min(rates[0], rate_info->target_power_54); 3557 /* 11S */ 3558 rates[14] = min(rates[0], rate_info->target_power_54); 3559 3560 /* XR rates */ 3561 rates[15] = min(rates[0], rate_info->target_power_6to24); 3562 3563 /* CCK rates have different peak to average ratio 3564 * so we have to tweak their power so that gainf 3565 * correction works ok. For this we use OFDM to 3566 * CCK delta from eeprom */ 3567 if ((ee_mode == AR5K_EEPROM_MODE_11G) && 3568 (ah->ah_phy_revision < AR5K_SREV_PHY_5212A)) 3569 for (i = 8; i <= 15; i++) 3570 rates[i] -= ah->ah_txpower.txp_cck_ofdm_gainf_delta; 3571 3572 /* Save min/max and current tx power for this channel 3573 * in 0.25dB units. 3574 * 3575 * Note: We use rates[0] for current tx power because 3576 * it covers most of the rates, in most cases. It's our 3577 * tx power limit and what the user expects to see. */ 3578 ah->ah_txpower.txp_min_pwr = 2 * rates[7]; 3579 ah->ah_txpower.txp_cur_pwr = 2 * rates[0]; 3580 3581 /* Set max txpower for correct OFDM operation on all rates 3582 * -that is the txpower for 54Mbit-, it's used for the PAPD 3583 * gain probe and it's in 0.5dB units */ 3584 ah->ah_txpower.txp_ofdm = rates[7]; 3585 3586 /* Now that we have all rates setup use table offset to 3587 * match the power range set by user with the power indices 3588 * on PCDAC/PDADC table */ 3589 for (i = 0; i < 16; i++) { 3590 rate_idx_scaled = rates[i] + ah->ah_txpower.txp_offset; 3591 /* Don't get out of bounds */ 3592 if (rate_idx_scaled > 63) 3593 rate_idx_scaled = 63; 3594 if (rate_idx_scaled < 0) 3595 rate_idx_scaled = 0; 3596 rates[i] = rate_idx_scaled; 3597 } 3598 } 3599 3600 3601 /** 3602 * ath5k_hw_txpower() - Set transmission power limit for a given channel 3603 * @ah: The &struct ath5k_hw 3604 * @channel: The &struct ieee80211_channel 3605 * @txpower: Requested tx power in 0.5dB steps 3606 * 3607 * Combines all of the above to set the requested tx power limit 3608 * on hw. 3609 */ 3610 static int 3611 ath5k_hw_txpower(struct ath5k_hw *ah, struct ieee80211_channel *channel, 3612 u8 txpower) 3613 { 3614 struct ath5k_rate_pcal_info rate_info; 3615 struct ieee80211_channel *curr_channel = ah->ah_current_channel; 3616 int ee_mode; 3617 u8 type; 3618 int ret; 3619 3620 if (txpower > AR5K_TUNE_MAX_TXPOWER) { 3621 ATH5K_ERR(ah, "invalid tx power: %u\n", txpower); 3622 return -EINVAL; 3623 } 3624 3625 ee_mode = ath5k_eeprom_mode_from_channel(channel); 3626 if (ee_mode < 0) { 3627 ATH5K_ERR(ah, 3628 "invalid channel: %d\n", channel->center_freq); 3629 return -EINVAL; 3630 } 3631 3632 /* Initialize TX power table */ 3633 switch (ah->ah_radio) { 3634 case AR5K_RF5110: 3635 /* TODO */ 3636 return 0; 3637 case AR5K_RF5111: 3638 type = AR5K_PWRTABLE_PWR_TO_PCDAC; 3639 break; 3640 case AR5K_RF5112: 3641 type = AR5K_PWRTABLE_LINEAR_PCDAC; 3642 break; 3643 case AR5K_RF2413: 3644 case AR5K_RF5413: 3645 case AR5K_RF2316: 3646 case AR5K_RF2317: 3647 case AR5K_RF2425: 3648 type = AR5K_PWRTABLE_PWR_TO_PDADC; 3649 break; 3650 default: 3651 return -EINVAL; 3652 } 3653 3654 /* 3655 * If we don't change channel/mode skip tx powertable calculation 3656 * and use the cached one. 3657 */ 3658 if (!ah->ah_txpower.txp_setup || 3659 (channel->hw_value != curr_channel->hw_value) || 3660 (channel->center_freq != curr_channel->center_freq)) { 3661 /* Reset TX power values but preserve requested 3662 * tx power from above */ 3663 int requested_txpower = ah->ah_txpower.txp_requested; 3664 3665 memset(&ah->ah_txpower, 0, sizeof(ah->ah_txpower)); 3666 3667 /* Restore TPC setting and requested tx power */ 3668 ah->ah_txpower.txp_tpc = AR5K_TUNE_TPC_TXPOWER; 3669 3670 ah->ah_txpower.txp_requested = requested_txpower; 3671 3672 /* Calculate the powertable */ 3673 ret = ath5k_setup_channel_powertable(ah, channel, 3674 ee_mode, type); 3675 if (ret) 3676 return ret; 3677 } 3678 3679 /* Write table on hw */ 3680 ath5k_write_channel_powertable(ah, ee_mode, type); 3681 3682 /* Limit max power if we have a CTL available */ 3683 ath5k_get_max_ctl_power(ah, channel); 3684 3685 /* FIXME: Antenna reduction stuff */ 3686 3687 /* FIXME: Limit power on turbo modes */ 3688 3689 /* FIXME: TPC scale reduction */ 3690 3691 /* Get surrounding channels for per-rate power table 3692 * calibration */ 3693 ath5k_get_rate_pcal_data(ah, channel, &rate_info); 3694 3695 /* Setup rate power table */ 3696 ath5k_setup_rate_powertable(ah, txpower, &rate_info, ee_mode); 3697 3698 /* Write rate power table on hw */ 3699 ath5k_hw_reg_write(ah, AR5K_TXPOWER_OFDM(3, 24) | 3700 AR5K_TXPOWER_OFDM(2, 16) | AR5K_TXPOWER_OFDM(1, 8) | 3701 AR5K_TXPOWER_OFDM(0, 0), AR5K_PHY_TXPOWER_RATE1); 3702 3703 ath5k_hw_reg_write(ah, AR5K_TXPOWER_OFDM(7, 24) | 3704 AR5K_TXPOWER_OFDM(6, 16) | AR5K_TXPOWER_OFDM(5, 8) | 3705 AR5K_TXPOWER_OFDM(4, 0), AR5K_PHY_TXPOWER_RATE2); 3706 3707 ath5k_hw_reg_write(ah, AR5K_TXPOWER_CCK(10, 24) | 3708 AR5K_TXPOWER_CCK(9, 16) | AR5K_TXPOWER_CCK(15, 8) | 3709 AR5K_TXPOWER_CCK(8, 0), AR5K_PHY_TXPOWER_RATE3); 3710 3711 ath5k_hw_reg_write(ah, AR5K_TXPOWER_CCK(14, 24) | 3712 AR5K_TXPOWER_CCK(13, 16) | AR5K_TXPOWER_CCK(12, 8) | 3713 AR5K_TXPOWER_CCK(11, 0), AR5K_PHY_TXPOWER_RATE4); 3714 3715 /* FIXME: TPC support */ 3716 if (ah->ah_txpower.txp_tpc) { 3717 ath5k_hw_reg_write(ah, AR5K_PHY_TXPOWER_RATE_MAX_TPC_ENABLE | 3718 AR5K_TUNE_MAX_TXPOWER, AR5K_PHY_TXPOWER_RATE_MAX); 3719 3720 ath5k_hw_reg_write(ah, 3721 AR5K_REG_MS(AR5K_TUNE_MAX_TXPOWER, AR5K_TPC_ACK) | 3722 AR5K_REG_MS(AR5K_TUNE_MAX_TXPOWER, AR5K_TPC_CTS) | 3723 AR5K_REG_MS(AR5K_TUNE_MAX_TXPOWER, AR5K_TPC_CHIRP), 3724 AR5K_TPC); 3725 } else { 3726 ath5k_hw_reg_write(ah, AR5K_PHY_TXPOWER_RATE_MAX | 3727 AR5K_TUNE_MAX_TXPOWER, AR5K_PHY_TXPOWER_RATE_MAX); 3728 } 3729 3730 return 0; 3731 } 3732 3733 /** 3734 * ath5k_hw_set_txpower_limit() - Set txpower limit for the current channel 3735 * @ah: The &struct ath5k_hw 3736 * @txpower: The requested tx power limit in 0.5dB steps 3737 * 3738 * This function provides access to ath5k_hw_txpower to the driver in 3739 * case user or an application changes it while PHY is running. 3740 */ 3741 int 3742 ath5k_hw_set_txpower_limit(struct ath5k_hw *ah, u8 txpower) 3743 { 3744 ATH5K_DBG(ah, ATH5K_DEBUG_TXPOWER, 3745 "changing txpower to %d\n", txpower); 3746 3747 return ath5k_hw_txpower(ah, ah->ah_current_channel, txpower); 3748 } 3749 3750 3751 /*************\ 3752 Init function 3753 \*************/ 3754 3755 /** 3756 * ath5k_hw_phy_init() - Initialize PHY 3757 * @ah: The &struct ath5k_hw 3758 * @channel: The @struct ieee80211_channel 3759 * @mode: One of enum ath5k_driver_mode 3760 * @fast: Try a fast channel switch instead 3761 * 3762 * This is the main function used during reset to initialize PHY 3763 * or do a fast channel change if possible. 3764 * 3765 * NOTE: Do not call this one from the driver, it assumes PHY is in a 3766 * warm reset state ! 3767 */ 3768 int 3769 ath5k_hw_phy_init(struct ath5k_hw *ah, struct ieee80211_channel *channel, 3770 u8 mode, bool fast) 3771 { 3772 struct ieee80211_channel *curr_channel; 3773 int ret, i; 3774 u32 phy_tst1; 3775 ret = 0; 3776 3777 /* 3778 * Sanity check for fast flag 3779 * Don't try fast channel change when changing modulation 3780 * mode/band. We check for chip compatibility on 3781 * ath5k_hw_reset. 3782 */ 3783 curr_channel = ah->ah_current_channel; 3784 if (fast && (channel->hw_value != curr_channel->hw_value)) 3785 return -EINVAL; 3786 3787 /* 3788 * On fast channel change we only set the synth parameters 3789 * while PHY is running, enable calibration and skip the rest. 3790 */ 3791 if (fast) { 3792 AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_RFBUS_REQ, 3793 AR5K_PHY_RFBUS_REQ_REQUEST); 3794 for (i = 0; i < 100; i++) { 3795 if (ath5k_hw_reg_read(ah, AR5K_PHY_RFBUS_GRANT)) 3796 break; 3797 udelay(5); 3798 } 3799 /* Failed */ 3800 if (i >= 100) 3801 return -EIO; 3802 3803 /* Set channel and wait for synth */ 3804 ret = ath5k_hw_channel(ah, channel); 3805 if (ret) 3806 return ret; 3807 3808 ath5k_hw_wait_for_synth(ah, channel); 3809 } 3810 3811 /* 3812 * Set TX power 3813 * 3814 * Note: We need to do that before we set 3815 * RF buffer settings on 5211/5212+ so that we 3816 * properly set curve indices. 3817 */ 3818 ret = ath5k_hw_txpower(ah, channel, ah->ah_txpower.txp_requested ? 3819 ah->ah_txpower.txp_requested * 2 : 3820 AR5K_TUNE_MAX_TXPOWER); 3821 if (ret) 3822 return ret; 3823 3824 /* Write OFDM timings on 5212*/ 3825 if (ah->ah_version == AR5K_AR5212 && 3826 channel->hw_value != AR5K_MODE_11B) { 3827 3828 ret = ath5k_hw_write_ofdm_timings(ah, channel); 3829 if (ret) 3830 return ret; 3831 3832 /* Spur info is available only from EEPROM versions 3833 * greater than 5.3, but the EEPROM routines will use 3834 * static values for older versions */ 3835 if (ah->ah_mac_srev >= AR5K_SREV_AR5424) 3836 ath5k_hw_set_spur_mitigation_filter(ah, 3837 channel); 3838 } 3839 3840 /* If we used fast channel switching 3841 * we are done, release RF bus and 3842 * fire up NF calibration. 3843 * 3844 * Note: Only NF calibration due to 3845 * channel change, not AGC calibration 3846 * since AGC is still running ! 3847 */ 3848 if (fast) { 3849 /* 3850 * Release RF Bus grant 3851 */ 3852 AR5K_REG_DISABLE_BITS(ah, AR5K_PHY_RFBUS_REQ, 3853 AR5K_PHY_RFBUS_REQ_REQUEST); 3854 3855 /* 3856 * Start NF calibration 3857 */ 3858 AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_AGCCTL, 3859 AR5K_PHY_AGCCTL_NF); 3860 3861 return ret; 3862 } 3863 3864 /* 3865 * For 5210 we do all initialization using 3866 * initvals, so we don't have to modify 3867 * any settings (5210 also only supports 3868 * a/aturbo modes) 3869 */ 3870 if (ah->ah_version != AR5K_AR5210) { 3871 3872 /* 3873 * Write initial RF gain settings 3874 * This should work for both 5111/5112 3875 */ 3876 ret = ath5k_hw_rfgain_init(ah, channel->band); 3877 if (ret) 3878 return ret; 3879 3880 usleep_range(1000, 1500); 3881 3882 /* 3883 * Write RF buffer 3884 */ 3885 ret = ath5k_hw_rfregs_init(ah, channel, mode); 3886 if (ret) 3887 return ret; 3888 3889 /*Enable/disable 802.11b mode on 5111 3890 (enable 2111 frequency converter + CCK)*/ 3891 if (ah->ah_radio == AR5K_RF5111) { 3892 if (mode == AR5K_MODE_11B) 3893 AR5K_REG_ENABLE_BITS(ah, AR5K_TXCFG, 3894 AR5K_TXCFG_B_MODE); 3895 else 3896 AR5K_REG_DISABLE_BITS(ah, AR5K_TXCFG, 3897 AR5K_TXCFG_B_MODE); 3898 } 3899 3900 } else if (ah->ah_version == AR5K_AR5210) { 3901 usleep_range(1000, 1500); 3902 /* Disable phy and wait */ 3903 ath5k_hw_reg_write(ah, AR5K_PHY_ACT_DISABLE, AR5K_PHY_ACT); 3904 usleep_range(1000, 1500); 3905 } 3906 3907 /* Set channel on PHY */ 3908 ret = ath5k_hw_channel(ah, channel); 3909 if (ret) 3910 return ret; 3911 3912 /* 3913 * Enable the PHY and wait until completion 3914 * This includes BaseBand and Synthesizer 3915 * activation. 3916 */ 3917 ath5k_hw_reg_write(ah, AR5K_PHY_ACT_ENABLE, AR5K_PHY_ACT); 3918 3919 ath5k_hw_wait_for_synth(ah, channel); 3920 3921 /* 3922 * Perform ADC test to see if baseband is ready 3923 * Set tx hold and check adc test register 3924 */ 3925 phy_tst1 = ath5k_hw_reg_read(ah, AR5K_PHY_TST1); 3926 ath5k_hw_reg_write(ah, AR5K_PHY_TST1_TXHOLD, AR5K_PHY_TST1); 3927 for (i = 0; i <= 20; i++) { 3928 if (!(ath5k_hw_reg_read(ah, AR5K_PHY_ADC_TEST) & 0x10)) 3929 break; 3930 usleep_range(200, 250); 3931 } 3932 ath5k_hw_reg_write(ah, phy_tst1, AR5K_PHY_TST1); 3933 3934 /* 3935 * Start automatic gain control calibration 3936 * 3937 * During AGC calibration RX path is re-routed to 3938 * a power detector so we don't receive anything. 3939 * 3940 * This method is used to calibrate some static offsets 3941 * used together with on-the fly I/Q calibration (the 3942 * one performed via ath5k_hw_phy_calibrate), which doesn't 3943 * interrupt rx path. 3944 * 3945 * While rx path is re-routed to the power detector we also 3946 * start a noise floor calibration to measure the 3947 * card's noise floor (the noise we measure when we are not 3948 * transmitting or receiving anything). 3949 * 3950 * If we are in a noisy environment, AGC calibration may time 3951 * out and/or noise floor calibration might timeout. 3952 */ 3953 AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_AGCCTL, 3954 AR5K_PHY_AGCCTL_CAL | AR5K_PHY_AGCCTL_NF); 3955 3956 /* At the same time start I/Q calibration for QAM constellation 3957 * -no need for CCK- */ 3958 ah->ah_iq_cal_needed = false; 3959 if (!(mode == AR5K_MODE_11B)) { 3960 ah->ah_iq_cal_needed = true; 3961 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_IQ, 3962 AR5K_PHY_IQ_CAL_NUM_LOG_MAX, 15); 3963 AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_IQ, 3964 AR5K_PHY_IQ_RUN); 3965 } 3966 3967 /* Wait for gain calibration to finish (we check for I/Q calibration 3968 * during ath5k_phy_calibrate) */ 3969 if (ath5k_hw_register_timeout(ah, AR5K_PHY_AGCCTL, 3970 AR5K_PHY_AGCCTL_CAL, 0, false)) { 3971 ATH5K_ERR(ah, "gain calibration timeout (%uMHz)\n", 3972 channel->center_freq); 3973 } 3974 3975 /* Restore antenna mode */ 3976 ath5k_hw_set_antenna_mode(ah, ah->ah_ant_mode); 3977 3978 return ret; 3979 } 3980