main.c 59.5 KB
Newer Older
1
/*
2
 * Copyright (c) 2008-2011 Atheros Communications Inc.
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
 *
 * 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 <linux/nl80211.h>
18
#include <linux/delay.h>
S
Sujith 已提交
19
#include "ath9k.h"
20
#include "btcoex.h"
21

S
Sujith 已提交
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
static u8 parse_mpdudensity(u8 mpdudensity)
{
	/*
	 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
	 *   0 for no restriction
	 *   1 for 1/4 us
	 *   2 for 1/2 us
	 *   3 for 1 us
	 *   4 for 2 us
	 *   5 for 4 us
	 *   6 for 8 us
	 *   7 for 16 us
	 */
	switch (mpdudensity) {
	case 0:
		return 0;
	case 1:
	case 2:
	case 3:
		/* Our lower layer calculations limit our precision to
		   1 microsecond */
		return 1;
	case 4:
		return 2;
	case 5:
		return 4;
	case 6:
		return 8;
	case 7:
		return 16;
	default:
		return 0;
	}
}

57 58 59 60 61 62 63 64 65 66 67 68 69
static bool ath9k_has_pending_frames(struct ath_softc *sc, struct ath_txq *txq)
{
	bool pending = false;

	spin_lock_bh(&txq->axq_lock);

	if (txq->axq_depth || !list_empty(&txq->axq_acq))
		pending = true;

	spin_unlock_bh(&txq->axq_lock);
	return pending;
}

70
static bool ath9k_setpower(struct ath_softc *sc, enum ath9k_power_mode mode)
71 72 73 74
{
	unsigned long flags;
	bool ret;

75 76 77
	spin_lock_irqsave(&sc->sc_pm_lock, flags);
	ret = ath9k_hw_setpower(sc->sc_ah, mode);
	spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
78 79 80 81

	return ret;
}

82 83
void ath9k_ps_wakeup(struct ath_softc *sc)
{
84
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
85
	unsigned long flags;
86
	enum ath9k_power_mode power_mode;
87 88 89 90 91

	spin_lock_irqsave(&sc->sc_pm_lock, flags);
	if (++sc->ps_usecount != 1)
		goto unlock;

92
	power_mode = sc->sc_ah->power_mode;
93
	ath9k_hw_setpower(sc->sc_ah, ATH9K_PM_AWAKE);
94

95 96 97 98 99
	/*
	 * While the hardware is asleep, the cycle counters contain no
	 * useful data. Better clear them now so that they don't mess up
	 * survey data results.
	 */
100 101 102 103 104 105
	if (power_mode != ATH9K_PM_AWAKE) {
		spin_lock(&common->cc_lock);
		ath_hw_cycle_counters_update(common);
		memset(&common->cc_survey, 0, sizeof(common->cc_survey));
		spin_unlock(&common->cc_lock);
	}
106

107 108 109 110 111 112
 unlock:
	spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
}

void ath9k_ps_restore(struct ath_softc *sc)
{
113
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
114 115 116 117 118 119
	unsigned long flags;

	spin_lock_irqsave(&sc->sc_pm_lock, flags);
	if (--sc->ps_usecount != 0)
		goto unlock;

120 121 122 123
	spin_lock(&common->cc_lock);
	ath_hw_cycle_counters_update(common);
	spin_unlock(&common->cc_lock);

124 125 126 127
	if (sc->ps_idle)
		ath9k_hw_setpower(sc->sc_ah, ATH9K_PM_FULL_SLEEP);
	else if (sc->ps_enabled &&
		 !(sc->ps_flags & (PS_WAIT_FOR_BEACON |
S
Sujith 已提交
128 129 130
			      PS_WAIT_FOR_CAB |
			      PS_WAIT_FOR_PSPOLL_DATA |
			      PS_WAIT_FOR_TX_ACK)))
131
		ath9k_hw_setpower(sc->sc_ah, ATH9K_PM_NETWORK_SLEEP);
132 133 134 135 136

 unlock:
	spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
}

137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
static void ath_start_ani(struct ath_common *common)
{
	struct ath_hw *ah = common->ah;
	unsigned long timestamp = jiffies_to_msecs(jiffies);
	struct ath_softc *sc = (struct ath_softc *) common->priv;

	if (!(sc->sc_flags & SC_OP_ANI_RUN))
		return;

	if (sc->sc_flags & SC_OP_OFFCHANNEL)
		return;

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

	mod_timer(&common->ani.timer,
		  jiffies +
			msecs_to_jiffies((u32)ah->config.ani_poll_interval));
}

158 159 160 161 162 163 164 165 166 167 168 169
static 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 = chan->noisefloor;
	}
}

170 171 172 173 174 175
/*
 * 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.
 */
static int ath_update_survey_stats(struct ath_softc *sc)
176 177 178 179 180 181 182
{
	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;
183
	int ret = 0;
184

185
	if (!ah->curchan)
186
		return -1;
187

188 189
	if (ah->power_mode == ATH9K_PM_AWAKE)
		ath_hw_cycle_counters_update(common);
190 191 192 193 194 195 196 197 198 199 200

	if (cc->cycles > 0) {
		survey->filled |= SURVEY_INFO_CHANNEL_TIME |
			SURVEY_INFO_CHANNEL_TIME_BUSY |
			SURVEY_INFO_CHANNEL_TIME_RX |
			SURVEY_INFO_CHANNEL_TIME_TX;
		survey->channel_time += cc->cycles / div;
		survey->channel_time_busy += cc->rx_busy / div;
		survey->channel_time_rx += cc->rx_frame / div;
		survey->channel_time_tx += cc->tx_frame / div;
	}
201 202 203 204 205 206 207

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

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

208 209 210
	memset(cc, 0, sizeof(*cc));

	ath_update_survey_nf(sc, pos);
211 212

	return ret;
213 214
}

S
Sujith 已提交
215 216 217 218 219
/*
 * Set/change channels.  If the channel is really being changed, it's done
 * by reseting the chip.  To accomplish this we must first cleanup any pending
 * DMA, then restart stuff.
*/
220
static int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
221
		    struct ath9k_channel *hchan)
S
Sujith 已提交
222
{
223
	struct ath_hw *ah = sc->sc_ah;
224
	struct ath_common *common = ath9k_hw_common(ah);
L
Luis R. Rodriguez 已提交
225
	struct ieee80211_conf *conf = &common->hw->conf;
S
Sujith 已提交
226
	bool fastcc = true, stopped;
227
	struct ieee80211_channel *channel = hw->conf.channel;
228
	struct ath9k_hw_cal_data *caldata = NULL;
229
	int r;
S
Sujith 已提交
230 231 232 233

	if (sc->sc_flags & SC_OP_INVALID)
		return -EIO;

234 235
	sc->hw_busy_count = 0;

236 237 238 239
	del_timer_sync(&common->ani.timer);
	cancel_work_sync(&sc->paprd_work);
	cancel_work_sync(&sc->hw_check_work);
	cancel_delayed_work_sync(&sc->tx_complete_work);
240
	cancel_delayed_work_sync(&sc->hw_pll_work);
241

242 243
	ath9k_ps_wakeup(sc);

244 245
	spin_lock_bh(&sc->sc_pcu_lock);

246 247 248 249 250 251 252 253 254
	/*
	 * This is only performed if the channel settings have
	 * actually changed.
	 *
	 * To switch channels clear any pending DMA operations;
	 * wait long enough for the RX fifo to drain, reset the
	 * hardware at the new frequency, and then re-enable
	 * the relevant bits of the h/w.
	 */
255
	ath9k_hw_disable_interrupts(ah);
256
	stopped = ath_drain_all_txq(sc, false);
257

258 259
	if (!ath_stoprecv(sc))
		stopped = false;
S
Sujith 已提交
260

261 262 263
	if (!ath9k_hw_check_alive(ah))
		stopped = false;

264 265 266
	/* XXX: do not flush receive queue here. We don't want
	 * to flush data frames already in queue because of
	 * changing channel. */
S
Sujith 已提交
267

268
	if (!stopped || !(sc->sc_flags & SC_OP_OFFCHANNEL))
269 270
		fastcc = false;

271
	if (!(sc->sc_flags & SC_OP_OFFCHANNEL))
272
		caldata = &sc->caldata;
273

J
Joe Perches 已提交
274 275 276 277 278
	ath_dbg(common, ATH_DBG_CONFIG,
		"(%u MHz) -> (%u MHz), conf_is_ht40: %d fastcc: %d\n",
		sc->sc_ah->curchan->channel,
		channel->center_freq, conf_is_ht40(conf),
		fastcc);
S
Sujith 已提交
279

280
	r = ath9k_hw_reset(ah, hchan, caldata, fastcc);
281
	if (r) {
282 283 284
		ath_err(common,
			"Unable to reset channel (%u MHz), reset status %d\n",
			channel->center_freq, r);
285
		goto ps_restore;
S
Sujith 已提交
286
	}
287 288

	if (ath_startrecv(sc) != 0) {
289
		ath_err(common, "Unable to restart recv logic\n");
290 291
		r = -EIO;
		goto ps_restore;
292 293
	}

294 295
	ath9k_cmn_update_txpow(ah, sc->curtxpow,
			       sc->config.txpowlimit, &sc->curtxpow);
P
Pavel Roskin 已提交
296
	ath9k_hw_set_interrupts(ah, ah->imask);
297

298
	if (!(sc->sc_flags & (SC_OP_OFFCHANNEL))) {
299
		if (sc->sc_flags & SC_OP_BEACONS)
300
			ath_set_beacon(sc);
301
		ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work, 0);
302
		ieee80211_queue_delayed_work(sc->hw, &sc->hw_pll_work, HZ/2);
303
		ath_start_ani(common);
304 305
	}

306
 ps_restore:
307 308
	ieee80211_wake_queues(hw);

309 310
	spin_unlock_bh(&sc->sc_pcu_lock);

311
	ath9k_ps_restore(sc);
312
	return r;
S
Sujith 已提交
313 314
}

315 316 317
static void ath_paprd_activate(struct ath_softc *sc)
{
	struct ath_hw *ah = sc->sc_ah;
318
	struct ath9k_hw_cal_data *caldata = ah->caldata;
319
	struct ath_common *common = ath9k_hw_common(ah);
320 321
	int chain;

322
	if (!caldata || !caldata->paprd_done)
323 324 325
		return;

	ath9k_ps_wakeup(sc);
326
	ar9003_paprd_enable(ah, false);
327
	for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {
328
		if (!(common->tx_chainmask & BIT(chain)))
329 330
			continue;

331
		ar9003_paprd_populate_single_table(ah, caldata, chain);
332 333 334 335 336 337
	}

	ar9003_paprd_enable(ah, true);
	ath9k_ps_restore(sc);
}

338 339 340 341
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);
342 343
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
	struct ath_tx_control txctl;
	int time_left;

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

	memset(tx_info, 0, sizeof(*tx_info));
	tx_info->band = hw->conf.channel->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);
360 361 362 363

	if (ath_tx_start(hw, skb, &txctl) != 0) {
		ath_dbg(common, ATH_DBG_XMIT, "PAPRD TX failed\n");
		dev_kfree_skb_any(skb);
364
		return false;
365
	}
366 367 368 369 370 371 372 373 374 375 376 377

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

	if (!time_left)
		ath_dbg(ath9k_hw_common(sc->sc_ah), ATH_DBG_CALIBRATE,
			"Timeout waiting for paprd training on TX chain %d\n",
			chain);

	return !!time_left;
}

378 379 380 381 382 383 384
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;
385
	struct ath9k_hw_cal_data *caldata = ah->caldata;
386
	struct ath_common *common = ath9k_hw_common(ah);
