drivers/net/wireless/ath/ath9k/calib.c

   1 /*
   2  * Copyright (c) 2008-2009 Atheros Communications Inc.
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include "hw.h"
  18 #include "hw-ops.h"
  19
  20 /* Common calibration code */
  21
  22 /* We can tune this as we go by monitoring really low values */
  23 #define ATH9K_NF_TOO_LOW        -60
  24
  25 /* AR5416 may return very high value (like -31 dBm), in those cases the nf
  26  * is incorrect and we should use the static NF value. Later we can try to
  27  * find out why they are reporting these values */
  28
  29 static bool ath9k_hw_nf_in_range(struct ath_hw *ah, s16 nf)
  30 {
  31         if (nf > ATH9K_NF_TOO_LOW) {
  32                 ath_print(ath9k_hw_common(ah), ATH_DBG_CALIBRATE,
  33                           "noise floor value detected (%d) is "
  34                           "lower than what we think is a "
  35                           "reasonable value (%d)\n",
  36                           nf, ATH9K_NF_TOO_LOW);
  37                 return false;
  38         }
  39         return true;
  40 }
  41
  42 static int16_t ath9k_hw_get_nf_hist_mid(int16_t *nfCalBuffer)
  43 {
  44         int16_t nfval;
  45         int16_t sort[ATH9K_NF_CAL_HIST_MAX];
  46         int i, j;
  47
  48         for (i = 0; i < ATH9K_NF_CAL_HIST_MAX; i++)
  49                 sort[i] = nfCalBuffer[i];
  50
  51         for (i = 0; i < ATH9K_NF_CAL_HIST_MAX - 1; i++) {
  52                 for (j = 1; j < ATH9K_NF_CAL_HIST_MAX - i; j++) {
  53                         if (sort[j] > sort[j - 1]) {
  54                                 nfval = sort[j];
  55                                 sort[j] = sort[j - 1];
  56                                 sort[j - 1] = nfval;
  57                         }
  58                 }
  59         }
  60         nfval = sort[(ATH9K_NF_CAL_HIST_MAX - 1) >> 1];
  61
  62         return nfval;
  63 }
  64
  65 static void ath9k_hw_update_nfcal_hist_buffer(struct ath9k_nfcal_hist *h,
  66                                               int16_t *nfarray)
  67 {
  68         int i;
  69
  70         for (i = 0; i < NUM_NF_READINGS; i++) {
  71                 h[i].nfCalBuffer[h[i].currIndex] = nfarray[i];
  72
  73                 if (++h[i].currIndex >= ATH9K_NF_CAL_HIST_MAX)
  74                         h[i].currIndex = 0;
  75
  76                 if (h[i].invalidNFcount > 0) {
  77                         if (nfarray[i] < AR_PHY_CCA_MIN_BAD_VALUE ||
  78                             nfarray[i] > AR_PHY_CCA_MAX_HIGH_VALUE) {
  79                                 h[i].invalidNFcount = ATH9K_NF_CAL_HIST_MAX;
  80                         } else {
  81                                 h[i].invalidNFcount--;
  82                                 h[i].privNF = nfarray[i];
  83                         }
  84                 } else {
  85                         h[i].privNF =
  86                                 ath9k_hw_get_nf_hist_mid(h[i].nfCalBuffer);
  87                 }
  88         }
  89         return;
  90 }
  91
  92 static bool ath9k_hw_get_nf_thresh(struct ath_hw *ah,
  93                                    enum ieee80211_band band,
  94                                    int16_t *nft)
  95 {
  96         switch (band) {
  97         case IEEE80211_BAND_5GHZ:
  98                 *nft = (int8_t)ah->eep_ops->get_eeprom(ah, EEP_NFTHRESH_5);
  99                 break;
 100         case IEEE80211_BAND_2GHZ:
 101                 *nft = (int8_t)ah->eep_ops->get_eeprom(ah, EEP_NFTHRESH_2);
 102                 break;
 103         default:
 104                 BUG_ON(1);
 105                 return false;
 106         }
 107
 108         return true;
 109 }
 110
 111 void ath9k_hw_reset_calibration(struct ath_hw *ah,
 112                                 struct ath9k_cal_list *currCal)
 113 {
 114         int i;
 115
 116         ath9k_hw_setup_calibration(ah, currCal);
 117
 118         currCal->calState = CAL_RUNNING;
 119
 120         for (i = 0; i < AR5416_MAX_CHAINS; i++) {
 121                 ah->meas0.sign[i] = 0;
 122                 ah->meas1.sign[i] = 0;
 123                 ah->meas2.sign[i] = 0;
 124                 ah->meas3.sign[i] = 0;
 125         }
 126
 127         ah->cal_samples = 0;
 128 }
 129
 130 /* This is done for the currently configured channel */
 131 bool ath9k_hw_reset_calvalid(struct ath_hw *ah)
 132 {
 133         struct ath_common *common = ath9k_hw_common(ah);
 134         struct ieee80211_conf *conf = &common->hw->conf;
 135         struct ath9k_cal_list *currCal = ah->cal_list_curr;
 136
 137         if (!ah->curchan)
 138                 return true;
 139
 140         if (!AR_SREV_9100(ah) && !AR_SREV_9160_10_OR_LATER(ah))
 141                 return true;
 142
 143         if (currCal == NULL)
 144                 return true;
 145
 146         if (currCal->calState != CAL_DONE) {
 147                 ath_print(common, ATH_DBG_CALIBRATE,
 148                           "Calibration state incorrect, %d\n",
 149                           currCal->calState);
 150                 return true;
 151         }
 152
 153         if (!ath9k_hw_iscal_supported(ah, currCal->calData->calType))
 154                 return true;
 155
 156         ath_print(common, ATH_DBG_CALIBRATE,
 157                   "Resetting Cal %d state for channel %u\n",
 158                   currCal->calData->calType, conf->channel->center_freq);
 159
 160         ah->curchan->CalValid &= ~currCal->calData->calType;
 161         currCal->calState = CAL_WAITING;
 162
 163         return false;
 164 }
 165 EXPORT_SYMBOL(ath9k_hw_reset_calvalid);
 166
 167 void ath9k_hw_start_nfcal(struct ath_hw *ah)
 168 {
 169         REG_SET_BIT(ah, AR_PHY_AGC_CONTROL,
 170                     AR_PHY_AGC_CONTROL_ENABLE_NF);
 171         REG_SET_BIT(ah, AR_PHY_AGC_CONTROL,
 172                     AR_PHY_AGC_CONTROL_NO_UPDATE_NF);
 173         REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_NF);
 174 }
 175
 176 int16_t ath9k_hw_getnf(struct ath_hw *ah,
 177                        struct ath9k_channel *chan)
 178 {
 179         struct ath_common *common = ath9k_hw_common(ah);
 180         int16_t nf, nfThresh;
 181         int16_t nfarray[NUM_NF_READINGS] = { 0 };
 182         struct ath9k_nfcal_hist *h;
 183         struct ieee80211_channel *c = chan->chan;
 184
 185         chan->channelFlags &= (~CHANNEL_CW_INT);
 186         if (REG_READ(ah, AR_PHY_AGC_CONTROL) & AR_PHY_AGC_CONTROL_NF) {
 187                 ath_print(common, ATH_DBG_CALIBRATE,
 188                           "NF did not complete in calibration window\n");
 189                 nf = 0;
 190                 chan->rawNoiseFloor = nf;
 191                 return chan->rawNoiseFloor;
 192         } else {
 193                 ath9k_hw_do_getnf(ah, nfarray);
 194                 nf = nfarray[0];
 195                 if (ath9k_hw_get_nf_thresh(ah, c->band, &nfThresh)
 196                     && nf > nfThresh) {
 197                         ath_print(common, ATH_DBG_CALIBRATE,
 198                                   "noise floor failed detected; "
 199                                   "detected %d, threshold %d\n",
 200                                   nf, nfThresh);
 201                         chan->channelFlags |= CHANNEL_CW_INT;
 202                 }
 203         }
 204
 205         h = ah->nfCalHist;
 206
 207         ath9k_hw_update_nfcal_hist_buffer(h, nfarray);
 208         chan->rawNoiseFloor = h[0].privNF;
 209
 210         return chan->rawNoiseFloor;
 211 }
 212
 213 void ath9k_init_nfcal_hist_buffer(struct ath_hw *ah)
 214 {
 215         int i, j;
 216         s16 noise_floor;
 217
 218         if (AR_SREV_9280(ah))
 219                 noise_floor = AR_PHY_CCA_MAX_AR9280_GOOD_VALUE;
 220         else if (AR_SREV_9285(ah) || AR_SREV_9271(ah))
 221                 noise_floor = AR_PHY_CCA_MAX_AR9285_GOOD_VALUE;
 222         else if (AR_SREV_9287(ah))
 223                 noise_floor = AR_PHY_CCA_MAX_AR9287_GOOD_VALUE;
 224         else
 225                 noise_floor = AR_PHY_CCA_MAX_AR5416_GOOD_VALUE;
 226
 227         for (i = 0; i < NUM_NF_READINGS; i++) {
 228                 ah->nfCalHist[i].currIndex = 0;
 229                 ah->nfCalHist[i].privNF = noise_floor;
 230                 ah->nfCalHist[i].invalidNFcount =
 231                         AR_PHY_CCA_FILTERWINDOW_LENGTH;
 232                 for (j = 0; j < ATH9K_NF_CAL_HIST_MAX; j++) {
 233                         ah->nfCalHist[i].nfCalBuffer[j] = noise_floor;
 234                 }
 235         }
 236 }
 237
 238 s16 ath9k_hw_getchan_noise(struct ath_hw *ah, struct ath9k_channel *chan)
 239 {
 240         s16 nf;
 241
 242         if (chan->rawNoiseFloor == 0)
 243                 nf = -96;
 244         else
 245                 nf = chan->rawNoiseFloor;
 246
 247         if (!ath9k_hw_nf_in_range(ah, nf))
 248                 nf = ATH_DEFAULT_NOISE_FLOOR;
 249
 250         return nf;
 251 }
 252 EXPORT_SYMBOL(ath9k_hw_getchan_noise);