main.c 53 KB
Newer Older
1
/*
2
 * Copyright (c) 2008-2009 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>
Sujith's avatar
Sujith committed
18
#include "ath9k.h"
19
#include "btcoex.h"
20

Sujith's avatar
Sujith committed
21 22
static void ath_update_txpow(struct ath_softc *sc)
{
23
	struct ath_hw *ah = sc->sc_ah;
Sujith's avatar
Sujith committed
24

Sujith's avatar
Sujith committed
25
	if (sc->curtxpow != sc->config.txpowlimit) {
26
		ath9k_hw_set_txpowerlimit(ah, sc->config.txpowlimit, false);
Sujith's avatar
Sujith committed
27
		/* read back in case value is clamped */
28
		sc->curtxpow = ath9k_hw_regulatory(ah)->power_limit;
Sujith's avatar
Sujith committed
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 57 58 59 60 61 62 63 64 65 66
	}
}

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;
	}
}

Sujith's avatar
Sujith committed
67
bool ath9k_setpower(struct ath_softc *sc, enum ath9k_power_mode mode)
68 69 70 71
{
	unsigned long flags;
	bool ret;

72 73 74
	spin_lock_irqsave(&sc->sc_pm_lock, flags);
	ret = ath9k_hw_setpower(sc->sc_ah, mode);
	spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
75 76 77 78

	return ret;
}

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

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

89
	power_mode = sc->sc_ah->power_mode;
90
	ath9k_hw_setpower(sc->sc_ah, ATH9K_PM_AWAKE);
91

92 93 94 95 96
	/*
	 * 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.
	 */
97 98 99 100 101 102
	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);
	}
103

104 105 106 107 108 109
 unlock:
	spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
}

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

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

117 118 119 120
	spin_lock(&common->cc_lock);
	ath_hw_cycle_counters_update(common);
	spin_unlock(&common->cc_lock);

121 122 123 124
	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 |
Sujith's avatar
Sujith committed
125 126 127
			      PS_WAIT_FOR_CAB |
			      PS_WAIT_FOR_PSPOLL_DATA |
			      PS_WAIT_FOR_TX_ACK)))
128
		ath9k_hw_setpower(sc->sc_ah, ATH9K_PM_NETWORK_SLEEP);
129 130 131 132 133

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

134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
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));
}

155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
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;
	}
}

static void 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;

176 177 178
	if (!ah->curchan)
		return;

179 180
	if (ah->power_mode == ATH9K_PM_AWAKE)
		ath_hw_cycle_counters_update(common);
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196

	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;
	}
	memset(cc, 0, sizeof(*cc));

	ath_update_survey_nf(sc, pos);
}

Sujith's avatar
Sujith committed
197 198 199 200 201
/*
 * 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.
*/
202 203
int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
		    struct ath9k_channel *hchan)
Sujith's avatar
Sujith committed
204
{
205
	struct ath_hw *ah = sc->sc_ah;
206
	struct ath_common *common = ath9k_hw_common(ah);
207
	struct ieee80211_conf *conf = &common->hw->conf;
Sujith's avatar
Sujith committed
208
	bool fastcc = true, stopped;
209
	struct ieee80211_channel *channel = hw->conf.channel;
210
	struct ath9k_hw_cal_data *caldata = NULL;
211
	int r;
Sujith's avatar
Sujith committed
212 213 214 215

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

216 217 218 219
	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);
220
	cancel_delayed_work_sync(&sc->hw_pll_work);
221

222 223
	ath9k_ps_wakeup(sc);

224 225
	spin_lock_bh(&sc->sc_pcu_lock);

226 227 228 229 230 231 232 233 234
	/*
	 * 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.
	 */
235
	ath9k_hw_disable_interrupts(ah);
236
	stopped = ath_drain_all_txq(sc, false);
237

238 239
	if (!ath_stoprecv(sc))
		stopped = false;
Sujith's avatar
Sujith committed
240

241 242 243
	if (!ath9k_hw_check_alive(ah))
		stopped = false;

244 245 246
	/* XXX: do not flush receive queue here. We don't want
	 * to flush data frames already in queue because of
	 * changing channel. */
Sujith's avatar
Sujith committed
247

248
	if (!stopped || !(sc->sc_flags & SC_OP_OFFCHANNEL))
249 250
		fastcc = false;

251
	if (!(sc->sc_flags & SC_OP_OFFCHANNEL))
252
		caldata = &sc->caldata;
253

254 255 256 257 258
	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);
Sujith's avatar
Sujith committed
259

260
	r = ath9k_hw_reset(ah, hchan, caldata, fastcc);
261
	if (r) {
262 263 264
		ath_err(common,
			"Unable to reset channel (%u MHz), reset status %d\n",
			channel->center_freq, r);
265
		goto ps_restore;
Sujith's avatar
Sujith committed
266
	}
267 268

	if (ath_startrecv(sc) != 0) {
269
		ath_err(common, "Unable to restart recv logic\n");
270 271
		r = -EIO;
		goto ps_restore;
272 273 274
	}

	ath_update_txpow(sc);
275
	ath9k_hw_set_interrupts(ah, ah->imask);
276

277
	if (!(sc->sc_flags & (SC_OP_OFFCHANNEL))) {
278 279
		if (sc->sc_flags & SC_OP_BEACONS)
			ath_beacon_config(sc, NULL);
280
		ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work, 0);
281
		ieee80211_queue_delayed_work(sc->hw, &sc->hw_pll_work, HZ/2);
282
		ath_start_ani(common);
283 284
	}

285
 ps_restore:
286 287
	ieee80211_wake_queues(hw);

288 289
	spin_unlock_bh(&sc->sc_pcu_lock);

290
	ath9k_ps_restore(sc);
291
	return r;
Sujith's avatar
Sujith committed
292 293
}

294 295 296
static void ath_paprd_activate(struct ath_softc *sc)
{
	struct ath_hw *ah = sc->sc_ah;
297
	struct ath9k_hw_cal_data *caldata = ah->caldata;
298
	struct ath_common *common = ath9k_hw_common(ah);
299 300
	int chain;

301
	if (!caldata || !caldata->paprd_done)
302 303 304
		return;

	ath9k_ps_wakeup(sc);
305
	ar9003_paprd_enable(ah, false);
306
	for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {
307
		if (!(common->tx_chainmask & BIT(chain)))
308 309
			continue;

310
		ar9003_paprd_populate_single_table(ah, caldata, chain);
311 312 313 314 315 316
	}

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

317 318 319 320
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);
321 322
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339
	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);
	sc->paprd_pending = true;
	txctl.paprd = BIT(chain);
340 341 342 343

	if (ath_tx_start(hw, skb, &txctl) != 0) {
		ath_dbg(common, ATH_DBG_XMIT, "PAPRD TX failed\n");
		dev_kfree_skb_any(skb);
344
		return false;
345
	}
346 347 348 349 350 351 352 353 354 355 356 357 358

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

	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;
}

359 360 361 362 363 364 365
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;
366
	struct ath9k_hw_cal_data *caldata = ah->caldata;
367
	struct ath_common *common = ath9k_hw_common(ah);
368
	int ftype;
369 370 371 372
	int chain_ok = 0;
	int chain;
	int len = 1800;

373 374 375
	if (!caldata)
		return;

376 377 378
	if (ar9003_paprd_init_table(ah) < 0)
		return;

379 380 381 382 383 384 385 386 387
	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);
388
	hdr->duration_id = cpu_to_le16(10);
389 390 391 392
	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);

393
	ath9k_ps_wakeup(sc);
394
	for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {
395
		if (!(common->tx_chainmask & BIT(chain)))
396 397 398 399
			continue;

		chain_ok = 0;

400 401 402 403 404
		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;
405 406 407

		ar9003_paprd_setup_gain_table(ah, chain);

408 409 410
		ath_dbg(common, ATH_DBG_CALIBRATE,
			"Sending PAPRD training frame on chain %d\n", chain);
		if (!ath_paprd_send_frame(sc, skb, chain))
411
			goto fail_paprd;
412 413 414 415

		if (!ar9003_paprd_is_done(ah))
			break;

416
		if (ar9003_paprd_create_curve(ah, caldata, chain) != 0)
417 418 419 420 421 422 423
			break;

		chain_ok = 1;
	}
	kfree_skb(skb);

	if (chain_ok) {
424
		caldata->paprd_done = true;
425 426 427
		ath_paprd_activate(sc);
	}