387
	int ftype;
388 389 390 391
	int chain_ok = 0;
	int chain;
	int len = 1800;

392 393 394
	if (!caldata)
		return;

395 396 397
	if (ar9003_paprd_init_table(ah) < 0)
		return;

398 399 400 401 402 403 404 405 406
	skb = alloc_skb(len, GFP_KERNEL);
	if (!skb)
		return;

	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);
407
	hdr->duration_id = cpu_to_le16(10);
408 409 410 411
	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);

412
	ath9k_ps_wakeup(sc);
413
	for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {
414
		if (!(common->tx_chainmask & BIT(chain)))
415 416 417 418
			continue;

		chain_ok = 0;

419 420 421 422 423
		ath_dbg(common, ATH_DBG_CALIBRATE,
			"Sending PAPRD frame for thermal measurement "
			"on chain %d\n", chain);
		if (!ath_paprd_send_frame(sc, skb, chain))
			goto fail_paprd;
424 425 426

		ar9003_paprd_setup_gain_table(ah, chain);

427 428 429
		ath_dbg(common, ATH_DBG_CALIBRATE,
			"Sending PAPRD training frame on chain %d\n", chain);
		if (!ath_paprd_send_frame(sc, skb, chain))
430
			goto fail_paprd;
431 432 433 434

		if (!ar9003_paprd_is_done(ah))
			break;

435
		if (ar9003_paprd_create_curve(ah, caldata, chain) != 0)
436 437 438 439 440 441 442
			break;

		chain_ok = 1;
	}
	kfree_skb(skb);

	if (chain_ok) {
443
		caldata->paprd_done = true;
444 445 446
		ath_paprd_activate(sc);
	}

447
fail_paprd:
448 449 450
	ath9k_ps_restore(sc);
}

S
Sujith 已提交
451 452 453 454 455 456 457
/*
 *  This routine performs the periodic noise floor calibration function
 *  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.
 */
S
Sujith 已提交
458
void ath_ani_calibrate(unsigned long data)
S
Sujith 已提交
459
{
460 461
	struct ath_softc *sc = (struct ath_softc *)data;
	struct ath_hw *ah = sc->sc_ah;
462
	struct ath_common *common = ath9k_hw_common(ah);
S
Sujith 已提交
463 464 465 466
	bool longcal = false;
	bool shortcal = false;
	bool aniflag = false;
	unsigned int timestamp = jiffies_to_msecs(jiffies);
467
	u32 cal_interval, short_cal_interval, long_cal_interval;
468
	unsigned long flags;
469 470 471 472 473

	if (ah->caldata && ah->caldata->nfcal_interference)
		long_cal_interval = ATH_LONG_CALINTERVAL_INT;
	else
		long_cal_interval = ATH_LONG_CALINTERVAL;
S
Sujith 已提交
474

475 476
	short_cal_interval = (ah->opmode == NL80211_IFTYPE_AP) ?
		ATH_AP_SHORT_CALINTERVAL : ATH_STA_SHORT_CALINTERVAL;
S
Sujith 已提交
477

478 479 480 481 482 483
	/* Only calibrate if awake */
	if (sc->sc_ah->power_mode != ATH9K_PM_AWAKE)
		goto set_timer;

	ath9k_ps_wakeup(sc);

S
Sujith 已提交
484
	/* Long calibration runs independently of short calibration. */
485
	if ((timestamp - common->ani.longcal_timer) >= long_cal_interval) {
S
Sujith 已提交
486
		longcal = true;
J
Joe Perches 已提交
487
		ath_dbg(common, ATH_DBG_ANI, "longcal @%lu\n", jiffies);
488
		common->ani.longcal_timer = timestamp;
S
Sujith 已提交
489 490
	}

S
Sujith 已提交
491
	/* Short calibration applies only while caldone is false */
492 493
	if (!common->ani.caldone) {
		if ((timestamp - common->ani.shortcal_timer) >= short_cal_interval) {
S
Sujith 已提交
494
			shortcal = true;
J
Joe Perches 已提交
495 496
			ath_dbg(common, ATH_DBG_ANI,
				"shortcal @%lu\n", jiffies);
497 498
			common->ani.shortcal_timer = timestamp;
			common->ani.resetcal_timer = timestamp;
S
Sujith 已提交
499 500
		}
	} else {
501
		if ((timestamp - common->ani.resetcal_timer) >=
S
Sujith 已提交
502
		    ATH_RESTART_CALINTERVAL) {
503 504 505
			common->ani.caldone = ath9k_hw_reset_calvalid(ah);
			if (common->ani.caldone)
				common->ani.resetcal_timer = timestamp;
S
Sujith 已提交
506 507 508 509
		}
	}

	/* Verify whether we must check ANI */
510 511
	if ((timestamp - common->ani.checkani_timer) >=
	     ah->config.ani_poll_interval) {
S
Sujith 已提交
512
		aniflag = true;
513
		common->ani.checkani_timer = timestamp;
S
Sujith 已提交
514 515
	}

516 517 518 519 520 521 522
	/* 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);
	}
S
Sujith 已提交
523

524 525 526 527 528
	/* Perform calibration if necessary */
	if (longcal || shortcal) {
		common->ani.caldone =
			ath9k_hw_calibrate(ah, ah->curchan,
						common->rx_chainmask, longcal);
S
Sujith 已提交
529 530
	}

531 532
	ath9k_ps_restore(sc);

533
set_timer:
S
Sujith 已提交
534 535 536 537 538
	/*
	* Set timer interval based on previous results.
	* The interval must be the shortest necessary to satisfy ANI,
	* short calibration and long calibration.
	*/
539
	cal_interval = ATH_LONG_CALINTERVAL;
540
	if (sc->sc_ah->config.enable_ani)
541 542
		cal_interval = min(cal_interval,
				   (u32)ah->config.ani_poll_interval);
543
	if (!common->ani.caldone)
544
		cal_interval = min(cal_interval, (u32)short_cal_interval);
S
Sujith 已提交
545

546
	mod_timer(&common->ani.timer, jiffies + msecs_to_jiffies(cal_interval));
547 548
	if ((sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_PAPRD) && ah->caldata) {
		if (!ah->caldata->paprd_done)
549
			ieee80211_queue_work(sc->hw, &sc->paprd_work);
550
		else if (!ah->paprd_table_write_done)
551 552
			ath_paprd_activate(sc);
	}
S
Sujith 已提交
553 554 555 556 557
}

static void ath_node_attach(struct ath_softc *sc, struct ieee80211_sta *sta)
{
	struct ath_node *an;
558
	struct ath_hw *ah = sc->sc_ah;
S
Sujith 已提交
559 560
	an = (struct ath_node *)sta->drv_priv;

561 562 563 564 565 566
#ifdef CONFIG_ATH9K_DEBUGFS
	spin_lock(&sc->nodes_lock);
	list_add(&an->list, &sc->nodes);
	spin_unlock(&sc->nodes_lock);
	an->sta = sta;
#endif
567 568 569
	if ((ah->caps.hw_caps) & ATH9K_HW_CAP_APM)
		sc->sc_flags |= SC_OP_ENABLE_APM;

570
	if (sc->sc_flags & SC_OP_TXAGGR) {
S
Sujith 已提交
571
		ath_tx_node_init(sc, an);
S
Sujith 已提交
572
		an->maxampdu = 1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
573 574 575
				     sta->ht_cap.ampdu_factor);
		an->mpdudensity = parse_mpdudensity(sta->ht_cap.ampdu_density);
	}
S
Sujith 已提交
576 577 578 579 580 581
}

static void ath_node_detach(struct ath_softc *sc, struct ieee80211_sta *sta)
{
	struct ath_node *an = (struct ath_node *)sta->drv_priv;

582 583 584 585 586 587 588
#ifdef CONFIG_ATH9K_DEBUGFS
	spin_lock(&sc->nodes_lock);
	list_del(&an->list);
	spin_unlock(&sc->nodes_lock);
	an->sta = NULL;
#endif

S
Sujith 已提交
589 590 591 592
	if (sc->sc_flags & SC_OP_TXAGGR)
		ath_tx_node_cleanup(sc, an);
}

593 594 595
void ath_hw_check(struct work_struct *work)
{
	struct ath_softc *sc = container_of(work, struct ath_softc, hw_check_work);
596 597 598
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
	unsigned long flags;
	int busy;
599 600

	ath9k_ps_wakeup(sc);
601 602
	if (ath9k_hw_check_alive(sc->sc_ah))
		goto out;
603

604 605 606
	spin_lock_irqsave(&common->cc_lock, flags);
	busy = ath_update_survey_stats(sc);
	spin_unlock_irqrestore(&common->cc_lock, flags);
607

608 609 610 611 612 613 614
	ath_dbg(common, ATH_DBG_RESET, "Possible baseband hang, "
		"busy=%d (try %d)\n", busy, sc->hw_busy_count + 1);
	if (busy >= 99) {
		if (++sc->hw_busy_count >= 3)
			ath_reset(sc, true);
	} else if (busy >= 0)
		sc->hw_busy_count = 0;
615 616 617 618 619

out:
	ath9k_ps_restore(sc);
}

620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637
static void 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) {
			/* Rx is hung for more than 500ms. Reset it */
			ath_dbg(common, ATH_DBG_RESET,
				"Possible RX hang, resetting");
			ath_reset(sc, true);
			count = 0;
		}
	} else
		count = 0;
}

638 639 640 641
void ath_hw_pll_work(struct work_struct *work)
{
	struct ath_softc *sc = container_of(work, struct ath_softc,
					    hw_pll_work.work);
642
	u32 pll_sqsum;
643 644

	if (AR_SREV_9485(sc->sc_ah)) {
645 646 647 648 649 650

		ath9k_ps_wakeup(sc);
		pll_sqsum = ar9003_get_pll_sqsum_dvc(sc->sc_ah);
		ath9k_ps_restore(sc);

		ath_hw_pll_rx_hang_check(sc, pll_sqsum);
651 652 653 654 655 656

		ieee80211_queue_delayed_work(sc->hw, &sc->hw_pll_work, HZ/5);
	}
}


