1 /* 2 * Copyright (c) 2012 Qualcomm Atheros, 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 "ath9k.h" 18 19 /* 20 * TX polling - checks if the TX engine is stuck somewhere 21 * and issues a chip reset if so. 22 */ 23 void ath_tx_complete_poll_work(struct work_struct *work) 24 { 25 struct ath_softc *sc = container_of(work, struct ath_softc, 26 tx_complete_work.work); 27 struct ath_txq *txq; 28 int i; 29 bool needreset = false; 30 #ifdef CONFIG_ATH9K_DEBUGFS 31 sc->tx_complete_poll_work_seen++; 32 #endif 33 34 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) 35 if (ATH_TXQ_SETUP(sc, i)) { 36 txq = &sc->tx.txq[i]; 37 ath_txq_lock(sc, txq); 38 if (txq->axq_depth) { 39 if (txq->axq_tx_inprogress) { 40 needreset = true; 41 ath_txq_unlock(sc, txq); 42 break; 43 } else { 44 txq->axq_tx_inprogress = true; 45 } 46 } 47 ath_txq_unlock_complete(sc, txq); 48 } 49 50 if (needreset) { 51 ath_dbg(ath9k_hw_common(sc->sc_ah), RESET, 52 "tx hung, resetting the chip\n"); 53 ath9k_queue_reset(sc, RESET_TYPE_TX_HANG); 54 return; 55 } 56 57 ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work, 58 msecs_to_jiffies(ATH_TX_COMPLETE_POLL_INT)); 59 } 60 61 /* 62 * Checks if the BB/MAC is hung. 63 */ 64 void ath_hw_check(struct work_struct *work) 65 { 66 struct ath_softc *sc = container_of(work, struct ath_softc, hw_check_work); 67 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 68 unsigned long flags; 69 int busy; 70 u8 is_alive, nbeacon = 1; 71 enum ath_reset_type type; 72 73 ath9k_ps_wakeup(sc); 74 is_alive = ath9k_hw_check_alive(sc->sc_ah); 75 76 if (is_alive && !AR_SREV_9300(sc->sc_ah)) 77 goto out; 78 else if (!is_alive && AR_SREV_9300(sc->sc_ah)) { 79 ath_dbg(common, RESET, 80 "DCU stuck is detected. Schedule chip reset\n"); 81 type = RESET_TYPE_MAC_HANG; 82 goto sched_reset; 83 } 84 85 spin_lock_irqsave(&common->cc_lock, flags); 86 busy = ath_update_survey_stats(sc); 87 spin_unlock_irqrestore(&common->cc_lock, flags); 88 89 ath_dbg(common, RESET, "Possible baseband hang, busy=%d (try %d)\n", 90 busy, sc->hw_busy_count + 1); 91 if (busy >= 99) { 92 if (++sc->hw_busy_count >= 3) { 93 type = RESET_TYPE_BB_HANG; 94 goto sched_reset; 95 } 96 } else if (busy >= 0) { 97 sc->hw_busy_count = 0; 98 nbeacon = 3; 99 } 100 101 ath_start_rx_poll(sc, nbeacon); 102 goto out; 103 104 sched_reset: 105 ath9k_queue_reset(sc, type); 106 out: 107 ath9k_ps_restore(sc); 108 } 109 110 /* 111 * PLL-WAR for AR9485/AR9340 112 */ 113 static bool ath_hw_pll_rx_hang_check(struct ath_softc *sc, u32 pll_sqsum) 114 { 115 static int count; 116 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 117 118 if (pll_sqsum >= 0x40000) { 119 count++; 120 if (count == 3) { 121 ath_dbg(common, RESET, "PLL WAR, resetting the chip\n"); 122 ath9k_queue_reset(sc, RESET_TYPE_PLL_HANG); 123 count = 0; 124 return true; 125 } 126 } else { 127 count = 0; 128 } 129 130 return false; 131 } 132 133 void ath_hw_pll_work(struct work_struct *work) 134 { 135 u32 pll_sqsum; 136 struct ath_softc *sc = container_of(work, struct ath_softc, 137 hw_pll_work.work); 138 /* 139 * ensure that the PLL WAR is executed only 140 * after the STA is associated (or) if the 141 * beaconing had started in interfaces that 142 * uses beacons. 143 */ 144 if (!test_bit(SC_OP_BEACONS, &sc->sc_flags)) 145 return; 146 147 ath9k_ps_wakeup(sc); 148 pll_sqsum = ar9003_get_pll_sqsum_dvc(sc->sc_ah); 149 ath9k_ps_restore(sc); 150 if (ath_hw_pll_rx_hang_check(sc, pll_sqsum)) 151 return; 152 153 ieee80211_queue_delayed_work(sc->hw, &sc->hw_pll_work, 154 msecs_to_jiffies(ATH_PLL_WORK_INTERVAL)); 155 } 156 157 /* 158 * RX Polling - monitors baseband hangs. 159 */ 160 void ath_start_rx_poll(struct ath_softc *sc, u8 nbeacon) 161 { 162 if (!AR_SREV_9300(sc->sc_ah)) 163 return; 164 165 if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) 166 return; 167 168 mod_timer(&sc->rx_poll_timer, jiffies + msecs_to_jiffies 169 (nbeacon * sc->cur_beacon_conf.beacon_interval)); 170 } 171 172 void ath_rx_poll(unsigned long data) 173 { 174 struct ath_softc *sc = (struct ath_softc *)data; 175 176 ieee80211_queue_work(sc->hw, &sc->hw_check_work); 177 } 178 179 /* 180 * PA Pre-distortion. 181 */ 182 static void ath_paprd_activate(struct ath_softc *sc) 183 { 184 struct ath_hw *ah = sc->sc_ah; 185 struct ath9k_hw_cal_data *caldata = ah->caldata; 186 int chain; 187 188 if (!caldata || !caldata->paprd_done) 189 return; 190 191 ath9k_ps_wakeup(sc); 192 ar9003_paprd_enable(ah, false); 193 for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) { 194 if (!(ah->txchainmask & BIT(chain))) 195 continue; 196 197 ar9003_paprd_populate_single_table(ah, caldata, chain); 198 } 199 200 ar9003_paprd_enable(ah, true); 201 ath9k_ps_restore(sc); 202 } 203 204 static bool ath_paprd_send_frame(struct ath_softc *sc, struct sk_buff *skb, int chain) 205 { 206 struct ieee80211_hw *hw = sc->hw; 207 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb); 208 struct ath_hw *ah = sc->sc_ah; 209 struct ath_common *common = ath9k_hw_common(ah); 210 struct ath_tx_control txctl; 211 int time_left; 212 213 memset(&txctl, 0, sizeof(txctl)); 214 txctl.txq = sc->tx.txq_map[WME_AC_BE]; 215 216 memset(tx_info, 0, sizeof(*tx_info)); 217 tx_info->band = hw->conf.channel->band; 218 tx_info->flags |= IEEE80211_TX_CTL_NO_ACK; 219 tx_info->control.rates[0].idx = 0; 220 tx_info->control.rates[0].count = 1; 221 tx_info->control.rates[0].flags = IEEE80211_TX_RC_MCS; 222 tx_info->control.rates[1].idx = -1; 223 224 init_completion(&sc->paprd_complete); 225 txctl.paprd = BIT(chain); 226 227 if (ath_tx_start(hw, skb, &txctl) != 0) { 228 ath_dbg(common, CALIBRATE, "PAPRD TX failed\n"); 229 dev_kfree_skb_any(skb); 230 return false; 231 } 232 233 time_left = wait_for_completion_timeout(&sc->paprd_complete, 234 msecs_to_jiffies(ATH_PAPRD_TIMEOUT)); 235 236 if (!time_left) 237 ath_dbg(common, CALIBRATE, 238 "Timeout waiting for paprd training on TX chain %d\n", 239 chain); 240 241 return !!time_left; 242 } 243 244 void ath_paprd_calibrate(struct work_struct *work) 245 { 246 struct ath_softc *sc = container_of(work, struct ath_softc, paprd_work); 247 struct ieee80211_hw *hw = sc->hw; 248 struct ath_hw *ah = sc->sc_ah; 249 struct ieee80211_hdr *hdr; 250 struct sk_buff *skb = NULL; 251 struct ath9k_hw_cal_data *caldata = ah->caldata; 252 struct ath_common *common = ath9k_hw_common(ah); 253 int ftype; 254 int chain_ok = 0; 255 int chain; 256 int len = 1800; 257 int ret; 258 259 if (!caldata) 260 return; 261 262 ath9k_ps_wakeup(sc); 263 264 if (ar9003_paprd_init_table(ah) < 0) 265 goto fail_paprd; 266 267 skb = alloc_skb(len, GFP_KERNEL); 268 if (!skb) 269 goto fail_paprd; 270 271 skb_put(skb, len); 272 memset(skb->data, 0, len); 273 hdr = (struct ieee80211_hdr *)skb->data; 274 ftype = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC; 275 hdr->frame_control = cpu_to_le16(ftype); 276 hdr->duration_id = cpu_to_le16(10); 277 memcpy(hdr->addr1, hw->wiphy->perm_addr, ETH_ALEN); 278 memcpy(hdr->addr2, hw->wiphy->perm_addr, ETH_ALEN); 279 memcpy(hdr->addr3, hw->wiphy->perm_addr, ETH_ALEN); 280 281 for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) { 282 if (!(ah->txchainmask & BIT(chain))) 283 continue; 284 285 chain_ok = 0; 286 287 ath_dbg(common, CALIBRATE, 288 "Sending PAPRD frame for thermal measurement on chain %d\n", 289 chain); 290 if (!ath_paprd_send_frame(sc, skb, chain)) 291 goto fail_paprd; 292 293 ar9003_paprd_setup_gain_table(ah, chain); 294 295 ath_dbg(common, CALIBRATE, 296 "Sending PAPRD training frame on chain %d\n", chain); 297 if (!ath_paprd_send_frame(sc, skb, chain)) 298 goto fail_paprd; 299 300 if (!ar9003_paprd_is_done(ah)) { 301 ath_dbg(common, CALIBRATE, 302 "PAPRD not yet done on chain %d\n", chain); 303 break; 304 } 305 306 ret = ar9003_paprd_create_curve(ah, caldata, chain); 307 if (ret == -EINPROGRESS) { 308 ath_dbg(common, CALIBRATE, 309 "PAPRD curve on chain %d needs to be re-trained\n", 310 chain); 311 break; 312 } else if (ret) { 313 ath_dbg(common, CALIBRATE, 314 "PAPRD create curve failed on chain %d\n", 315 chain); 316 break; 317 } 318 319 chain_ok = 1; 320 } 321 kfree_skb(skb); 322 323 if (chain_ok) { 324 caldata->paprd_done = true; 325 ath_paprd_activate(sc); 326 } 327 328 fail_paprd: 329 ath9k_ps_restore(sc); 330 } 331 332 /* 333 * ANI performs periodic noise floor calibration 334 * that is used to adjust and optimize the chip performance. This 335 * takes environmental changes (location, temperature) into account. 336 * When the task is complete, it reschedules itself depending on the 337 * appropriate interval that was calculated. 338 */ 339 void ath_ani_calibrate(unsigned long data) 340 { 341 struct ath_softc *sc = (struct ath_softc *)data; 342 struct ath_hw *ah = sc->sc_ah; 343 struct ath_common *common = ath9k_hw_common(ah); 344 bool longcal = false; 345 bool shortcal = false; 346 bool aniflag = false; 347 unsigned int timestamp = jiffies_to_msecs(jiffies); 348 u32 cal_interval, short_cal_interval, long_cal_interval; 349 unsigned long flags; 350 351 if (ah->caldata && ah->caldata->nfcal_interference) 352 long_cal_interval = ATH_LONG_CALINTERVAL_INT; 353 else 354 long_cal_interval = ATH_LONG_CALINTERVAL; 355 356 short_cal_interval = (ah->opmode == NL80211_IFTYPE_AP) ? 357 ATH_AP_SHORT_CALINTERVAL : ATH_STA_SHORT_CALINTERVAL; 358 359 /* Only calibrate if awake */ 360 if (sc->sc_ah->power_mode != ATH9K_PM_AWAKE) 361 goto set_timer; 362 363 ath9k_ps_wakeup(sc); 364 365 /* Long calibration runs independently of short calibration. */ 366 if ((timestamp - common->ani.longcal_timer) >= long_cal_interval) { 367 longcal = true; 368 common->ani.longcal_timer = timestamp; 369 } 370 371 /* Short calibration applies only while caldone is false */ 372 if (!common->ani.caldone) { 373 if ((timestamp - common->ani.shortcal_timer) >= short_cal_interval) { 374 shortcal = true; 375 common->ani.shortcal_timer = timestamp; 376 common->ani.resetcal_timer = timestamp; 377 } 378 } else { 379 if ((timestamp - common->ani.resetcal_timer) >= 380 ATH_RESTART_CALINTERVAL) { 381 common->ani.caldone = ath9k_hw_reset_calvalid(ah); 382 if (common->ani.caldone) 383 common->ani.resetcal_timer = timestamp; 384 } 385 } 386 387 /* Verify whether we must check ANI */ 388 if (sc->sc_ah->config.enable_ani 389 && (timestamp - common->ani.checkani_timer) >= 390 ah->config.ani_poll_interval) { 391 aniflag = true; 392 common->ani.checkani_timer = timestamp; 393 } 394 395 /* Call ANI routine if necessary */ 396 if (aniflag) { 397 spin_lock_irqsave(&common->cc_lock, flags); 398 ath9k_hw_ani_monitor(ah, ah->curchan); 399 ath_update_survey_stats(sc); 400 spin_unlock_irqrestore(&common->cc_lock, flags); 401 } 402 403 /* Perform calibration if necessary */ 404 if (longcal || shortcal) { 405 common->ani.caldone = 406 ath9k_hw_calibrate(ah, ah->curchan, 407 ah->rxchainmask, longcal); 408 } 409 410 ath_dbg(common, ANI, 411 "Calibration @%lu finished: %s %s %s, caldone: %s\n", 412 jiffies, 413 longcal ? "long" : "", shortcal ? "short" : "", 414 aniflag ? "ani" : "", common->ani.caldone ? "true" : "false"); 415 416 ath9k_debug_samp_bb_mac(sc); 417 ath9k_ps_restore(sc); 418 419 set_timer: 420 /* 421 * Set timer interval based on previous results. 422 * The interval must be the shortest necessary to satisfy ANI, 423 * short calibration and long calibration. 424 */ 425 cal_interval = ATH_LONG_CALINTERVAL; 426 if (sc->sc_ah->config.enable_ani) 427 cal_interval = min(cal_interval, 428 (u32)ah->config.ani_poll_interval); 429 if (!common->ani.caldone) 430 cal_interval = min(cal_interval, (u32)short_cal_interval); 431 432 mod_timer(&common->ani.timer, jiffies + msecs_to_jiffies(cal_interval)); 433 if ((sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_PAPRD) && ah->caldata) { 434 if (!ah->caldata->paprd_done) 435 ieee80211_queue_work(sc->hw, &sc->paprd_work); 436 else if (!ah->paprd_table_write_done) 437 ath_paprd_activate(sc); 438 } 439 } 440 441 void ath_start_ani(struct ath_softc *sc) 442 { 443 struct ath_hw *ah = sc->sc_ah; 444 struct ath_common *common = ath9k_hw_common(ah); 445 unsigned long timestamp = jiffies_to_msecs(jiffies); 446 447 if (common->disable_ani || 448 !test_bit(SC_OP_ANI_RUN, &sc->sc_flags) || 449 (sc->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)) 450 return; 451 452 common->ani.longcal_timer = timestamp; 453 common->ani.shortcal_timer = timestamp; 454 common->ani.checkani_timer = timestamp; 455 456 ath_dbg(common, ANI, "Starting ANI\n"); 457 mod_timer(&common->ani.timer, 458 jiffies + msecs_to_jiffies((u32)ah->config.ani_poll_interval)); 459 } 460 461 void ath_stop_ani(struct ath_softc *sc) 462 { 463 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 464 465 ath_dbg(common, ANI, "Stopping ANI\n"); 466 del_timer_sync(&common->ani.timer); 467 } 468 469 void ath_check_ani(struct ath_softc *sc) 470 { 471 struct ath_hw *ah = sc->sc_ah; 472 struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; 473 474 /* 475 * Check for the various conditions in which ANI has to 476 * be stopped. 477 */ 478 if (ah->opmode == NL80211_IFTYPE_ADHOC) { 479 if (!cur_conf->enable_beacon) 480 goto stop_ani; 481 } else if (ah->opmode == NL80211_IFTYPE_AP) { 482 if (!cur_conf->enable_beacon) { 483 /* 484 * Disable ANI only when there are no 485 * associated stations. 486 */ 487 if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) 488 goto stop_ani; 489 } 490 } else if (ah->opmode == NL80211_IFTYPE_STATION) { 491 if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) 492 goto stop_ani; 493 } 494 495 if (!test_bit(SC_OP_ANI_RUN, &sc->sc_flags)) { 496 set_bit(SC_OP_ANI_RUN, &sc->sc_flags); 497 ath_start_ani(sc); 498 } 499 500 return; 501 502 stop_ani: 503 clear_bit(SC_OP_ANI_RUN, &sc->sc_flags); 504 ath_stop_ani(sc); 505 } 506 507 void ath_update_survey_nf(struct ath_softc *sc, int channel) 508 { 509 struct ath_hw *ah = sc->sc_ah; 510 struct ath9k_channel *chan = &ah->channels[channel]; 511 struct survey_info *survey = &sc->survey[channel]; 512 513 if (chan->noisefloor) { 514 survey->filled |= SURVEY_INFO_NOISE_DBM; 515 survey->noise = ath9k_hw_getchan_noise(ah, chan); 516 } 517 } 518 519 /* 520 * Updates the survey statistics and returns the busy time since last 521 * update in %, if the measurement duration was long enough for the 522 * result to be useful, -1 otherwise. 523 */ 524 int ath_update_survey_stats(struct ath_softc *sc) 525 { 526 struct ath_hw *ah = sc->sc_ah; 527 struct ath_common *common = ath9k_hw_common(ah); 528 int pos = ah->curchan - &ah->channels[0]; 529 struct survey_info *survey = &sc->survey[pos]; 530 struct ath_cycle_counters *cc = &common->cc_survey; 531 unsigned int div = common->clockrate * 1000; 532 int ret = 0; 533 534 if (!ah->curchan) 535 return -1; 536 537 if (ah->power_mode == ATH9K_PM_AWAKE) 538 ath_hw_cycle_counters_update(common); 539 540 if (cc->cycles > 0) { 541 survey->filled |= SURVEY_INFO_CHANNEL_TIME | 542 SURVEY_INFO_CHANNEL_TIME_BUSY | 543 SURVEY_INFO_CHANNEL_TIME_RX | 544 SURVEY_INFO_CHANNEL_TIME_TX; 545 survey->channel_time += cc->cycles / div; 546 survey->channel_time_busy += cc->rx_busy / div; 547 survey->channel_time_rx += cc->rx_frame / div; 548 survey->channel_time_tx += cc->tx_frame / div; 549 } 550 551 if (cc->cycles < div) 552 return -1; 553 554 if (cc->cycles > 0) 555 ret = cc->rx_busy * 100 / cc->cycles; 556 557 memset(cc, 0, sizeof(*cc)); 558 559 ath_update_survey_nf(sc, pos); 560 561 return ret; 562 } 563