428
fail_paprd:
429 430 431
	ath9k_ps_restore(sc);
}

Sujith's avatar
Sujith committed
432 433 434 435 436 437 438
/*
 *  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.
 */
Sujith's avatar
Sujith committed
439
void ath_ani_calibrate(unsigned long data)
Sujith's avatar
Sujith committed
440
{
441 442
	struct ath_softc *sc = (struct ath_softc *)data;
	struct ath_hw *ah = sc->sc_ah;
443
	struct ath_common *common = ath9k_hw_common(ah);
Sujith's avatar
Sujith committed
444 445 446 447
	bool longcal = false;
	bool shortcal = false;
	bool aniflag = false;
	unsigned int timestamp = jiffies_to_msecs(jiffies);
448
	u32 cal_interval, short_cal_interval, long_cal_interval;
449
	unsigned long flags;
450 451 452 453 454

	if (ah->caldata && ah->caldata->nfcal_interference)
		long_cal_interval = ATH_LONG_CALINTERVAL_INT;
	else
		long_cal_interval = ATH_LONG_CALINTERVAL;
Sujith's avatar
Sujith committed
455

456 457
	short_cal_interval = (ah->opmode == NL80211_IFTYPE_AP) ?
		ATH_AP_SHORT_CALINTERVAL : ATH_STA_SHORT_CALINTERVAL;
Sujith's avatar
Sujith committed
458

459 460 461 462 463 464
	/* Only calibrate if awake */
	if (sc->sc_ah->power_mode != ATH9K_PM_AWAKE)
		goto set_timer;

	ath9k_ps_wakeup(sc);

Sujith's avatar
Sujith committed
465
	/* Long calibration runs independently of short calibration. */
466
	if ((timestamp - common->ani.longcal_timer) >= long_cal_interval) {
Sujith's avatar
Sujith committed
467
		longcal = true;
468
		ath_dbg(common, ATH_DBG_ANI, "longcal @%lu\n", jiffies);
469
		common->ani.longcal_timer = timestamp;
Sujith's avatar
Sujith committed
470 471
	}

Sujith's avatar
Sujith committed
472
	/* Short calibration applies only while caldone is false */
473 474
	if (!common->ani.caldone) {
		if ((timestamp - common->ani.shortcal_timer) >= short_cal_interval) {
Sujith's avatar
Sujith committed
475
			shortcal = true;
476 477
			ath_dbg(common, ATH_DBG_ANI,
				"shortcal @%lu\n", jiffies);
478 479
			common->ani.shortcal_timer = timestamp;
			common->ani.resetcal_timer = timestamp;
Sujith's avatar
Sujith committed
480 481
		}
	} else {
482
		if ((timestamp - common->ani.resetcal_timer) >=
Sujith's avatar
Sujith committed
483
		    ATH_RESTART_CALINTERVAL) {
484 485 486
			common->ani.caldone = ath9k_hw_reset_calvalid(ah);
			if (common->ani.caldone)
				common->ani.resetcal_timer = timestamp;
Sujith's avatar
Sujith committed
487 488 489 490
		}
	}

	/* Verify whether we must check ANI */
491 492
	if ((timestamp - common->ani.checkani_timer) >=
	     ah->config.ani_poll_interval) {
Sujith's avatar
Sujith committed
493
		aniflag = true;
494
		common->ani.checkani_timer = timestamp;
Sujith's avatar
Sujith committed
495 496 497 498 499
	}

	/* Skip all processing if there's nothing to do. */
	if (longcal || shortcal || aniflag) {
		/* Call ANI routine if necessary */
500 501
		if (aniflag) {
			spin_lock_irqsave(&common->cc_lock, flags);
502
			ath9k_hw_ani_monitor(ah, ah->curchan);
503
			ath_update_survey_stats(sc);
504 505
			spin_unlock_irqrestore(&common->cc_lock, flags);
		}
Sujith's avatar
Sujith committed
506 507 508

		/* Perform calibration if necessary */
		if (longcal || shortcal) {
509
			common->ani.caldone =
510 511 512 513
				ath9k_hw_calibrate(ah,
						   ah->curchan,
						   common->rx_chainmask,
						   longcal);
Sujith's avatar
Sujith committed
514 515 516
		}
	}

517 518
	ath9k_ps_restore(sc);

519
set_timer:
Sujith's avatar
Sujith committed
520 521 522 523 524
	/*
	* Set timer interval based on previous results.
	* The interval must be the shortest necessary to satisfy ANI,
	* short calibration and long calibration.
	*/
525
	cal_interval = ATH_LONG_CALINTERVAL;
526
	if (sc->sc_ah->config.enable_ani)
527 528
		cal_interval = min(cal_interval,
				   (u32)ah->config.ani_poll_interval);
529
	if (!common->ani.caldone)
530
		cal_interval = min(cal_interval, (u32)short_cal_interval);
Sujith's avatar
Sujith committed
531

532
	mod_timer(&common->ani.timer, jiffies + msecs_to_jiffies(cal_interval));
533 534
	if ((sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_PAPRD) && ah->caldata) {
		if (!ah->caldata->paprd_done)
535
			ieee80211_queue_work(sc->hw, &sc->paprd_work);
536
		else if (!ah->paprd_table_write_done)
537 538
			ath_paprd_activate(sc);
	}
Sujith's avatar
Sujith committed
539 540 541 542 543
}

static void ath_node_attach(struct ath_softc *sc, struct ieee80211_sta *sta)
{
	struct ath_node *an;
544
	struct ath_hw *ah = sc->sc_ah;
Sujith's avatar
Sujith committed
545 546
	an = (struct ath_node *)sta->drv_priv;

547 548 549 550 551 552
#ifdef CONFIG_ATH9K_DEBUGFS
	spin_lock(&sc->nodes_lock);
	list_add(&an->list, &sc->nodes);
	spin_unlock(&sc->nodes_lock);
	an->sta = sta;
#endif
553 554 555
	if ((ah->caps.hw_caps) & ATH9K_HW_CAP_APM)
		sc->sc_flags |= SC_OP_ENABLE_APM;

556
	if (sc->sc_flags & SC_OP_TXAGGR) {
Sujith's avatar
Sujith committed
557
		ath_tx_node_init(sc, an);
Sujith's avatar
Sujith committed
558
		an->maxampdu = 1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
559 560 561
				     sta->ht_cap.ampdu_factor);
		an->mpdudensity = parse_mpdudensity(sta->ht_cap.ampdu_density);
	}
Sujith's avatar
Sujith committed
562 563 564 565 566 567
}

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

568 569 570 571 572 573 574
#ifdef CONFIG_ATH9K_DEBUGFS
	spin_lock(&sc->nodes_lock);
	list_del(&an->list);
	spin_unlock(&sc->nodes_lock);
	an->sta = NULL;
#endif

Sujith's avatar
Sujith committed
575 576 577 578
	if (sc->sc_flags & SC_OP_TXAGGR)
		ath_tx_node_cleanup(sc, an);
}

579 580 581 582 583 584 585 586 587 588 589 590 591
void ath_hw_check(struct work_struct *work)
{
	struct ath_softc *sc = container_of(work, struct ath_softc, hw_check_work);
	int i;

	ath9k_ps_wakeup(sc);

	for (i = 0; i < 3; i++) {
		if (ath9k_hw_check_alive(sc->sc_ah))
			goto out;

		msleep(1);
	}
592
	ath_reset(sc, true);
593 594 595 596 597

out:
	ath9k_ps_restore(sc);
}