S
Sujith 已提交
657
void ath9k_tasklet(unsigned long data)
S
Sujith 已提交
658 659
{
	struct ath_softc *sc = (struct ath_softc *)data;
660
	struct ath_hw *ah = sc->sc_ah;
661
	struct ath_common *common = ath9k_hw_common(ah);
662

S
Sujith 已提交
663
	u32 status = sc->intrstatus;
F
Felix Fietkau 已提交
664
	u32 rxmask;
S
Sujith 已提交
665

666 667
	if ((status & ATH9K_INT_FATAL) ||
	    (status & ATH9K_INT_BB_WATCHDOG)) {
668
		ath_reset(sc, true);
S
Sujith 已提交
669
		return;
S
Sujith 已提交
670
	}
S
Sujith 已提交
671

672
	ath9k_ps_wakeup(sc);
673
	spin_lock(&sc->sc_pcu_lock);
674

675 676 677 678 679 680 681 682 683
	/*
	 * Only run the baseband hang check if beacons stop working in AP or
	 * IBSS mode, because it has a high false positive rate. For station
	 * mode it should not be necessary, since the upper layers will detect
	 * this through a beacon miss automatically and the following channel
	 * change will trigger a hardware reset anyway
	 */
	if (ath9k_hw_numtxpending(ah, sc->beacon.beaconq) != 0 &&
	    !ath9k_hw_check_alive(ah))
684 685
		ieee80211_queue_work(sc->hw, &sc->hw_check_work);

686 687 688 689 690 691 692 693 694 695 696
	if ((status & ATH9K_INT_TSFOOR) && sc->ps_enabled) {
		/*
		 * TSF sync does not look correct; remain awake to sync with
		 * the next Beacon.
		 */
		ath_dbg(common, ATH_DBG_PS,
			"TSFOOR - Sync with next Beacon\n");
		sc->ps_flags |= PS_WAIT_FOR_BEACON | PS_BEACON_SYNC |
				PS_TSFOOR_SYNC;
	}

F
Felix Fietkau 已提交
697 698 699 700 701 702 703 704 705 706 707 708 709
	if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
		rxmask = (ATH9K_INT_RXHP | ATH9K_INT_RXLP | ATH9K_INT_RXEOL |
			  ATH9K_INT_RXORN);
	else
		rxmask = (ATH9K_INT_RX | ATH9K_INT_RXEOL | ATH9K_INT_RXORN);

	if (status & rxmask) {
		/* Check for high priority Rx first */
		if ((ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) &&
		    (status & ATH9K_INT_RXHP))
			ath_rx_tasklet(sc, 0, true);

		ath_rx_tasklet(sc, 0, false);
S
Sujith 已提交
710 711
	}

712 713 714 715 716 717
	if (status & ATH9K_INT_TX) {
		if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
			ath_tx_edma_tasklet(sc);
		else
			ath_tx_tasklet(sc);
	}
S
Sujith 已提交
718

719
	if (ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
720 721 722
		if (status & ATH9K_INT_GENTIMER)
			ath_gen_timer_isr(sc->sc_ah);

S
Sujith 已提交
723
	/* re-enable hardware interrupt */
724
	ath9k_hw_enable_interrupts(ah);
725

726
	spin_unlock(&sc->sc_pcu_lock);
727
	ath9k_ps_restore(sc);
S
Sujith 已提交
728 729
}

730
irqreturn_t ath_isr(int irq, void *dev)
S
Sujith 已提交
731
{
S
Sujith 已提交
732 733
#define SCHED_INTR (				\
		ATH9K_INT_FATAL |		\
734
		ATH9K_INT_BB_WATCHDOG |		\
S
Sujith 已提交
735 736 737
		ATH9K_INT_RXORN |		\
		ATH9K_INT_RXEOL |		\
		ATH9K_INT_RX |			\
F
Felix Fietkau 已提交
738 739
		ATH9K_INT_RXLP |		\
		ATH9K_INT_RXHP |		\
S
Sujith 已提交
740 741 742
		ATH9K_INT_TX |			\
		ATH9K_INT_BMISS |		\
		ATH9K_INT_CST |			\
743 744
		ATH9K_INT_TSFOOR |		\
		ATH9K_INT_GENTIMER)
S
Sujith 已提交
745

S
Sujith 已提交
746
	struct ath_softc *sc = dev;
747
	struct ath_hw *ah = sc->sc_ah;
748
	struct ath_common *common = ath9k_hw_common(ah);
S
Sujith 已提交
749 750 751
	enum ath9k_int status;
	bool sched = false;

S
Sujith 已提交
752 753 754 755 756 757 758
	/*
	 * The hardware is not ready/present, don't
	 * touch anything. Note this can happen early
	 * on if the IRQ is shared.
	 */
	if (sc->sc_flags & SC_OP_INVALID)
		return IRQ_NONE;
S
Sujith 已提交
759

S
Sujith 已提交
760 761 762

	/* shared irq, not for us */

763
	if (!ath9k_hw_intrpend(ah))
S
Sujith 已提交
764 765 766 767 768 769 770 771 772
		return IRQ_NONE;

	/*
	 * Figure out the reason(s) for the interrupt.  Note
	 * that the hal returns a pseudo-ISR that may include
	 * bits we haven't explicitly enabled so we mask the
	 * value to insure we only process bits we requested.
	 */
	ath9k_hw_getisr(ah, &status);	/* NB: clears ISR too */
P
Pavel Roskin 已提交
773
	status &= ah->imask;	/* discard unasked-for bits */
S
Sujith 已提交
774

S
Sujith 已提交
775 776 777 778
	/*
	 * If there are no status bits set, then this interrupt was not
	 * for me (should have been caught above).
	 */
779
	if (!status)
S
Sujith 已提交
780
		return IRQ_NONE;
S
Sujith 已提交
781

S
Sujith 已提交
782 783 784 785 786 787 788 789 790 791
	/* Cache the status */
	sc->intrstatus = status;

	if (status & SCHED_INTR)
		sched = true;

	/*
	 * If a FATAL or RXORN interrupt is received, we have to reset the
	 * chip immediately.
	 */
F
Felix Fietkau 已提交
792 793
	if ((status & ATH9K_INT_FATAL) || ((status & ATH9K_INT_RXORN) &&
	    !(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)))
S
Sujith 已提交
794 795
		goto chip_reset;

796 797
	if ((ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) &&
	    (status & ATH9K_INT_BB_WATCHDOG)) {
798 799 800

		spin_lock(&common->cc_lock);
		ath_hw_cycle_counters_update(common);
801
		ar9003_hw_bb_watchdog_dbg_info(ah);
802 803
		spin_unlock(&common->cc_lock);

804 805 806
		goto chip_reset;
	}

S
Sujith 已提交
807 808 809 810 811 812
	if (status & ATH9K_INT_SWBA)
		tasklet_schedule(&sc->bcon_tasklet);

	if (status & ATH9K_INT_TXURN)
		ath9k_hw_updatetxtriglevel(ah, true);

F
Felix Fietkau 已提交
813 814 815 816 817 818 819
	if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) {
		if (status & ATH9K_INT_RXEOL) {
			ah->imask &= ~(ATH9K_INT_RXEOL | ATH9K_INT_RXORN);
			ath9k_hw_set_interrupts(ah, ah->imask);
		}
	}

S
Sujith 已提交
820
	if (status & ATH9K_INT_MIB) {
S
Sujith 已提交
821
		/*
S
Sujith 已提交
822 823 824
		 * Disable interrupts until we service the MIB
		 * interrupt; otherwise it will continue to
		 * fire.
S
Sujith 已提交
825
		 */
826
		ath9k_hw_disable_interrupts(ah);
S
Sujith 已提交
827 828 829 830 831
		/*
		 * Let the hal handle the event. We assume
		 * it will clear whatever condition caused
		 * the interrupt.
		 */
832
		spin_lock(&common->cc_lock);
833
		ath9k_hw_proc_mib_event(ah);
834
		spin_unlock(&common->cc_lock);
835
		ath9k_hw_enable_interrupts(ah);
S
Sujith 已提交
836
	}
S
Sujith 已提交
837

838 839
	if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
		if (status & ATH9K_INT_TIM_TIMER) {
840 841
			if (ATH_DBG_WARN_ON_ONCE(sc->ps_idle))
				goto chip_reset;
S
Sujith 已提交
842 843
			/* Clear RxAbort bit so that we can
			 * receive frames */
844
			ath9k_setpower(sc, ATH9K_PM_AWAKE);
845
			ath9k_hw_setrxabort(sc->sc_ah, 0);
S
Sujith 已提交
846
			sc->ps_flags |= PS_WAIT_FOR_BEACON;
S
Sujith 已提交
847
		}
S
Sujith 已提交
848 849

chip_reset:
S
Sujith 已提交
850

851 852
	ath_debug_stat_interrupt(sc, status);

S
Sujith 已提交
853
	if (sched) {
854 855
		/* turn off every interrupt */
		ath9k_hw_disable_interrupts(ah);
S
Sujith 已提交
856 857 858 859
		tasklet_schedule(&sc->intr_tq);
	}

	return IRQ_HANDLED;
S
Sujith 已提交
860 861

#undef SCHED_INTR
S
Sujith 已提交
862 863
}

864
static void ath_radio_enable(struct ath_softc *sc, struct ieee80211_hw *hw)
865
{
866
	struct ath_hw *ah = sc->sc_ah;
867
	struct ath_common *common = ath9k_hw_common(ah);
868
	struct ieee80211_channel *channel = hw->conf.channel;
869
	int r;
870

871
	ath9k_ps_wakeup(sc);
872 873
	spin_lock_bh(&sc->sc_pcu_lock);

V
Vivek Natarajan 已提交
874
	ath9k_hw_configpcipowersave(ah, 0, 0);
875

876
	if (!ah->curchan)
877
		ah->curchan = ath9k_cmn_get_curchannel(sc->hw, ah);
878

879
	r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
880
	if (r) {
881 882 883
		ath_err(common,
			"Unable to reset channel (%u MHz), reset status %d\n",
			channel->center_freq, r);
884 885
	}

886 887
	ath9k_cmn_update_txpow(ah, sc->curtxpow,
			       sc->config.txpowlimit, &sc->curtxpow);
888
	if (ath_startrecv(sc) != 0) {
889
		ath_err(common, "Unable to restart recv logic\n");
890
		goto out;
891 892
	}
	if (sc->sc_flags & SC_OP_BEACONS)
893
		ath_set_beacon(sc);	/* restart beacons */
894 895

	/* Re-Enable  interrupts */
P
Pavel Roskin 已提交
896
	ath9k_hw_set_interrupts(ah, ah->imask);
897 898

	/* Enable LED */
899
	ath9k_hw_cfg_output(ah, ah->led_pin,
900
			    AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
901
	ath9k_hw_set_gpio(ah, ah->led_pin, 0);
902

903
	ieee80211_wake_queues(hw);
904 905
	ieee80211_queue_delayed_work(hw, &sc->hw_pll_work, HZ/2);

906
out:
907 908
	spin_unlock_bh(&sc->sc_pcu_lock);

909
	ath9k_ps_restore(sc);
910 911
}

912
void ath_radio_disable(struct ath_softc *sc, struct ieee80211_hw *hw)
913
{
914
	struct ath_hw *ah = sc->sc_ah;
915
	struct ieee80211_channel *channel = hw->conf.channel;
916
	int r;
917

918
	ath9k_ps_wakeup(sc);
919 920
	cancel_delayed_work_sync(&sc->hw_pll_work);

921 922
	spin_lock_bh(&sc->sc_pcu_lock);

923
	ieee80211_stop_queues(hw);
924

925 926 927 928 929 930 931 932
	/*
	 * Keep the LED on when the radio is disabled
	 * during idle unassociated state.
	 */
	if (!sc->ps_idle) {
		ath9k_hw_set_gpio(ah, ah->led_pin, 1);
		ath9k_hw_cfg_gpio_input(ah, ah->led_pin);
	}
933 934

	/* Disable interrupts */
935
	ath9k_hw_disable_interrupts(ah);
936

S
Sujith 已提交
937
	ath_drain_all_txq(sc, false);	/* clear pending tx frames */
938

939 940 941
	ath_stoprecv(sc);		/* turn off frame recv */
	ath_flushrecv(sc);		/* flush recv queue */

942
	if (!ah->curchan)
943
		ah->curchan = ath9k_cmn_get_curchannel(hw, ah);
944

945
	r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
946
	if (r) {
947 948 949
		ath_err(ath9k_hw_common(sc->sc_ah),
			"Unable to reset channel (%u MHz), reset status %d\n",
			channel->center_freq, r);
950 951 952
	}

	ath9k_hw_phy_disable(ah);
953

V
Vivek Natarajan 已提交
954
	ath9k_hw_configpcipowersave(ah, 1, 1);
955 956

	spin_unlock_bh(&sc->sc_pcu_lock);
957
	ath9k_ps_restore(sc);
958 959
}

S
Sujith 已提交
960 961
int ath_reset(struct ath_softc *sc, bool retry_tx)
{
962
	struct ath_hw *ah = sc->sc_ah;
963
	struct ath_common *common = ath9k_hw_common(ah);
964
	struct ieee80211_hw *hw = sc->hw;
965
	int r;
S
Sujith 已提交
966

967 968
	sc->hw_busy_count = 0;

S
Sujith 已提交
969 970 971
	/* Stop ANI */
	del_timer_sync(&common->ani.timer);

972
	ath9k_ps_wakeup(sc);
973 974
	spin_lock_bh(&sc->sc_pcu_lock);

S
Sujith 已提交
975 976
	ieee80211_stop_queues(hw);

977
	ath9k_hw_disable_interrupts(ah);
S
Sujith 已提交
978
	ath_drain_all_txq(sc, retry_tx);
979

S
Sujith 已提交
980 981 982
	ath_stoprecv(sc);
	ath_flushrecv(sc);

983
	r = ath9k_hw_reset(ah, sc->sc_ah->curchan, ah->caldata, false);
984
	if (r)
985 986
		ath_err(common,
			"Unable to reset hardware; reset status %d\n", r);
S
Sujith 已提交
987 988

	if (ath_startrecv(sc) != 0)
989
		ath_err(common, "Unable to start recv logic\n");
S
Sujith 已提交
990 991 992 993 994 995

	/*
	 * We may be doing a reset in response to a request
	 * that changes the channel so update any state that
	 * might change as a result.
	 */
996 997
	ath9k_cmn_update_txpow(ah, sc->curtxpow,
			       sc->config.txpowlimit, &sc->curtxpow);
S
Sujith 已提交
998

999
	if ((sc->sc_flags & SC_OP_BEACONS) || !(sc->sc_flags & (SC_OP_OFFCHANNEL)))
1000
		ath_set_beacon(sc);	/* restart beacons */
S
Sujith 已提交
1001

P
Pavel Roskin 已提交
1002
	ath9k_hw_set_interrupts(ah, ah->imask);
S
Sujith 已提交
1003 1004 1005 1006 1007

	if (retry_tx) {
		int i;
		for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
			if (ATH_TXQ_SETUP(sc, i)) {
S
Sujith 已提交
1008 1009 1010
				spin_lock_bh(&sc->tx.txq[i].axq_lock);
				ath_txq_schedule(sc, &sc->tx.txq[i]);
				spin_unlock_bh(&sc->tx.txq[i].axq_lock);
S
Sujith 已提交
1011 1012 1013 1014
			}
		}
	}

S
Sujith 已提交
1015
	ieee80211_wake_queues(hw);
1016
	spin_unlock_bh(&sc->sc_pcu_lock);
S
Sujith 已提交
1017

S
Sujith 已提交
1018 1019
	/* Start ANI */
	ath_start_ani(common);
1020
	ath9k_ps_restore(sc);
S
Sujith 已提交
1021

1022
	return r;
S
Sujith 已提交
1023 1024 1025 1026 1027 1028
}

