Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
phy.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2004-2007 Reyk Floeter <[email protected]>
3  * Copyright (c) 2006-2009 Nick Kossifidis <[email protected]>
4  * Copyright (c) 2007-2008 Jiri Slaby <[email protected]>
5  * Copyright (c) 2008-2009 Felix Fietkau <[email protected]>
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 
71 /******************\
72 * Helper functions *
73 \******************/
74 
83 u16
85 {
86  unsigned int i;
87  u32 srev;
88  u16 ret;
89 
90  /*
91  * Set the radio chip access register
92  */
93  switch (band) {
95  ath5k_hw_reg_write(ah, AR5K_PHY_SHIFT_2GHZ, AR5K_PHY(0));
96  break;
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 
135 bool
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 
158 bool
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 
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 
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 
338  AR5K_PHY_TIMING_3_DSC_MAN, ds_coef_man);
340  AR5K_PHY_TIMING_3_DSC_EXP, ds_coef_exp);
341 
342  return 0;
343 }
344 
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 
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) &
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 
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 
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,
470 
471  ah->ah_gain.g_state = AR5K_RFGAIN_READ_REQUESTED;
472 
473 }
474 
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) ||
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 
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 
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 
682 enum ath5k_rfgain
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;
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) {
710  ah->ah_gain.g_current +=
712  else
713  ah->ah_gain.g_current +=
715  }
716 
717  /* Further correct gain_F measurement for
718  * RF5112A radios */
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) &&
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 
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 
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:
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 
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 
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 &&
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 
1182 static u32
1183 ath5k_hw_rf5110_chan2athchan(struct ieee80211_channel *channel)
1184 {
1185  u32 athchan;
1186 
1187  athchan = (ath5k_hw_bitswap(
1189  channel->center_freq) - 24) / 2, 5)
1190  << 1) | (1 << 6) | 0x1;
1191  return athchan;
1192 }
1193 
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 
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 
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 =
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(
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),
1300 
1301  return 0;
1302 }
1303 
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 
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 
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) {
1478  } else {
1481  }
1482 
1484 
1485  return 0;
1486 }
1487 
1488 
1489 /*****************\
1490  PHY calibration
1491 \*****************/
1492 
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 
1539 void
1541 {
1542  int i;
1543 
1544  ah->ah_nfcal_hist.index = 0;
1545  for (i = 0; i < ATH5K_NF_CAL_HIST_MAX; i++)
1547 }
1548 
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 
1565 static s16
1566 ath5k_hw_get_median_noise_floor(struct ath5k_hw *ah)
1567 {
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 
1597 void
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 
1614 
1616 
1617  /* completed NF calibration, test threshold */
1618  nf = ath5k_hw_read_measured_noise_floor(ah);
1619  threshold = ee->ee_noise_floor_thr[ee_mode];
1620 
1621  if (nf > threshold) {
1622  ATH5K_DBG(ah, ATH5K_DEBUG_CALIBRATE,
1623  "noise floor failure detected; "
1624  "read %d, threshold %d\n",
1625  nf, threshold);
1626 
1628  }
1629 
1630  ath5k_hw_update_nfcal_hist(ah, nf);
1631  nf = ath5k_hw_get_median_noise_floor(ah);
1632 
1633  /* load noise floor (in .5 dBm) so the hardware will use it */
1634  val = ath5k_hw_reg_read(ah, AR5K_PHY_NF) & ~AR5K_PHY_NF_M;
1635  val |= (nf * 2) & AR5K_PHY_NF_M;
1636  ath5k_hw_reg_write(ah, val, AR5K_PHY_NF);
1637 
1638  AR5K_REG_MASKED_BITS(ah, AR5K_PHY_AGCCTL, AR5K_PHY_AGCCTL_NF,
1640 
1641  ath5k_hw_register_timeout(ah, AR5K_PHY_AGCCTL, AR5K_PHY_AGCCTL_NF,
1642  0, false);
1643 
1644  /*
1645  * Load a high max CCA Power value (-50 dBm in .5 dBm units)
1646  * so that we're not capped by the median we just loaded.
1647  * This will be used as the initial value for the next noise
1648  * floor calibration.
1649  */
1650  val = (val & ~AR5K_PHY_NF_M) | ((-50 * 2) & AR5K_PHY_NF_M);
1651  ath5k_hw_reg_write(ah, val, AR5K_PHY_NF);
1655  AR5K_PHY_AGCCTL_NF);
1656 
1657  ah->ah_noise_floor = nf;
1658 
1660 
1661  ATH5K_DBG(ah, ATH5K_DEBUG_CALIBRATE,
1662  "noise floor calibrated: %d\n", nf);
1663 }
1664 
1672 static int
1673 ath5k_hw_rf5110_calibrate(struct ath5k_hw *ah,
1674  struct ieee80211_channel *channel)
1675 {
1676  u32 phy_sig, phy_agc, phy_sat, beacon;
1677  int ret;
1678 
1679  if (!(ah->ah_cal_mask & AR5K_CALIBRATION_FULL))
1680  return 0;
1681 
1682  /*
1683  * Disable beacons and RX/TX queues, wait
1684  */
1687  beacon = ath5k_hw_reg_read(ah, AR5K_BEACON_5210);
1688  ath5k_hw_reg_write(ah, beacon & ~AR5K_BEACON_ENABLE, AR5K_BEACON_5210);
1689 
1690  usleep_range(2000, 2500);
1691 
1692  /*
1693  * Set the channel (with AGC turned off)
1694  */
1696  udelay(10);
1697  ret = ath5k_hw_channel(ah, channel);
1698 
1699  /*
1700  * Activate PHY and wait
1701  */
1702  ath5k_hw_reg_write(ah, AR5K_PHY_ACT_ENABLE, AR5K_PHY_ACT);
1703  usleep_range(1000, 1500);
1704 
1706 
1707  if (ret)
1708  return ret;
1709 
1710  /*
1711  * Calibrate the radio chip
1712  */
1713 
1714  /* Remember normal state */
1715  phy_sig = ath5k_hw_reg_read(ah, AR5K_PHY_SIG);
1716  phy_agc = ath5k_hw_reg_read(ah, AR5K_PHY_AGCCOARSE);
1717  phy_sat = ath5k_hw_reg_read(ah, AR5K_PHY_ADCSAT);
1718 
1719  /* Update radio registers */
1720  ath5k_hw_reg_write(ah, (phy_sig & ~(AR5K_PHY_SIG_FIRPWR)) |
1722 
1723  ath5k_hw_reg_write(ah, (phy_agc & ~(AR5K_PHY_AGCCOARSE_HI |
1727 
1728  ath5k_hw_reg_write(ah, (phy_sat & ~(AR5K_PHY_ADCSAT_ICNT |
1732 
1733  udelay(20);
1734 
1736  udelay(10);
1737  ath5k_hw_reg_write(ah, AR5K_PHY_RFSTG_DISABLE, AR5K_PHY_RFSTG);
1739 
1740  usleep_range(1000, 1500);
1741 
1742  /*
1743  * Enable calibration and wait until completion
1744  */
1746 
1748  AR5K_PHY_AGCCTL_CAL, 0, false);
1749 
1750  /* Reset to normal state */
1751  ath5k_hw_reg_write(ah, phy_sig, AR5K_PHY_SIG);
1752  ath5k_hw_reg_write(ah, phy_agc, AR5K_PHY_AGCCOARSE);
1753  ath5k_hw_reg_write(ah, phy_sat, AR5K_PHY_ADCSAT);
1754 
1755  if (ret) {
1756  ATH5K_ERR(ah, "calibration timeout (%uMHz)\n",
1757  channel->center_freq);
1758  return ret;
1759  }
1760 
1761  /*
1762  * Re-enable RX/TX and beacons
1763  */
1766  ath5k_hw_reg_write(ah, beacon, AR5K_BEACON_5210);
1767 
1768  return 0;
1769 }
1770 
1775 static int
1776 ath5k_hw_rf511x_iq_calibrate(struct ath5k_hw *ah)
1777 {
1778  u32 i_pwr, q_pwr;
1779  s32 iq_corr, i_coff, i_coffd, q_coff, q_coffd;
1780  int i;
1781 
1782  /* Skip if I/Q calibration is not needed or if it's still running */
1783  if (!ah->ah_iq_cal_needed)
1784  return -EINVAL;
1785  else if (ath5k_hw_reg_read(ah, AR5K_PHY_IQ) & AR5K_PHY_IQ_RUN) {
1786  ATH5K_DBG_UNLIMIT(ah, ATH5K_DEBUG_CALIBRATE,
1787  "I/Q calibration still running");
1788  return -EBUSY;
1789  }
1790 
1791  /* Calibration has finished, get the results and re-run */
1792 
1793  /* Work around for empty results which can apparently happen on 5212:
1794  * Read registers up to 10 times until we get both i_pr and q_pwr */
1795  for (i = 0; i <= 10; i++) {
1796  iq_corr = ath5k_hw_reg_read(ah, AR5K_PHY_IQRES_CAL_CORR);
1797  i_pwr = ath5k_hw_reg_read(ah, AR5K_PHY_IQRES_CAL_PWR_I);
1798  q_pwr = ath5k_hw_reg_read(ah, AR5K_PHY_IQRES_CAL_PWR_Q);
1799  ATH5K_DBG_UNLIMIT(ah, ATH5K_DEBUG_CALIBRATE,
1800  "iq_corr:%x i_pwr:%x q_pwr:%x", iq_corr, i_pwr, q_pwr);
1801  if (i_pwr && q_pwr)
1802  break;
1803  }
1804 
1805  i_coffd = ((i_pwr >> 1) + (q_pwr >> 1)) >> 7;
1806 
1807  if (ah->ah_version == AR5K_AR5211)
1808  q_coffd = q_pwr >> 6;
1809  else
1810  q_coffd = q_pwr >> 7;
1811 
1812  /* In case i_coffd became zero, cancel calibration
1813  * not only it's too small, it'll also result a divide
1814  * by zero later on. */
1815  if (i_coffd == 0 || q_coffd < 2)
1816  return -ECANCELED;
1817 
1818  /* Protect against loss of sign bits */
1819 
1820  i_coff = (-iq_corr) / i_coffd;
1821  i_coff = clamp(i_coff, -32, 31); /* signed 6 bit */
1822 
1823  if (ah->ah_version == AR5K_AR5211)
1824  q_coff = (i_pwr / q_coffd) - 64;
1825  else
1826  q_coff = (i_pwr / q_coffd) - 128;
1827  q_coff = clamp(q_coff, -16, 15); /* signed 5 bit */
1828 
1829  ATH5K_DBG_UNLIMIT(ah, ATH5K_DEBUG_CALIBRATE,
1830  "new I:%d Q:%d (i_coffd:%x q_coffd:%x)",
1831  i_coff, q_coff, i_coffd, q_coffd);
1832 
1833  /* Commit new I/Q values (set enable bit last to match HAL sources) */
1837 
1838  /* Re-enable calibration -if we don't we'll commit
1839  * the same values again and again */
1842  AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_IQ, AR5K_PHY_IQ_RUN);
1843 
1844  return 0;
1845 }
1846 
1856 int
1858  struct ieee80211_channel *channel)
1859 {
1860  int ret;
1861 
1862  if (ah->ah_radio == AR5K_RF5110)
1863  return ath5k_hw_rf5110_calibrate(ah, channel);
1864 
1865  ret = ath5k_hw_rf511x_iq_calibrate(ah);
1866  if (ret) {
1867  ATH5K_DBG_UNLIMIT(ah, ATH5K_DEBUG_CALIBRATE,
1868  "No I/Q correction performed (%uMHz)\n",
1869  channel->center_freq);
1870 
1871  /* Happens all the time if there is not much
1872  * traffic, consider it normal behaviour. */
1873  ret = 0;
1874  }
1875 
1876  /* On full calibration request a PAPD probe for
1877  * gainf calibration if needed */
1878  if ((ah->ah_cal_mask & AR5K_CALIBRATION_FULL) &&
1879  (ah->ah_radio == AR5K_RF5111 ||
1880  ah->ah_radio == AR5K_RF5112) &&
1881  channel->hw_value != AR5K_MODE_11B)
1882  ath5k_hw_request_rfgain_probe(ah);
1883 
1884  /* Update noise floor */
1885  if (!(ah->ah_cal_mask & AR5K_CALIBRATION_NF))
1887 
1888  return ret;
1889 }
1890 
1891 
1892 /***************************\
1893 * Spur mitigation functions *
1894 \***************************/
1895 
1906 static void
1907 ath5k_hw_set_spur_mitigation_filter(struct ath5k_hw *ah,
1908  struct ieee80211_channel *channel)
1909 {
1910  struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
1911  u32 mag_mask[4] = {0, 0, 0, 0};
1912  u32 pilot_mask[2] = {0, 0};
1913  /* Note: fbin values are scaled up by 2 */
1914  u16 spur_chan_fbin, chan_fbin, symbol_width, spur_detection_window;
1915  s32 spur_delta_phase, spur_freq_sigma_delta;
1916  s32 spur_offset, num_symbols_x16;
1917  u8 num_symbol_offsets, i, freq_band;
1918 
1919  /* Convert current frequency to fbin value (the same way channels
1920  * are stored on EEPROM, check out ath5k_eeprom_bin2freq) and scale
1921  * up by 2 so we can compare it later */
1922  if (channel->band == IEEE80211_BAND_2GHZ) {
1923  chan_fbin = (channel->center_freq - 2300) * 10;
1924  freq_band = AR5K_EEPROM_BAND_2GHZ;
1925  } else {
1926  chan_fbin = (channel->center_freq - 4900) * 10;
1927  freq_band = AR5K_EEPROM_BAND_5GHZ;
1928  }
1929 
1930  /* Check if any spur_chan_fbin from EEPROM is
1931  * within our current channel's spur detection range */
1932  spur_chan_fbin = AR5K_EEPROM_NO_SPUR;
1933  spur_detection_window = AR5K_SPUR_CHAN_WIDTH;
1934  /* XXX: Half/Quarter channels ?*/
1935  if (ah->ah_bwmode == AR5K_BWMODE_40MHZ)
1936  spur_detection_window *= 2;
1937 
1938  for (i = 0; i < AR5K_EEPROM_N_SPUR_CHANS; i++) {
1939  spur_chan_fbin = ee->ee_spur_chans[i][freq_band];
1940 
1941  /* Note: mask cleans AR5K_EEPROM_NO_SPUR flag
1942  * so it's zero if we got nothing from EEPROM */
1943  if (spur_chan_fbin == AR5K_EEPROM_NO_SPUR) {
1944  spur_chan_fbin &= AR5K_EEPROM_SPUR_CHAN_MASK;
1945  break;
1946  }
1947 
1948  if ((chan_fbin - spur_detection_window <=
1949  (spur_chan_fbin & AR5K_EEPROM_SPUR_CHAN_MASK)) &&
1950  (chan_fbin + spur_detection_window >=
1951  (spur_chan_fbin & AR5K_EEPROM_SPUR_CHAN_MASK))) {
1952  spur_chan_fbin &= AR5K_EEPROM_SPUR_CHAN_MASK;
1953  break;
1954  }
1955  }
1956 
1957  /* We need to enable spur filter for this channel */
1958  if (spur_chan_fbin) {
1959  spur_offset = spur_chan_fbin - chan_fbin;
1960  /*
1961  * Calculate deltas:
1962  * spur_freq_sigma_delta -> spur_offset / sample_freq << 21
1963  * spur_delta_phase -> spur_offset / chip_freq << 11
1964  * Note: Both values have 100Hz resolution
1965  */
1966  switch (ah->ah_bwmode) {
1967  case AR5K_BWMODE_40MHZ:
1968  /* Both sample_freq and chip_freq are 80MHz */
1969  spur_delta_phase = (spur_offset << 16) / 25;
1970  spur_freq_sigma_delta = (spur_delta_phase >> 10);
1971  symbol_width = AR5K_SPUR_SYMBOL_WIDTH_BASE_100Hz * 2;
1972  break;
1973  case AR5K_BWMODE_10MHZ:
1974  /* Both sample_freq and chip_freq are 20MHz (?) */
1975  spur_delta_phase = (spur_offset << 18) / 25;
1976  spur_freq_sigma_delta = (spur_delta_phase >> 10);
1977  symbol_width = AR5K_SPUR_SYMBOL_WIDTH_BASE_100Hz / 2;
1978  break;
1979  case AR5K_BWMODE_5MHZ:
1980  /* Both sample_freq and chip_freq are 10MHz (?) */
1981  spur_delta_phase = (spur_offset << 19) / 25;
1982  spur_freq_sigma_delta = (spur_delta_phase >> 10);
1983  symbol_width = AR5K_SPUR_SYMBOL_WIDTH_BASE_100Hz / 4;
1984  break;
1985  default:
1986  if (channel->band == IEEE80211_BAND_5GHZ) {
1987  /* Both sample_freq and chip_freq are 40MHz */
1988  spur_delta_phase = (spur_offset << 17) / 25;
1989  spur_freq_sigma_delta =
1990  (spur_delta_phase >> 10);
1991  symbol_width =
1993  } else {
1994  /* sample_freq -> 40MHz chip_freq -> 44MHz
1995  * (for b compatibility) */
1996  spur_delta_phase = (spur_offset << 17) / 25;
1997  spur_freq_sigma_delta =
1998  (spur_offset << 8) / 55;
1999  symbol_width =
2001  }
2002  break;
2003  }
2004 
2005  /* Calculate pilot and magnitude masks */
2006 
2007  /* Scale up spur_offset by 1000 to switch to 100HZ resolution
2008  * and divide by symbol_width to find how many symbols we have
2009  * Note: number of symbols is scaled up by 16 */
2010  num_symbols_x16 = ((spur_offset * 1000) << 4) / symbol_width;
2011 
2012  /* Spur is on a symbol if num_symbols_x16 % 16 is zero */
2013  if (!(num_symbols_x16 & 0xF))
2014  /* _X_ */
2015  num_symbol_offsets = 3;
2016  else
2017  /* _xx_ */
2018  num_symbol_offsets = 4;
2019 
2020  for (i = 0; i < num_symbol_offsets; i++) {
2021 
2022  /* Calculate pilot mask */
2023  s32 curr_sym_off =
2024  (num_symbols_x16 / 16) + i + 25;
2025 
2026  /* Pilot magnitude mask seems to be a way to
2027  * declare the boundaries for our detection
2028  * window or something, it's 2 for the middle
2029  * value(s) where the symbol is expected to be
2030  * and 1 on the boundary values */
2031  u8 plt_mag_map =
2032  (i == 0 || i == (num_symbol_offsets - 1))
2033  ? 1 : 2;
2034 
2035  if (curr_sym_off >= 0 && curr_sym_off <= 32) {
2036  if (curr_sym_off <= 25)
2037  pilot_mask[0] |= 1 << curr_sym_off;
2038  else if (curr_sym_off >= 27)
2039  pilot_mask[0] |= 1 << (curr_sym_off - 1);
2040  } else if (curr_sym_off >= 33 && curr_sym_off <= 52)
2041  pilot_mask[1] |= 1 << (curr_sym_off - 33);
2042 
2043  /* Calculate magnitude mask (for viterbi decoder) */
2044  if (curr_sym_off >= -1 && curr_sym_off <= 14)
2045  mag_mask[0] |=
2046  plt_mag_map << (curr_sym_off + 1) * 2;
2047  else if (curr_sym_off >= 15 && curr_sym_off <= 30)
2048  mag_mask[1] |=
2049  plt_mag_map << (curr_sym_off - 15) * 2;
2050  else if (curr_sym_off >= 31 && curr_sym_off <= 46)
2051  mag_mask[2] |=
2052  plt_mag_map << (curr_sym_off - 31) * 2;
2053  else if (curr_sym_off >= 47 && curr_sym_off <= 53)
2054  mag_mask[3] |=
2055  plt_mag_map << (curr_sym_off - 47) * 2;
2056 
2057  }
2058 
2059  /* Write settings on hw to enable spur filter */
2062  /* XXX: Self correlator also ? */
2067 
2068  /* Set delta phase and freq sigma delta */
2069  ath5k_hw_reg_write(ah,
2070  AR5K_REG_SM(spur_delta_phase,
2072  AR5K_REG_SM(spur_freq_sigma_delta,
2076 
2077  /* Write pilot masks */
2078  ath5k_hw_reg_write(ah, pilot_mask[0], AR5K_PHY_TIMING_7);
2081  pilot_mask[1]);
2082 
2083  ath5k_hw_reg_write(ah, pilot_mask[0], AR5K_PHY_TIMING_9);
2086  pilot_mask[1]);
2087 
2088  /* Write magnitude masks */
2089  ath5k_hw_reg_write(ah, mag_mask[0], AR5K_PHY_BIN_MASK_1);
2090  ath5k_hw_reg_write(ah, mag_mask[1], AR5K_PHY_BIN_MASK_2);
2091  ath5k_hw_reg_write(ah, mag_mask[2], AR5K_PHY_BIN_MASK_3);
2094  mag_mask[3]);
2095 
2096  ath5k_hw_reg_write(ah, mag_mask[0], AR5K_PHY_BIN_MASK2_1);
2097  ath5k_hw_reg_write(ah, mag_mask[1], AR5K_PHY_BIN_MASK2_2);
2098  ath5k_hw_reg_write(ah, mag_mask[2], AR5K_PHY_BIN_MASK2_3);
2101  mag_mask[3]);
2102 
2103  } else if (ath5k_hw_reg_read(ah, AR5K_PHY_IQ) &
2105  /* Clean up spur mitigation settings and disable filter */
2111  AR5K_PHY_IQ_SPUR_FILT_EN);
2112  ath5k_hw_reg_write(ah, 0, AR5K_PHY_TIMING_11);
2113 
2114  /* Clear pilot masks */
2115  ath5k_hw_reg_write(ah, 0, AR5K_PHY_TIMING_7);
2118  0);
2119 
2120  ath5k_hw_reg_write(ah, 0, AR5K_PHY_TIMING_9);
2123  0);
2124 
2125  /* Clear magnitude masks */
2126  ath5k_hw_reg_write(ah, 0, AR5K_PHY_BIN_MASK_1);
2127  ath5k_hw_reg_write(ah, 0, AR5K_PHY_BIN_MASK_2);
2128  ath5k_hw_reg_write(ah, 0, AR5K_PHY_BIN_MASK_3);
2131  0);
2132 
2133  ath5k_hw_reg_write(ah, 0, AR5K_PHY_BIN_MASK2_1);
2134  ath5k_hw_reg_write(ah, 0, AR5K_PHY_BIN_MASK2_2);
2135  ath5k_hw_reg_write(ah, 0, AR5K_PHY_BIN_MASK2_3);
2138  0);
2139  }
2140 }
2141 
2142 
2143 /*****************\
2144 * Antenna control *
2145 \*****************/
2146 
2202 static void
2203 ath5k_hw_set_def_antenna(struct ath5k_hw *ah, u8 ant)
2204 {
2205  if (ah->ah_version != AR5K_AR5210)
2206  ath5k_hw_reg_write(ah, ant & 0x7, AR5K_DEFAULT_ANTENNA);
2207 }
2208 
2215 static void
2216 ath5k_hw_set_fast_div(struct ath5k_hw *ah, u8 ee_mode, bool enable)
2217 {
2218  switch (ee_mode) {
2219  case AR5K_EEPROM_MODE_11G:
2220  /* XXX: This is set to
2221  * disabled on initvals !!! */
2222  case AR5K_EEPROM_MODE_11A:
2223  if (enable)
2226  else
2229  break;
2230  case AR5K_EEPROM_MODE_11B:
2233  break;
2234  default:
2235  return;
2236  }
2237 
2238  if (enable) {
2241 
2244  } else {
2247 
2250  }
2251 }
2252 
2261 void
2263 {
2264  u8 ant0, ant1;
2265 
2266  /*
2267  * In case a fixed antenna was set as default
2268  * use the same switch table twice.
2269  */
2270  if (ah->ah_ant_mode == AR5K_ANTMODE_FIXED_A)
2271  ant0 = ant1 = AR5K_ANT_SWTABLE_A;
2272  else if (ah->ah_ant_mode == AR5K_ANTMODE_FIXED_B)
2273  ant0 = ant1 = AR5K_ANT_SWTABLE_B;
2274  else {
2275  ant0 = AR5K_ANT_SWTABLE_A;
2276  ant1 = AR5K_ANT_SWTABLE_B;
2277  }
2278 
2279  /* Set antenna idle switch table */
2282  (ah->ah_ant_ctl[ee_mode][AR5K_ANT_CTL] |
2284 
2285  /* Set antenna switch tables */
2286  ath5k_hw_reg_write(ah, ah->ah_ant_ctl[ee_mode][ant0],
2288  ath5k_hw_reg_write(ah, ah->ah_ant_ctl[ee_mode][ant1],
2290 }
2291 
2297 void
2299 {
2300  struct ieee80211_channel *channel = ah->ah_current_channel;
2301  bool use_def_for_tx, update_def_on_tx, use_def_for_rts, fast_div;
2302  bool use_def_for_sg;
2303  int ee_mode;
2304  u8 def_ant, tx_ant;
2305  u32 sta_id1 = 0;
2306 
2307  /* if channel is not initialized yet we can't set the antennas
2308  * so just store the mode. it will be set on the next reset */
2309  if (channel == NULL) {
2310  ah->ah_ant_mode = ant_mode;
2311  return;
2312  }
2313 
2314  def_ant = ah->ah_def_ant;
2315 
2316  ee_mode = ath5k_eeprom_mode_from_channel(channel);
2317  if (ee_mode < 0) {
2318  ATH5K_ERR(ah,
2319  "invalid channel: %d\n", channel->center_freq);
2320  return;
2321  }
2322 
2323  switch (ant_mode) {
2324  case AR5K_ANTMODE_DEFAULT:
2325  tx_ant = 0;
2326  use_def_for_tx = false;
2327  update_def_on_tx = false;
2328  use_def_for_rts = false;
2329  use_def_for_sg = false;
2330  fast_div = true;
2331  break;
2332  case AR5K_ANTMODE_FIXED_A:
2333  def_ant = 1;
2334  tx_ant = 1;
2335  use_def_for_tx = true;
2336  update_def_on_tx = false;
2337  use_def_for_rts = true;
2338  use_def_for_sg = true;
2339  fast_div = false;
2340  break;
2341  case AR5K_ANTMODE_FIXED_B:
2342  def_ant = 2;
2343  tx_ant = 2;
2344  use_def_for_tx = true;
2345  update_def_on_tx = false;
2346  use_def_for_rts = true;
2347  use_def_for_sg = true;
2348  fast_div = false;
2349  break;
2351  def_ant = 1; /* updated on tx */
2352  tx_ant = 0;
2353  use_def_for_tx = true;
2354  update_def_on_tx = true;
2355  use_def_for_rts = true;
2356  use_def_for_sg = true;
2357  fast_div = true;
2358  break;
2360  tx_ant = 1; /* variable */
2361  use_def_for_tx = false;
2362  update_def_on_tx = false;
2363  use_def_for_rts = true;
2364  use_def_for_sg = false;
2365  fast_div = false;
2366  break;
2368  tx_ant = 1; /* variable */
2369  use_def_for_tx = true;
2370  update_def_on_tx = false;
2371  use_def_for_rts = true;
2372  use_def_for_sg = false;
2373  fast_div = true;
2374  break;
2375  case AR5K_ANTMODE_DEBUG:
2376  def_ant = 1;
2377  tx_ant = 2;
2378  use_def_for_tx = false;
2379  update_def_on_tx = false;
2380  use_def_for_rts = false;
2381  use_def_for_sg = false;
2382  fast_div = false;
2383  break;
2384  default:
2385  return;
2386  }
2387 
2388  ah->ah_tx_ant = tx_ant;
2389  ah->ah_ant_mode = ant_mode;
2390  ah->ah_def_ant = def_ant;
2391 
2392  sta_id1 |= use_def_for_tx ? AR5K_STA_ID1_DEFAULT_ANTENNA : 0;
2393  sta_id1 |= update_def_on_tx ? AR5K_STA_ID1_DESC_ANTENNA : 0;
2394  sta_id1 |= use_def_for_rts ? AR5K_STA_ID1_RTS_DEF_ANTENNA : 0;
2395  sta_id1 |= use_def_for_sg ? AR5K_STA_ID1_SELFGEN_DEF_ANT : 0;
2396 
2398 
2399  if (sta_id1)
2400  AR5K_REG_ENABLE_BITS(ah, AR5K_STA_ID1, sta_id1);
2401 
2402  ath5k_hw_set_antenna_switch(ah, ee_mode);
2403  /* Note: set diversity before default antenna
2404  * because it won't work correctly */
2405  ath5k_hw_set_fast_div(ah, ee_mode, fast_div);
2406  ath5k_hw_set_def_antenna(ah, def_ant);
2407 }
2408 
2409 
2410 /****************\
2411 * TX power setup *
2412 \****************/
2413 
2414 /*
2415  * Helper functions
2416  */
2417 
2426 static s16
2427 ath5k_get_interpolated_value(s16 target, s16 x_left, s16 x_right,
2428  s16 y_left, s16 y_right)
2429 {
2430  s16 ratio, result;
2431 
2432  /* Avoid divide by zero and skip interpolation
2433  * if we have the same point */
2434  if ((x_left == x_right) || (y_left == y_right))
2435  return y_left;
2436 
2437  /*
2438  * Since we use ints and not fps, we need to scale up in
2439  * order to get a sane ratio value (or else we 'll eg. get
2440  * always 1 instead of 1.25, 1.75 etc). We scale up by 100
2441  * to have some accuracy both for 0.5 and 0.25 steps.
2442  */
2443  ratio = ((100 * y_right - 100 * y_left) / (x_right - x_left));
2444 
2445  /* Now scale down to be in range */
2446  result = y_left + (ratio * (target - x_left) / 100);
2447 
2448  return result;
2449 }
2450 
2464 static s16
2465 ath5k_get_linear_pcdac_min(const u8 *stepL, const u8 *stepR,
2466  const s16 *pwrL, const s16 *pwrR)
2467 {
2468  s8 tmp;
2469  s16 min_pwrL, min_pwrR;
2470  s16 pwr_i;
2471 
2472  /* Some vendors write the same pcdac value twice !!! */
2473  if (stepL[0] == stepL[1] || stepR[0] == stepR[1])
2474  return max(pwrL[0], pwrR[0]);
2475 
2476  if (pwrL[0] == pwrL[1])
2477  min_pwrL = pwrL[0];
2478  else {
2479  pwr_i = pwrL[0];
2480  do {
2481  pwr_i--;
2482  tmp = (s8) ath5k_get_interpolated_value(pwr_i,
2483  pwrL[0], pwrL[1],
2484  stepL[0], stepL[1]);
2485  } while (tmp > 1);
2486 
2487  min_pwrL = pwr_i;
2488  }
2489 
2490  if (pwrR[0] == pwrR[1])
2491  min_pwrR = pwrR[0];
2492  else {
2493  pwr_i = pwrR[0];
2494  do {
2495  pwr_i--;
2496  tmp = (s8) ath5k_get_interpolated_value(pwr_i,
2497  pwrR[0], pwrR[1],
2498  stepR[0], stepR[1]);
2499  } while (tmp > 1);
2500 
2501  min_pwrR = pwr_i;
2502  }
2503 
2504  /* Keep the right boundary so that it works for both curves */
2505  return max(min_pwrL, min_pwrR);
2506 }
2507 
2529 static void
2530 ath5k_create_power_curve(s16 pmin, s16 pmax,
2531  const s16 *pwr, const u8 *vpd,
2532  u8 num_points,
2533  u8 *vpd_table, u8 type)
2534 {
2535  u8 idx[2] = { 0, 1 };
2536  s16 pwr_i = 2 * pmin;
2537  int i;
2538 
2539  if (num_points < 2)
2540  return;
2541 
2542  /* We want the whole line, so adjust boundaries
2543  * to cover the entire power range. Note that
2544  * power values are already 0.25dB so no need
2545  * to multiply pwr_i by 2 */
2546  if (type == AR5K_PWRTABLE_LINEAR_PCDAC) {
2547  pwr_i = pmin;
2548  pmin = 0;
2549  pmax = 63;
2550  }
2551 
2552  /* Find surrounding turning points (TPs)
2553  * and interpolate between them */
2554  for (i = 0; (i <= (u16) (pmax - pmin)) &&
2555  (i < AR5K_EEPROM_POWER_TABLE_SIZE); i++) {
2556 
2557  /* We passed the right TP, move to the next set of TPs
2558  * if we pass the last TP, extrapolate above using the last
2559  * two TPs for ratio */
2560  if ((pwr_i > pwr[idx[1]]) && (idx[1] < num_points - 1)) {
2561  idx[0]++;
2562  idx[1]++;
2563  }
2564 
2565  vpd_table[i] = (u8) ath5k_get_interpolated_value(pwr_i,
2566  pwr[idx[0]], pwr[idx[1]],
2567  vpd[idx[0]], vpd[idx[1]]);
2568 
2569  /* Increase by 0.5dB
2570  * (0.25 dB units) */
2571  pwr_i += 2;
2572  }
2573 }
2574 
2588 static void
2589 ath5k_get_chan_pcal_surrounding_piers(struct ath5k_hw *ah,
2590  struct ieee80211_channel *channel,
2591  struct ath5k_chan_pcal_info **pcinfo_l,
2592  struct ath5k_chan_pcal_info **pcinfo_r)
2593 {
2594  struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
2595  struct ath5k_chan_pcal_info *pcinfo;
2596  u8 idx_l, idx_r;
2597  u8 mode, max, i;
2598  u32 target = channel->center_freq;
2599 
2600  idx_l = 0;
2601  idx_r = 0;
2602 
2603  switch (channel->hw_value) {
2604  case AR5K_EEPROM_MODE_11A:
2605  pcinfo = ee->ee_pwr_cal_a;
2606  mode = AR5K_EEPROM_MODE_11A;
2607  break;
2608  case AR5K_EEPROM_MODE_11B:
2609  pcinfo = ee->ee_pwr_cal_b;
2610  mode = AR5K_EEPROM_MODE_11B;
2611  break;
2612  case AR5K_EEPROM_MODE_11G:
2613  default:
2614  pcinfo = ee->ee_pwr_cal_g;
2615  mode = AR5K_EEPROM_MODE_11G;
2616  break;
2617  }
2618  max = ee->ee_n_piers[mode] - 1;
2619 
2620  /* Frequency is below our calibrated
2621  * range. Use the lowest power curve
2622  * we have */
2623  if (target < pcinfo[0].freq) {
2624  idx_l = idx_r = 0;
2625  goto done;
2626  }
2627 
2628  /* Frequency is above our calibrated
2629  * range. Use the highest power curve
2630  * we have */
2631  if (target > pcinfo[max].freq) {
2632  idx_l = idx_r = max;
2633  goto done;
2634  }
2635 
2636  /* Frequency is inside our calibrated
2637  * channel range. Pick the surrounding
2638  * calibration piers so that we can
2639  * interpolate */
2640  for (i = 0; i <= max; i++) {
2641 
2642  /* Frequency matches one of our calibration
2643  * piers, no need to interpolate, just use
2644  * that calibration pier */
2645  if (pcinfo[i].freq == target) {
2646  idx_l = idx_r = i;
2647  goto done;
2648  }
2649 
2650  /* We found a calibration pier that's above
2651  * frequency, use this pier and the previous
2652  * one to interpolate */
2653  if (target < pcinfo[i].freq) {
2654  idx_r = i;
2655  idx_l = idx_r - 1;
2656  goto done;
2657  }
2658  }
2659 
2660 done:
2661  *pcinfo_l = &pcinfo[idx_l];
2662  *pcinfo_r = &pcinfo[idx_r];
2663 }
2664 
2677 static void
2678 ath5k_get_rate_pcal_data(struct ath5k_hw *ah,
2679  struct ieee80211_channel *channel,
2680  struct ath5k_rate_pcal_info *rates)
2681 {
2682  struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
2683  struct ath5k_rate_pcal_info *rpinfo;
2684  u8 idx_l, idx_r;
2685  u8 mode, max, i;
2686  u32 target = channel->center_freq;
2687 
2688  idx_l = 0;
2689  idx_r = 0;
2690 
2691  switch (channel->hw_value) {
2692  case AR5K_MODE_11A:
2693  rpinfo = ee->ee_rate_tpwr_a;
2694  mode = AR5K_EEPROM_MODE_11A;
2695  break;
2696  case AR5K_MODE_11B:
2697  rpinfo = ee->ee_rate_tpwr_b;
2698  mode = AR5K_EEPROM_MODE_11B;
2699  break;
2700  case AR5K_MODE_11G:
2701  default:
2702  rpinfo = ee->ee_rate_tpwr_g;
2703  mode = AR5K_EEPROM_MODE_11G;
2704  break;
2705  }
2706  max = ee->ee_rate_target_pwr_num[mode] - 1;
2707 
2708  /* Get the surrounding calibration
2709  * piers - same as above */
2710  if (target < rpinfo[0].freq) {
2711  idx_l = idx_r = 0;
2712  goto done;
2713  }
2714 
2715  if (target > rpinfo[max].freq) {
2716  idx_l = idx_r = max;
2717  goto done;
2718  }
2719 
2720  for (i = 0; i <= max; i++) {
2721 
2722  if (rpinfo[i].freq == target) {
2723  idx_l = idx_r = i;
2724  goto done;
2725  }
2726 
2727  if (target < rpinfo[i].freq) {
2728  idx_r = i;
2729  idx_l = idx_r - 1;
2730  goto done;
2731  }
2732  }
2733 
2734 done:
2735  /* Now interpolate power value, based on the frequency */
2736  rates->freq = target;
2737 
2738  rates->target_power_6to24 =
2739  ath5k_get_interpolated_value(target, rpinfo[idx_l].freq,
2740  rpinfo[idx_r].freq,
2741  rpinfo[idx_l].target_power_6to24,
2742  rpinfo[idx_r].target_power_6to24);
2743 
2744  rates->target_power_36 =
2745  ath5k_get_interpolated_value(target, rpinfo[idx_l].freq,
2746  rpinfo[idx_r].freq,
2747  rpinfo[idx_l].target_power_36,
2748  rpinfo[idx_r].target_power_36);
2749 
2750  rates->target_power_48 =
2751  ath5k_get_interpolated_value(target, rpinfo[idx_l].freq,
2752  rpinfo[idx_r].freq,
2753  rpinfo[idx_l].target_power_48,
2754  rpinfo[idx_r].target_power_48);
2755 
2756  rates->target_power_54 =
2757  ath5k_get_interpolated_value(target, rpinfo[idx_l].freq,
2758  rpinfo[idx_r].freq,
2759  rpinfo[idx_l].target_power_54,
2760  rpinfo[idx_r].target_power_54);
2761 }
2762 
2772 static void
2773 ath5k_get_max_ctl_power(struct ath5k_hw *ah,
2774  struct ieee80211_channel *channel)
2775 {
2776  struct ath_regulatory *regulatory = ath5k_hw_regulatory(ah);
2777  struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
2778  struct ath5k_edge_power *rep = ee->ee_ctl_pwr;
2779  u8 *ctl_val = ee->ee_ctl;
2780  s16 max_chan_pwr = ah->ah_txpower.txp_max_pwr / 4;
2781  s16 edge_pwr = 0;
2782  u8 rep_idx;
2783  u8 i, ctl_mode;
2784  u8 ctl_idx = 0xFF;
2785  u32 target = channel->center_freq;
2786 
2787  ctl_mode = ath_regd_get_band_ctl(regulatory, channel->band);
2788 
2789  switch (channel->hw_value) {
2790  case AR5K_MODE_11A:
2791  if (ah->ah_bwmode == AR5K_BWMODE_40MHZ)
2792  ctl_mode |= AR5K_CTL_TURBO;
2793  else
2794  ctl_mode |= AR5K_CTL_11A;
2795  break;
2796  case AR5K_MODE_11G:
2797  if (ah->ah_bwmode == AR5K_BWMODE_40MHZ)
2798  ctl_mode |= AR5K_CTL_TURBOG;
2799  else
2800  ctl_mode |= AR5K_CTL_11G;
2801  break;
2802  case AR5K_MODE_11B:
2803  ctl_mode |= AR5K_CTL_11B;
2804  break;
2805  default:
2806  return;
2807  }
2808 
2809  for (i = 0; i < ee->ee_ctls; i++) {
2810  if (ctl_val[i] == ctl_mode) {
2811  ctl_idx = i;
2812  break;
2813  }
2814  }
2815 
2816  /* If we have a CTL dataset available grab it and find the
2817  * edge power for our frequency */
2818  if (ctl_idx == 0xFF)
2819  return;
2820 
2821  /* Edge powers are sorted by frequency from lower
2822  * to higher. Each CTL corresponds to 8 edge power
2823  * measurements. */
2824  rep_idx = ctl_idx * AR5K_EEPROM_N_EDGES;
2825 
2826  /* Don't do boundaries check because we
2827  * might have more that one bands defined
2828  * for this mode */
2829 
2830  /* Get the edge power that's closer to our
2831  * frequency */
2832  for (i = 0; i < AR5K_EEPROM_N_EDGES; i++) {
2833  rep_idx += i;
2834  if (target <= rep[rep_idx].freq)
2835  edge_pwr = (s16) rep[rep_idx].edge;
2836  }
2837 
2838  if (edge_pwr)
2839  ah->ah_txpower.txp_max_pwr = 4 * min(edge_pwr, max_chan_pwr);
2840 }
2841 
2842 
2843 /*
2844  * Power to PCDAC table functions
2845  */
2846 
2885 static void
2886 ath5k_fill_pwr_to_pcdac_table(struct ath5k_hw *ah, s16* table_min,
2887  s16 *table_max)
2888 {
2889  u8 *pcdac_out = ah->ah_txpower.txp_pd_table;
2890  u8 *pcdac_tmp = ah->ah_txpower.tmpL[0];
2891  u8 pcdac_0, pcdac_n, pcdac_i, pwr_idx, i;
2892  s16 min_pwr, max_pwr;
2893 
2894  /* Get table boundaries */
2895  min_pwr = table_min[0];
2896  pcdac_0 = pcdac_tmp[0];
2897 
2898  max_pwr = table_max[0];
2899  pcdac_n = pcdac_tmp[table_max[0] - table_min[0]];
2900 
2901  /* Extrapolate below minimum using pcdac_0 */
2902  pcdac_i = 0;
2903  for (i = 0; i < min_pwr; i++)
2904  pcdac_out[pcdac_i++] = pcdac_0;
2905 
2906  /* Copy values from pcdac_tmp */
2907  pwr_idx = min_pwr;
2908  for (i = 0; pwr_idx <= max_pwr &&
2909  pcdac_i < AR5K_EEPROM_POWER_TABLE_SIZE; i++) {
2910  pcdac_out[pcdac_i++] = pcdac_tmp[i];
2911  pwr_idx++;
2912  }
2913 
2914  /* Extrapolate above maximum */
2915  while (pcdac_i < AR5K_EEPROM_POWER_TABLE_SIZE)
2916  pcdac_out[pcdac_i++] = pcdac_n;
2917 
2918 }
2919 
2935 static void
2936 ath5k_combine_linear_pcdac_curves(struct ath5k_hw *ah, s16* table_min,
2937  s16 *table_max, u8 pdcurves)
2938 {
2939  u8 *pcdac_out = ah->ah_txpower.txp_pd_table;
2940  u8 *pcdac_low_pwr;
2941  u8 *pcdac_high_pwr;
2942  u8 *pcdac_tmp;
2943  u8 pwr;
2944  s16 max_pwr_idx;
2945  s16 min_pwr_idx;
2946  s16 mid_pwr_idx = 0;
2947  /* Edge flag turns on the 7nth bit on the PCDAC
2948  * to declare the higher power curve (force values
2949  * to be greater than 64). If we only have one curve
2950  * we don't need to set this, if we have 2 curves and
2951  * fill the table backwards this can also be used to
2952  * switch from higher power curve to lower power curve */
2953  u8 edge_flag;
2954  int i;
2955 
2956  /* When we have only one curve available
2957  * that's the higher power curve. If we have
2958  * two curves the first is the high power curve
2959  * and the next is the low power curve. */
2960  if (pdcurves > 1) {
2961  pcdac_low_pwr = ah->ah_txpower.tmpL[1];
2962  pcdac_high_pwr = ah->ah_txpower.tmpL[0];
2963  mid_pwr_idx = table_max[1] - table_min[1] - 1;
2964  max_pwr_idx = (table_max[0] - table_min[0]) / 2;
2965 
2966  /* If table size goes beyond 31.5dB, keep the
2967  * upper 31.5dB range when setting tx power.
2968  * Note: 126 = 31.5 dB in quarter dB steps */
2969  if (table_max[0] - table_min[1] > 126)
2970  min_pwr_idx = table_max[0] - 126;
2971  else
2972  min_pwr_idx = table_min[1];
2973 
2974  /* Since we fill table backwards
2975  * start from high power curve */
2976  pcdac_tmp = pcdac_high_pwr;
2977 
2978  edge_flag = 0x40;
2979  } else {
2980  pcdac_low_pwr = ah->ah_txpower.tmpL[1]; /* Zeroed */
2981  pcdac_high_pwr = ah->ah_txpower.tmpL[0];
2982  min_pwr_idx = table_min[0];
2983  max_pwr_idx = (table_max[0] - table_min[0]) / 2;
2984  pcdac_tmp = pcdac_high_pwr;
2985  edge_flag = 0;
2986  }
2987 
2988  /* This is used when setting tx power*/
2989  ah->ah_txpower.txp_min_idx = min_pwr_idx / 2;
2990 
2991  /* Fill Power to PCDAC table backwards */
2992  pwr = max_pwr_idx;
2993  for (i = 63; i >= 0; i--) {
2994  /* Entering lower power range, reset
2995  * edge flag and set pcdac_tmp to lower
2996  * power curve.*/
2997  if (edge_flag == 0x40 &&
2998  (2 * pwr <= (table_max[1] - table_min[0]) || pwr == 0)) {
2999  edge_flag = 0x00;
3000  pcdac_tmp = pcdac_low_pwr;
3001  pwr = mid_pwr_idx / 2;
3002  }
3003 
3004  /* Don't go below 1, extrapolate below if we have
3005  * already switched to the lower power curve -or
3006  * we only have one curve and edge_flag is zero
3007  * anyway */
3008  if (pcdac_tmp[pwr] < 1 && (edge_flag == 0x00)) {
3009  while (i >= 0) {
3010  pcdac_out[i] = pcdac_out[i + 1];
3011  i--;
3012  }
3013  break;
3014  }
3015 
3016  pcdac_out[i] = pcdac_tmp[pwr] | edge_flag;
3017 
3018  /* Extrapolate above if pcdac is greater than
3019  * 126 -this can happen because we OR pcdac_out
3020  * value with edge_flag on high power curve */
3021  if (pcdac_out[i] > 126)
3022  pcdac_out[i] = 126;
3023 
3024  /* Decrease by a 0.5dB step */
3025  pwr--;
3026  }
3027 }
3028 
3033 static void
3034 ath5k_write_pcdac_table(struct ath5k_hw *ah)
3035 {
3036  u8 *pcdac_out = ah->ah_txpower.txp_pd_table;
3037  int i;
3038 
3039  /*
3040  * Write TX power values
3041  */
3042  for (i = 0; i < (AR5K_EEPROM_POWER_TABLE_SIZE / 2); i++) {
3043  ath5k_hw_reg_write(ah,
3044  (((pcdac_out[2 * i + 0] << 8 | 0xff) & 0xffff) << 0) |
3045  (((pcdac_out[2 * i + 1] << 8 | 0xff) & 0xffff) << 16),
3047  }
3048 }
3049 
3050 
3051 /*
3052  * Power to PDADC table functions
3053  */
3054 
3085 static void
3086 ath5k_combine_pwr_to_pdadc_curves(struct ath5k_hw *ah,
3087  s16 *pwr_min, s16 *pwr_max, u8 pdcurves)
3088 {
3089  u8 gain_boundaries[AR5K_EEPROM_N_PD_GAINS];
3090  u8 *pdadc_out = ah->ah_txpower.txp_pd_table;
3091  u8 *pdadc_tmp;
3092  s16 pdadc_0;
3093  u8 pdadc_i, pdadc_n, pwr_step, pdg, max_idx, table_size;
3094  u8 pd_gain_overlap;
3095 
3096  /* Note: Register value is initialized on initvals
3097  * there is no feedback from hw.
3098  * XXX: What about pd_gain_overlap from EEPROM ? */
3099  pd_gain_overlap = (u8) ath5k_hw_reg_read(ah, AR5K_PHY_TPC_RG5) &
3101 
3102  /* Create final PDADC table */
3103  for (pdg = 0, pdadc_i = 0; pdg < pdcurves; pdg++) {
3104  pdadc_tmp = ah->ah_txpower.tmpL[pdg];
3105 
3106  if (pdg == pdcurves - 1)
3107  /* 2 dB boundary stretch for last
3108  * (higher power) curve */
3109  gain_boundaries[pdg] = pwr_max[pdg] + 4;
3110  else
3111  /* Set gain boundary in the middle
3112  * between this curve and the next one */
3113  gain_boundaries[pdg] =
3114  (pwr_max[pdg] + pwr_min[pdg + 1]) / 2;
3115 
3116  /* Sanity check in case our 2 db stretch got out of
3117  * range. */
3118  if (gain_boundaries[pdg] > AR5K_TUNE_MAX_TXPOWER)
3119  gain_boundaries[pdg] = AR5K_TUNE_MAX_TXPOWER;
3120 
3121  /* For the first curve (lower power)
3122  * start from 0 dB */
3123  if (pdg == 0)
3124  pdadc_0 = 0;
3125  else
3126  /* For the other curves use the gain overlap */
3127  pdadc_0 = (gain_boundaries[pdg - 1] - pwr_min[pdg]) -
3128  pd_gain_overlap;
3129 
3130  /* Force each power step to be at least 0.5 dB */
3131  if ((pdadc_tmp[1] - pdadc_tmp[0]) > 1)
3132  pwr_step = pdadc_tmp[1] - pdadc_tmp[0];
3133  else
3134  pwr_step = 1;
3135 
3136  /* If pdadc_0 is negative, we need to extrapolate
3137  * below this pdgain by a number of pwr_steps */
3138  while ((pdadc_0 < 0) && (pdadc_i < 128)) {
3139  s16 tmp = pdadc_tmp[0] + pdadc_0 * pwr_step;
3140  pdadc_out[pdadc_i++] = (tmp < 0) ? 0 : (u8) tmp;
3141  pdadc_0++;
3142  }
3143 
3144  /* Set last pwr level, using gain boundaries */
3145  pdadc_n = gain_boundaries[pdg] + pd_gain_overlap - pwr_min[pdg];
3146  /* Limit it to be inside pwr range */
3147  table_size = pwr_max[pdg] - pwr_min[pdg];
3148  max_idx = (pdadc_n < table_size) ? pdadc_n : table_size;
3149 
3150  /* Fill pdadc_out table */
3151  while (pdadc_0 < max_idx && pdadc_i < 128)
3152  pdadc_out[pdadc_i++] = pdadc_tmp[pdadc_0++];
3153 
3154  /* Need to extrapolate above this pdgain? */
3155  if (pdadc_n <= max_idx)
3156  continue;
3157 
3158  /* Force each power step to be at least 0.5 dB */
3159  if ((pdadc_tmp[table_size - 1] - pdadc_tmp[table_size - 2]) > 1)
3160  pwr_step = pdadc_tmp[table_size - 1] -
3161  pdadc_tmp[table_size - 2];
3162  else
3163  pwr_step = 1;
3164 
3165  /* Extrapolate above */
3166  while ((pdadc_0 < (s16) pdadc_n) &&
3167  (pdadc_i < AR5K_EEPROM_POWER_TABLE_SIZE * 2)) {
3168  s16 tmp = pdadc_tmp[table_size - 1] +
3169  (pdadc_0 - max_idx) * pwr_step;
3170  pdadc_out[pdadc_i++] = (tmp > 127) ? 127 : (u8) tmp;
3171  pdadc_0++;
3172  }
3173  }
3174 
3175  while (pdg < AR5K_EEPROM_N_PD_GAINS) {
3176  gain_boundaries[pdg] = gain_boundaries[pdg - 1];
3177  pdg++;
3178  }
3179 
3180  while (pdadc_i < AR5K_EEPROM_POWER_TABLE_SIZE * 2) {
3181  pdadc_out[pdadc_i] = pdadc_out[pdadc_i - 1];
3182  pdadc_i++;
3183  }
3184 
3185  /* Set gain boundaries */
3186  ath5k_hw_reg_write(ah,
3187  AR5K_REG_SM(pd_gain_overlap,
3189  AR5K_REG_SM(gain_boundaries[0],
3191  AR5K_REG_SM(gain_boundaries[1],
3193  AR5K_REG_SM(gain_boundaries[2],
3195  AR5K_REG_SM(gain_boundaries[3],
3198 
3199  /* Used for setting rate power table */
3200  ah->ah_txpower.txp_min_idx = pwr_min[0];
3201 
3202 }
3203 
3209 static void
3210 ath5k_write_pwr_to_pdadc_table(struct ath5k_hw *ah, u8 ee_mode)
3211 {
3212  struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
3213  u8 *pdadc_out = ah->ah_txpower.txp_pd_table;
3214  u8 *pdg_to_idx = ee->ee_pdc_to_idx[ee_mode];
3215  u8 pdcurves = ee->ee_pd_gains[ee_mode];
3216  u32 reg;
3217  u8 i;
3218 
3219  /* Select the right pdgain curves */
3220 
3221  /* Clear current settings */
3222  reg = ath5k_hw_reg_read(ah, AR5K_PHY_TPC_RG1);
3223  reg &= ~(AR5K_PHY_TPC_RG1_PDGAIN_1 |
3227 
3228  /*
3229  * Use pd_gains curve from eeprom
3230  *
3231  * This overrides the default setting from initvals
3232  * in case some vendors (e.g. Zcomax) don't use the default
3233  * curves. If we don't honor their settings we 'll get a
3234  * 5dB (1 * gain overlap ?) drop.
3235  */
3236  reg |= AR5K_REG_SM(pdcurves, AR5K_PHY_TPC_RG1_NUM_PD_GAIN);
3237 
3238  switch (pdcurves) {
3239  case 3:
3240  reg |= AR5K_REG_SM(pdg_to_idx[2], AR5K_PHY_TPC_RG1_PDGAIN_3);
3241  /* Fall through */
3242  case 2:
3243  reg |= AR5K_REG_SM(pdg_to_idx[1], AR5K_PHY_TPC_RG1_PDGAIN_2);
3244  /* Fall through */
3245  case 1:
3246  reg |= AR5K_REG_SM(pdg_to_idx[0], AR5K_PHY_TPC_RG1_PDGAIN_1);
3247  break;
3248  }
3249  ath5k_hw_reg_write(ah, reg, AR5K_PHY_TPC_RG1);
3250 
3251  /*
3252  * Write TX power values
3253  */
3254  for (i = 0; i < (AR5K_EEPROM_POWER_TABLE_SIZE / 2); i++) {
3255  u32 val = get_unaligned_le32(&pdadc_out[4 * i]);
3256  ath5k_hw_reg_write(ah, val, AR5K_PHY_PDADC_TXPOWER(i));
3257  }
3258 }
3259 
3260 
3261 /*
3262  * Common code for PCDAC/PDADC tables
3263  */
3264 
3278 static int
3279 ath5k_setup_channel_powertable(struct ath5k_hw *ah,
3280  struct ieee80211_channel *channel,
3281  u8 ee_mode, u8 type)
3282 {
3283  struct ath5k_pdgain_info *pdg_L, *pdg_R;
3284  struct ath5k_chan_pcal_info *pcinfo_L;
3285  struct ath5k_chan_pcal_info *pcinfo_R;
3286  struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
3287  u8 *pdg_curve_to_idx = ee->ee_pdc_to_idx[ee_mode];
3288  s16 table_min[AR5K_EEPROM_N_PD_GAINS];
3289  s16 table_max[AR5K_EEPROM_N_PD_GAINS];
3290  u8 *tmpL;
3291  u8 *tmpR;
3292  u32 target = channel->center_freq;
3293  int pdg, i;
3294 
3295  /* Get surrounding freq piers for this channel */
3296  ath5k_get_chan_pcal_surrounding_piers(ah, channel,
3297  &pcinfo_L,
3298  &pcinfo_R);
3299 
3300  /* Loop over pd gain curves on
3301  * surrounding freq piers by index */
3302  for (pdg = 0; pdg < ee->ee_pd_gains[ee_mode]; pdg++) {
3303 
3304  /* Fill curves in reverse order
3305  * from lower power (max gain)
3306  * to higher power. Use curve -> idx
3307  * backmapping we did on eeprom init */
3308  u8 idx = pdg_curve_to_idx[pdg];
3309 
3310  /* Grab the needed curves by index */
3311  pdg_L = &pcinfo_L->pd_curves[idx];
3312  pdg_R = &pcinfo_R->pd_curves[idx];
3313 
3314  /* Initialize the temp tables */
3315  tmpL = ah->ah_txpower.tmpL[pdg];
3316  tmpR = ah->ah_txpower.tmpR[pdg];
3317 
3318  /* Set curve's x boundaries and create
3319  * curves so that they cover the same
3320  * range (if we don't do that one table
3321  * will have values on some range and the
3322  * other one won't have any so interpolation
3323  * will fail) */
3324  table_min[pdg] = min(pdg_L->pd_pwr[0],
3325  pdg_R->pd_pwr[0]) / 2;
3326 
3327  table_max[pdg] = max(pdg_L->pd_pwr[pdg_L->pd_points - 1],
3328  pdg_R->pd_pwr[pdg_R->pd_points - 1]) / 2;
3329 
3330  /* Now create the curves on surrounding channels
3331  * and interpolate if needed to get the final
3332  * curve for this gain on this channel */
3333  switch (type) {
3335  /* Override min/max so that we don't loose
3336  * accuracy (don't divide by 2) */
3337  table_min[pdg] = min(pdg_L->pd_pwr[0],
3338  pdg_R->pd_pwr[0]);
3339 
3340  table_max[pdg] =
3341  max(pdg_L->pd_pwr[pdg_L->pd_points - 1],
3342  pdg_R->pd_pwr[pdg_R->pd_points - 1]);
3343 
3344  /* Override minimum so that we don't get
3345  * out of bounds while extrapolating
3346  * below. Don't do this when we have 2
3347  * curves and we are on the high power curve
3348  * because table_min is ok in this case */
3349  if (!(ee->ee_pd_gains[ee_mode] > 1 && pdg == 0)) {
3350 
3351  table_min[pdg] =
3352  ath5k_get_linear_pcdac_min(pdg_L->pd_step,
3353  pdg_R->pd_step,
3354  pdg_L->pd_pwr,
3355  pdg_R->pd_pwr);
3356 
3357  /* Don't go too low because we will
3358  * miss the upper part of the curve.
3359  * Note: 126 = 31.5dB (max power supported)
3360  * in 0.25dB units */
3361  if (table_max[pdg] - table_min[pdg] > 126)
3362  table_min[pdg] = table_max[pdg] - 126;
3363  }
3364 
3365  /* Fall through */
3368 
3369  ath5k_create_power_curve(table_min[pdg],
3370  table_max[pdg],
3371  pdg_L->pd_pwr,
3372  pdg_L->pd_step,
3373  pdg_L->pd_points, tmpL, type);
3374 
3375  /* We are in a calibration
3376  * pier, no need to interpolate
3377  * between freq piers */
3378  if (pcinfo_L == pcinfo_R)
3379  continue;
3380 
3381  ath5k_create_power_curve(table_min[pdg],
3382  table_max[pdg],
3383  pdg_R->pd_pwr,
3384  pdg_R->pd_step,
3385  pdg_R->pd_points, tmpR, type);
3386  break;
3387  default:
3388  return -EINVAL;
3389  }
3390 
3391  /* Interpolate between curves
3392  * of surrounding freq piers to
3393  * get the final curve for this
3394  * pd gain. Re-use tmpL for interpolation
3395  * output */
3396  for (i = 0; (i < (u16) (table_max[pdg] - table_min[pdg])) &&
3397  (i < AR5K_EEPROM_POWER_TABLE_SIZE); i++) {
3398  tmpL[i] = (u8) ath5k_get_interpolated_value(target,
3399  (s16) pcinfo_L->freq,
3400  (s16) pcinfo_R->freq,
3401  (s16) tmpL[i],
3402  (s16) tmpR[i]);
3403  }
3404  }
3405 
3406  /* Now we have a set of curves for this
3407  * channel on tmpL (x range is table_max - table_min
3408  * and y values are tmpL[pdg][]) sorted in the same
3409  * order as EEPROM (because we've used the backmapping).
3410  * So for RF5112 it's from higher power to lower power
3411  * and for RF2413 it's from lower power to higher power.
3412  * For RF5111 we only have one curve. */
3413 
3414  /* Fill min and max power levels for this
3415  * channel by interpolating the values on
3416  * surrounding channels to complete the dataset */
3417  ah->ah_txpower.txp_min_pwr = ath5k_get_interpolated_value(target,
3418  (s16) pcinfo_L->freq,
3419  (s16) pcinfo_R->freq,
3420  pcinfo_L->min_pwr, pcinfo_R->min_pwr);
3421 
3422  ah->ah_txpower.txp_max_pwr = ath5k_get_interpolated_value(target,
3423  (s16) pcinfo_L->freq,
3424  (s16) pcinfo_R->freq,
3425  pcinfo_L->max_pwr, pcinfo_R->max_pwr);
3426 
3427  /* Fill PCDAC/PDADC table */
3428  switch (type) {
3430  /* For RF5112 we can have one or two curves
3431  * and each curve covers a certain power lvl
3432  * range so we need to do some more processing */
3433  ath5k_combine_linear_pcdac_curves(ah, table_min, table_max,
3434  ee->ee_pd_gains[ee_mode]);
3435 
3436  /* Set txp.offset so that we can
3437  * match max power value with max
3438  * table index */
3439  ah->ah_txpower.txp_offset = 64 - (table_max[0] / 2);
3440  break;
3442  /* We are done for RF5111 since it has only
3443  * one curve, just fit the curve on the table */
3444  ath5k_fill_pwr_to_pcdac_table(ah, table_min, table_max);
3445 
3446  /* No rate powertable adjustment for RF5111 */
3447  ah->ah_txpower.txp_min_idx = 0;
3448  ah->ah_txpower.txp_offset = 0;
3449  break;
3451  /* Set PDADC boundaries and fill
3452  * final PDADC table */
3453  ath5k_combine_pwr_to_pdadc_curves(ah, table_min, table_max,
3454  ee->ee_pd_gains[ee_mode]);
3455 
3456  /* Set txp.offset, note that table_min
3457  * can be negative */
3458  ah->ah_txpower.txp_offset = table_min[0];
3459  break;
3460  default:
3461  return -EINVAL;
3462  }
3463 
3464  ah->ah_txpower.txp_setup = true;
3465 
3466  return 0;
3467 }
3468 
3475 static void
3476 ath5k_write_channel_powertable(struct ath5k_hw *ah, u8 ee_mode, u8 type)
3477 {
3478  if (type == AR5K_PWRTABLE_PWR_TO_PDADC)
3479  ath5k_write_pwr_to_pdadc_table(ah, ee_mode);
3480  else
3481  ath5k_write_pcdac_table(ah);
3482 }
3483 
3484 
3514 static void
3515 ath5k_setup_rate_powertable(struct ath5k_hw *ah, u16 max_pwr,
3517  u8 ee_mode)
3518 {
3519  unsigned int i;
3520  u16 *rates;
3521  s16 rate_idx_scaled = 0;
3522 
3523  /* max_pwr is power level we got from driver/user in 0.5dB
3524  * units, switch to 0.25dB units so we can compare */
3525  max_pwr *= 2;
3526  max_pwr = min(max_pwr, (u16) ah->ah_txpower.txp_max_pwr) / 2;
3527 
3528  /* apply rate limits */
3529  rates = ah->ah_txpower.txp_rates_power_table;
3530 
3531  /* OFDM rates 6 to 24Mb/s */
3532  for (i = 0; i < 5; i++)
3533  rates[i] = min(max_pwr, rate_info->target_power_6to24);
3534 
3535  /* Rest OFDM rates */
3536  rates[5] = min(rates[0], rate_info->target_power_36);
3537  rates[6] = min(rates[0], rate_info->target_power_48);
3538  rates[7] = min(rates[0], rate_info->target_power_54);
3539 
3540  /* CCK rates */
3541  /* 1L */
3542  rates[8] = min(rates[0], rate_info->target_power_6to24);
3543  /* 2L */
3544  rates[9] = min(rates[0], rate_info->target_power_36);
3545  /* 2S */
3546  rates[10] = min(rates[0], rate_info->target_power_36);
3547  /* 5L */
3548  rates[11] = min(rates[0], rate_info->target_power_48);
3549  /* 5S */
3550  rates[12] = min(rates[0], rate_info->target_power_48);
3551  /* 11L */
3552  rates[13] = min(rates[0], rate_info->target_power_54);
3553  /* 11S */
3554  rates[14] = min(rates[0], rate_info->target_power_54);
3555 
3556  /* XR rates */
3557  rates[15] = min(rates[0], rate_info->target_power_6to24);
3558 
3559  /* CCK rates have different peak to average ratio
3560  * so we have to tweak their power so that gainf
3561  * correction works ok. For this we use OFDM to
3562  * CCK delta from eeprom */
3563  if ((ee_mode == AR5K_EEPROM_MODE_11G) &&
3565  for (i = 8; i <= 15; i++)
3566  rates[i] -= ah->ah_txpower.txp_cck_ofdm_gainf_delta;
3567 
3568  /* Save min/max and current tx power for this channel
3569  * in 0.25dB units.
3570  *
3571  * Note: We use rates[0] for current tx power because
3572  * it covers most of the rates, in most cases. It's our
3573  * tx power limit and what the user expects to see. */
3574  ah->ah_txpower.txp_min_pwr = 2 * rates[7];
3575  ah->ah_txpower.txp_cur_pwr = 2 * rates[0];
3576 
3577  /* Set max txpower for correct OFDM operation on all rates
3578  * -that is the txpower for 54Mbit-, it's used for the PAPD
3579  * gain probe and it's in 0.5dB units */
3580  ah->ah_txpower.txp_ofdm = rates[7];
3581 
3582  /* Now that we have all rates setup use table offset to
3583  * match the power range set by user with the power indices
3584  * on PCDAC/PDADC table */
3585  for (i = 0; i < 16; i++) {
3586  rate_idx_scaled = rates[i] + ah->ah_txpower.txp_offset;
3587  /* Don't get out of bounds */
3588  if (rate_idx_scaled > 63)
3589  rate_idx_scaled = 63;
3590  if (rate_idx_scaled < 0)
3591  rate_idx_scaled = 0;
3592  rates[i] = rate_idx_scaled;
3593  }
3594 }
3595 
3596 
3606 static int
3607 ath5k_hw_txpower(struct ath5k_hw *ah, struct ieee80211_channel *channel,
3608  u8 txpower)
3609 {
3610  struct ath5k_rate_pcal_info rate_info;
3611  struct ieee80211_channel *curr_channel = ah->ah_current_channel;
3612  int ee_mode;
3613  u8 type;
3614  int ret;
3615 
3616  if (txpower > AR5K_TUNE_MAX_TXPOWER) {
3617  ATH5K_ERR(ah, "invalid tx power: %u\n", txpower);
3618  return -EINVAL;
3619  }
3620 
3621  ee_mode = ath5k_eeprom_mode_from_channel(channel);
3622  if (ee_mode < 0) {
3623  ATH5K_ERR(ah,
3624  "invalid channel: %d\n", channel->center_freq);
3625  return -EINVAL;
3626  }
3627 
3628  /* Initialize TX power table */
3629  switch (ah->ah_radio) {
3630  case AR5K_RF5110:
3631  /* TODO */
3632  return 0;
3633  case AR5K_RF5111:
3635  break;
3636  case AR5K_RF5112:
3638  break;
3639  case AR5K_RF2413:
3640  case AR5K_RF5413:
3641  case AR5K_RF2316:
3642  case AR5K_RF2317:
3643  case AR5K_RF2425:
3645  break;
3646  default:
3647  return -EINVAL;
3648  }
3649 
3650  /*
3651  * If we don't change channel/mode skip tx powertable calculation
3652  * and use the cached one.
3653  */
3654  if (!ah->ah_txpower.txp_setup ||
3655  (channel->hw_value != curr_channel->hw_value) ||
3656  (channel->center_freq != curr_channel->center_freq)) {
3657  /* Reset TX power values but preserve requested
3658  * tx power from above */
3659  int requested_txpower = ah->ah_txpower.txp_requested;
3660 
3661  memset(&ah->ah_txpower, 0, sizeof(ah->ah_txpower));
3662 
3663  /* Restore TPC setting and requested tx power */
3664  ah->ah_txpower.txp_tpc = AR5K_TUNE_TPC_TXPOWER;
3665 
3666  ah->ah_txpower.txp_requested = requested_txpower;
3667 
3668  /* Calculate the powertable */
3669  ret = ath5k_setup_channel_powertable(ah, channel,
3670  ee_mode, type);
3671  if (ret)
3672  return ret;
3673  }
3674 
3675  /* Write table on hw */
3676  ath5k_write_channel_powertable(ah, ee_mode, type);
3677 
3678  /* Limit max power if we have a CTL available */
3679  ath5k_get_max_ctl_power(ah, channel);
3680 
3681  /* FIXME: Antenna reduction stuff */
3682 
3683  /* FIXME: Limit power on turbo modes */
3684 
3685  /* FIXME: TPC scale reduction */
3686 
3687  /* Get surrounding channels for per-rate power table
3688  * calibration */
3689  ath5k_get_rate_pcal_data(ah, channel, &rate_info);
3690 
3691  /* Setup rate power table */
3692  ath5k_setup_rate_powertable(ah, txpower, &rate_info, ee_mode);
3693 
3694  /* Write rate power table on hw */
3695  ath5k_hw_reg_write(ah, AR5K_TXPOWER_OFDM(3, 24) |
3696  AR5K_TXPOWER_OFDM(2, 16) | AR5K_TXPOWER_OFDM(1, 8) |
3698 
3699  ath5k_hw_reg_write(ah, AR5K_TXPOWER_OFDM(7, 24) |
3700  AR5K_TXPOWER_OFDM(6, 16) | AR5K_TXPOWER_OFDM(5, 8) |
3702 
3703  ath5k_hw_reg_write(ah, AR5K_TXPOWER_CCK(10, 24) |
3704  AR5K_TXPOWER_CCK(9, 16) | AR5K_TXPOWER_CCK(15, 8) |
3706 
3707  ath5k_hw_reg_write(ah, AR5K_TXPOWER_CCK(14, 24) |
3708  AR5K_TXPOWER_CCK(13, 16) | AR5K_TXPOWER_CCK(12, 8) |
3710 
3711  /* FIXME: TPC support */
3712  if (ah->ah_txpower.txp_tpc) {
3713  ath5k_hw_reg_write(ah, AR5K_PHY_TXPOWER_RATE_MAX_TPC_ENABLE |
3715 
3716  ath5k_hw_reg_write(ah,
3720  AR5K_TPC);
3721  } else {
3722  ath5k_hw_reg_write(ah, AR5K_PHY_TXPOWER_RATE_MAX |
3724  }
3725 
3726  return 0;
3727 }
3728 
3737 int
3739 {
3740  ATH5K_DBG(ah, ATH5K_DEBUG_TXPOWER,
3741  "changing txpower to %d\n", txpower);
3742 
3743  return ath5k_hw_txpower(ah, ah->ah_current_channel, txpower);
3744 }
3745 
3746 
3747 /*************\
3748  Init function
3749 \*************/
3750 
3764 int
3765 ath5k_hw_phy_init(struct ath5k_hw *ah, struct ieee80211_channel *channel,
3766  u8 mode, bool fast)
3767 {
3768  struct ieee80211_channel *curr_channel;
3769  int ret, i;
3770  u32 phy_tst1;
3771  ret = 0;
3772 
3773  /*
3774  * Sanity check for fast flag
3775  * Don't try fast channel change when changing modulation
3776  * mode/band. We check for chip compatibility on
3777  * ath5k_hw_reset.
3778  */
3779  curr_channel = ah->ah_current_channel;
3780  if (fast && (channel->hw_value != curr_channel->hw_value))
3781  return -EINVAL;
3782 
3783  /*
3784  * On fast channel change we only set the synth parameters
3785  * while PHY is running, enable calibration and skip the rest.
3786  */
3787  if (fast) {
3790  for (i = 0; i < 100; i++) {
3791  if (ath5k_hw_reg_read(ah, AR5K_PHY_RFBUS_GRANT))
3792  break;
3793  udelay(5);
3794  }
3795  /* Failed */
3796  if (i >= 100)
3797  return -EIO;
3798 
3799  /* Set channel and wait for synth */
3800  ret = ath5k_hw_channel(ah, channel);
3801  if (ret)
3802  return ret;
3803 
3804  ath5k_hw_wait_for_synth(ah, channel);
3805  }
3806 
3807  /*
3808  * Set TX power
3809  *
3810  * Note: We need to do that before we set
3811  * RF buffer settings on 5211/5212+ so that we
3812  * properly set curve indices.
3813  */
3814  ret = ath5k_hw_txpower(ah, channel, ah->ah_txpower.txp_requested ?
3815  ah->ah_txpower.txp_requested * 2 :
3817  if (ret)
3818  return ret;
3819 
3820  /* Write OFDM timings on 5212*/
3821  if (ah->ah_version == AR5K_AR5212 &&
3822  channel->hw_value != AR5K_MODE_11B) {
3823 
3824  ret = ath5k_hw_write_ofdm_timings(ah, channel);
3825  if (ret)
3826  return ret;
3827 
3828  /* Spur info is available only from EEPROM versions
3829  * greater than 5.3, but the EEPROM routines will use
3830  * static values for older versions */
3831  if (ah->ah_mac_srev >= AR5K_SREV_AR5424)
3832  ath5k_hw_set_spur_mitigation_filter(ah,
3833  channel);
3834  }
3835 
3836  /* If we used fast channel switching
3837  * we are done, release RF bus and
3838  * fire up NF calibration.
3839  *
3840  * Note: Only NF calibration due to
3841  * channel change, not AGC calibration
3842  * since AGC is still running !
3843  */
3844  if (fast) {
3845  /*
3846  * Release RF Bus grant
3847  */
3850 
3851  /*
3852  * Start NF calibration
3853  */
3856 
3857  return ret;
3858  }
3859 
3860  /*
3861  * For 5210 we do all initialization using
3862  * initvals, so we don't have to modify
3863  * any settings (5210 also only supports
3864  * a/aturbo modes)
3865  */
3866  if (ah->ah_version != AR5K_AR5210) {
3867 
3868  /*
3869  * Write initial RF gain settings
3870  * This should work for both 5111/5112
3871  */
3872  ret = ath5k_hw_rfgain_init(ah, channel->band);
3873  if (ret)
3874  return ret;
3875 
3876  usleep_range(1000, 1500);
3877 
3878  /*
3879  * Write RF buffer
3880  */
3881  ret = ath5k_hw_rfregs_init(ah, channel, mode);
3882  if (ret)
3883  return ret;
3884 
3885  /*Enable/disable 802.11b mode on 5111
3886  (enable 2111 frequency converter + CCK)*/
3887  if (ah->ah_radio == AR5K_RF5111) {
3888  if (mode == AR5K_MODE_11B)
3891  else
3894  }
3895 
3896  } else if (ah->ah_version == AR5K_AR5210) {
3897  usleep_range(1000, 1500);
3898  /* Disable phy and wait */
3899  ath5k_hw_reg_write(ah, AR5K_PHY_ACT_DISABLE, AR5K_PHY_ACT);
3900  usleep_range(1000, 1500);
3901  }
3902 
3903  /* Set channel on PHY */
3904  ret = ath5k_hw_channel(ah, channel);
3905  if (ret)
3906  return ret;
3907 
3908  /*
3909  * Enable the PHY and wait until completion
3910  * This includes BaseBand and Synthesizer
3911  * activation.
3912  */
3913  ath5k_hw_reg_write(ah, AR5K_PHY_ACT_ENABLE, AR5K_PHY_ACT);
3914 
3915  ath5k_hw_wait_for_synth(ah, channel);
3916 
3917  /*
3918  * Perform ADC test to see if baseband is ready
3919  * Set tx hold and check adc test register
3920  */
3921  phy_tst1 = ath5k_hw_reg_read(ah, AR5K_PHY_TST1);
3922  ath5k_hw_reg_write(ah, AR5K_PHY_TST1_TXHOLD, AR5K_PHY_TST1);
3923  for (i = 0; i <= 20; i++) {
3924  if (!(ath5k_hw_reg_read(ah, AR5K_PHY_ADC_TEST) & 0x10))
3925  break;
3926  usleep_range(200, 250);
3927  }
3928  ath5k_hw_reg_write(ah, phy_tst1, AR5K_PHY_TST1);
3929 
3930  /*
3931  * Start automatic gain control calibration
3932  *
3933  * During AGC calibration RX path is re-routed to
3934  * a power detector so we don't receive anything.
3935  *
3936  * This method is used to calibrate some static offsets
3937  * used together with on-the fly I/Q calibration (the
3938  * one performed via ath5k_hw_phy_calibrate), which doesn't
3939  * interrupt rx path.
3940  *
3941  * While rx path is re-routed to the power detector we also
3942  * start a noise floor calibration to measure the
3943  * card's noise floor (the noise we measure when we are not
3944  * transmitting or receiving anything).
3945  *
3946  * If we are in a noisy environment, AGC calibration may time
3947  * out and/or noise floor calibration might timeout.
3948  */
3951 
3952  /* At the same time start I/Q calibration for QAM constellation
3953  * -no need for CCK- */
3954  ah->ah_iq_cal_needed = false;
3955  if (!(mode == AR5K_MODE_11B)) {
3956  ah->ah_iq_cal_needed = true;
3960  AR5K_PHY_IQ_RUN);
3961  }
3962 
3963  /* Wait for gain calibration to finish (we check for I/Q calibration
3964  * during ath5k_phy_calibrate) */
3966  AR5K_PHY_AGCCTL_CAL, 0, false)) {
3967  ATH5K_ERR(ah, "gain calibration timeout (%uMHz)\n",
3968  channel->center_freq);
3969  }
3970 
3971  /* Restore antenna mode */
3973 
3974  return ret;
3975 }