Quelle  link.c   Sprache: C

/*
 * Copyright (c) 2012 Qualcomm Atheros, Inc.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include "ath9k.h"

/*
 * TX polling - checks if the TX engine is stuck somewhere
 * and issues a chip reset if so.
 */
static bool ath_tx_complete_check(struct ath_softc *sc)
{
 struct ath_txq *txq;
 int i;

 if (sc->tx99_state)
  return true;

 for (i = 0; i < IEEE80211_NUM_ACS; i++) {
  txq = sc->tx.txq_map[i];

  ath_txq_lock(sc, txq);
  if (txq->axq_depth) {
   if (txq->axq_tx_inprogress) {
    ath_txq_unlock(sc, txq);
    goto reset;
   }

   txq->axq_tx_inprogress = true;
  }
  ath_txq_unlock(sc, txq);
 }

 return true;

reset:
 ath_dbg(ath9k_hw_common(sc->sc_ah), RESET,
  "tx hung, resetting the chip\n");
 ath9k_queue_reset(sc, RESET_TYPE_TX_HANG);
 return false;
}

#define RX_INACTIVE_CHECK_INTERVAL (4 * MSEC_PER_SEC)

static bool ath_hw_rx_inactive_check(struct ath_softc *sc)
{
 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 u32 interval, count;

 interval = jiffies_to_msecs(jiffies - sc->rx_active_check_time);
 count = sc->rx_active_count;

 if (interval < RX_INACTIVE_CHECK_INTERVAL)
  return true; /* too soon to check */

 sc->rx_active_count = 0;
 sc->rx_active_check_time = jiffies;

 /* Need at least one interrupt per second, and we should only react if
  * we are within a factor two of the expected interval
 */
 if (interval > RX_INACTIVE_CHECK_INTERVAL * 2 ||
     count >= interval / MSEC_PER_SEC)
  return true;

 ath_dbg(common, RESET,
  "RX inactivity detected. Schedule chip reset\n");
 ath9k_queue_reset(sc, RESET_TYPE_RX_INACTIVE);

 return false;
}

void ath_hw_check_work(struct work_struct *work)
{
 struct ath_softc *sc = container_of(work, struct ath_softc,
         hw_check_work.work);

 if (!ath_hw_check(sc) || !ath_tx_complete_check(sc) ||
     !ath_hw_rx_inactive_check(sc))
  return;

 ieee80211_queue_delayed_work(sc->hw, &sc->hw_check_work,
         msecs_to_jiffies(ATH_HW_CHECK_POLL_INT));
}

/*
 * Checks if the BB/MAC is hung.
 */
bool ath_hw_check(struct ath_softc *sc)
{
 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 enum ath_reset_type type;
 bool is_alive;

 ath9k_ps_wakeup(sc);

 is_alive = ath9k_hw_check_alive(sc->sc_ah);

 if (!is_alive) {
  ath_dbg(common, RESET,
   "HW hang detected, schedule chip reset\n");
  type = RESET_TYPE_MAC_HANG;
  ath9k_queue_reset(sc, type);
 }

 ath9k_ps_restore(sc);

 return is_alive;
}

/*
 * PLL-WAR for AR9485/AR9340
 */
static bool ath_hw_pll_rx_hang_check(struct ath_softc *sc, u32 pll_sqsum)
{
 static int count;
 struct ath_common *common = ath9k_hw_common(sc->sc_ah);

 if (pll_sqsum >= 0x40000) {
  count++;
  if (count == 3) {
   ath_dbg(common, RESET, "PLL WAR, resetting the chip\n");
   ath9k_queue_reset(sc, RESET_TYPE_PLL_HANG);
   count = 0;
   return true;
  }
 } else {
  count = 0;
 }

 return false;
}

void ath_hw_pll_work(struct work_struct *work)
{
 u32 pll_sqsum;
 struct ath_softc *sc = container_of(work, struct ath_softc,
         hw_pll_work.work);
 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 /*
  * ensure that the PLL WAR is executed only
  * after the STA is associated (or) if the
  * beaconing had started in interfaces that
  * uses beacons.
 */
 if (!test_bit(ATH_OP_BEACONS, &common->op_flags))
  return;

 if (sc->tx99_state)
  return;

 ath9k_ps_wakeup(sc);
 pll_sqsum = ar9003_get_pll_sqsum_dvc(sc->sc_ah);
 ath9k_ps_restore(sc);
 if (ath_hw_pll_rx_hang_check(sc, pll_sqsum))
  return;

 ieee80211_queue_delayed_work(sc->hw, &sc->hw_pll_work,
         msecs_to_jiffies(ATH_PLL_WORK_INTERVAL));
}

/*
 * PA Pre-distortion.
 */