/**********************/
/* mac80211 callbacks */
/**********************/

1029
static int ath9k_start(struct ieee80211_hw *hw)
1030
{
1031
	struct ath_softc *sc = hw->priv;
1032
	struct ath_hw *ah = sc->sc_ah;
1033
	struct ath_common *common = ath9k_hw_common(ah);
1034
	struct ieee80211_channel *curchan = hw->conf.channel;
S
Sujith 已提交
1035
	struct ath9k_channel *init_channel;
1036
	int r;
1037

J
Joe Perches 已提交
1038 1039 1040
	ath_dbg(common, ATH_DBG_CONFIG,
		"Starting driver with initial channel: %d MHz\n",
		curchan->center_freq);
1041

1042 1043
	ath9k_ps_wakeup(sc);

1044 1045
	mutex_lock(&sc->mutex);

1046
	/* setup initial channel */
1047
	sc->chan_idx = curchan->hw_value;
1048

1049
	init_channel = ath9k_cmn_get_curchannel(hw, ah);
S
Sujith 已提交
1050 1051

	/* Reset SERDES registers */
1052
	ath9k_hw_configpcipowersave(ah, 0, 0);
S
Sujith 已提交
1053 1054 1055 1056 1057 1058 1059 1060

	/*
	 * The basic interface to setting the hardware in a good
	 * state is ``reset''.  On return the hardware is known to
	 * be powered up and with interrupts disabled.  This must
	 * be followed by initialization of the appropriate bits
	 * and then setup of the interrupt mask.
	 */
1061
	spin_lock_bh(&sc->sc_pcu_lock);
1062
	r = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
1063
	if (r) {
1064 1065 1066
		ath_err(common,
			"Unable to reset hardware; reset status %d (freq %u MHz)\n",
			r, curchan->center_freq);
1067
		spin_unlock_bh(&sc->sc_pcu_lock);
1068
		goto mutex_unlock;
S
Sujith 已提交
1069 1070 1071 1072 1073 1074
	}

	/*
	 * This is needed only to setup initial state
	 * but it's best done after a reset.
	 */
1075 1076
	ath9k_cmn_update_txpow(ah, sc->curtxpow,
			sc->config.txpowlimit, &sc->curtxpow);
1077

S
Sujith 已提交
1078 1079 1080 1081 1082 1083 1084 1085
	/*
	 * Setup the hardware after reset:
	 * The receive engine is set going.
	 * Frame transmit is handled entirely
	 * in the frame output path; there's nothing to do
	 * here except setup the interrupt mask.
	 */
	if (ath_startrecv(sc) != 0) {
1086
		ath_err(common, "Unable to start recv logic\n");
1087
		r = -EIO;
1088
		spin_unlock_bh(&sc->sc_pcu_lock);
1089
		goto mutex_unlock;
1090
	}
1091
	spin_unlock_bh(&sc->sc_pcu_lock);
1092

S
Sujith 已提交
1093
	/* Setup our intr mask. */
F
Felix Fietkau 已提交
1094 1095 1096 1097 1098
	ah->imask = ATH9K_INT_TX | ATH9K_INT_RXEOL |
		    ATH9K_INT_RXORN | ATH9K_INT_FATAL |
		    ATH9K_INT_GLOBAL;

	if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
1099 1100 1101
		ah->imask |= ATH9K_INT_RXHP |
			     ATH9K_INT_RXLP |
			     ATH9K_INT_BB_WATCHDOG;
F
Felix Fietkau 已提交
1102 1103
	else
		ah->imask |= ATH9K_INT_RX;
S
Sujith 已提交
1104

1105
	ah->imask |= ATH9K_INT_GTT;
S
Sujith 已提交
1106

1107
	if (ah->caps.hw_caps & ATH9K_HW_CAP_HT)
P
Pavel Roskin 已提交
1108
		ah->imask |= ATH9K_INT_CST;
S
Sujith 已提交
1109 1110

	sc->sc_flags &= ~SC_OP_INVALID;
1111
	sc->sc_ah->is_monitoring = false;
S
Sujith 已提交
1112 1113

	/* Disable BMISS interrupt when we're not associated */
P
Pavel Roskin 已提交
1114 1115
	ah->imask &= ~(ATH9K_INT_SWBA | ATH9K_INT_BMISS);
	ath9k_hw_set_interrupts(ah, ah->imask);
S
Sujith 已提交
1116

1117
	ieee80211_wake_queues(hw);
S
Sujith 已提交
1118

1119
	ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work, 0);
1120

1121 1122
	if ((ah->btcoex_hw.scheme != ATH_BTCOEX_CFG_NONE) &&
	    !ah->btcoex_hw.enabled) {
1123 1124
		ath9k_hw_btcoex_set_weight(ah, AR_BT_COEX_WGHT,
					   AR_STOMP_LOW_WLAN_WGHT);
1125
		ath9k_hw_btcoex_enable(ah);
1126

1127 1128
		if (common->bus_ops->bt_coex_prep)
			common->bus_ops->bt_coex_prep(common);
1129
		if (ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
1130
			ath9k_btcoex_timer_resume(sc);
1131 1132
	}

1133 1134 1135
	if (ah->caps.pcie_lcr_extsync_en && common->bus_ops->extn_synch_en)
		common->bus_ops->extn_synch_en(common);

1136 1137 1138
mutex_unlock:
	mutex_unlock(&sc->mutex);

1139 1140
	ath9k_ps_restore(sc);

1141
	return r;
1142 1143
}

1144
static void ath9k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
1145
{
1146
	struct ath_softc *sc = hw->priv;
1147
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
S
Sujith 已提交
1148
	struct ath_tx_control txctl;
1149
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
S
Sujith 已提交
1150

1151
	if (sc->ps_enabled) {
1152 1153 1154 1155 1156 1157 1158
		/*
		 * mac80211 does not set PM field for normal data frames, so we
		 * need to update that based on the current PS mode.
		 */
		if (ieee80211_is_data(hdr->frame_control) &&
		    !ieee80211_is_nullfunc(hdr->frame_control) &&
		    !ieee80211_has_pm(hdr->frame_control)) {
J
Joe Perches 已提交
1159 1160
			ath_dbg(common, ATH_DBG_PS,
				"Add PM=1 for a TX frame while in PS mode\n");
1161 1162 1163 1164
			hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
		}
	}

1165 1166 1167 1168 1169 1170 1171
	if (unlikely(sc->sc_ah->power_mode != ATH9K_PM_AWAKE)) {
		/*
		 * We are using PS-Poll and mac80211 can request TX while in
		 * power save mode. Need to wake up hardware for the TX to be
		 * completed and if needed, also for RX of buffered frames.
		 */
		ath9k_ps_wakeup(sc);
1172 1173
		if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
			ath9k_hw_setrxabort(sc->sc_ah, 0);
1174
		if (ieee80211_is_pspoll(hdr->frame_control)) {
J
Joe Perches 已提交
1175 1176
			ath_dbg(common, ATH_DBG_PS,
				"Sending PS-Poll to pick a buffered frame\n");
S
Sujith 已提交
1177
			sc->ps_flags |= PS_WAIT_FOR_PSPOLL_DATA;
1178
		} else {
J
Joe Perches 已提交
1179 1180
			ath_dbg(common, ATH_DBG_PS,
				"Wake up to complete TX\n");
S
Sujith 已提交
1181
			sc->ps_flags |= PS_WAIT_FOR_TX_ACK;
1182 1183 1184 1185 1186 1187 1188 1189 1190
		}
		/*
		 * The actual restore operation will happen only after
		 * the sc_flags bit is cleared. We are just dropping
		 * the ps_usecount here.
		 */
		ath9k_ps_restore(sc);
	}

S
Sujith 已提交
1191
	memset(&txctl, 0, sizeof(struct ath_tx_control));
1192
	txctl.txq = sc->tx.txq_map[skb_get_queue_mapping(skb)];
S
Sujith 已提交
1193

J
Joe Perches 已提交
1194
	ath_dbg(common, ATH_DBG_XMIT, "transmitting packet, skb: %p\n", skb);
1195

1196
	if (ath_tx_start(hw, skb, &txctl) != 0) {
J
Joe Perches 已提交
1197
		ath_dbg(common, ATH_DBG_XMIT, "TX failed\n");
S
Sujith 已提交
1198
		goto exit;
1199 1200
	}

1201
	return;
S
Sujith 已提交
1202 1203
exit:
	dev_kfree_skb_any(skb);
1204 1205
}