Sujith's avatar
Sujith committed
598
void ath9k_tasklet(unsigned long data)
Sujith's avatar
Sujith committed
599 600
{
	struct ath_softc *sc = (struct ath_softc *)data;
601
	struct ath_hw *ah = sc->sc_ah;
602
	struct ath_common *common = ath9k_hw_common(ah);
603

Sujith's avatar
Sujith committed
604
	u32 status = sc->intrstatus;
Felix Fietkau's avatar
Felix Fietkau committed
605
	u32 rxmask;
Sujith's avatar
Sujith committed
606

607
	if (status & ATH9K_INT_FATAL) {
608
		ath_reset(sc, true);
Sujith's avatar
Sujith committed
609
		return;
610
	}
Sujith's avatar
Sujith committed
611

612
	ath9k_ps_wakeup(sc);
613
	spin_lock(&sc->sc_pcu_lock);
614

615 616 617 618 619 620 621 622 623
	/*
	 * 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))
624 625
		ieee80211_queue_work(sc->hw, &sc->hw_check_work);

Felix Fietkau's avatar
Felix Fietkau committed
626 627 628 629 630 631 632 633 634 635 636 637 638
	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);
Sujith's avatar
Sujith committed
639 640
	}

641 642 643 644 645 646
	if (status & ATH9K_INT_TX) {
		if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
			ath_tx_edma_tasklet(sc);
		else
			ath_tx_tasklet(sc);
	}
647

648
	if ((status & ATH9K_INT_TSFOOR) && sc->ps_enabled) {
649 650 651 652
		/*
		 * TSF sync does not look correct; remain awake to sync with
		 * the next Beacon.
		 */
653 654
		ath_dbg(common, ATH_DBG_PS,
			"TSFOOR - Sync with next Beacon\n");
Sujith's avatar
Sujith committed
655
		sc->ps_flags |= PS_WAIT_FOR_BEACON | PS_BEACON_SYNC;
656 657
	}

658
	if (ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
659 660 661
		if (status & ATH9K_INT_GENTIMER)
			ath_gen_timer_isr(sc->sc_ah);

Sujith's avatar
Sujith committed
662
	/* re-enable hardware interrupt */
663
	ath9k_hw_enable_interrupts(ah);
664

665
	spin_unlock(&sc->sc_pcu_lock);
666
	ath9k_ps_restore(sc);
Sujith's avatar
Sujith committed
667 668
}

669
irqreturn_t ath_isr(int irq, void *dev)
Sujith's avatar
Sujith committed
670
{
671 672 673 674 675
#define SCHED_INTR (				\
		ATH9K_INT_FATAL |		\
		ATH9K_INT_RXORN |		\
		ATH9K_INT_RXEOL |		\
		ATH9K_INT_RX |			\
Felix Fietkau's avatar
Felix Fietkau committed
676 677
		ATH9K_INT_RXLP |		\
		ATH9K_INT_RXHP |		\
678 679 680
		ATH9K_INT_TX |			\
		ATH9K_INT_BMISS |		\
		ATH9K_INT_CST |			\
681 682
		ATH9K_INT_TSFOOR |		\
		ATH9K_INT_GENTIMER)
683

Sujith's avatar
Sujith committed
684
	struct ath_softc *sc = dev;
685
	struct ath_hw *ah = sc->sc_ah;
686
	struct ath_common *common = ath9k_hw_common(ah);
Sujith's avatar
Sujith committed
687 688 689
	enum ath9k_int status;
	bool sched = false;

690 691 692 693 694 695 696
	/*
	 * 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;
Sujith's avatar
Sujith committed
697

698 699 700

	/* shared irq, not for us */

701
	if (!ath9k_hw_intrpend(ah))
702 703 704 705 706 707 708 709 710
		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 */
711
	status &= ah->imask;	/* discard unasked-for bits */
Sujith's avatar
Sujith committed
712

713 714 715 716
	/*
	 * If there are no status bits set, then this interrupt was not
	 * for me (should have been caught above).
	 */
717
	if (!status)
718
		return IRQ_NONE;
Sujith's avatar
Sujith committed
719

720 721 722 723 724 725 726 727 728 729
	/* 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.
	 */
Felix Fietkau's avatar
Felix Fietkau committed
730 731
	if ((status & ATH9K_INT_FATAL) || ((status & ATH9K_INT_RXORN) &&
	    !(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)))
732 733
		goto chip_reset;

734 735
	if ((ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) &&
	    (status & ATH9K_INT_BB_WATCHDOG)) {
736 737 738

		spin_lock(&common->cc_lock);
		ath_hw_cycle_counters_update(common);
739
		ar9003_hw_bb_watchdog_dbg_info(ah);
740 741
		spin_unlock(&common->cc_lock);

742 743 744
		goto chip_reset;
	}

745 746 747 748 749 750
	if (status & ATH9K_INT_SWBA)
		tasklet_schedule(&sc->bcon_tasklet);

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

Felix Fietkau's avatar
Felix Fietkau committed
751 752 753 754 755 756 757
	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);
		}
	}

758
	if (status & ATH9K_INT_MIB) {
Sujith's avatar
Sujith committed
759
		/*
760 761 762
		 * Disable interrupts until we service the MIB
		 * interrupt; otherwise it will continue to
		 * fire.
Sujith's avatar
Sujith committed
763
		 */
764
		ath9k_hw_disable_interrupts(ah);
765 766 767 768 769
		/*
		 * Let the hal handle the event. We assume
		 * it will clear whatever condition caused
		 * the interrupt.
		 */
770
		spin_lock(&common->cc_lock);
771
		ath9k_hw_proc_mib_event(ah);
772
		spin_unlock(&common->cc_lock);
773
		ath9k_hw_enable_interrupts(ah);
774
	}
Sujith's avatar
Sujith committed
775

776 777
	if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
		if (status & ATH9K_INT_TIM_TIMER) {
778 779
			if (ATH_DBG_WARN_ON_ONCE(sc->ps_idle))
				goto chip_reset;
780 781
			/* Clear RxAbort bit so that we can
			 * receive frames */
782
			ath9k_setpower(sc, ATH9K_PM_AWAKE);
783
			ath9k_hw_setrxabort(sc->sc_ah, 0);
Sujith's avatar
Sujith committed
784
			sc->ps_flags |= PS_WAIT_FOR_BEACON;
Sujith's avatar
Sujith committed
785
		}
786 787

chip_reset:
Sujith's avatar
Sujith committed
788

789 790
	ath_debug_stat_interrupt(sc, status);

Sujith's avatar
Sujith committed
791
	if (sched) {
792 793
		/* turn off every interrupt */
		ath9k_hw_disable_interrupts(ah);
Sujith's avatar
Sujith committed
794 795 796 797
		tasklet_schedule(&sc->intr_tq);
	}

	return IRQ_HANDLED;
798 799

#undef SCHED_INTR
Sujith's avatar
Sujith committed
800 801
}

802
static void ath9k_bss_assoc_info(struct ath_softc *sc,
803
				 struct ieee80211_hw *hw,
Sujith's avatar
Sujith committed
804
				 struct ieee80211_vif *vif,
805
				 struct ieee80211_bss_conf *bss_conf)
806
{
807
	struct ath_hw *ah = sc->sc_ah;
808
	struct ath_common *common = ath9k_hw_common(ah);
809

810
	if (bss_conf->assoc) {
811 812 813
		ath_dbg(common, ATH_DBG_CONFIG,
			"Bss Info ASSOC %d, bssid: %pM\n",
			bss_conf->aid, common->curbssid);
814

815
		/* New association, store aid */
816
		common->curaid = bss_conf->aid;
817
		ath9k_hw_write_associd(ah);
818 819 820 821 822 823

		/*
		 * Request a re-configuration of Beacon related timers
		 * on the receipt of the first Beacon frame (i.e.,
		 * after time sync with the AP).
		 */
Sujith's avatar
Sujith committed
824
		sc->ps_flags |= PS_BEACON_SYNC;
825

826
		/* Configure the beacon */
827
		ath_beacon_config(sc, vif);
828

829
		/* Reset rssi stats */
830
		sc->last_rssi = ATH_RSSI_DUMMY_MARKER;
831
		sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
832

833
		sc->sc_flags |= SC_OP_ANI_RUN;
834
		ath_start_ani(common);
835
	} else {
836
		ath_dbg(common, ATH_DBG_CONFIG, "Bss Info DISASSOC\n");
837
		common->curaid = 0;
838
		/* Stop ANI */
839
		sc->sc_flags &= ~SC_OP_ANI_RUN;
840
		del_timer_sync(&common->ani.timer);
841
	}
842
}
843