static void ath_paprd_activate(struct ath_softc *sc)
{
 struct ath_hw *ah = sc->sc_ah;
 struct ath_common *common = ath9k_hw_common(ah);
 struct ath9k_hw_cal_data *caldata = ah->caldata;
 int chain;

 if (!caldata || !test_bit(PAPRD_DONE, &caldata->cal_flags)) {
  ath_dbg(common, CALIBRATE, "Failed to activate PAPRD\n");
  return;
 }

 ar9003_paprd_enable(ah, false);
 for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {
  if (!(ah->txchainmask & BIT(chain)))
   continue;

  ar9003_paprd_populate_single_table(ah, caldata, chain);
 }

 ath_dbg(common, CALIBRATE, "Activating PAPRD\n");
 ar9003_paprd_enable(ah, true);
}

static bool ath_paprd_send_frame(struct ath_softc *sc, struct sk_buff *skb, int chain)
{
 struct ieee80211_hw *hw = sc->hw;
 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
 struct ath_hw *ah = sc->sc_ah;
 struct ath_common *common = ath9k_hw_common(ah);
 struct ath_tx_control txctl;
 unsigned long time_left;

 memset(&txctl, 0, sizeof(txctl));
 txctl.txq = sc->tx.txq_map[IEEE80211_AC_BE];

 memset(tx_info, 0, sizeof(*tx_info));
 tx_info->band = sc->cur_chandef.chan->band;
 tx_info->flags |= IEEE80211_TX_CTL_NO_ACK;
 tx_info->control.rates[0].idx = 0;
 tx_info->control.rates[0].count = 1;
 tx_info->control.rates[0].flags = IEEE80211_TX_RC_MCS;
 tx_info->control.rates[1].idx = -1;

 init_completion(&sc->paprd_complete);
 txctl.paprd = BIT(chain);

 if (ath_tx_start(hw, skb, &txctl) != 0) {
  ath_dbg(common, CALIBRATE, "PAPRD TX failed\n");
  dev_kfree_skb_any(skb);
  return false;
 }

 time_left = wait_for_completion_timeout(&sc->paprd_complete,
   msecs_to_jiffies(ATH_PAPRD_TIMEOUT));

 if (!time_left)
  ath_dbg(common, CALIBRATE,
   "Timeout waiting for paprd training on TX chain %d\n",
   chain);

 return !!time_left;
}

void ath_paprd_calibrate(struct work_struct *work)
{
 struct ath_softc *sc = container_of(work, struct ath_softc, paprd_work);
 struct ieee80211_hw *hw = sc->hw;
 struct ath_hw *ah = sc->sc_ah;
 struct ieee80211_hdr *hdr;
 struct sk_buff *skb = NULL;
 struct ath9k_hw_cal_data *caldata = ah->caldata;
 struct ath_common *common = ath9k_hw_common(ah);
 int ftype;
 int chain_ok = 0;
 int chain;
 int len = 1800;
 int ret;

 if (!caldata ||
     !test_bit(PAPRD_PACKET_SENT, &caldata->cal_flags) ||
     test_bit(PAPRD_DONE, &caldata->cal_flags)) {
  ath_dbg(common, CALIBRATE, "Skipping PAPRD calibration\n");
  return;
 }

 ath9k_ps_wakeup(sc);

 if (ar9003_paprd_init_table(ah) < 0)
  goto fail_paprd;

 skb = alloc_skb(len, GFP_KERNEL);
 if (!skb)
  goto fail_paprd;

 skb_put(skb, len);
 memset(skb->data, 0, len);
 hdr = (struct ieee80211_hdr *)skb->data;
 ftype = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC;
 hdr->frame_control = cpu_to_le16(ftype);
 hdr->duration_id = cpu_to_le16(10);
 memcpy(hdr->addr1, hw->wiphy->perm_addr, ETH_ALEN);
 memcpy(hdr->addr2, hw->wiphy->perm_addr, ETH_ALEN);
 memcpy(hdr->addr3, hw->wiphy->perm_addr, ETH_ALEN);

 for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {
  if (!(ah->txchainmask & BIT(chain)))
   continue;

  chain_ok = 0;
  ar9003_paprd_setup_gain_table(ah, chain);

  ath_dbg(common, CALIBRATE,
   "Sending PAPRD training frame on chain %d\n", chain);
  if (!ath_paprd_send_frame(sc, skb, chain))
   goto fail_paprd;

  if (!ar9003_paprd_is_done(ah)) {
   ath_dbg(common, CALIBRATE,
    "PAPRD not yet done on chain %d\n", chain);
   break;
  }

  ret = ar9003_paprd_create_curve(ah, caldata, chain);
  if (ret == -EINPROGRESS) {
   ath_dbg(common, CALIBRATE,
    "PAPRD curve on chain %d needs to be re-trained\n",
    chain);
   break;
  } else if (ret) {
   ath_dbg(common, CALIBRATE,
    "PAPRD create curve failed on chain %d\n",
    chain);
   break;
  }

  chain_ok = 1;
 }
 kfree_skb(skb);

 if (chain_ok) {
  set_bit(PAPRD_DONE, &caldata->cal_flags);
  ath_paprd_activate(sc);
 }

fail_paprd:
 ath9k_ps_restore(sc);
}