1206
static void ath9k_stop(struct ieee80211_hw *hw)
1207
{
1208
	struct ath_softc *sc = hw->priv;
1209
	struct ath_hw *ah = sc->sc_ah;
1210
	struct ath_common *common = ath9k_hw_common(ah);
1211

S
Sujith 已提交
1212 1213
	mutex_lock(&sc->mutex);

1214
	cancel_delayed_work_sync(&sc->tx_complete_work);
1215
	cancel_delayed_work_sync(&sc->hw_pll_work);
1216
	cancel_work_sync(&sc->paprd_work);
1217
	cancel_work_sync(&sc->hw_check_work);
1218

S
Sujith 已提交
1219
	if (sc->sc_flags & SC_OP_INVALID) {
J
Joe Perches 已提交
1220
		ath_dbg(common, ATH_DBG_ANY, "Device not present\n");
S
Sujith 已提交
1221
		mutex_unlock(&sc->mutex);
S
Sujith 已提交
1222 1223
		return;
	}
1224

1225 1226 1227
	/* Ensure HW is awake when we try to shut it down. */
	ath9k_ps_wakeup(sc);

1228
	if (ah->btcoex_hw.enabled) {
1229
		ath9k_hw_btcoex_disable(ah);
1230
		if (ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
1231
			ath9k_btcoex_timer_pause(sc);
1232 1233
	}

1234 1235
	spin_lock_bh(&sc->sc_pcu_lock);

1236 1237 1238
	/* prevent tasklets to enable interrupts once we disable them */
	ah->imask &= ~ATH9K_INT_GLOBAL;

S
Sujith 已提交
1239 1240
	/* make sure h/w will not generate any interrupt
	 * before setting the invalid flag. */
1241
	ath9k_hw_disable_interrupts(ah);
S
Sujith 已提交
1242 1243

	if (!(sc->sc_flags & SC_OP_INVALID)) {
S
Sujith 已提交
1244
		ath_drain_all_txq(sc, false);
S
Sujith 已提交
1245
		ath_stoprecv(sc);
1246
		ath9k_hw_phy_disable(ah);
1247
	} else
S
Sujith 已提交
1248
		sc->rx.rxlink = NULL;
S
Sujith 已提交
1249

1250 1251 1252 1253 1254
	if (sc->rx.frag) {
		dev_kfree_skb_any(sc->rx.frag);
		sc->rx.frag = NULL;
	}

S
Sujith 已提交
1255
	/* disable HAL and put h/w to sleep */
1256 1257
	ath9k_hw_disable(ah);
	ath9k_hw_configpcipowersave(ah, 1, 1);
1258 1259 1260

	spin_unlock_bh(&sc->sc_pcu_lock);

1261 1262 1263 1264 1265 1266
	/* we can now sync irq and kill any running tasklets, since we already
	 * disabled interrupts and not holding a spin lock */
	synchronize_irq(sc->irq);
	tasklet_kill(&sc->intr_tq);
	tasklet_kill(&sc->bcon_tasklet);

1267 1268
	ath9k_ps_restore(sc);

1269 1270
	sc->ps_idle = true;
	ath_radio_disable(sc, hw);
S
Sujith 已提交
1271 1272

	sc->sc_flags |= SC_OP_INVALID;
1273

1274 1275
	mutex_unlock(&sc->mutex);

J
Joe Perches 已提交
1276
	ath_dbg(common, ATH_DBG_CONFIG, "Driver halt\n");
1277 1278
}

1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292
bool ath9k_uses_beacons(int type)
{
	switch (type) {
	case NL80211_IFTYPE_AP:
	case NL80211_IFTYPE_ADHOC:
	case NL80211_IFTYPE_MESH_POINT:
		return true;
	default:
		return false;
	}
}

static void ath9k_reclaim_beacon(struct ath_softc *sc,
				 struct ieee80211_vif *vif)
1293
{
1294
	struct ath_vif *avp = (void *)vif->drv_priv;
1295

1296
	ath9k_set_beaconing_status(sc, false);
1297
	ath_beacon_return(sc, avp);
1298
	ath9k_set_beaconing_status(sc, true);
1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310
	sc->sc_flags &= ~SC_OP_BEACONS;
}

static void ath9k_vif_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
{
	struct ath9k_vif_iter_data *iter_data = data;
	int i;

	if (iter_data->hw_macaddr)
		for (i = 0; i < ETH_ALEN; i++)
			iter_data->mask[i] &=
				~(iter_data->hw_macaddr[i] ^ mac[i]);
1311

1312
	switch (vif->type) {
1313 1314
	case NL80211_IFTYPE_AP:
		iter_data->naps++;
1315
		break;
1316 1317
	case NL80211_IFTYPE_STATION:
		iter_data->nstations++;
B
Bill Jordan 已提交
1318
		break;
1319
	case NL80211_IFTYPE_ADHOC:
1320 1321
		iter_data->nadhocs++;
		break;
1322
	case NL80211_IFTYPE_MESH_POINT:
1323 1324 1325 1326
		iter_data->nmeshes++;
		break;
	case NL80211_IFTYPE_WDS:
		iter_data->nwds++;
1327 1328
		break;
	default:
1329 1330
		iter_data->nothers++;
		break;
1331
	}
1332
}
1333

1334 1335 1336 1337 1338
/* Called with sc->mutex held. */
void ath9k_calculate_iter_data(struct ieee80211_hw *hw,
			       struct ieee80211_vif *vif,
			       struct ath9k_vif_iter_data *iter_data)
{
1339
	struct ath_softc *sc = hw->priv;
1340 1341
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
1342

1343 1344 1345 1346 1347 1348 1349
	/*
	 * Use the hardware MAC address as reference, the hardware uses it
	 * together with the BSSID mask when matching addresses.
	 */
	memset(iter_data, 0, sizeof(*iter_data));
	iter_data->hw_macaddr = common->macaddr;
	memset(&iter_data->mask, 0xff, ETH_ALEN);
S
Sujith 已提交
1350

1351 1352 1353 1354 1355 1356 1357
	if (vif)
		ath9k_vif_iter(iter_data, vif->addr, vif);

	/* Get list of all active MAC addresses */
	ieee80211_iterate_active_interfaces_atomic(sc->hw, ath9k_vif_iter,
						   iter_data);
}
1358

1359 1360 1361 1362
/* Called with sc->mutex held. */
static void ath9k_calculate_summary_state(struct ieee80211_hw *hw,
					  struct ieee80211_vif *vif)
{
1363
	struct ath_softc *sc = hw->priv;
1364 1365 1366
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
	struct ath9k_vif_iter_data iter_data;
1367

1368
	ath9k_calculate_iter_data(hw, vif, &iter_data);
1369

1370 1371 1372 1373 1374 1375
	/* Set BSSID mask. */
	memcpy(common->bssidmask, iter_data.mask, ETH_ALEN);
	ath_hw_setbssidmask(common);

	/* Set op-mode & TSF */
	if (iter_data.naps > 0) {
P
Pavel Roskin 已提交
1376
		ath9k_hw_set_tsfadjust(ah, 1);
S
Sujith 已提交
1377
		sc->sc_flags |= SC_OP_TSF_RESET;
1378 1379 1380 1381
		ah->opmode = NL80211_IFTYPE_AP;
	} else {
		ath9k_hw_set_tsfadjust(ah, 0);
		sc->sc_flags &= ~SC_OP_TSF_RESET;
S
Sujith 已提交
1382

1383 1384 1385
		if (iter_data.nmeshes)
			ah->opmode = NL80211_IFTYPE_MESH_POINT;
		else if (iter_data.nwds)
1386 1387 1388 1389 1390 1391
			ah->opmode = NL80211_IFTYPE_AP;
		else if (iter_data.nadhocs)
			ah->opmode = NL80211_IFTYPE_ADHOC;
		else
			ah->opmode = NL80211_IFTYPE_STATION;
	}
S
Sujith 已提交
1392

1393 1394 1395
	/*
	 * Enable MIB interrupts when there are hardware phy counters.
	 */
1396
	if ((iter_data.nstations + iter_data.nadhocs + iter_data.nmeshes) > 0) {
1397 1398
		if (ah->config.enable_ani)
			ah->imask |= ATH9K_INT_MIB;
P
Pavel Roskin 已提交
1399
		ah->imask |= ATH9K_INT_TSFOOR;
1400 1401 1402
	} else {
		ah->imask &= ~ATH9K_INT_MIB;
		ah->imask &= ~ATH9K_INT_TSFOOR;
1403 1404
	}

P
Pavel Roskin 已提交
1405
	ath9k_hw_set_interrupts(ah, ah->imask);
1406

1407 1408
	/* Set up ANI */
	if ((iter_data.naps + iter_data.nadhocs) > 0) {
1409
		sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
1410
		sc->sc_flags |= SC_OP_ANI_RUN;
1411
		ath_start_ani(common);
1412 1413 1414
	} else {
		sc->sc_flags &= ~SC_OP_ANI_RUN;
		del_timer_sync(&common->ani.timer);
1415
	}
1416
}
1417

1418 1419 1420 1421
/* Called with sc->mutex held, vif counts set up properly. */
static void ath9k_do_vif_add_setup(struct ieee80211_hw *hw,
				   struct ieee80211_vif *vif)
{
1422
	struct ath_softc *sc = hw->priv;
1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433

	ath9k_calculate_summary_state(hw, vif);

	if (ath9k_uses_beacons(vif->type)) {
		int error;
		/* This may fail because upper levels do not have beacons
		 * properly configured yet.  That's OK, we assume it
		 * will be properly configured and then we will be notified
		 * in the info_changed method and set up beacons properly
		 * there.
		 */
1434
		ath9k_set_beaconing_status(sc, false);
1435
		error = ath_beacon_alloc(sc, vif);
1436
		if (!error)
1437
			ath_beacon_config(sc, vif);
1438
		ath9k_set_beaconing_status(sc, true);
1439
	}
1440 1441
}

1442 1443 1444

static int ath9k_add_interface(struct ieee80211_hw *hw,
			       struct ieee80211_vif *vif)
1445
{
1446
	struct ath_softc *sc = hw->priv;
1447 1448 1449
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
	int ret = 0;
1450

1451
	ath9k_ps_wakeup(sc);
1452
	mutex_lock(&sc->mutex);
1453

1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466
	switch (vif->type) {
	case NL80211_IFTYPE_STATION:
	case NL80211_IFTYPE_WDS:
	case NL80211_IFTYPE_ADHOC:
	case NL80211_IFTYPE_AP:
	case NL80211_IFTYPE_MESH_POINT:
		break;
	default:
		ath_err(common, "Interface type %d not yet supported\n",
			vif->type);
		ret = -EOPNOTSUPP;
		goto out;
	}
1467

1468 1469 1470 1471 1472 1473 1474 1475 1476 1477
	if (ath9k_uses_beacons(vif->type)) {
		if (sc->nbcnvifs >= ATH_BCBUF) {
			ath_err(common, "Not enough beacon buffers when adding"
				" new interface of type: %i\n",
				vif->type);
			ret = -ENOBUFS;
			goto out;
		}
	}

1478 1479 1480
	if ((ah->opmode == NL80211_IFTYPE_ADHOC) ||
	    ((vif->type == NL80211_IFTYPE_ADHOC) &&
	     sc->nvifs > 0)) {
1481 1482 1483 1484
		ath_err(common, "Cannot create ADHOC interface when other"
			" interfaces already exist.\n");
		ret = -EINVAL;
		goto out;
1485
	}
1486 1487 1488 1489 1490 1491 1492 1493 1494

	ath_dbg(common, ATH_DBG_CONFIG,
		"Attach a VIF of type: %d\n", vif->type);

	sc->nvifs++;

	ath9k_do_vif_add_setup(hw, vif);
out:
	mutex_unlock(&sc->mutex);
1495
	ath9k_ps_restore(sc);
1496
	return ret;
1497 1498 1499 1500 1501 1502 1503
}

static int ath9k_change_interface(struct ieee80211_hw *hw,
				  struct ieee80211_vif *vif,
				  enum nl80211_iftype new_type,
				  bool p2p)
{
1504
	struct ath_softc *sc = hw->priv;
1505
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1506
	int ret = 0;
1507 1508 1509

	ath_dbg(common, ATH_DBG_CONFIG, "Change Interface\n");
	mutex_lock(&sc->mutex);
1510
	ath9k_ps_wakeup(sc);
1511

1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522
	/* See if new interface type is valid. */
	if ((new_type == NL80211_IFTYPE_ADHOC) &&
	    (sc->nvifs > 1)) {
		ath_err(common, "When using ADHOC, it must be the only"
			" interface.\n");
		ret = -EINVAL;
		goto out;
	}

	if (ath9k_uses_beacons(new_type) &&
	    !ath9k_uses_beacons(vif->type)) {
1523 1524
		if (sc->nbcnvifs >= ATH_BCBUF) {
			ath_err(common, "No beacon slot available\n");
1525 1526
			ret = -ENOBUFS;
			goto out;
1527 1528
		}
	}
1529 1530 1531 1532 1533 1534

	/* Clean up old vif stuff */
	if (ath9k_uses_beacons(vif->type))
		ath9k_reclaim_beacon(sc, vif);

	/* Add new settings */
1535 1536 1537
	vif->type = new_type;
	vif->p2p = p2p;

1538
	ath9k_do_vif_add_setup(hw, vif);
1539
out:
1540
	ath9k_ps_restore(sc);
1541
	mutex_unlock(&sc->mutex);
1542
	return ret;
1543 1544
}

1545
static void ath9k_remove_interface(struct ieee80211_hw *hw,
1546
				   struct ieee80211_vif *vif)
1547
{
1548
	struct ath_softc *sc = hw->priv;
1549
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1550

J
Joe Perches 已提交
1551
	ath_dbg(common, ATH_DBG_CONFIG, "Detach Interface\n");
1552

1553
	ath9k_ps_wakeup(sc);
1554 1555
	mutex_lock(&sc->mutex);

1556
	sc->nvifs--;
J
Jouni Malinen 已提交
1557

1558
	/* Reclaim beacon resources */
1559
	if (ath9k_uses_beacons(vif->type))
1560
		ath9k_reclaim_beacon(sc, vif);
1561

1562
	ath9k_calculate_summary_state(hw, NULL);
1563 1564

	mutex_unlock(&sc->mutex);
1565
	ath9k_ps_restore(sc);
1566 1567
}

1568
static void ath9k_enable_ps(struct ath_softc *sc)
1569
{
P
Pavel Roskin 已提交
1570 1571
	struct ath_hw *ah = sc->sc_ah;

1572
	sc->ps_enabled = true;
P
Pavel Roskin 已提交
1573 1574 1575 1576
	if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP)) {
		if ((ah->imask & ATH9K_INT_TIM_TIMER) == 0) {
			ah->imask |= ATH9K_INT_TIM_TIMER;
			ath9k_hw_set_interrupts(ah, ah->imask);
1577
		}
1578
		ath9k_hw_setrxabort(ah, 1);
1579 1580 1581
	}
}