844
void ath_radio_enable(struct ath_softc *sc, struct ieee80211_hw *hw)
845
{
846
	struct ath_hw *ah = sc->sc_ah;
847
	struct ath_common *common = ath9k_hw_common(ah);
848
	struct ieee80211_channel *channel = hw->conf.channel;
849
	int r;
850

851
	ath9k_ps_wakeup(sc);
852 853
	spin_lock_bh(&sc->sc_pcu_lock);

854
	ath9k_hw_configpcipowersave(ah, 0, 0);
855

856
	if (!ah->curchan)
857
		ah->curchan = ath9k_cmn_get_curchannel(sc->hw, ah);
858

859
	r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
860
	if (r) {
861 862 863
		ath_err(common,
			"Unable to reset channel (%u MHz), reset status %d\n",
			channel->center_freq, r);
864 865 866 867
	}

	ath_update_txpow(sc);
	if (ath_startrecv(sc) != 0) {
868
		ath_err(common, "Unable to restart recv logic\n");
869
		goto out;
870 871
	}
	if (sc->sc_flags & SC_OP_BEACONS)
872
		ath_beacon_config(sc, NULL);	/* restart beacons */
873 874

	/* Re-Enable  interrupts */
875
	ath9k_hw_set_interrupts(ah, ah->imask);
876 877

	/* Enable LED */
878
	ath9k_hw_cfg_output(ah, ah->led_pin,
879
			    AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
880
	ath9k_hw_set_gpio(ah, ah->led_pin, 0);
881

882
	ieee80211_wake_queues(hw);
883
out:
884 885
	spin_unlock_bh(&sc->sc_pcu_lock);

886
	ath9k_ps_restore(sc);
887 888
}

889
void ath_radio_disable(struct ath_softc *sc, struct ieee80211_hw *hw)
890
{
891
	struct ath_hw *ah = sc->sc_ah;
892
	struct ieee80211_channel *channel = hw->conf.channel;
893
	int r;
894

895
	ath9k_ps_wakeup(sc);
896 897
	spin_lock_bh(&sc->sc_pcu_lock);

898
	ieee80211_stop_queues(hw);
899

900 901 902 903 904 905 906 907
	/*
	 * 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);
	}
908 909

	/* Disable interrupts */
910
	ath9k_hw_disable_interrupts(ah);
911

912
	ath_drain_all_txq(sc, false);	/* clear pending tx frames */
913

914 915 916
	ath_stoprecv(sc);		/* turn off frame recv */
	ath_flushrecv(sc);		/* flush recv queue */

917
	if (!ah->curchan)
918
		ah->curchan = ath9k_cmn_get_curchannel(hw, ah);
919

920
	r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
921
	if (r) {
922 923 924
		ath_err(ath9k_hw_common(sc->sc_ah),
			"Unable to reset channel (%u MHz), reset status %d\n",
			channel->center_freq, r);
925 926 927
	}

	ath9k_hw_phy_disable(ah);
928

929
	ath9k_hw_configpcipowersave(ah, 1, 1);
930 931

	spin_unlock_bh(&sc->sc_pcu_lock);
932
	ath9k_ps_restore(sc);
933 934
}

Sujith's avatar
Sujith committed
935 936
int ath_reset(struct ath_softc *sc, bool retry_tx)
{
937
	struct ath_hw *ah = sc->sc_ah;
938
	struct ath_common *common = ath9k_hw_common(ah);
939
	struct ieee80211_hw *hw = sc->hw;
940
	int r;
Sujith's avatar
Sujith committed
941

Sujith's avatar
Sujith committed
942 943 944
	/* Stop ANI */
	del_timer_sync(&common->ani.timer);

945
	ath9k_ps_wakeup(sc);
946 947
	spin_lock_bh(&sc->sc_pcu_lock);

Sujith's avatar
Sujith committed
948 949
	ieee80211_stop_queues(hw);

950
	ath9k_hw_disable_interrupts(ah);
951
	ath_drain_all_txq(sc, retry_tx);
952

Sujith's avatar
Sujith committed
953 954 955
	ath_stoprecv(sc);
	ath_flushrecv(sc);

956
	r = ath9k_hw_reset(ah, sc->sc_ah->curchan, ah->caldata, false);
957
	if (r)
958 959
		ath_err(common,
			"Unable to reset hardware; reset status %d\n", r);
Sujith's avatar
Sujith committed
960 961

	if (ath_startrecv(sc) != 0)
962
		ath_err(common, "Unable to start recv logic\n");
Sujith's avatar
Sujith committed
963 964 965 966 967 968 969 970

	/*
	 * 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.
	 */
	ath_update_txpow(sc);

971
	if ((sc->sc_flags & SC_OP_BEACONS) || !(sc->sc_flags & (SC_OP_OFFCHANNEL)))
972
		ath_beacon_config(sc, NULL);	/* restart beacons */
Sujith's avatar
Sujith committed
973

974
	ath9k_hw_set_interrupts(ah, ah->imask);
Sujith's avatar
Sujith committed
975 976 977 978 979

	if (retry_tx) {
		int i;
		for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
			if (ATH_TXQ_SETUP(sc, i)) {
Sujith's avatar
Sujith committed
980 981 982
				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);
Sujith's avatar
Sujith committed
983 984 985 986
			}
		}
	}

Sujith's avatar
Sujith committed
987
	ieee80211_wake_queues(hw);
988
	spin_unlock_bh(&sc->sc_pcu_lock);
Sujith's avatar
Sujith committed
989

Sujith's avatar
Sujith committed
990 991
	/* Start ANI */
	ath_start_ani(common);
992
	ath9k_ps_restore(sc);
Sujith's avatar
Sujith committed
993

994
	return r;
Sujith's avatar
Sujith committed
995 996 997 998 999 1000
}

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

1001
static int ath9k_start(struct ieee80211_hw *hw)
1002
{
1003
	struct ath_softc *sc = hw->priv;
1004
	struct ath_hw *ah = sc->sc_ah;
1005
	struct ath_common *common = ath9k_hw_common(ah);
1006
	struct ieee80211_channel *curchan = hw->conf.channel;
Sujith's avatar
Sujith committed
1007
	struct ath9k_channel *init_channel;
1008
	int r;
1009

1010 1011 1012
	ath_dbg(common, ATH_DBG_CONFIG,
		"Starting driver with initial channel: %d MHz\n",
		curchan->center_freq);
1013

1014 1015
	mutex_lock(&sc->mutex);

1016
	/* setup initial channel */
1017
	sc->chan_idx = curchan->hw_value;
1018

1019
	init_channel = ath9k_cmn_get_curchannel(hw, ah);
Sujith's avatar
Sujith committed
1020 1021

	/* Reset SERDES registers */
1022
	ath9k_hw_configpcipowersave(ah, 0, 0);
Sujith's avatar
Sujith committed
1023 1024 1025 1026 1027 1028 1029 1030

	/*
	 * 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.
	 */
1031
	spin_lock_bh(&sc->sc_pcu_lock);
1032
	r = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
1033
	if (r) {
1034 1035 1036
		ath_err(common,
			"Unable to reset hardware; reset status %d (freq %u MHz)\n",
			r, curchan->center_freq);
1037
		spin_unlock_bh(&sc->sc_pcu_lock);
1038
		goto mutex_unlock;
Sujith's avatar
Sujith committed
1039 1040 1041 1042 1043 1044 1045
	}

	/*
	 * This is needed only to setup initial state
	 * but it's best done after a reset.
	 */
	ath_update_txpow(sc);
1046

Sujith's avatar
Sujith committed
1047 1048 1049 1050 1051 1052 1053 1054
	/*
	 * 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) {
1055
		ath_err(common, "Unable to start recv logic\n");
1056
		r = -EIO;
1057
		spin_unlock_bh(&sc->sc_pcu_lock);
1058
		goto mutex_unlock;
1059
	}
1060
	spin_unlock_bh(&sc->sc_pcu_lock);
1061

Sujith's avatar
Sujith committed
1062
	/* Setup our intr mask. */
Felix Fietkau's avatar
Felix Fietkau committed
1063 1064 1065 1066 1067
	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)
1068 1069 1070
		ah->imask |= ATH9K_INT_RXHP |
			     ATH9K_INT_RXLP |
			     ATH9K_INT_BB_WATCHDOG;
Felix Fietkau's avatar
Felix Fietkau committed
1071 1072
	else
		ah->imask |= ATH9K_INT_RX;
Sujith's avatar
Sujith committed
1073

1074
	ah->imask |= ATH9K_INT_GTT;
Sujith's avatar
Sujith committed
1075

1076
	if (ah->caps.hw_caps & ATH9K_HW_CAP_HT)
1077
		ah->imask |= ATH9K_INT_CST;
Sujith's avatar
Sujith committed
1078 1079

	sc->sc_flags &= ~SC_OP_INVALID;
1080
	sc->sc_ah->is_monitoring = false;
Sujith's avatar
Sujith committed
1081 1082

	/* Disable BMISS interrupt when we're not associated */
1083 1084
	ah->imask &= ~(ATH9K_INT_SWBA | ATH9K_INT_BMISS);
	ath9k_hw_set_interrupts(ah, ah->imask);