/*
 *  ANI performs periodic noise floor calibration
 *  that is used to adjust and optimize the chip performance.  This
 *  takes environmental changes (location, temperature) into account.
 *  When the task is complete, it reschedules itself depending on the
 *  appropriate interval that was calculated.
 */
void ath_ani_calibrate(struct timer_list *t)
{
 struct ath_common *common = timer_container_of(common, t, ani.timer);
 struct ath_softc *sc = common->priv;
 struct ath_hw *ah = sc->sc_ah;
 bool longcal = false;
 bool shortcal = false;
 bool aniflag = false;
 unsigned int timestamp = jiffies_to_msecs(jiffies);
 u32 cal_interval, short_cal_interval, long_cal_interval;
 unsigned long flags;

 if (ah->caldata && test_bit(NFCAL_INTF, &ah->caldata->cal_flags))
  long_cal_interval = ATH_LONG_CALINTERVAL_INT;
 else
  long_cal_interval = ATH_LONG_CALINTERVAL;

 short_cal_interval = (ah->opmode == NL80211_IFTYPE_AP) ?
  ATH_AP_SHORT_CALINTERVAL : ATH_STA_SHORT_CALINTERVAL;

 /* Only calibrate if awake */
 if (sc->sc_ah->power_mode != ATH9K_PM_AWAKE) {
  if (++ah->ani_skip_count >= ATH_ANI_MAX_SKIP_COUNT) {
   spin_lock_irqsave(&sc->sc_pm_lock, flags);
   sc->ps_flags |= PS_WAIT_FOR_ANI;
   spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
  }
  goto set_timer;
 }
 ah->ani_skip_count = 0;
 spin_lock_irqsave(&sc->sc_pm_lock, flags);
 sc->ps_flags &= ~PS_WAIT_FOR_ANI;
 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);

 ath9k_ps_wakeup(sc);

 /* Long calibration runs independently of short calibration. */
 if ((timestamp - common->ani.longcal_timer) >= long_cal_interval) {
  longcal = true;
  common->ani.longcal_timer = timestamp;
 }

 /* Short calibration applies only while caldone is false */
 if (!common->ani.caldone) {
  if ((timestamp - common->ani.shortcal_timer) >= short_cal_interval) {
   shortcal = true;
   common->ani.shortcal_timer = timestamp;
   common->ani.resetcal_timer = timestamp;
  }
 } else {
  if ((timestamp - common->ani.resetcal_timer) >=
      ATH_RESTART_CALINTERVAL) {
   common->ani.caldone = ath9k_hw_reset_calvalid(ah);
   if (common->ani.caldone)
    common->ani.resetcal_timer = timestamp;
  }
 }

 /* Verify whether we must check ANI */
 if ((timestamp - common->ani.checkani_timer) >= ah->config.ani_poll_interval) {
  aniflag = true;
  common->ani.checkani_timer = timestamp;
 }

 /* Call ANI routine if necessary */
 if (aniflag) {
  spin_lock_irqsave(&common->cc_lock, flags);
  ath9k_hw_ani_monitor(ah, ah->curchan);
  ath_update_survey_stats(sc);
  spin_unlock_irqrestore(&common->cc_lock, flags);
 }

 /* Perform calibration if necessary */
 if (longcal || shortcal) {
  int ret = ath9k_hw_calibrate(ah, ah->curchan, ah->rxchainmask,
          longcal);
  if (ret < 0) {
   common->ani.caldone = 0;
   ath9k_queue_reset(sc, RESET_TYPE_CALIBRATION);
   return;
  }

  common->ani.caldone = ret;
 }

 ath_dbg(common, ANI,
  "Calibration @%lu finished: %s %s %s, caldone: %s\n",
  jiffies,
  longcal ? "long" : "", shortcal ? "short" : "",
  aniflag ? "ani" : "", common->ani.caldone ? "true" : "false");

 ath9k_ps_restore(sc);