1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601
static void ath9k_disable_ps(struct ath_softc *sc)
{
	struct ath_hw *ah = sc->sc_ah;

	sc->ps_enabled = false;
	ath9k_hw_setpower(ah, ATH9K_PM_AWAKE);
	if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP)) {
		ath9k_hw_setrxabort(ah, 0);
		sc->ps_flags &= ~(PS_WAIT_FOR_BEACON |
				  PS_WAIT_FOR_CAB |
				  PS_WAIT_FOR_PSPOLL_DATA |
				  PS_WAIT_FOR_TX_ACK);
		if (ah->imask & ATH9K_INT_TIM_TIMER) {
			ah->imask &= ~ATH9K_INT_TIM_TIMER;
			ath9k_hw_set_interrupts(ah, ah->imask);
		}
	}

}

1602
static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
1603
{
1604
	struct ath_softc *sc = hw->priv;
1605 1606
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
1607
	struct ieee80211_conf *conf = &hw->conf;
1608
	bool disable_radio = false;
1609

1610
	mutex_lock(&sc->mutex);
1611

1612 1613 1614 1615 1616 1617
	/*
	 * Leave this as the first check because we need to turn on the
	 * radio if it was disabled before prior to processing the rest
	 * of the changes. Likewise we must only disable the radio towards
	 * the end.
	 */
1618
	if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1619 1620
		sc->ps_idle = !!(conf->flags & IEEE80211_CONF_IDLE);
		if (!sc->ps_idle) {
1621
			ath_radio_enable(sc, hw);
J
Joe Perches 已提交
1622 1623
			ath_dbg(common, ATH_DBG_CONFIG,
				"not-idle: enabling radio\n");
1624 1625
		} else {
			disable_radio = true;
1626 1627 1628
		}
	}

1629 1630 1631 1632 1633 1634
	/*
	 * We just prepare to enable PS. We have to wait until our AP has
	 * ACK'd our null data frame to disable RX otherwise we'll ignore
	 * those ACKs and end up retransmitting the same null data frames.
	 * IEEE80211_CONF_CHANGE_PS is only passed by mac80211 for STA mode.
	 */
1635
	if (changed & IEEE80211_CONF_CHANGE_PS) {
1636 1637
		unsigned long flags;
		spin_lock_irqsave(&sc->sc_pm_lock, flags);
1638 1639
		if (conf->flags & IEEE80211_CONF_PS)
			ath9k_enable_ps(sc);
1640 1641
		else
			ath9k_disable_ps(sc);
1642
		spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
1643 1644
	}

S
Sujith 已提交
1645 1646
	if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
		if (conf->flags & IEEE80211_CONF_MONITOR) {
J
Joe Perches 已提交
1647 1648
			ath_dbg(common, ATH_DBG_CONFIG,
				"Monitor mode is enabled\n");
1649 1650
			sc->sc_ah->is_monitoring = true;
		} else {
J
Joe Perches 已提交
1651 1652
			ath_dbg(common, ATH_DBG_CONFIG,
				"Monitor mode is disabled\n");
1653
			sc->sc_ah->is_monitoring = false;
S
Sujith 已提交
1654 1655 1656
		}
	}

1657
	if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
1658
		struct ieee80211_channel *curchan = hw->conf.channel;
1659
		int pos = curchan->hw_value;
1660 1661 1662 1663 1664
		int old_pos = -1;
		unsigned long flags;

		if (ah->curchan)
			old_pos = ah->curchan - &ah->channels[0];
J
Johannes Berg 已提交
1665

1666 1667 1668 1669
		if (hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)
			sc->sc_flags |= SC_OP_OFFCHANNEL;
		else
			sc->sc_flags &= ~SC_OP_OFFCHANNEL;
1670

1671 1672 1673
		ath_dbg(common, ATH_DBG_CONFIG,
			"Set channel: %d MHz type: %d\n",
			curchan->center_freq, conf->channel_type);
1674

1675 1676
		ath9k_cmn_update_ichannel(&sc->sc_ah->channels[pos],
					  curchan, conf->channel_type);
1677

1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702
		/* update survey stats for the old channel before switching */
		spin_lock_irqsave(&common->cc_lock, flags);
		ath_update_survey_stats(sc);
		spin_unlock_irqrestore(&common->cc_lock, flags);

		/*
		 * If the operating channel changes, change the survey in-use flags
		 * along with it.
		 * Reset the survey data for the new channel, unless we're switching
		 * back to the operating channel from an off-channel operation.
		 */
		if (!(hw->conf.flags & IEEE80211_CONF_OFFCHANNEL) &&
		    sc->cur_survey != &sc->survey[pos]) {

			if (sc->cur_survey)
				sc->cur_survey->filled &= ~SURVEY_INFO_IN_USE;

			sc->cur_survey = &sc->survey[pos];

			memset(sc->cur_survey, 0, sizeof(struct survey_info));
			sc->cur_survey->filled |= SURVEY_INFO_IN_USE;
		} else if (!(sc->survey[pos].filled & SURVEY_INFO_IN_USE)) {
			memset(&sc->survey[pos], 0, sizeof(struct survey_info));
		}

1703
		if (ath_set_channel(sc, hw, &sc->sc_ah->channels[pos]) < 0) {
1704
			ath_err(common, "Unable to set channel\n");
1705
			mutex_unlock(&sc->mutex);
1706 1707
			return -EINVAL;
		}
1708 1709 1710 1711 1712 1713 1714 1715

		/*
		 * The most recent snapshot of channel->noisefloor for the old
		 * channel is only available after the hardware reset. Copy it to
		 * the survey stats now.
		 */
		if (old_pos >= 0)
			ath_update_survey_nf(sc, old_pos);
S
Sujith 已提交
1716
	}
1717

1718
	if (changed & IEEE80211_CONF_CHANGE_POWER) {
1719 1720
		ath_dbg(common, ATH_DBG_CONFIG,
			"Set power: %d\n", conf->power_level);
S
Sujith 已提交
1721
		sc->config.txpowlimit = 2 * conf->power_level;
1722
		ath9k_ps_wakeup(sc);
1723 1724
		ath9k_cmn_update_txpow(ah, sc->curtxpow,
				       sc->config.txpowlimit, &sc->curtxpow);
1725
		ath9k_ps_restore(sc);
1726
	}
1727

1728
	if (disable_radio) {
J
Joe Perches 已提交
1729
		ath_dbg(common, ATH_DBG_CONFIG, "idle: disabling radio\n");
1730
		ath_radio_disable(sc, hw);
1731 1732
	}

1733
	mutex_unlock(&sc->mutex);
1734

1735 1736 1737
	return 0;
}

1738 1739 1740 1741
#define SUPPORTED_FILTERS			\
	(FIF_PROMISC_IN_BSS |			\
	FIF_ALLMULTI |				\
	FIF_CONTROL |				\
1742
	FIF_PSPOLL |				\
1743 1744
	FIF_OTHER_BSS |				\
	FIF_BCN_PRBRESP_PROMISC |		\
1745
	FIF_PROBE_REQ |				\
1746
	FIF_FCSFAIL)
1747

1748 1749 1750 1751
/* FIXME: sc->sc_full_reset ? */
static void ath9k_configure_filter(struct ieee80211_hw *hw,
				   unsigned int changed_flags,
				   unsigned int *total_flags,
1752
				   u64 multicast)
1753
{
1754
	struct ath_softc *sc = hw->priv;
1755
	u32 rfilt;
1756

1757 1758
	changed_flags &= SUPPORTED_FILTERS;
	*total_flags &= SUPPORTED_FILTERS;
1759

S
Sujith 已提交
1760
	sc->rx.rxfilter = *total_flags;
1761
	ath9k_ps_wakeup(sc);
1762 1763
	rfilt = ath_calcrxfilter(sc);
	ath9k_hw_setrxfilter(sc->sc_ah, rfilt);
1764
	ath9k_ps_restore(sc);
1765

J
Joe Perches 已提交
1766 1767
	ath_dbg(ath9k_hw_common(sc->sc_ah), ATH_DBG_CONFIG,
		"Set HW RX filter: 0x%x\n", rfilt);
1768
}
1769

1770 1771 1772
static int ath9k_sta_add(struct ieee80211_hw *hw,
			 struct ieee80211_vif *vif,
			 struct ieee80211_sta *sta)
1773
{
1774
	struct ath_softc *sc = hw->priv;
1775 1776 1777
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
	struct ath_node *an = (struct ath_node *) sta->drv_priv;
	struct ieee80211_key_conf ps_key = { };
1778

1779
	ath_node_attach(sc, sta);
1780 1781 1782 1783 1784

	if (vif->type != NL80211_IFTYPE_AP &&
	    vif->type != NL80211_IFTYPE_AP_VLAN)
		return 0;

1785
	an->ps_key = ath_key_config(common, vif, sta, &ps_key);
1786 1787 1788 1789

	return 0;
}