Sujith's avatar
Sujith committed
1085

1086
	ieee80211_wake_queues(hw);
Sujith's avatar
Sujith committed
1087

1088
	ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work, 0);
1089

1090 1091
	if ((ah->btcoex_hw.scheme != ATH_BTCOEX_CFG_NONE) &&
	    !ah->btcoex_hw.enabled) {
1092 1093
		ath9k_hw_btcoex_set_weight(ah, AR_BT_COEX_WGHT,
					   AR_STOMP_LOW_WLAN_WGHT);
1094
		ath9k_hw_btcoex_enable(ah);
1095

1096 1097
		if (common->bus_ops->bt_coex_prep)
			common->bus_ops->bt_coex_prep(common);
1098
		if (ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
1099
			ath9k_btcoex_timer_resume(sc);
1100 1101
	}

1102 1103 1104 1105
	/* User has the option to provide pm-qos value as a module
	 * parameter rather than using the default value of
	 * 'ATH9K_PM_QOS_DEFAULT_VALUE'.
	 */
1106
	pm_qos_update_request(&sc->pm_qos_req, ath9k_pm_qos_value);
1107

1108 1109 1110
	if (ah->caps.pcie_lcr_extsync_en && common->bus_ops->extn_synch_en)
		common->bus_ops->extn_synch_en(common);

1111 1112 1113
mutex_unlock:
	mutex_unlock(&sc->mutex);

1114
	return r;
1115 1116
}

1117 1118
static int ath9k_tx(struct ieee80211_hw *hw,
		    struct sk_buff *skb)
1119
{
1120
	struct ath_softc *sc = hw->priv;
1121
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1122
	struct ath_tx_control txctl;
1123
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1124

1125
	if (sc->ps_enabled) {
1126 1127 1128 1129 1130 1131 1132
		/*
		 * 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)) {
1133 1134
			ath_dbg(common, ATH_DBG_PS,
				"Add PM=1 for a TX frame while in PS mode\n");
1135 1136 1137 1138
			hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
		}
	}

1139 1140 1141 1142 1143 1144 1145
	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);
1146 1147
		if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
			ath9k_hw_setrxabort(sc->sc_ah, 0);
1148
		if (ieee80211_is_pspoll(hdr->frame_control)) {
1149 1150
			ath_dbg(common, ATH_DBG_PS,
				"Sending PS-Poll to pick a buffered frame\n");
Sujith's avatar
Sujith committed
1151
			sc->ps_flags |= PS_WAIT_FOR_PSPOLL_DATA;
1152
		} else {
1153 1154
			ath_dbg(common, ATH_DBG_PS,
				"Wake up to complete TX\n");
Sujith's avatar
Sujith committed
1155
			sc->ps_flags |= PS_WAIT_FOR_TX_ACK;
1156 1157 1158 1159 1160 1161 1162 1163 1164
		}
		/*
		 * 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);
	}

1165
	memset(&txctl, 0, sizeof(struct ath_tx_control));
1166
	txctl.txq = sc->tx.txq_map[skb_get_queue_mapping(skb)];
1167

1168
	ath_dbg(common, ATH_DBG_XMIT, "transmitting packet, skb: %p\n", skb);
1169

1170
	if (ath_tx_start(hw, skb, &txctl) != 0) {
1171
		ath_dbg(common, ATH_DBG_XMIT, "TX failed\n");
1172
		goto exit;
1173 1174
	}

1175 1176 1177
	return 0;
exit:
	dev_kfree_skb_any(skb);
1178
	return 0;
1179 1180
}

1181
static void ath9k_stop(struct ieee80211_hw *hw)
1182
{
1183
	struct ath_softc *sc = hw->priv;
1184
	struct ath_hw *ah = sc->sc_ah;
1185
	struct ath_common *common = ath9k_hw_common(ah);
1186

Sujith's avatar
Sujith committed
1187 1188
	mutex_lock(&sc->mutex);

1189 1190 1191
	if (led_blink)
		cancel_delayed_work_sync(&sc->ath_led_blink_work);

1192
	cancel_delayed_work_sync(&sc->tx_complete_work);
1193
	cancel_delayed_work_sync(&sc->hw_pll_work);
1194
	cancel_work_sync(&sc->paprd_work);
1195
	cancel_work_sync(&sc->hw_check_work);
1196

Sujith's avatar
Sujith committed
1197
	if (sc->sc_flags & SC_OP_INVALID) {
1198
		ath_dbg(common, ATH_DBG_ANY, "Device not present\n");
Sujith's avatar
Sujith committed
1199
		mutex_unlock(&sc->mutex);
Sujith's avatar
Sujith committed
1200 1201
		return;
	}
1202

1203 1204 1205
	/* Ensure HW is awake when we try to shut it down. */
	ath9k_ps_wakeup(sc);

1206
	if (ah->btcoex_hw.enabled) {
1207
		ath9k_hw_btcoex_disable(ah);
1208
		if (ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
1209
			ath9k_btcoex_timer_pause(sc);
1210 1211
	}

1212 1213
	spin_lock_bh(&sc->sc_pcu_lock);

1214 1215 1216
	/* prevent tasklets to enable interrupts once we disable them */
	ah->imask &= ~ATH9K_INT_GLOBAL;

Sujith's avatar
Sujith committed
1217 1218
	/* make sure h/w will not generate any interrupt
	 * before setting the invalid flag. */
1219
	ath9k_hw_disable_interrupts(ah);
Sujith's avatar
Sujith committed
1220 1221

	if (!(sc->sc_flags & SC_OP_INVALID)) {
1222
		ath_drain_all_txq(sc, false);
Sujith's avatar
Sujith committed
1223
		ath_stoprecv(sc);
1224
		ath9k_hw_phy_disable(ah);
1225
	} else
Sujith's avatar
Sujith committed
1226
		sc->rx.rxlink = NULL;
Sujith's avatar
Sujith committed
1227

1228 1229 1230 1231 1232
	if (sc->rx.frag) {
		dev_kfree_skb_any(sc->rx.frag);
		sc->rx.frag = NULL;
	}

Sujith's avatar
Sujith committed
1233
	/* disable HAL and put h/w to sleep */
1234 1235
	ath9k_hw_disable(ah);
	ath9k_hw_configpcipowersave(ah, 1, 1);
1236 1237 1238

	spin_unlock_bh(&sc->sc_pcu_lock);

1239 1240 1241 1242 1243 1244
	/* 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);

1245 1246
	ath9k_ps_restore(sc);

1247 1248
	sc->ps_idle = true;
	ath_radio_disable(sc, hw);
Sujith's avatar
Sujith committed
1249 1250

	sc->sc_flags |= SC_OP_INVALID;
1251

1252
	pm_qos_update_request(&sc->pm_qos_req, PM_QOS_DEFAULT_VALUE);
1253

1254 1255
	mutex_unlock(&sc->mutex);

1256
	ath_dbg(common, ATH_DBG_CONFIG, "Driver halt\n");
1257 1258
}

1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272
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)
1273
{
1274
	struct ath_vif *avp = (void *)vif->drv_priv;
1275

1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304
	/* Disable SWBA interrupt */
	sc->sc_ah->imask &= ~ATH9K_INT_SWBA;
	ath9k_ps_wakeup(sc);
	ath9k_hw_set_interrupts(sc->sc_ah, sc->sc_ah->imask);
	ath9k_hw_stoptxdma(sc->sc_ah, sc->beacon.beaconq);
	tasklet_kill(&sc->bcon_tasklet);
	ath9k_ps_restore(sc);

	ath_beacon_return(sc, avp);
	sc->sc_flags &= ~SC_OP_BEACONS;

	if (sc->nbcnvifs > 0) {
		/* Re-enable beaconing */
		sc->sc_ah->imask |= ATH9K_INT_SWBA;
		ath9k_ps_wakeup(sc);
		ath9k_hw_set_interrupts(sc->sc_ah, sc->sc_ah->imask);
		ath9k_ps_restore(sc);
	}
}

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]);
1305

1306
	switch (vif->type) {
1307 1308
	case NL80211_IFTYPE_AP:
		iter_data->naps++;
1309
		break;
1310 1311
	case NL80211_IFTYPE_STATION:
		iter_data->nstations++;
1312
		break;
1313
	case NL80211_IFTYPE_ADHOC:
1314 1315
		iter_data->nadhocs++;
		break;
1316
	case NL80211_IFTYPE_MESH_POINT:
1317 1318 1319 1320
		iter_data->nmeshes++;
		break;
	case NL80211_IFTYPE_WDS:
		iter_data->nwds++;
1321 1322
		break;
	default:
1323 1324
		iter_data->nothers++;
		break;
1325
	}