set_timer:
 /*
 * Set timer interval based on previous results.
 * The interval must be the shortest necessary to satisfy ANI,
 * short calibration and long calibration.
*/
 cal_interval = ATH_LONG_CALINTERVAL;
 cal_interval = min(cal_interval, (u32)ah->config.ani_poll_interval);
 if (!common->ani.caldone)
  cal_interval = min(cal_interval, (u32)short_cal_interval);

 mod_timer(&common->ani.timer, jiffies + msecs_to_jiffies(cal_interval));

 if (ar9003_is_paprd_enabled(ah) && ah->caldata) {
  if (!test_bit(PAPRD_DONE, &ah->caldata->cal_flags)) {
   ieee80211_queue_work(sc->hw, &sc->paprd_work);
  } else if (!ah->paprd_table_write_done) {
   ath9k_ps_wakeup(sc);
   ath_paprd_activate(sc);
   ath9k_ps_restore(sc);
  }
 }
}

void ath_start_ani(struct ath_softc *sc)
{
 struct ath_hw *ah = sc->sc_ah;
 struct ath_common *common = ath9k_hw_common(ah);
 unsigned long timestamp = jiffies_to_msecs(jiffies);

 if (common->disable_ani ||
     !test_bit(ATH_OP_ANI_RUN, &common->op_flags) ||
     sc->cur_chan->offchannel)
  return;

 common->ani.longcal_timer = timestamp;
 common->ani.shortcal_timer = timestamp;
 common->ani.checkani_timer = timestamp;

 ath_dbg(common, ANI, "Starting ANI\n");
 mod_timer(&common->ani.timer,
    jiffies + msecs_to_jiffies((u32)ah->config.ani_poll_interval));
}

void ath_stop_ani(struct ath_softc *sc)
{
 struct ath_common *common = ath9k_hw_common(sc->sc_ah);

 ath_dbg(common, ANI, "Stopping ANI\n");
 timer_delete_sync(&common->ani.timer);
}

void ath_check_ani(struct ath_softc *sc)
{
 struct ath_hw *ah = sc->sc_ah;
 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 struct ath_beacon_config *cur_conf = &sc->cur_chan->beacon;

 /*
  * Check for the various conditions in which ANI has to
  * be stopped.
 */
 if (ah->opmode == NL80211_IFTYPE_ADHOC) {
  if (!cur_conf->enable_beacon)
   goto stop_ani;
 } else if (ah->opmode == NL80211_IFTYPE_AP) {
  if (!cur_conf->enable_beacon) {
   /*
    * Disable ANI only when there are no
    * associated stations.
 */
   if (!test_bit(ATH_OP_PRIM_STA_VIF, &common->op_flags))
    goto stop_ani;
  }
 } else if (ah->opmode == NL80211_IFTYPE_STATION) {
  if (!test_bit(ATH_OP_PRIM_STA_VIF, &common->op_flags))
   goto stop_ani;
 }

 if (!test_bit(ATH_OP_ANI_RUN, &common->op_flags)) {
  set_bit(ATH_OP_ANI_RUN, &common->op_flags);
  ath_start_ani(sc);
 }

 return;

stop_ani:
 clear_bit(ATH_OP_ANI_RUN, &common->op_flags);
 ath_stop_ani(sc);
}

void ath_update_survey_nf(struct ath_softc *sc, int channel)
{
 struct ath_hw *ah = sc->sc_ah;
 struct ath9k_channel *chan = &ah->channels[channel];
 struct survey_info *survey = &sc->survey[channel];

 if (chan->noisefloor) {
  survey->filled |= SURVEY_INFO_NOISE_DBM;
  survey->noise = ath9k_hw_getchan_noise(ah, chan,
             chan->noisefloor);
 }
}

/*
 * Updates the survey statistics and returns the busy time since last
 * update in %, if the measurement duration was long enough for the
 * result to be useful, -1 otherwise.
 */
int ath_update_survey_stats(struct ath_softc *sc)
{
 struct ath_hw *ah = sc->sc_ah;
 struct ath_common *common = ath9k_hw_common(ah);
 int pos = ah->curchan - &ah->channels[0];
 struct survey_info *survey = &sc->survey[pos];
 struct ath_cycle_counters *cc = &common->cc_survey;
 unsigned int div = common->clockrate * 1000;
 int ret = 0;

 if (!ah->curchan)
  return -1;

 if (ah->power_mode == ATH9K_PM_AWAKE)
  ath_hw_cycle_counters_update(common);

 if (cc->cycles > 0) {
  survey->filled |= SURVEY_INFO_TIME |
   SURVEY_INFO_TIME_BUSY |
   SURVEY_INFO_TIME_RX |
   SURVEY_INFO_TIME_TX;
  survey->time += cc->cycles / div;
  survey->time_busy += cc->rx_busy / div;
  survey->time_rx += cc->rx_frame / div;
  survey->time_tx += cc->tx_frame / div;
 }

 if (cc->cycles < div)
  return -1;

 if (cc->cycles > 0)
  ret = cc->rx_busy * 100 / cc->cycles;

 memset(cc, 0, sizeof(*cc));

 ath_update_survey_nf(sc, pos);

 return ret;
}