1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803
static void ath9k_del_ps_key(struct ath_softc *sc,
			     struct ieee80211_vif *vif,
			     struct ieee80211_sta *sta)
{
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
	struct ath_node *an = (struct ath_node *) sta->drv_priv;
	struct ieee80211_key_conf ps_key = { .hw_key_idx = an->ps_key };

	if (!an->ps_key)
	    return;

	ath_key_delete(common, &ps_key);
}

1804 1805 1806 1807
static int ath9k_sta_remove(struct ieee80211_hw *hw,
			    struct ieee80211_vif *vif,
			    struct ieee80211_sta *sta)
{
1808
	struct ath_softc *sc = hw->priv;
1809

1810
	ath9k_del_ps_key(sc, vif, sta);
1811 1812 1813
	ath_node_detach(sc, sta);

	return 0;
1814 1815
}

1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836
static void ath9k_sta_notify(struct ieee80211_hw *hw,
			 struct ieee80211_vif *vif,
			 enum sta_notify_cmd cmd,
			 struct ieee80211_sta *sta)
{
	struct ath_softc *sc = hw->priv;
	struct ath_node *an = (struct ath_node *) sta->drv_priv;

	switch (cmd) {
	case STA_NOTIFY_SLEEP:
		an->sleeping = true;
		if (ath_tx_aggr_sleep(sc, an))
			ieee80211_sta_set_tim(sta);
		break;
	case STA_NOTIFY_AWAKE:
		an->sleeping = false;
		ath_tx_aggr_wakeup(sc, an);
		break;
	}
}

1837
static int ath9k_conf_tx(struct ieee80211_hw *hw, u16 queue,
1838
			 const struct ieee80211_tx_queue_params *params)
1839
{
1840
	struct ath_softc *sc = hw->priv;
1841
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1842
	struct ath_txq *txq;
1843
	struct ath9k_tx_queue_info qi;
1844
	int ret = 0;
1845

1846 1847
	if (queue >= WME_NUM_AC)
		return 0;
1848

1849 1850
	txq = sc->tx.txq_map[queue];

1851
	ath9k_ps_wakeup(sc);
1852 1853
	mutex_lock(&sc->mutex);

1854 1855
	memset(&qi, 0, sizeof(struct ath9k_tx_queue_info));

1856 1857 1858 1859
	qi.tqi_aifs = params->aifs;
	qi.tqi_cwmin = params->cw_min;
	qi.tqi_cwmax = params->cw_max;
	qi.tqi_burstTime = params->txop;
1860

J
Joe Perches 已提交
1861 1862 1863 1864
	ath_dbg(common, ATH_DBG_CONFIG,
		"Configure tx [queue/halq] [%d/%d], aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
		queue, txq->axq_qnum, params->aifs, params->cw_min,
		params->cw_max, params->txop);
1865

1866
	ret = ath_txq_update(sc, txq->axq_qnum, &qi);
1867
	if (ret)
1868
		ath_err(common, "TXQ Update failed\n");
1869

1870
	if (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC)
1871
		if (queue == WME_AC_BE && !ret)
1872 1873
			ath_beaconq_config(sc);

1874
	mutex_unlock(&sc->mutex);
1875
	ath9k_ps_restore(sc);
1876

1877 1878
	return ret;
}
1879

1880 1881
static int ath9k_set_key(struct ieee80211_hw *hw,
			 enum set_key_cmd cmd,
1882 1883
			 struct ieee80211_vif *vif,
			 struct ieee80211_sta *sta,
1884 1885
			 struct ieee80211_key_conf *key)
{
1886
	struct ath_softc *sc = hw->priv;
1887
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1888
	int ret = 0;
1889

1890
	if (ath9k_modparam_nohwcrypt)
1891 1892
		return -ENOSPC;

J
Jouni Malinen 已提交
1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906
	if (vif->type == NL80211_IFTYPE_ADHOC &&
	    (key->cipher == WLAN_CIPHER_SUITE_TKIP ||
	     key->cipher == WLAN_CIPHER_SUITE_CCMP) &&
	    !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
		/*
		 * For now, disable hw crypto for the RSN IBSS group keys. This
		 * could be optimized in the future to use a modified key cache
		 * design to support per-STA RX GTK, but until that gets
		 * implemented, use of software crypto for group addressed
		 * frames is a acceptable to allow RSN IBSS to be used.
		 */
		return -EOPNOTSUPP;
	}

1907
	mutex_lock(&sc->mutex);
1908
	ath9k_ps_wakeup(sc);
J
Joe Perches 已提交
1909
	ath_dbg(common, ATH_DBG_CONFIG, "Set HW Key\n");
1910

1911 1912
	switch (cmd) {
	case SET_KEY:
1913 1914 1915
		if (sta)
			ath9k_del_ps_key(sc, vif, sta);

1916
		ret = ath_key_config(common, vif, sta, key);
1917 1918
		if (ret >= 0) {
			key->hw_key_idx = ret;
1919 1920
			/* push IV and Michael MIC generation to stack */
			key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1921
			if (key->cipher == WLAN_CIPHER_SUITE_TKIP)
1922
				key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
1923 1924
			if (sc->sc_ah->sw_mgmt_crypto &&
			    key->cipher == WLAN_CIPHER_SUITE_CCMP)
1925
				key->flags |= IEEE80211_KEY_FLAG_SW_MGMT;
1926
			ret = 0;
1927 1928 1929
		}
		break;
	case DISABLE_KEY:
1930
		ath_key_delete(common, key);
1931 1932 1933 1934
		break;
	default:
		ret = -EINVAL;
	}
1935

1936
	ath9k_ps_restore(sc);
1937 1938
	mutex_unlock(&sc->mutex);

1939 1940
	return ret;
}
1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953
static void ath9k_bss_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
{
	struct ath_softc *sc = data;
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
	struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
	struct ath_vif *avp = (void *)vif->drv_priv;

	switch (sc->sc_ah->opmode) {
	case NL80211_IFTYPE_ADHOC:
		/* There can be only one vif available */
		memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
		common->curaid = bss_conf->aid;
		ath9k_hw_write_associd(sc->sc_ah);
1954 1955 1956
		/* configure beacon */
		if (bss_conf->enable_beacon)
			ath_beacon_config(sc, vif);
1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971
		break;
	case NL80211_IFTYPE_STATION:
		/*
		 * Skip iteration if primary station vif's bss info
		 * was not changed
		 */
		if (sc->sc_flags & SC_OP_PRIM_STA_VIF)
			break;

		if (bss_conf->assoc) {
			sc->sc_flags |= SC_OP_PRIM_STA_VIF;
			avp->primary_sta_vif = true;
			memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
			common->curaid = bss_conf->aid;
			ath9k_hw_write_associd(sc->sc_ah);
1972 1973 1974 1975
			ath_dbg(common, ATH_DBG_CONFIG,
				"Bss Info ASSOC %d, bssid: %pM\n",
				bss_conf->aid, common->curbssid);
			ath_beacon_config(sc, vif);
1976 1977 1978 1979 1980 1981
			/*
			 * Request a re-configuration of Beacon related timers
			 * on the receipt of the first Beacon frame (i.e.,
			 * after time sync with the AP).
			 */
			sc->ps_flags |= PS_BEACON_SYNC | PS_WAIT_FOR_BEACON;
1982 1983 1984 1985 1986 1987
			/* Reset rssi stats */
			sc->last_rssi = ATH_RSSI_DUMMY_MARKER;
			sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;

			sc->sc_flags |= SC_OP_ANI_RUN;
			ath_start_ani(common);
1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002
		}
		break;
	default:
		break;
	}
}

static void ath9k_config_bss(struct ath_softc *sc, struct ieee80211_vif *vif)
{
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
	struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
	struct ath_vif *avp = (void *)vif->drv_priv;

	/* Reconfigure bss info */
	if (avp->primary_sta_vif && !bss_conf->assoc) {
2003 2004 2005 2006
		ath_dbg(common, ATH_DBG_CONFIG,
			"Bss Info DISASSOC %d, bssid %pM\n",
			common->curaid, common->curbssid);
		sc->sc_flags &= ~(SC_OP_PRIM_STA_VIF | SC_OP_BEACONS);
2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019
		avp->primary_sta_vif = false;
		memset(common->curbssid, 0, ETH_ALEN);
		common->curaid = 0;
	}

	ieee80211_iterate_active_interfaces_atomic(
			sc->hw, ath9k_bss_iter, sc);

	/*
	 * None of station vifs are associated.
	 * Clear bssid & aid
	 */
	if ((sc->sc_ah->opmode == NL80211_IFTYPE_STATION) &&
2020
	    !(sc->sc_flags & SC_OP_PRIM_STA_VIF)) {
2021
		ath9k_hw_write_associd(sc->sc_ah);
2022 2023 2024 2025
		/* Stop ANI */
		sc->sc_flags &= ~SC_OP_ANI_RUN;
		del_timer_sync(&common->ani.timer);
	}
2026
}
2027

2028 2029 2030 2031 2032
static void ath9k_bss_info_changed(struct ieee80211_hw *hw,
				   struct ieee80211_vif *vif,
				   struct ieee80211_bss_conf *bss_conf,
				   u32 changed)
{
2033
	struct ath_softc *sc = hw->priv;
2034
	struct ath_hw *ah = sc->sc_ah;
2035
	struct ath_common *common = ath9k_hw_common(ah);
2036
	struct ath_vif *avp = (void *)vif->drv_priv;
2037
	int slottime;
S
Sujith 已提交
2038
	int error;
2039

2040
	ath9k_ps_wakeup(sc);
2041 2042
	mutex_lock(&sc->mutex);

S
Sujith 已提交
2043
	if (changed & BSS_CHANGED_BSSID) {
2044
		ath9k_config_bss(sc, vif);
2045

J
Joe Perches 已提交
2046 2047
		ath_dbg(common, ATH_DBG_CONFIG, "BSSID: %pM aid: 0x%x\n",
			common->curbssid, common->curaid);
S
Sujith 已提交
2048
	}
2049

S
Sujith 已提交
2050 2051 2052
	/* Enable transmission of beacons (AP, IBSS, MESH) */
	if ((changed & BSS_CHANGED_BEACON) ||
	    ((changed & BSS_CHANGED_BEACON_ENABLED) && bss_conf->enable_beacon)) {
2053
		ath9k_set_beaconing_status(sc, false);
2054
		error = ath_beacon_alloc(sc, vif);
S
Sujith 已提交
2055 2056
		if (!error)
			ath_beacon_config(sc, vif);
2057
		ath9k_set_beaconing_status(sc, true);
2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076
	}

	if (changed & BSS_CHANGED_ERP_SLOT) {
		if (bss_conf->use_short_slot)
			slottime = 9;
		else
			slottime = 20;
		if (vif->type == NL80211_IFTYPE_AP) {
			/*
			 * Defer update, so that connected stations can adjust
			 * their settings at the same time.
			 * See beacon.c for more details
			 */
			sc->beacon.slottime = slottime;
			sc->beacon.updateslot = UPDATE;
		} else {
			ah->slottime = slottime;
			ath9k_hw_init_global_settings(ah);
		}
2077 2078
	}

S
Sujith 已提交
2079
	/* Disable transmission of beacons */
2080 2081 2082 2083 2084 2085
	if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
	    !bss_conf->enable_beacon) {
		ath9k_set_beaconing_status(sc, false);
		avp->is_bslot_active = false;
		ath9k_set_beaconing_status(sc, true);
	}
2086