1326
}
1327

1328 1329 1330 1331 1332
/* 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)
{
1333
	struct ath_softc *sc = hw->priv;
1334 1335
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
1336

1337 1338 1339 1340 1341 1342 1343
	/*
	 * 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);
Sujith's avatar
Sujith committed
1344

1345 1346 1347 1348 1349 1350 1351
	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);
}
1352

1353 1354 1355 1356
/* Called with sc->mutex held. */
static void ath9k_calculate_summary_state(struct ieee80211_hw *hw,
					  struct ieee80211_vif *vif)
{
1357
	struct ath_softc *sc = hw->priv;
1358 1359 1360
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
	struct ath9k_vif_iter_data iter_data;
1361

1362
	ath9k_calculate_iter_data(hw, vif, &iter_data);
1363

1364 1365 1366 1367 1368 1369
	/* Set BSSID mask. */
	memcpy(common->bssidmask, iter_data.mask, ETH_ALEN);
	ath_hw_setbssidmask(common);

	/* Set op-mode & TSF */
	if (iter_data.naps > 0) {
1370
		ath9k_hw_set_tsfadjust(ah, 1);
1371
		sc->sc_flags |= SC_OP_TSF_RESET;
1372 1373 1374 1375
		ah->opmode = NL80211_IFTYPE_AP;
	} else {
		ath9k_hw_set_tsfadjust(ah, 0);
		sc->sc_flags &= ~SC_OP_TSF_RESET;
Sujith's avatar
Sujith committed
1376

1377 1378 1379 1380 1381 1382 1383
		if (iter_data.nwds + iter_data.nmeshes)
			ah->opmode = NL80211_IFTYPE_AP;
		else if (iter_data.nadhocs)
			ah->opmode = NL80211_IFTYPE_ADHOC;
		else
			ah->opmode = NL80211_IFTYPE_STATION;
	}
Sujith's avatar
Sujith committed
1384

1385 1386 1387
	/*
	 * Enable MIB interrupts when there are hardware phy counters.
	 */
1388
	if ((iter_data.nstations + iter_data.nadhocs + iter_data.nmeshes) > 0) {
1389 1390
		if (ah->config.enable_ani)
			ah->imask |= ATH9K_INT_MIB;
1391
		ah->imask |= ATH9K_INT_TSFOOR;
1392 1393 1394
	} else {
		ah->imask &= ~ATH9K_INT_MIB;
		ah->imask &= ~ATH9K_INT_TSFOOR;
1395 1396
	}

1397
	ath9k_hw_set_interrupts(ah, ah->imask);
1398

1399 1400
	/* Set up ANI */
	if ((iter_data.naps + iter_data.nadhocs) > 0) {
1401
		sc->sc_flags |= SC_OP_ANI_RUN;
1402
		ath_start_ani(common);
1403 1404 1405
	} else {
		sc->sc_flags &= ~SC_OP_ANI_RUN;
		del_timer_sync(&common->ani.timer);
1406
	}
1407
}
1408

1409 1410 1411 1412
/* 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)
{
1413
	struct ath_softc *sc = hw->priv;
1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425

	ath9k_calculate_summary_state(hw, vif);

	if (ath9k_uses_beacons(vif->type)) {
		int error;
		ath9k_hw_stoptxdma(sc->sc_ah, sc->beacon.beaconq);
		/* 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.
		 */
1426
		error = ath_beacon_alloc(sc, vif);
1427 1428 1429 1430 1431
		if (error)
			ath9k_reclaim_beacon(sc, vif);
		else
			ath_beacon_config(sc, vif);
	}
1432 1433
}

1434 1435 1436

static int ath9k_add_interface(struct ieee80211_hw *hw,
			       struct ieee80211_vif *vif)
1437
{
1438
	struct ath_softc *sc = hw->priv;
1439 1440
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
1441
	struct ath_vif *avp = (void *)vif->drv_priv;
1442
	int ret = 0;
1443

1444
	mutex_lock(&sc->mutex);
1445

1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458
	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;
	}
1459

1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475
	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;
		}
	}

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

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

	/* Set the VIF opmode */
	avp->av_opmode = vif->type;
	avp->av_bslot = -1;

	sc->nvifs++;

	ath9k_do_vif_add_setup(hw, vif);
out:
	mutex_unlock(&sc->mutex);
	return ret;
1491 1492 1493 1494 1495 1496 1497
}

static int ath9k_change_interface(struct ieee80211_hw *hw,
				  struct ieee80211_vif *vif,
				  enum nl80211_iftype new_type,
				  bool p2p)
{
1498
	struct ath_softc *sc = hw->priv;
1499
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1500
	int ret = 0;
1501 1502 1503 1504

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

1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515
	/* 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)) {
1516 1517
		if (sc->nbcnvifs >= ATH_BCBUF) {
			ath_err(common, "No beacon slot available\n");
1518 1519
			ret = -ENOBUFS;
			goto out;
1520 1521
		}
	}
1522 1523 1524 1525 1526 1527

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

	/* Add new settings */
1528 1529 1530
	vif->type = new_type;
	vif->p2p = p2p;

1531
	ath9k_do_vif_add_setup(hw, vif);
1532
out:
1533
	mutex_unlock(&sc->mutex);
1534
	return ret;
1535 1536
}

1537
static void ath9k_remove_interface(struct ieee80211_hw *hw,
1538
				   struct ieee80211_vif *vif)
1539
{
1540
	struct ath_softc *sc = hw->priv;
1541
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1542

1543
	ath_dbg(common, ATH_DBG_CONFIG, "Detach Interface\n");
1544

1545 1546
	mutex_lock(&sc->mutex);

1547
	sc->nvifs--;
1548

1549
	/* Reclaim beacon resources */
1550
	if (ath9k_uses_beacons(vif->type))
1551
		ath9k_reclaim_beacon(sc, vif);
1552

1553
	ath9k_calculate_summary_state(hw, NULL);
1554 1555

	mutex_unlock(&sc->mutex);
1556 1557
}

1558
static void ath9k_enable_ps(struct ath_softc *sc)
1559
{
1560 1561
	struct ath_hw *ah = sc->sc_ah;

1562
	sc->ps_enabled = true;
1563 1564 1565 1566
	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);
1567
		}
1568
		ath9k_hw_setrxabort(ah, 1);
1569 1570 1571
	}
}

1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591
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);
		}
	}

}

1592
static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
1593
{
1594
	struct ath_softc *sc = hw->priv;
1595 1596
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
1597
	struct ieee80211_conf *conf = &hw->conf;
1598
	bool disable_radio = false;
1599

1600
	mutex_lock(&sc->mutex);
1601

1602 1603 1604 1605 1606 1607
	/*
	 * 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.
	 */
1608
	if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1609 1610
		sc->ps_idle = !!(conf->flags & IEEE80211_CONF_IDLE);
		if (!sc->ps_idle) {
1611
			ath_radio_enable(sc, hw);
1612 1613
			ath_dbg(common, ATH_DBG_CONFIG,
				"not-idle: enabling radio\n");
1614 1615
		} else {
			disable_radio = true;
1616 1617 1618
		}
	}

1619 1620 1621 1622 1623 1624
	/*
	 * 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.
	 */
1625
	if (changed & IEEE80211_CONF_CHANGE_PS) {
1626 1627
		unsigned long flags;
		spin_lock_irqsave(&sc->sc_pm_lock, flags);
1628 1629
		if (conf->flags & IEEE80211_CONF_PS)
			ath9k_enable_ps(sc);
1630 1631
		else
			ath9k_disable_ps(sc);
1632
		spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
1633 1634
	}

Sujith's avatar
Sujith committed
1635 1636
	if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
		if (conf->flags & IEEE80211_CONF_MONITOR) {
1637 1638
			ath_dbg(common, ATH_DBG_CONFIG,
				"Monitor mode is enabled\n");
1639 1640
			sc->sc_ah->is_monitoring = true;
		} else {
1641 1642
			ath_dbg(common, ATH_DBG_CONFIG,
				"Monitor mode is disabled\n");
1643
			sc->sc_ah->is_monitoring = false;
Sujith's avatar
Sujith committed
1644 1645 1646
		}
	}

1647
	if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
1648
		struct ieee80211_channel *curchan = hw->conf.channel;
1649
		int pos = curchan->hw_value;
1650 1651 1652 1653 1654
		int old_pos = -1;
		unsigned long flags;

		if (ah->curchan)
			old_pos = ah->curchan - &ah->channels[0];
1655

1656 1657 1658 1659
		if (hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)
			sc->sc_flags |= SC_OP_OFFCHANNEL;
		else
			sc->sc_flags &= ~SC_OP_OFFCHANNEL;
1660

1661 1662
		ath_dbg(common, ATH_DBG_CONFIG, "Set channel: %d MHz\n",
			curchan->center_freq);
1663

1664 1665
		ath9k_cmn_update_ichannel(&sc->sc_ah->channels[pos],
					  curchan, conf->channel_type);
1666

1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691
		/* 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));
		}

1692
		if (ath_set_channel(sc, hw, &sc->sc_ah->channels[pos]) < 0) {
1693
			ath_err(common, "Unable to set channel\n");
1694
			mutex_unlock(&sc->mutex);
1695 1696
			return -EINVAL;
		}
1697 1698 1699 1700 1701 1702 1703 1704

		/*
		 * 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);
Sujith's avatar
Sujith committed
1705
	}
1706

1707
	if (changed & IEEE80211_CONF_CHANGE_POWER) {
Sujith's avatar
Sujith committed
1708
		sc->config.txpowlimit = 2 * conf->power_level;
1709
		ath9k_ps_wakeup(sc);
1710
		ath_update_txpow(sc);
1711
		ath9k_ps_restore(sc);
1712
	}
1713

1714
	if (disable_radio) {
1715
		ath_dbg(common, ATH_DBG_CONFIG, "idle: disabling radio\n");
1716
		ath_radio_disable(sc, hw);
1717 1718
	}

1719
	mutex_unlock(&sc->mutex);
1720

1721 1722 1723
	return 0;
}

1724 1725 1726 1727
#define SUPPORTED_FILTERS			\
	(FIF_PROMISC_IN_BSS |			\
	FIF_ALLMULTI |				\
	FIF_CONTROL |				\
1728
	FIF_PSPOLL |				\
1729 1730
	FIF_OTHER_BSS |				\
	FIF_BCN_PRBRESP_PROMISC |		\
1731
	FIF_PROBE_REQ |				\
1732
	FIF_FCSFAIL)
1733

1734 1735 1736 1737
/* FIXME: sc->sc_full_reset ? */
static void ath9k_configure_filter(struct ieee80211_hw *hw,
				   unsigned int changed_flags,
				   unsigned int *total_flags,
1738
				   u64 multicast)
1739
{
1740
	struct ath_softc *sc = hw->priv;
1741
	u32 rfilt;
1742

1743 1744
	changed_flags &= SUPPORTED_FILTERS;
	*total_flags &= SUPPORTED_FILTERS;
1745

Sujith's avatar
Sujith committed
1746
	sc->rx.rxfilter = *total_flags;
1747
	ath9k_ps_wakeup(sc);
1748 1749
	rfilt = ath_calcrxfilter(sc);
	ath9k_hw_setrxfilter(sc->sc_ah, rfilt);
1750
	ath9k_ps_restore(sc);
1751

1752 1753
	ath_dbg(ath9k_hw_common(sc->sc_ah), ATH_DBG_CONFIG,
		"Set HW RX filter: 0x%x\n", rfilt);
1754
}
1755

1756 1757 1758
static int ath9k_sta_add(struct ieee80211_hw *hw,
			 struct ieee80211_vif *vif,
			 struct ieee80211_sta *sta)
1759
{
1760
	struct ath_softc *sc = hw->priv;
1761

1762 1763 1764 1765 1766 1767 1768 1769 1770
	ath_node_attach(sc, sta);

	return 0;
}

static int ath9k_sta_remove(struct ieee80211_hw *hw,
			    struct ieee80211_vif *vif,
			    struct ieee80211_sta *sta)
{
1771
	struct ath_softc *sc = hw->priv;
1772 1773 1774 1775

	ath_node_detach(sc, sta);

	return 0;
1776 1777
}

1778
static int ath9k_conf_tx(struct ieee80211_hw *hw, u16 queue,
1779
			 const struct ieee80211_tx_queue_params *params)
1780
{
1781
	struct ath_softc *sc = hw->priv;
1782
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1783
	struct ath_txq *txq;
1784
	struct ath9k_tx_queue_info qi;
1785
	int ret = 0;
1786

1787 1788
	if (queue >= WME_NUM_AC)
		return 0;
1789

1790 1791
	txq = sc->tx.txq_map[queue];

1792 1793
	mutex_lock(&sc->mutex);

1794 1795
	memset(&qi, 0, sizeof(struct ath9k_tx_queue_info));

1796 1797 1798 1799
	qi.tqi_aifs = params->aifs;
	qi.tqi_cwmin = params->cw_min;
	qi.tqi_cwmax = params->cw_max;
	qi.tqi_burstTime = params->txop;
1800

1801 1802 1803 1804
	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);
1805

1806
	ret = ath_txq_update(sc, txq->axq_qnum, &qi);
1807
	if (ret)
1808
		ath_err(common, "TXQ Update failed\n");
1809

1810
	if (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC)
1811
		if (queue == WME_AC_BE && !ret)
1812 1813
			ath_beaconq_config(sc);

1814 1815
	mutex_unlock(&sc->mutex);

1816 1817
	return ret;
}
1818

1819 1820
static int ath9k_set_key(struct ieee80211_hw *hw,
			 enum set_key_cmd cmd,
1821 1822
			 struct ieee80211_vif *vif,
			 struct ieee80211_sta *sta,
1823 1824
			 struct ieee80211_key_conf *key)
{
1825
	struct ath_softc *sc = hw->priv;
1826
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1827
	int ret = 0;
1828

1829
	if (ath9k_modparam_nohwcrypt)
1830 1831
		return -ENOSPC;

1832
	mutex_lock(&sc->mutex);
1833
	ath9k_ps_wakeup(sc);
1834
	ath_dbg(common, ATH_DBG_CONFIG, "Set HW Key\n");
1835

1836 1837
	switch (cmd) {
	case SET_KEY:
1838
		ret = ath_key_config(common, vif, sta, key);
1839 1840
		if (ret >= 0) {
			key->hw_key_idx = ret;
1841 1842
			/* push IV and Michael MIC generation to stack */
			key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1843
			if (key->cipher == WLAN_CIPHER_SUITE_TKIP)
1844
				key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
1845 1846
			if (sc->sc_ah->sw_mgmt_crypto &&
			    key->cipher == WLAN_CIPHER_SUITE_CCMP)
1847
				key->flags |= IEEE80211_KEY_FLAG_SW_MGMT;
1848
			ret = 0;
1849 1850 1851
		}
		break;
	case DISABLE_KEY:
1852
		ath_key_delete(common, key);
1853 1854 1855 1856
		break;
	default:
		ret = -EINVAL;
	}
1857

1858
	ath9k_ps_restore(sc);
1859 1860
	mutex_unlock(&sc->mutex);

1861 1862
	return ret;
}
1863

1864 1865 1866 1867 1868
static void ath9k_bss_info_changed(struct ieee80211_hw *hw,
				   struct ieee80211_vif *vif,
				   struct ieee80211_bss_conf *bss_conf,
				   u32 changed)
{
1869
	struct ath_softc *sc = hw->priv;
1870
	struct ath_hw *ah = sc->sc_ah;
1871
	struct ath_common *common = ath9k_hw_common(ah);
1872
	struct ath_vif *avp = (void *)vif->drv_priv;
1873
	int slottime;
1874
	int error;
1875

1876 1877
	mutex_lock(&sc->mutex);

1878 1879 1880 1881
	if (changed & BSS_CHANGED_BSSID) {
		/* Set BSSID */
		memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
		memcpy(avp->bssid, bss_conf->bssid, ETH_ALEN);
1882
		common->curaid = 0;
1883
		ath9k_hw_write_associd(ah);
1884

1885 1886
		/* Set aggregation protection mode parameters */
		sc->config.ath_aggr_prot = 0;
1887

1888 1889
		ath_dbg(common, ATH_DBG_CONFIG, "BSSID: %pM aid: 0x%x\n",
			common->curbssid, common->curaid);
1890

1891 1892 1893
		/* need to reconfigure the beacon */
		sc->sc_flags &= ~SC_OP_BEACONS ;
	}
1894

1895 1896 1897 1898
	/* Enable transmission of beacons (AP, IBSS, MESH) */
	if ((changed & BSS_CHANGED_BEACON) ||
	    ((changed & BSS_CHANGED_BEACON_ENABLED) && bss_conf->enable_beacon)) {
		ath9k_hw_stoptxdma(sc->sc_ah, sc->beacon.beaconq);
1899
		error = ath_beacon_alloc(sc, vif);
1900 1901
		if (!error)
			ath_beacon_config(sc, vif);
1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920
	}

	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);
		}