S
Sujith 已提交
2087 2088 2089 2090 2091 2092 2093
	if (changed & BSS_CHANGED_BEACON_INT) {
		/*
		 * In case of AP mode, the HW TSF has to be reset
		 * when the beacon interval changes.
		 */
		if (vif->type == NL80211_IFTYPE_AP) {
			sc->sc_flags |= SC_OP_TSF_RESET;
2094
			ath9k_set_beaconing_status(sc, false);
2095
			error = ath_beacon_alloc(sc, vif);
2096 2097
			if (!error)
				ath_beacon_config(sc, vif);
2098
			ath9k_set_beaconing_status(sc, true);
2099
		} else
S
Sujith 已提交
2100
			ath_beacon_config(sc, vif);
2101 2102
	}

2103
	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
J
Joe Perches 已提交
2104 2105
		ath_dbg(common, ATH_DBG_CONFIG, "BSS Changed PREAMBLE %d\n",
			bss_conf->use_short_preamble);
2106 2107 2108 2109 2110
		if (bss_conf->use_short_preamble)
			sc->sc_flags |= SC_OP_PREAMBLE_SHORT;
		else
			sc->sc_flags &= ~SC_OP_PREAMBLE_SHORT;
	}
2111

2112
	if (changed & BSS_CHANGED_ERP_CTS_PROT) {
J
Joe Perches 已提交
2113 2114
		ath_dbg(common, ATH_DBG_CONFIG, "BSS Changed CTS PROT %d\n",
			bss_conf->use_cts_prot);
2115 2116 2117 2118 2119 2120
		if (bss_conf->use_cts_prot &&
		    hw->conf.channel->band != IEEE80211_BAND_5GHZ)
			sc->sc_flags |= SC_OP_PROTECT_ENABLE;
		else
			sc->sc_flags &= ~SC_OP_PROTECT_ENABLE;
	}
2121

2122
	mutex_unlock(&sc->mutex);
2123
	ath9k_ps_restore(sc);
2124
}
2125

2126 2127
static u64 ath9k_get_tsf(struct ieee80211_hw *hw)
{
2128
	struct ath_softc *sc = hw->priv;
2129
	u64 tsf;
2130

2131
	mutex_lock(&sc->mutex);
2132
	ath9k_ps_wakeup(sc);
2133
	tsf = ath9k_hw_gettsf64(sc->sc_ah);
2134
	ath9k_ps_restore(sc);
2135
	mutex_unlock(&sc->mutex);
2136

2137 2138
	return tsf;
}
2139

2140 2141
static void ath9k_set_tsf(struct ieee80211_hw *hw, u64 tsf)
{
2142
	struct ath_softc *sc = hw->priv;
2143

2144
	mutex_lock(&sc->mutex);
2145
	ath9k_ps_wakeup(sc);
2146
	ath9k_hw_settsf64(sc->sc_ah, tsf);
2147
	ath9k_ps_restore(sc);
2148
	mutex_unlock(&sc->mutex);
2149 2150
}

2151 2152
static void ath9k_reset_tsf(struct ieee80211_hw *hw)
{
2153
	struct ath_softc *sc = hw->priv;
2154

2155
	mutex_lock(&sc->mutex);
2156 2157

	ath9k_ps_wakeup(sc);
2158
	ath9k_hw_reset_tsf(sc->sc_ah);
2159 2160
	ath9k_ps_restore(sc);

2161
	mutex_unlock(&sc->mutex);
2162
}
2163

2164
static int ath9k_ampdu_action(struct ieee80211_hw *hw,
2165
			      struct ieee80211_vif *vif,
2166 2167
			      enum ieee80211_ampdu_mlme_action action,
			      struct ieee80211_sta *sta,
2168
			      u16 tid, u16 *ssn, u8 buf_size)
2169
{
2170
	struct ath_softc *sc = hw->priv;
2171
	int ret = 0;
2172

2173 2174
	local_bh_disable();

2175 2176
	switch (action) {
	case IEEE80211_AMPDU_RX_START:
2177 2178
		if (!(sc->sc_flags & SC_OP_RXAGGR))
			ret = -ENOTSUPP;
2179 2180 2181 2182
		break;
	case IEEE80211_AMPDU_RX_STOP:
		break;
	case IEEE80211_AMPDU_TX_START:
2183 2184 2185
		if (!(sc->sc_flags & SC_OP_TXAGGR))
			return -EOPNOTSUPP;

2186
		ath9k_ps_wakeup(sc);
2187 2188 2189
		ret = ath_tx_aggr_start(sc, sta, tid, ssn);
		if (!ret)
			ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
2190
		ath9k_ps_restore(sc);
2191 2192
		break;
	case IEEE80211_AMPDU_TX_STOP:
2193
		ath9k_ps_wakeup(sc);
S
Sujith 已提交
2194
		ath_tx_aggr_stop(sc, sta, tid);
2195
		ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
2196
		ath9k_ps_restore(sc);
2197
		break;
2198
	case IEEE80211_AMPDU_TX_OPERATIONAL:
2199
		ath9k_ps_wakeup(sc);
2200
		ath_tx_aggr_resume(sc, sta, tid);
2201
		ath9k_ps_restore(sc);
2202
		break;
2203
	default:
2204
		ath_err(ath9k_hw_common(sc->sc_ah), "Unknown AMPDU action\n");
2205 2206
	}

2207 2208
	local_bh_enable();

2209
	return ret;
2210 2211
}

2212 2213 2214
static int ath9k_get_survey(struct ieee80211_hw *hw, int idx,
			     struct survey_info *survey)
{
2215
	struct ath_softc *sc = hw->priv;
2216
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
2217
	struct ieee80211_supported_band *sband;
2218 2219 2220 2221 2222 2223 2224
	struct ieee80211_channel *chan;
	unsigned long flags;
	int pos;

	spin_lock_irqsave(&common->cc_lock, flags);
	if (idx == 0)
		ath_update_survey_stats(sc);
2225 2226 2227 2228 2229 2230

	sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
	if (sband && idx >= sband->n_channels) {
		idx -= sband->n_channels;
		sband = NULL;
	}
2231

2232 2233
	if (!sband)
		sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
2234

2235 2236 2237
	if (!sband || idx >= sband->n_channels) {
		spin_unlock_irqrestore(&common->cc_lock, flags);
		return -ENOENT;
2238
	}
2239

2240 2241 2242 2243 2244 2245
	chan = &sband->channels[idx];
	pos = chan->hw_value;
	memcpy(survey, &sc->survey[pos], sizeof(*survey));
	survey->channel = chan;
	spin_unlock_irqrestore(&common->cc_lock, flags);

2246 2247 2248
	return 0;
}

2249 2250
static void ath9k_set_coverage_class(struct ieee80211_hw *hw, u8 coverage_class)
{
2251
	struct ath_softc *sc = hw->priv;
2252 2253 2254 2255 2256 2257 2258 2259
	struct ath_hw *ah = sc->sc_ah;

	mutex_lock(&sc->mutex);
	ah->coverage_class = coverage_class;
	ath9k_hw_init_global_settings(ah);
	mutex_unlock(&sc->mutex);
}

2260 2261 2262
static void ath9k_flush(struct ieee80211_hw *hw, bool drop)
{
	struct ath_softc *sc = hw->priv;
2263 2264
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
2265 2266
	int timeout = 200; /* ms */
	int i, j;
2267
	bool drain_txq;
2268 2269 2270 2271

	mutex_lock(&sc->mutex);
	cancel_delayed_work_sync(&sc->tx_complete_work);

2272 2273 2274 2275 2276 2277
	if (sc->sc_flags & SC_OP_INVALID) {
		ath_dbg(common, ATH_DBG_ANY, "Device not present\n");
		mutex_unlock(&sc->mutex);
		return;
	}

2278 2279
	if (drop)
		timeout = 1;
2280

2281
	for (j = 0; j < timeout; j++) {
2282
		bool npend = false;
2283 2284 2285

		if (j)
			usleep_range(1000, 2000);
2286

2287 2288 2289 2290
		for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
			if (!ATH_TXQ_SETUP(sc, i))
				continue;

2291 2292 2293 2294
			npend = ath9k_has_pending_frames(sc, &sc->tx.txq[i]);

			if (npend)
				break;
2295
		}
2296 2297 2298

		if (!npend)
		    goto out;
2299 2300
	}

2301
	ath9k_ps_wakeup(sc);
2302 2303 2304 2305
	spin_lock_bh(&sc->sc_pcu_lock);
	drain_txq = ath_drain_all_txq(sc, false);
	spin_unlock_bh(&sc->sc_pcu_lock);
	if (!drain_txq)
2306
		ath_reset(sc, false);
2307
	ath9k_ps_restore(sc);
2308 2309
	ieee80211_wake_queues(hw);

2310
out:
2311 2312 2313 2314
	ieee80211_queue_delayed_work(hw, &sc->tx_complete_work, 0);
	mutex_unlock(&sc->mutex);
}

2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329
static bool ath9k_tx_frames_pending(struct ieee80211_hw *hw)
{
	struct ath_softc *sc = hw->priv;
	int i;

	for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
		if (!ATH_TXQ_SETUP(sc, i))
			continue;

		if (ath9k_has_pending_frames(sc, &sc->tx.txq[i]))
			return true;
	}
	return false;
}

2330
static int ath9k_tx_last_beacon(struct ieee80211_hw *hw)
2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368
{
	struct ath_softc *sc = hw->priv;
	struct ath_hw *ah = sc->sc_ah;
	struct ieee80211_vif *vif;
	struct ath_vif *avp;
	struct ath_buf *bf;
	struct ath_tx_status ts;
	int status;

	vif = sc->beacon.bslot[0];
	if (!vif)
		return 0;

	avp = (void *)vif->drv_priv;
	if (!avp->is_bslot_active)
		return 0;

	if (!sc->beacon.tx_processed) {
		tasklet_disable(&sc->bcon_tasklet);

		bf = avp->av_bcbuf;
		if (!bf || !bf->bf_mpdu)
			goto skip;

		status = ath9k_hw_txprocdesc(ah, bf->bf_desc, &ts);
		if (status == -EINPROGRESS)
			goto skip;

		sc->beacon.tx_processed = true;
		sc->beacon.tx_last = !(ts.ts_status & ATH9K_TXERR_MASK);

skip:
		tasklet_enable(&sc->bcon_tasklet);
	}

	return sc->beacon.tx_last;
}

2369
struct ieee80211_ops ath9k_ops = {
2370 2371 2372 2373
	.tx 		    = ath9k_tx,
	.start 		    = ath9k_start,
	.stop 		    = ath9k_stop,
	.add_interface 	    = ath9k_add_interface,
2374
	.change_interface   = ath9k_change_interface,
2375 2376 2377
	.remove_interface   = ath9k_remove_interface,
	.config 	    = ath9k_config,
	.configure_filter   = ath9k_configure_filter,
2378 2379
	.sta_add	    = ath9k_sta_add,
	.sta_remove	    = ath9k_sta_remove,
2380
	.sta_notify         = ath9k_sta_notify,
2381 2382 2383 2384
	.conf_tx 	    = ath9k_conf_tx,
	.bss_info_changed   = ath9k_bss_info_changed,
	.set_key            = ath9k_set_key,
	.get_tsf 	    = ath9k_get_tsf,
2385
	.set_tsf 	    = ath9k_set_tsf,
2386
	.reset_tsf 	    = ath9k_reset_tsf,
2387
	.ampdu_action       = ath9k_ampdu_action,
2388
	.get_survey	    = ath9k_get_survey,
J
Johannes Berg 已提交
2389
	.rfkill_poll        = ath9k_rfkill_poll_state,
2390
	.set_coverage_class = ath9k_set_coverage_class,
2391
	.flush		    = ath9k_flush,
2392
	.tx_frames_pending  = ath9k_tx_frames_pending,
2393
	.tx_last_beacon = ath9k_tx_last_beacon,
2394
};