1921 1922
	}

1923 1924 1925
	/* Disable transmission of beacons */
	if ((changed & BSS_CHANGED_BEACON_ENABLED) && !bss_conf->enable_beacon)
		ath9k_hw_stoptxdma(sc->sc_ah, sc->beacon.beaconq);
1926

1927 1928 1929 1930 1931 1932 1933 1934 1935
	if (changed & BSS_CHANGED_BEACON_INT) {
		sc->beacon_interval = bss_conf->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;
			ath9k_hw_stoptxdma(sc->sc_ah, sc->beacon.beaconq);
1936
			error = ath_beacon_alloc(sc, vif);
1937 1938
			if (!error)
				ath_beacon_config(sc, vif);
1939 1940
		} else {
			ath_beacon_config(sc, vif);
1941 1942 1943
		}
	}

1944
	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1945 1946
		ath_dbg(common, ATH_DBG_CONFIG, "BSS Changed PREAMBLE %d\n",
			bss_conf->use_short_preamble);
1947 1948 1949 1950 1951
		if (bss_conf->use_short_preamble)
			sc->sc_flags |= SC_OP_PREAMBLE_SHORT;
		else
			sc->sc_flags &= ~SC_OP_PREAMBLE_SHORT;
	}
1952

1953
	if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1954 1955
		ath_dbg(common, ATH_DBG_CONFIG, "BSS Changed CTS PROT %d\n",
			bss_conf->use_cts_prot);
1956 1957 1958 1959 1960 1961
		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;
	}
1962

1963
	if (changed & BSS_CHANGED_ASSOC) {
1964
		ath_dbg(common, ATH_DBG_CONFIG, "BSS Changed ASSOC %d\n",
1965
			bss_conf->assoc);
1966
		ath9k_bss_assoc_info(sc, hw, vif, bss_conf);
1967
	}
1968 1969

	mutex_unlock(&sc->mutex);
1970
}
1971

1972 1973
static u64 ath9k_get_tsf(struct ieee80211_hw *hw)
{
1974
	struct ath_softc *sc = hw->priv;
1975
	u64 tsf;
1976

1977
	mutex_lock(&sc->mutex);
1978
	ath9k_ps_wakeup(sc);
1979
	tsf = ath9k_hw_gettsf64(sc->sc_ah);
1980
	ath9k_ps_restore(sc);
1981
	mutex_unlock(&sc->mutex);
1982

1983 1984
	return tsf;
}
1985

1986 1987
static void ath9k_set_tsf(struct ieee80211_hw *hw, u64 tsf)
{
1988
	struct ath_softc *sc = hw->priv;
1989

1990
	mutex_lock(&sc->mutex);
1991
	ath9k_ps_wakeup(sc);
1992
	ath9k_hw_settsf64(sc->sc_ah, tsf);
1993
	ath9k_ps_restore(sc);
1994
	mutex_unlock(&sc->mutex);
1995 1996
}

1997 1998
static void ath9k_reset_tsf(struct ieee80211_hw *hw)
{
1999
	struct ath_softc *sc = hw->priv;
2000

2001
	mutex_lock(&sc->mutex);
2002 2003

	ath9k_ps_wakeup(sc);
2004
	ath9k_hw_reset_tsf(sc->sc_ah);
2005 2006
	ath9k_ps_restore(sc);

2007
	mutex_unlock(&sc->mutex);
2008
}
2009

2010
static int ath9k_ampdu_action(struct ieee80211_hw *hw,
2011
			      struct ieee80211_vif *vif,
2012 2013
			      enum ieee80211_ampdu_mlme_action action,
			      struct ieee80211_sta *sta,
2014
			      u16 tid, u16 *ssn, u8 buf_size)
2015
{
2016
	struct ath_softc *sc = hw->priv;
2017
	int ret = 0;
2018

2019 2020
	local_bh_disable();

2021 2022
	switch (action) {
	case IEEE80211_AMPDU_RX_START:
2023 2024
		if (!(sc->sc_flags & SC_OP_RXAGGR))
			ret = -ENOTSUPP;
2025 2026 2027 2028
		break;
	case IEEE80211_AMPDU_RX_STOP:
		break;
	case IEEE80211_AMPDU_TX_START:
2029 2030 2031
		if (!(sc->sc_flags & SC_OP_TXAGGR))
			return -EOPNOTSUPP;

2032
		ath9k_ps_wakeup(sc);
2033 2034 2035
		ret = ath_tx_aggr_start(sc, sta, tid, ssn);
		if (!ret)
			ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
2036
		ath9k_ps_restore(sc);
2037 2038
		break;
	case IEEE80211_AMPDU_TX_STOP:
2039
		ath9k_ps_wakeup(sc);
Sujith's avatar
Sujith committed
2040
		ath_tx_aggr_stop(sc, sta, tid);
2041
		ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
2042
		ath9k_ps_restore(sc);
2043
		break;
2044
	case IEEE80211_AMPDU_TX_OPERATIONAL:
2045
		ath9k_ps_wakeup(sc);
2046
		ath_tx_aggr_resume(sc, sta, tid);
2047
		ath9k_ps_restore(sc);
2048
		break;
2049
	default:
2050
		ath_err(ath9k_hw_common(sc->sc_ah), "Unknown AMPDU action\n");
2051 2052
	}

2053 2054
	local_bh_enable();

2055
	return ret;
2056 2057
}

2058 2059 2060
static int ath9k_get_survey(struct ieee80211_hw *hw, int idx,
			     struct survey_info *survey)
{
2061
	struct ath_softc *sc = hw->priv;
2062
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
2063
	struct ieee80211_supported_band *sband;
2064 2065 2066 2067 2068 2069 2070
	struct ieee80211_channel *chan;
	unsigned long flags;
	int pos;

	spin_lock_irqsave(&common->cc_lock, flags);
	if (idx == 0)
		ath_update_survey_stats(sc);
2071 2072 2073 2074 2075 2076

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

2078 2079
	if (!sband)
		sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
2080

2081 2082 2083
	if (!sband || idx >= sband->n_channels) {
		spin_unlock_irqrestore(&common->cc_lock, flags);
		return -ENOENT;
2084
	}
2085

2086 2087 2088 2089 2090 2091
	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);

2092 2093 2094
	return 0;
}

2095 2096
static void ath9k_set_coverage_class(struct ieee80211_hw *hw, u8 coverage_class)
{
2097
	struct ath_softc *sc = hw->priv;
2098 2099 2100 2101 2102 2103 2104 2105
	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);
}

2106
struct ieee80211_ops ath9k_ops = {
2107 2108 2109 2110
	.tx 		    = ath9k_tx,
	.start 		    = ath9k_start,
	.stop 		    = ath9k_stop,
	.add_interface 	    = ath9k_add_interface,
2111
	.change_interface   = ath9k_change_interface,
2112 2113 2114
	.remove_interface   = ath9k_remove_interface,
	.config 	    = ath9k_config,
	.configure_filter   = ath9k_configure_filter,
2115 2116
	.sta_add	    = ath9k_sta_add,
	.sta_remove	    = ath9k_sta_remove,
2117 2118 2119 2120
	.conf_tx 	    = ath9k_conf_tx,
	.bss_info_changed   = ath9k_bss_info_changed,
	.set_key            = ath9k_set_key,
	.get_tsf 	    = ath9k_get_tsf,
2121
	.set_tsf 	    = ath9k_set_tsf,
2122
	.reset_tsf 	    = ath9k_reset_tsf,
2123
	.ampdu_action       = ath9k_ampdu_action,
2124
	.get_survey	    = ath9k_get_survey,
2125
	.rfkill_poll        = ath9k_rfkill_poll_state,
2126
	.set_coverage_class = ath9k_set_coverage_class,
2127
};