main.c 54.1 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>
S
Sujith 已提交
18
#include "ath9k.h"
19
#include "btcoex.h"
20

S
Sujith 已提交
21 22
static void ath_update_txpow(struct ath_softc *sc)
{
23
	struct ath_hw *ah = sc->sc_ah;
S
Sujith 已提交
24

S
Sujith 已提交
25 26
	if (sc->curtxpow != sc->config.txpowlimit) {
		ath9k_hw_set_txpowerlimit(ah, sc->config.txpowlimit);
S
Sujith 已提交
27
		/* read back in case value is clamped */
F
Felix Fietkau 已提交
28
		sc->curtxpow = ath9k_hw_regulatory(ah)->power_limit;
S
Sujith 已提交
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;
	}
}

67 68 69 70 71 72 73 74 75 76 77 78 79
static struct ath9k_channel *ath_get_curchannel(struct ath_softc *sc,
						struct ieee80211_hw *hw)
{
	struct ieee80211_channel *curchan = hw->conf.channel;
	struct ath9k_channel *channel;
	u8 chan_idx;

	chan_idx = curchan->hw_value;
	channel = &sc->sc_ah->channels[chan_idx];
	ath9k_update_ichannel(sc, hw, channel);
	return channel;
}

S
Sujith 已提交
80
bool ath9k_setpower(struct ath_softc *sc, enum ath9k_power_mode mode)
81 82 83 84
{
	unsigned long flags;
	bool ret;

85 86 87
	spin_lock_irqsave(&sc->sc_pm_lock, flags);
	ret = ath9k_hw_setpower(sc->sc_ah, mode);
	spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
88 89 90 91

	return ret;
}

92 93
void ath9k_ps_wakeup(struct ath_softc *sc)
{
94
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
95 96 97 98 99 100
	unsigned long flags;

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

101
	ath9k_hw_setpower(sc->sc_ah, ATH9K_PM_AWAKE);
102

103 104 105 106 107 108 109 110 111 112
	/*
	 * 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.
	 */
	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);

113 114 115 116 117 118
 unlock:
	spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
}

void ath9k_ps_restore(struct ath_softc *sc)
{
119
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
120 121 122 123 124 125
	unsigned long flags;

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

126 127 128 129
	spin_lock(&common->cc_lock);
	ath_hw_cycle_counters_update(common);
	spin_unlock(&common->cc_lock);

130 131 132 133
	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 已提交
134 135 136
			      PS_WAIT_FOR_CAB |
			      PS_WAIT_FOR_PSPOLL_DATA |
			      PS_WAIT_FOR_TX_ACK)))
137
		ath9k_hw_setpower(sc->sc_ah, ATH9K_PM_NETWORK_SLEEP);
138 139 140 141 142

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

143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
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));
}

164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
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;

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

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 201 202 203 204 205

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

S
Sujith 已提交
206 207 208 209 210
/*
 * 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.
*/
211 212
int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
		    struct ath9k_channel *hchan)
S
Sujith 已提交
213
{
214
	struct ath_wiphy *aphy = hw->priv;
215
	struct ath_hw *ah = sc->sc_ah;
216
	struct ath_common *common = ath9k_hw_common(ah);
L
Luis R. Rodriguez 已提交
217
	struct ieee80211_conf *conf = &common->hw->conf;
S
Sujith 已提交
218
	bool fastcc = true, stopped;
219
	struct ieee80211_channel *channel = hw->conf.channel;
220
	struct ath9k_hw_cal_data *caldata = NULL;
221
	int r;
S
Sujith 已提交
222 223 224 225

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

226 227 228 229 230
	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);

231 232
	ath9k_ps_wakeup(sc);

233 234 235 236 237 238 239 240 241 242
	/*
	 * 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.
	 */
	ath9k_hw_set_interrupts(ah, 0);
S
Sujith 已提交
243
	ath_drain_all_txq(sc, false);
244
	stopped = ath_stoprecv(sc);
S
Sujith 已提交
245

246 247 248
	/* XXX: do not flush receive queue here. We don't want
	 * to flush data frames already in queue because of
	 * changing channel. */
S
Sujith 已提交
249

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

253 254 255
	if (!(sc->sc_flags & SC_OP_OFFCHANNEL))
		caldata = &aphy->caldata;

256
	ath_print(common, ATH_DBG_CONFIG,
257
		  "(%u MHz) -> (%u MHz), conf_is_ht40: %d fastcc: %d\n",
258
		  sc->sc_ah->curchan->channel,
259 260
		  channel->center_freq, conf_is_ht40(conf),
		  fastcc);
S
Sujith 已提交
261

262 263
	spin_lock_bh(&sc->sc_resetlock);

264
	r = ath9k_hw_reset(ah, hchan, caldata, fastcc);
265
	if (r) {
266
		ath_print(common, ATH_DBG_FATAL,
267
			  "Unable to reset channel (%u MHz), "
268 269
			  "reset status %d\n",
			  channel->center_freq, r);
270
		spin_unlock_bh(&sc->sc_resetlock);
271
		goto ps_restore;
S
Sujith 已提交
272
	}
273 274 275
	spin_unlock_bh(&sc->sc_resetlock);

	if (ath_startrecv(sc) != 0) {
276 277
		ath_print(common, ATH_DBG_FATAL,
			  "Unable to restart recv logic\n");
278 279
		r = -EIO;
		goto ps_restore;
280 281 282
	}

	ath_update_txpow(sc);
P
Pavel Roskin 已提交
283
	ath9k_hw_set_interrupts(ah, ah->imask);
284

285 286
	if (!(sc->sc_flags & (SC_OP_OFFCHANNEL))) {
		ath_beacon_config(sc, NULL);
287
		ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work, 0);
288
		ath_start_ani(common);
289 290
	}

291
 ps_restore:
292
	ath9k_ps_restore(sc);
293
	return r;
S
Sujith 已提交
294 295
}

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

303
	if (!caldata || !caldata->paprd_done)
304 305 306
		return;

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

312
		ar9003_paprd_populate_single_table(ah, caldata, chain);
313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329
	}

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

void ath_paprd_calibrate(struct work_struct *work)
{
	struct ath_softc *sc = container_of(work, struct ath_softc, paprd_work);
	struct ieee80211_hw *hw = sc->hw;
	struct ath_hw *ah = sc->sc_ah;
	struct ieee80211_hdr *hdr;
	struct sk_buff *skb = NULL;
	struct ieee80211_tx_info *tx_info;
	int band = hw->conf.channel->band;
	struct ieee80211_supported_band *sband = &sc->sbands[band];
	struct ath_tx_control txctl;
330
	struct ath9k_hw_cal_data *caldata = ah->caldata;
331
	struct ath_common *common = ath9k_hw_common(ah);
332 333 334 335 336 337 338
	int qnum, ftype;
	int chain_ok = 0;
	int chain;
	int len = 1800;
	int time_left;
	int i;

339 340 341
	if (!caldata)
		return;

342 343 344 345 346 347 348 349 350 351 352
	skb = alloc_skb(len, GFP_KERNEL);
	if (!skb)
		return;

	tx_info = IEEE80211_SKB_CB(skb);

	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);
353
	hdr->duration_id = cpu_to_le16(10);
354 355 356 357 358 359 360 361
	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);

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

362
	ath9k_ps_wakeup(sc);
363 364
	ar9003_paprd_init_table(ah);
	for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {
365
		if (!(common->tx_chainmask & BIT(chain)))
366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
			continue;

		chain_ok = 0;
		memset(tx_info, 0, sizeof(*tx_info));
		tx_info->band = band;

		for (i = 0; i < 4; i++) {
			tx_info->control.rates[i].idx = sband->n_bitrates - 1;
			tx_info->control.rates[i].count = 6;
		}

		init_completion(&sc->paprd_complete);
		ar9003_paprd_setup_gain_table(ah, chain);
		txctl.paprd = BIT(chain);
		if (ath_tx_start(hw, skb, &txctl) != 0)
			break;

		time_left = wait_for_completion_timeout(&sc->paprd_complete,
384
				msecs_to_jiffies(ATH_PAPRD_TIMEOUT));
385 386 387 388 389
		if (!time_left) {
			ath_print(ath9k_hw_common(ah), ATH_DBG_CALIBRATE,
				  "Timeout waiting for paprd training on "
				  "TX chain %d\n",
				  chain);
390
			goto fail_paprd;
391 392 393 394 395
		}

		if (!ar9003_paprd_is_done(ah))
			break;

396
		if (ar9003_paprd_create_curve(ah, caldata, chain) != 0)
397 398 399 400 401 402 403
			break;

		chain_ok = 1;
	}
	kfree_skb(skb);

	if (chain_ok) {
404
		caldata->paprd_done = true;
405 406 407
		ath_paprd_activate(sc);
	}

408
fail_paprd:
409 410 411
	ath9k_ps_restore(sc);
}

S
Sujith 已提交
412 413 414 415 416 417 418
/*
 *  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 已提交
419
void ath_ani_calibrate(unsigned long data)
S
Sujith 已提交
420
{
421 422
	struct ath_softc *sc = (struct ath_softc *)data;
	struct ath_hw *ah = sc->sc_ah;
423
	struct ath_common *common = ath9k_hw_common(ah);
S
Sujith 已提交
424 425 426 427
	bool longcal = false;
	bool shortcal = false;
	bool aniflag = false;
	unsigned int timestamp = jiffies_to_msecs(jiffies);
428
	u32 cal_interval, short_cal_interval, long_cal_interval;
429
	unsigned long flags;
430 431 432 433 434

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

436 437
	short_cal_interval = (ah->opmode == NL80211_IFTYPE_AP) ?
		ATH_AP_SHORT_CALINTERVAL : ATH_STA_SHORT_CALINTERVAL;
S
Sujith 已提交
438

439 440 441 442 443 444
	/* Only calibrate if awake */
	if (sc->sc_ah->power_mode != ATH9K_PM_AWAKE)
		goto set_timer;

	ath9k_ps_wakeup(sc);

S
Sujith 已提交
445
	/* Long calibration runs independently of short calibration. */
446
	if ((timestamp - common->ani.longcal_timer) >= long_cal_interval) {
S
Sujith 已提交
447
		longcal = true;
448
		ath_print(common, ATH_DBG_ANI, "longcal @%lu\n", jiffies);
449
		common->ani.longcal_timer = timestamp;
S
Sujith 已提交
450 451
	}

S
Sujith 已提交
452
	/* Short calibration applies only while caldone is false */
453 454
	if (!common->ani.caldone) {
		if ((timestamp - common->ani.shortcal_timer) >= short_cal_interval) {
S
Sujith 已提交
455
			shortcal = true;
456 457
			ath_print(common, ATH_DBG_ANI,
				  "shortcal @%lu\n", jiffies);
458 459
			common->ani.shortcal_timer = timestamp;
			common->ani.resetcal_timer = timestamp;
S
Sujith 已提交
460 461
		}
	} else {
462
		if ((timestamp - common->ani.resetcal_timer) >=
S
Sujith 已提交
463
		    ATH_RESTART_CALINTERVAL) {
464 465 466
			common->ani.caldone = ath9k_hw_reset_calvalid(ah);
			if (common->ani.caldone)
				common->ani.resetcal_timer = timestamp;
S
Sujith 已提交
467 468 469 470
		}
	}

	/* Verify whether we must check ANI */
471 472
	if ((timestamp - common->ani.checkani_timer) >=
	     ah->config.ani_poll_interval) {
S
Sujith 已提交
473
		aniflag = true;
474
		common->ani.checkani_timer = timestamp;
S
Sujith 已提交
475 476 477 478 479
	}

	/* Skip all processing if there's nothing to do. */
	if (longcal || shortcal || aniflag) {
		/* Call ANI routine if necessary */
480 481
		if (aniflag) {
			spin_lock_irqsave(&common->cc_lock, flags);
482
			ath9k_hw_ani_monitor(ah, ah->curchan);
483
			ath_update_survey_stats(sc);
484 485
			spin_unlock_irqrestore(&common->cc_lock, flags);
		}
S
Sujith 已提交
486 487 488

		/* Perform calibration if necessary */
		if (longcal || shortcal) {
489
			common->ani.caldone =
490 491 492 493
				ath9k_hw_calibrate(ah,
						   ah->curchan,
						   common->rx_chainmask,
						   longcal);
S
Sujith 已提交
494 495 496
		}
	}

497 498
	ath9k_ps_restore(sc);

499
set_timer:
S
Sujith 已提交
500 501 502 503 504
	/*
	* Set timer interval based on previous results.
	* The interval must be the shortest necessary to satisfy ANI,
	* short calibration and long calibration.
	*/
505
	cal_interval = ATH_LONG_CALINTERVAL;
506
	if (sc->sc_ah->config.enable_ani)
507 508
		cal_interval = min(cal_interval,
				   (u32)ah->config.ani_poll_interval);
509
	if (!common->ani.caldone)
510
		cal_interval = min(cal_interval, (u32)short_cal_interval);
S
Sujith 已提交
511

512
	mod_timer(&common->ani.timer, jiffies + msecs_to_jiffies(cal_interval));
513 514
	if ((sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_PAPRD) && ah->caldata) {
		if (!ah->caldata->paprd_done)
515 516 517 518
			ieee80211_queue_work(sc->hw, &sc->paprd_work);
		else
			ath_paprd_activate(sc);
	}
S
Sujith 已提交
519 520 521 522 523
}

/*
 * Update tx/rx chainmask. For legacy association,
 * hard code chainmask to 1x1, for 11n association, use
524 525
 * the chainmask configuration, for bt coexistence, use
 * the chainmask configuration even in legacy mode.
S
Sujith 已提交
526
 */
527
void ath_update_chainmask(struct ath_softc *sc, int is_ht)
S
Sujith 已提交
528
{
529
	struct ath_hw *ah = sc->sc_ah;
530
	struct ath_common *common = ath9k_hw_common(ah);
531

532
	if ((sc->sc_flags & SC_OP_OFFCHANNEL) || is_ht ||
533
	    (ah->btcoex_hw.scheme != ATH_BTCOEX_CFG_NONE)) {
534 535
		common->tx_chainmask = ah->caps.tx_chainmask;
		common->rx_chainmask = ah->caps.rx_chainmask;
S
Sujith 已提交
536
	} else {
537 538
		common->tx_chainmask = 1;
		common->rx_chainmask = 1;
S
Sujith 已提交
539 540
	}

541
	ath_print(common, ATH_DBG_CONFIG,
542
		  "tx chmask: %d, rx chmask: %d\n",
543 544
		  common->tx_chainmask,
		  common->rx_chainmask);
S
Sujith 已提交
545 546 547 548 549 550 551 552
}

static void ath_node_attach(struct ath_softc *sc, struct ieee80211_sta *sta)
{
	struct ath_node *an;

	an = (struct ath_node *)sta->drv_priv;

553
	if (sc->sc_flags & SC_OP_TXAGGR) {
S
Sujith 已提交
554
		ath_tx_node_init(sc, an);
S
Sujith 已提交
555
		an->maxampdu = 1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
556 557
				     sta->ht_cap.ampdu_factor);
		an->mpdudensity = parse_mpdudensity(sta->ht_cap.ampdu_density);
558
		an->last_rssi = ATH_RSSI_DUMMY_MARKER;
559
	}
S
Sujith 已提交
560 561 562 563 564 565 566 567 568 569
}

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

	if (sc->sc_flags & SC_OP_TXAGGR)
		ath_tx_node_cleanup(sc, an);
}

570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
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);
	}
	ath_reset(sc, false);

out:
	ath9k_ps_restore(sc);
}

S
Sujith 已提交
589
void ath9k_tasklet(unsigned long data)
S
Sujith 已提交
590 591
{
	struct ath_softc *sc = (struct ath_softc *)data;
592
	struct ath_hw *ah = sc->sc_ah;
593
	struct ath_common *common = ath9k_hw_common(ah);
594

S
Sujith 已提交
595
	u32 status = sc->intrstatus;
F
Felix Fietkau 已提交
596
	u32 rxmask;
S
Sujith 已提交
597

598 599
	ath9k_ps_wakeup(sc);

600
	if (status & ATH9K_INT_FATAL) {
S
Sujith 已提交
601
		ath_reset(sc, false);
602
		ath9k_ps_restore(sc);
S
Sujith 已提交
603
		return;
S
Sujith 已提交
604
	}
S
Sujith 已提交
605

606 607 608
	if (!ath9k_hw_check_alive(ah))
		ieee80211_queue_work(sc->hw, &sc->hw_check_work);

F
Felix Fietkau 已提交
609 610 611 612 613 614 615
	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) {
S
Sujith 已提交
616
		spin_lock_bh(&sc->rx.rxflushlock);
F
Felix Fietkau 已提交
617 618 619 620 621 622 623

		/* 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 已提交
624
		spin_unlock_bh(&sc->rx.rxflushlock);
S
Sujith 已提交
625 626
	}

627 628 629 630 631 632
	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 已提交
633

634
	if ((status & ATH9K_INT_TSFOOR) && sc->ps_enabled) {
635 636 637 638
		/*
		 * TSF sync does not look correct; remain awake to sync with
		 * the next Beacon.
		 */
639 640
		ath_print(common, ATH_DBG_PS,
			  "TSFOOR - Sync with next Beacon\n");
S
Sujith 已提交
641
		sc->ps_flags |= PS_WAIT_FOR_BEACON | PS_BEACON_SYNC;
642 643
	}

644
	if (ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
645 646 647
		if (status & ATH9K_INT_GENTIMER)
			ath_gen_timer_isr(sc->sc_ah);

S
Sujith 已提交
648
	/* re-enable hardware interrupt */
P
Pavel Roskin 已提交
649
	ath9k_hw_set_interrupts(ah, ah->imask);
650
	ath9k_ps_restore(sc);
S
Sujith 已提交
651 652
}

653
irqreturn_t ath_isr(int irq, void *dev)
S
Sujith 已提交
654
{
S
Sujith 已提交
655 656 657 658 659
#define SCHED_INTR (				\
		ATH9K_INT_FATAL |		\
		ATH9K_INT_RXORN |		\
		ATH9K_INT_RXEOL |		\
		ATH9K_INT_RX |			\
F
Felix Fietkau 已提交
660 661
		ATH9K_INT_RXLP |		\
		ATH9K_INT_RXHP |		\
S
Sujith 已提交
662 663 664
		ATH9K_INT_TX |			\
		ATH9K_INT_BMISS |		\
		ATH9K_INT_CST |			\
665 666
		ATH9K_INT_TSFOOR |		\
		ATH9K_INT_GENTIMER)
S
Sujith 已提交
667

S
Sujith 已提交
668
	struct ath_softc *sc = dev;
669
	struct ath_hw *ah = sc->sc_ah;
670
	struct ath_common *common = ath9k_hw_common(ah);
S
Sujith 已提交
671 672 673
	enum ath9k_int status;
	bool sched = false;

S
Sujith 已提交
674 675 676 677 678 679 680
	/*
	 * 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 已提交
681

S
Sujith 已提交
682 683 684

	/* shared irq, not for us */

685
	if (!ath9k_hw_intrpend(ah))
S
Sujith 已提交
686 687 688 689 690 691 692 693 694
		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 已提交
695
	status &= ah->imask;	/* discard unasked-for bits */
S
Sujith 已提交
696

S
Sujith 已提交
697 698 699 700
	/*
	 * If there are no status bits set, then this interrupt was not
	 * for me (should have been caught above).
	 */
701
	if (!status)
S
Sujith 已提交
702
		return IRQ_NONE;
S
Sujith 已提交
703

S
Sujith 已提交
704 705 706 707 708 709 710 711 712 713
	/* 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 已提交
714 715
	if ((status & ATH9K_INT_FATAL) || ((status & ATH9K_INT_RXORN) &&
	    !(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)))
S
Sujith 已提交
716 717
		goto chip_reset;

718 719
	if ((ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) &&
	    (status & ATH9K_INT_BB_WATCHDOG)) {
720 721 722

		spin_lock(&common->cc_lock);
		ath_hw_cycle_counters_update(common);
723
		ar9003_hw_bb_watchdog_dbg_info(ah);
724 725
		spin_unlock(&common->cc_lock);

726 727 728
		goto chip_reset;
	}

S
Sujith 已提交
729 730 731 732 733 734
	if (status & ATH9K_INT_SWBA)
		tasklet_schedule(&sc->bcon_tasklet);

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

F
Felix Fietkau 已提交
735 736 737 738 739 740 741
	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 已提交
742
	if (status & ATH9K_INT_MIB) {
S
Sujith 已提交
743
		/*
S
Sujith 已提交
744 745 746
		 * Disable interrupts until we service the MIB
		 * interrupt; otherwise it will continue to
		 * fire.
S
Sujith 已提交
747
		 */
S
Sujith 已提交
748 749 750 751 752 753
		ath9k_hw_set_interrupts(ah, 0);
		/*
		 * Let the hal handle the event. We assume
		 * it will clear whatever condition caused
		 * the interrupt.
		 */
754
		spin_lock(&common->cc_lock);
755
		ath9k_hw_proc_mib_event(ah);
756
		spin_unlock(&common->cc_lock);
P
Pavel Roskin 已提交
757
		ath9k_hw_set_interrupts(ah, ah->imask);
S
Sujith 已提交
758
	}
S
Sujith 已提交
759

760 761
	if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
		if (status & ATH9K_INT_TIM_TIMER) {
S
Sujith 已提交
762 763
			/* Clear RxAbort bit so that we can
			 * receive frames */
764
			ath9k_setpower(sc, ATH9K_PM_AWAKE);
765
			ath9k_hw_setrxabort(sc->sc_ah, 0);
S
Sujith 已提交
766
			sc->ps_flags |= PS_WAIT_FOR_BEACON;
S
Sujith 已提交
767
		}
S
Sujith 已提交
768 769

chip_reset:
S
Sujith 已提交
770

771 772
	ath_debug_stat_interrupt(sc, status);

S
Sujith 已提交
773 774
	if (sched) {
		/* turn off every interrupt except SWBA */
P
Pavel Roskin 已提交
775
		ath9k_hw_set_interrupts(ah, (ah->imask & ATH9K_INT_SWBA));
S
Sujith 已提交
776 777 778 779
		tasklet_schedule(&sc->intr_tq);
	}

	return IRQ_HANDLED;
S
Sujith 已提交
780 781

#undef SCHED_INTR
S
Sujith 已提交
782 783
}

784
static u32 ath_get_extchanmode(struct ath_softc *sc,
785
			       struct ieee80211_channel *chan,
S
Sujith 已提交
786
			       enum nl80211_channel_type channel_type)
787 788 789 790 791
{
	u32 chanmode = 0;

	switch (chan->band) {
	case IEEE80211_BAND_2GHZ:
S
Sujith 已提交
792 793 794
		switch(channel_type) {
		case NL80211_CHAN_NO_HT:
		case NL80211_CHAN_HT20:
795
			chanmode = CHANNEL_G_HT20;
S
Sujith 已提交
796 797
			break;
		case NL80211_CHAN_HT40PLUS:
798
			chanmode = CHANNEL_G_HT40PLUS;
S
Sujith 已提交
799 800
			break;
		case NL80211_CHAN_HT40MINUS:
801
			chanmode = CHANNEL_G_HT40MINUS;
S
Sujith 已提交
802 803
			break;
		}
804 805
		break;
	case IEEE80211_BAND_5GHZ:
S
Sujith 已提交
806 807 808
		switch(channel_type) {
		case NL80211_CHAN_NO_HT:
		case NL80211_CHAN_HT20:
809
			chanmode = CHANNEL_A_HT20;
S
Sujith 已提交
810 811
			break;
		case NL80211_CHAN_HT40PLUS:
812
			chanmode = CHANNEL_A_HT40PLUS;
S
Sujith 已提交
813 814
			break;
		case NL80211_CHAN_HT40MINUS:
815
			chanmode = CHANNEL_A_HT40MINUS;
S
Sujith 已提交
816 817
			break;
		}
818 819 820 821 822 823 824 825
		break;
	default:
		break;
	}

	return chanmode;
}

826
static void ath9k_bss_assoc_info(struct ath_softc *sc,
S
Sujith 已提交
827
				 struct ieee80211_vif *vif,
828
				 struct ieee80211_bss_conf *bss_conf)
829
{
830
	struct ath_hw *ah = sc->sc_ah;
831
	struct ath_common *common = ath9k_hw_common(ah);
832

833
	if (bss_conf->assoc) {
834 835 836
		ath_print(common, ATH_DBG_CONFIG,
			  "Bss Info ASSOC %d, bssid: %pM\n",
			   bss_conf->aid, common->curbssid);
837

838
		/* New association, store aid */
839
		common->curaid = bss_conf->aid;
840
		ath9k_hw_write_associd(ah);
841 842 843 844 845 846

		/*
		 * Request a re-configuration of Beacon related timers
		 * on the receipt of the first Beacon frame (i.e.,
		 * after time sync with the AP).
		 */
S
Sujith 已提交
847
		sc->ps_flags |= PS_BEACON_SYNC;
848

849
		/* Configure the beacon */
850
		ath_beacon_config(sc, vif);
851

852
		/* Reset rssi stats */
853
		sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
854

855
		sc->sc_flags |= SC_OP_ANI_RUN;
856
		ath_start_ani(common);
857
	} else {
858
		ath_print(common, ATH_DBG_CONFIG, "Bss Info DISASSOC\n");
859
		common->curaid = 0;
860
		/* Stop ANI */
861
		sc->sc_flags &= ~SC_OP_ANI_RUN;
862
		del_timer_sync(&common->ani.timer);
863
	}
864
}
865

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

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

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

S
Sujith 已提交
879
	spin_lock_bh(&sc->sc_resetlock);
880
	r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
881
	if (r) {
882
		ath_print(common, ATH_DBG_FATAL,
883
			  "Unable to reset channel (%u MHz), "
884 885
			  "reset status %d\n",
			  channel->center_freq, r);
886 887 888 889 890
	}
	spin_unlock_bh(&sc->sc_resetlock);

	ath_update_txpow(sc);
	if (ath_startrecv(sc) != 0) {
891 892
		ath_print(common, ATH_DBG_FATAL,
			  "Unable to restart recv logic\n");
893 894 895 896
		return;
	}

	if (sc->sc_flags & SC_OP_BEACONS)
897
		ath_beacon_config(sc, NULL);	/* restart beacons */
898 899

	/* Re-Enable  interrupts */
P
Pavel Roskin 已提交
900
	ath9k_hw_set_interrupts(ah, ah->imask);
901 902

	/* Enable LED */
903
	ath9k_hw_cfg_output(ah, ah->led_pin,
904
			    AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
905
	ath9k_hw_set_gpio(ah, ah->led_pin, 0);
906

907
	ieee80211_wake_queues(hw);
908
	ath9k_ps_restore(sc);
909 910
}

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

917
	ath9k_ps_wakeup(sc);
918
	ieee80211_stop_queues(hw);
919

920 921 922 923 924 925 926 927
	/*
	 * 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);
	}
928 929 930 931

	/* Disable interrupts */
	ath9k_hw_set_interrupts(ah, 0);

S
Sujith 已提交
932
	ath_drain_all_txq(sc, false);	/* clear pending tx frames */
933 934 935
	ath_stoprecv(sc);		/* turn off frame recv */
	ath_flushrecv(sc);		/* flush recv queue */

936
	if (!ah->curchan)
937
		ah->curchan = ath_get_curchannel(sc, hw);
938

939
	spin_lock_bh(&sc->sc_resetlock);
940
	r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
941
	if (r) {
942
		ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_FATAL,
943
			  "Unable to reset channel (%u MHz), "
944 945
			  "reset status %d\n",
			  channel->center_freq, r);
946 947 948 949
	}
	spin_unlock_bh(&sc->sc_resetlock);

	ath9k_hw_phy_disable(ah);
V
Vivek Natarajan 已提交
950
	ath9k_hw_configpcipowersave(ah, 1, 1);
951
	ath9k_ps_restore(sc);
952
	ath9k_setpower(sc, ATH9K_PM_FULL_SLEEP);
953 954
}

S
Sujith 已提交
955 956
int ath_reset(struct ath_softc *sc, bool retry_tx)
{
957
	struct ath_hw *ah = sc->sc_ah;
958
	struct ath_common *common = ath9k_hw_common(ah);
959
	struct ieee80211_hw *hw = sc->hw;
960
	int r;
S
Sujith 已提交
961

S
Sujith 已提交
962 963 964
	/* Stop ANI */
	del_timer_sync(&common->ani.timer);

S
Sujith 已提交
965 966
	ieee80211_stop_queues(hw);

S
Sujith 已提交
967
	ath9k_hw_set_interrupts(ah, 0);
S
Sujith 已提交
968
	ath_drain_all_txq(sc, retry_tx);
S
Sujith 已提交
969 970 971 972
	ath_stoprecv(sc);
	ath_flushrecv(sc);

	spin_lock_bh(&sc->sc_resetlock);
973
	r = ath9k_hw_reset(ah, sc->sc_ah->curchan, ah->caldata, false);
974
	if (r)
975 976
		ath_print(common, ATH_DBG_FATAL,
			  "Unable to reset hardware; reset status %d\n", r);
S
Sujith 已提交
977 978 979
	spin_unlock_bh(&sc->sc_resetlock);

	if (ath_startrecv(sc) != 0)
980 981
		ath_print(common, ATH_DBG_FATAL,
			  "Unable to start recv logic\n");
S
Sujith 已提交
982 983 984 985 986 987 988 989

	/*
	 * 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);

990
	if ((sc->sc_flags & SC_OP_BEACONS) || !(sc->sc_flags & (SC_OP_OFFCHANNEL)))
991
		ath_beacon_config(sc, NULL);	/* restart beacons */
S
Sujith 已提交
992

P
Pavel Roskin 已提交
993
	ath9k_hw_set_interrupts(ah, ah->imask);
S
Sujith 已提交
994 995 996 997 998

	if (retry_tx) {
		int i;
		for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
			if (ATH_TXQ_SETUP(sc, i)) {
S
Sujith 已提交
999 1000 1001
				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 已提交
1002 1003 1004 1005
			}
		}
	}

S
Sujith 已提交
1006 1007
	ieee80211_wake_queues(hw);

S
Sujith 已提交
1008 1009 1010
	/* Start ANI */
	ath_start_ani(common);

1011
	return r;
S
Sujith 已提交
1012 1013
}

1014
static int ath_get_hal_qnum(u16 queue, struct ath_softc *sc)
S
Sujith 已提交
1015 1016 1017 1018 1019
{
	int qnum;

	switch (queue) {
	case 0:
1020
		qnum = sc->tx.hwq_map[WME_AC_VO];
S
Sujith 已提交
1021 1022
		break;
	case 1:
1023
		qnum = sc->tx.hwq_map[WME_AC_VI];
S
Sujith 已提交
1024 1025
		break;
	case 2:
1026
		qnum = sc->tx.hwq_map[WME_AC_BE];
S
Sujith 已提交
1027 1028
		break;
	case 3:
1029
		qnum = sc->tx.hwq_map[WME_AC_BK];
S
Sujith 已提交
1030 1031
		break;
	default:
1032
		qnum = sc->tx.hwq_map[WME_AC_BE];
S
Sujith 已提交
1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043
		break;
	}

	return qnum;
}

int ath_get_mac80211_qnum(u32 queue, struct ath_softc *sc)
{
	int qnum;

	switch (queue) {
1044
	case WME_AC_VO:
S
Sujith 已提交
1045 1046
		qnum = 0;
		break;
1047
	case WME_AC_VI:
S
Sujith 已提交
1048 1049
		qnum = 1;
		break;
1050
	case WME_AC_BE:
S
Sujith 已提交
1051 1052
		qnum = 2;
		break;
1053
	case WME_AC_BK:
S
Sujith 已提交
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063
		qnum = 3;
		break;
	default:
		qnum = -1;
		break;
	}

	return qnum;
}

1064 1065
/* XXX: Remove me once we don't depend on ath9k_channel for all
 * this redundant data */
1066 1067
void ath9k_update_ichannel(struct ath_softc *sc, struct ieee80211_hw *hw,
			   struct ath9k_channel *ichan)
1068 1069 1070 1071 1072 1073 1074 1075 1076
{
	struct ieee80211_channel *chan = hw->conf.channel;
	struct ieee80211_conf *conf = &hw->conf;

	ichan->channel = chan->center_freq;
	ichan->chan = chan;

	if (chan->band == IEEE80211_BAND_2GHZ) {
		ichan->chanmode = CHANNEL_G;
S
Sujith 已提交
1077
		ichan->channelFlags = CHANNEL_2GHZ | CHANNEL_OFDM | CHANNEL_G;
1078 1079 1080 1081 1082
	} else {
		ichan->chanmode = CHANNEL_A;
		ichan->channelFlags = CHANNEL_5GHZ | CHANNEL_OFDM;
	}

L
Luis R. Rodriguez 已提交
1083
	if (conf_is_ht(conf))
1084 1085 1086 1087
		ichan->chanmode = ath_get_extchanmode(sc, chan,
					    conf->channel_type);
}

S
Sujith 已提交
1088 1089 1090 1091
/**********************/
/* mac80211 callbacks */
/**********************/

1092
static int ath9k_start(struct ieee80211_hw *hw)
1093
{
1094 1095
	struct ath_wiphy *aphy = hw->priv;
	struct ath_softc *sc = aphy->sc;
1096
	struct ath_hw *ah = sc->sc_ah;
1097
	struct ath_common *common = ath9k_hw_common(ah);
1098
	struct ieee80211_channel *curchan = hw->conf.channel;
S
Sujith 已提交
1099
	struct ath9k_channel *init_channel;
1100
	int r;
1101

1102 1103 1104
	ath_print(common, ATH_DBG_CONFIG,
		  "Starting driver with initial channel: %d MHz\n",
		  curchan->center_freq);
1105

1106 1107
	mutex_lock(&sc->mutex);

1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
	if (ath9k_wiphy_started(sc)) {
		if (sc->chan_idx == curchan->hw_value) {
			/*
			 * Already on the operational channel, the new wiphy
			 * can be marked active.
			 */
			aphy->state = ATH_WIPHY_ACTIVE;
			ieee80211_wake_queues(hw);
		} else {
			/*
			 * Another wiphy is on another channel, start the new
			 * wiphy in paused state.
			 */
			aphy->state = ATH_WIPHY_PAUSED;
			ieee80211_stop_queues(hw);
		}
		mutex_unlock(&sc->mutex);
		return 0;
	}
	aphy->state = ATH_WIPHY_ACTIVE;

1129
	/* setup initial channel */
1130

1131
	sc->chan_idx = curchan->hw_value;
1132

1133
	init_channel = ath_get_curchannel(sc, hw);
S
Sujith 已提交
1134 1135

	/* Reset SERDES registers */
1136
	ath9k_hw_configpcipowersave(ah, 0, 0);
S
Sujith 已提交
1137 1138 1139 1140 1141 1142 1143 1144 1145

	/*
	 * 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.
	 */
	spin_lock_bh(&sc->sc_resetlock);
1146
	r = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
1147
	if (r) {
1148 1149 1150 1151
		ath_print(common, ATH_DBG_FATAL,
			  "Unable to reset hardware; reset status %d "
			  "(freq %u MHz)\n", r,
			  curchan->center_freq);
S
Sujith 已提交
1152
		spin_unlock_bh(&sc->sc_resetlock);
1153
		goto mutex_unlock;
S
Sujith 已提交
1154 1155 1156 1157 1158 1159 1160 1161
	}
	spin_unlock_bh(&sc->sc_resetlock);

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

S
Sujith 已提交
1163 1164 1165 1166 1167 1168 1169 1170
	/*
	 * 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) {
1171 1172
		ath_print(common, ATH_DBG_FATAL,
			  "Unable to start recv logic\n");
1173 1174
		r = -EIO;
		goto mutex_unlock;
1175
	}
1176

S
Sujith 已提交
1177
	/* Setup our intr mask. */
F
Felix Fietkau 已提交
1178 1179 1180 1181 1182
	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)
1183 1184 1185
		ah->imask |= ATH9K_INT_RXHP |
			     ATH9K_INT_RXLP |
			     ATH9K_INT_BB_WATCHDOG;
F
Felix Fietkau 已提交
1186 1187
	else
		ah->imask |= ATH9K_INT_RX;
S
Sujith 已提交
1188

1189
	ah->imask |= ATH9K_INT_GTT;
S
Sujith 已提交
1190

1191
	if (ah->caps.hw_caps & ATH9K_HW_CAP_HT)
P
Pavel Roskin 已提交
1192
		ah->imask |= ATH9K_INT_CST;
S
Sujith 已提交
1193 1194 1195 1196

	sc->sc_flags &= ~SC_OP_INVALID;

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

1200
	ieee80211_wake_queues(hw);
S
Sujith 已提交
1201

1202
	ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work, 0);
1203

1204 1205
	if ((ah->btcoex_hw.scheme != ATH_BTCOEX_CFG_NONE) &&
	    !ah->btcoex_hw.enabled) {
1206 1207
		ath9k_hw_btcoex_set_weight(ah, AR_BT_COEX_WGHT,
					   AR_STOMP_LOW_WLAN_WGHT);
1208
		ath9k_hw_btcoex_enable(ah);
1209

1210 1211
		if (common->bus_ops->bt_coex_prep)
			common->bus_ops->bt_coex_prep(common);
1212
		if (ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
1213
			ath9k_btcoex_timer_resume(sc);
1214 1215
	}

1216 1217 1218
mutex_unlock:
	mutex_unlock(&sc->mutex);

1219
	return r;
1220 1221
}

1222 1223
static int ath9k_tx(struct ieee80211_hw *hw,
		    struct sk_buff *skb)
1224
{
S
Sujith 已提交
1225
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1226 1227
	struct ath_wiphy *aphy = hw->priv;
	struct ath_softc *sc = aphy->sc;
1228
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
S
Sujith 已提交
1229
	struct ath_tx_control txctl;
1230 1231
	int padpos, padsize;
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1232
	int qnum;
S
Sujith 已提交
1233

1234
	if (aphy->state != ATH_WIPHY_ACTIVE && aphy->state != ATH_WIPHY_SCAN) {
1235 1236 1237
		ath_print(common, ATH_DBG_XMIT,
			  "ath9k: %s: TX in unexpected wiphy state "
			  "%d\n", wiphy_name(hw->wiphy), aphy->state);
1238 1239 1240
		goto exit;
	}

1241
	if (sc->ps_enabled) {
1242 1243 1244 1245 1246 1247 1248
		/*
		 * 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)) {
1249 1250
			ath_print(common, ATH_DBG_PS, "Add PM=1 for a TX frame "
				  "while in PS mode\n");
1251 1252 1253 1254
			hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
		}
	}

1255 1256 1257 1258 1259 1260 1261
	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);
1262 1263
		if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
			ath9k_hw_setrxabort(sc->sc_ah, 0);
1264
		if (ieee80211_is_pspoll(hdr->frame_control)) {
1265 1266
			ath_print(common, ATH_DBG_PS,
				  "Sending PS-Poll to pick a buffered frame\n");
S
Sujith 已提交
1267
			sc->ps_flags |= PS_WAIT_FOR_PSPOLL_DATA;
1268
		} else {
1269 1270
			ath_print(common, ATH_DBG_PS,
				  "Wake up to complete TX\n");
S
Sujith 已提交
1271
			sc->ps_flags |= PS_WAIT_FOR_TX_ACK;
1272 1273 1274 1275 1276 1277 1278 1279 1280
		}
		/*
		 * 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 已提交
1281
	memset(&txctl, 0, sizeof(struct ath_tx_control));
1282

1283 1284 1285 1286 1287 1288 1289
	/*
	 * As a temporary workaround, assign seq# here; this will likely need
	 * to be cleaned up to work better with Beacon transmission and virtual
	 * BSSes.
	 */
	if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
		if (info->flags & IEEE80211_TX_CTL_FIRST_FRAGMENT)
S
Sujith 已提交
1290
			sc->tx.seq_no += 0x10;
1291
		hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
S
Sujith 已提交
1292
		hdr->seq_ctrl |= cpu_to_le16(sc->tx.seq_no);
1293
	}
1294

1295
	/* Add the padding after the header if this is not already done */
1296 1297 1298
	padpos = ath9k_cmn_padpos(hdr->frame_control);
	padsize = padpos & 3;
	if (padsize && skb->len>padpos) {
1299 1300 1301
		if (skb_headroom(skb) < padsize)
			return -1;
		skb_push(skb, padsize);
1302
		memmove(skb->data, skb->data + padsize, padpos);
1303 1304
	}

1305 1306
	qnum = ath_get_hal_qnum(skb_get_queue_mapping(skb), sc);
	txctl.txq = &sc->tx.txq[qnum];
S
Sujith 已提交
1307

1308
	ath_print(common, ATH_DBG_XMIT, "transmitting packet, skb: %p\n", skb);
1309

1310
	if (ath_tx_start(hw, skb, &txctl) != 0) {
1311
		ath_print(common, ATH_DBG_XMIT, "TX failed\n");
S
Sujith 已提交
1312
		goto exit;
1313 1314
	}

S
Sujith 已提交
1315 1316 1317
	return 0;
exit:
	dev_kfree_skb_any(skb);
1318
	return 0;
1319 1320
}

1321
static void ath9k_stop(struct ieee80211_hw *hw)
1322
{
1323 1324
	struct ath_wiphy *aphy = hw->priv;
	struct ath_softc *sc = aphy->sc;
1325
	struct ath_hw *ah = sc->sc_ah;
1326
	struct ath_common *common = ath9k_hw_common(ah);
1327
	int i;
1328

S
Sujith 已提交
1329 1330
	mutex_lock(&sc->mutex);

1331 1332
	aphy->state = ATH_WIPHY_INACTIVE;

1333 1334 1335
	if (led_blink)
		cancel_delayed_work_sync(&sc->ath_led_blink_work);

1336
	cancel_delayed_work_sync(&sc->tx_complete_work);
1337
	cancel_work_sync(&sc->paprd_work);
1338
	cancel_work_sync(&sc->hw_check_work);
1339

1340 1341 1342 1343 1344 1345
	for (i = 0; i < sc->num_sec_wiphy; i++) {
		if (sc->sec_wiphy[i])
			break;
	}

	if (i == sc->num_sec_wiphy) {
1346 1347 1348 1349
		cancel_delayed_work_sync(&sc->wiphy_work);
		cancel_work_sync(&sc->chan_work);
	}

S
Sujith 已提交
1350
	if (sc->sc_flags & SC_OP_INVALID) {
1351
		ath_print(common, ATH_DBG_ANY, "Device not present\n");
S
Sujith 已提交
1352
		mutex_unlock(&sc->mutex);
S
Sujith 已提交
1353 1354
		return;
	}
1355

1356 1357 1358 1359 1360
	if (ath9k_wiphy_started(sc)) {
		mutex_unlock(&sc->mutex);
		return; /* another wiphy still in use */
	}

1361 1362 1363
	/* Ensure HW is awake when we try to shut it down. */
	ath9k_ps_wakeup(sc);

1364
	if (ah->btcoex_hw.enabled) {
1365
		ath9k_hw_btcoex_disable(ah);
1366
		if (ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
1367
			ath9k_btcoex_timer_pause(sc);
1368 1369
	}

S
Sujith 已提交
1370 1371
	/* make sure h/w will not generate any interrupt
	 * before setting the invalid flag. */
1372
	ath9k_hw_set_interrupts(ah, 0);
S
Sujith 已提交
1373 1374

	if (!(sc->sc_flags & SC_OP_INVALID)) {
S
Sujith 已提交
1375
		ath_drain_all_txq(sc, false);
S
Sujith 已提交
1376
		ath_stoprecv(sc);
1377
		ath9k_hw_phy_disable(ah);
S
Sujith 已提交
1378
	} else
S
Sujith 已提交
1379
		sc->rx.rxlink = NULL;
S
Sujith 已提交
1380 1381

	/* disable HAL and put h/w to sleep */
1382 1383
	ath9k_hw_disable(ah);
	ath9k_hw_configpcipowersave(ah, 1, 1);
1384 1385 1386
	ath9k_ps_restore(sc);

	/* Finally, put the chip in FULL SLEEP mode */
1387
	ath9k_setpower(sc, ATH9K_PM_FULL_SLEEP);
S
Sujith 已提交
1388 1389

	sc->sc_flags |= SC_OP_INVALID;
1390

1391 1392
	mutex_unlock(&sc->mutex);

1393
	ath_print(common, ATH_DBG_CONFIG, "Driver halt\n");
1394 1395
}

1396
static int ath9k_add_interface(struct ieee80211_hw *hw,
1397
			       struct ieee80211_vif *vif)
1398
{
1399 1400
	struct ath_wiphy *aphy = hw->priv;
	struct ath_softc *sc = aphy->sc;
P
Pavel Roskin 已提交
1401 1402
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
1403
	struct ath_vif *avp = (void *)vif->drv_priv;
1404
	enum nl80211_iftype ic_opmode = NL80211_IFTYPE_UNSPECIFIED;
1405
	int ret = 0;
1406

1407 1408
	mutex_lock(&sc->mutex);

1409
	switch (vif->type) {
1410
	case NL80211_IFTYPE_STATION:
1411
		ic_opmode = NL80211_IFTYPE_STATION;
1412
		break;
B
Bill Jordan 已提交
1413 1414 1415
	case NL80211_IFTYPE_WDS:
		ic_opmode = NL80211_IFTYPE_WDS;
		break;
1416 1417
	case NL80211_IFTYPE_ADHOC:
	case NL80211_IFTYPE_AP:
1418
	case NL80211_IFTYPE_MESH_POINT:
1419 1420 1421 1422
		if (sc->nbcnvifs >= ATH_BCBUF) {
			ret = -ENOBUFS;
			goto out;
		}
1423
		ic_opmode = vif->type;
1424 1425
		break;
	default:
1426
		ath_print(common, ATH_DBG_FATAL,
1427
			"Interface type %d not yet supported\n", vif->type);
1428 1429
		ret = -EOPNOTSUPP;
		goto out;
1430 1431
	}

1432 1433
	ath_print(common, ATH_DBG_CONFIG,
		  "Attach a VIF of type: %d\n", ic_opmode);
1434

S
Sujith 已提交
1435
	/* Set the VIF opmode */
S
Sujith 已提交
1436 1437 1438
	avp->av_opmode = ic_opmode;
	avp->av_bslot = -1;

1439
	sc->nvifs++;
1440

1441
	ath9k_set_bssid_mask(hw, vif);
1442

1443 1444 1445
	if (sc->nvifs > 1)
		goto out; /* skip global settings for secondary vif */

S
Sujith 已提交
1446
	if (ic_opmode == NL80211_IFTYPE_AP) {
P
Pavel Roskin 已提交
1447
		ath9k_hw_set_tsfadjust(ah, 1);
S
Sujith 已提交
1448 1449
		sc->sc_flags |= SC_OP_TSF_RESET;
	}
S
Sujith 已提交
1450 1451

	/* Set the device opmode */
P
Pavel Roskin 已提交
1452
	ah->opmode = ic_opmode;
S
Sujith 已提交
1453

1454 1455 1456 1457
	/*
	 * Enable MIB interrupts when there are hardware phy counters.
	 * Note we only do this (at the moment) for station mode.
	 */
1458 1459 1460
	if ((vif->type == NL80211_IFTYPE_STATION) ||
	    (vif->type == NL80211_IFTYPE_ADHOC) ||
	    (vif->type == NL80211_IFTYPE_MESH_POINT)) {
1461 1462
		if (ah->config.enable_ani)
			ah->imask |= ATH9K_INT_MIB;
P
Pavel Roskin 已提交
1463
		ah->imask |= ATH9K_INT_TSFOOR;
1464 1465
	}

P
Pavel Roskin 已提交
1466
	ath9k_hw_set_interrupts(ah, ah->imask);
1467

1468 1469
	if (vif->type == NL80211_IFTYPE_AP    ||
	    vif->type == NL80211_IFTYPE_ADHOC ||
1470 1471
	    vif->type == NL80211_IFTYPE_MONITOR) {
		sc->sc_flags |= SC_OP_ANI_RUN;
1472
		ath_start_ani(common);
1473
	}
1474

1475
out:
1476
	mutex_unlock(&sc->mutex);
1477
	return ret;
1478 1479
}

1480
static void ath9k_remove_interface(struct ieee80211_hw *hw,
1481
				   struct ieee80211_vif *vif)
1482
{
1483 1484
	struct ath_wiphy *aphy = hw->priv;
	struct ath_softc *sc = aphy->sc;
1485
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1486
	struct ath_vif *avp = (void *)vif->drv_priv;
1487
	int i;
1488

1489
	ath_print(common, ATH_DBG_CONFIG, "Detach Interface\n");
1490

1491 1492
	mutex_lock(&sc->mutex);

1493
	/* Stop ANI */
1494
	sc->sc_flags &= ~SC_OP_ANI_RUN;
1495
	del_timer_sync(&common->ani.timer);
J
Jouni Malinen 已提交
1496

1497
	/* Reclaim beacon resources */
1498 1499 1500
	if ((sc->sc_ah->opmode == NL80211_IFTYPE_AP) ||
	    (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC) ||
	    (sc->sc_ah->opmode == NL80211_IFTYPE_MESH_POINT)) {
1501
		ath9k_ps_wakeup(sc);
S
Sujith 已提交
1502
		ath9k_hw_stoptxdma(sc->sc_ah, sc->beacon.beaconq);
1503
		ath9k_ps_restore(sc);
J
Jouni Malinen 已提交
1504
	}
1505

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

1509
	for (i = 0; i < ARRAY_SIZE(sc->beacon.bslot); i++) {
1510
		if (sc->beacon.bslot[i] == vif) {
1511 1512 1513
			printk(KERN_DEBUG "%s: vif had allocated beacon "
			       "slot\n", __func__);
			sc->beacon.bslot[i] = NULL;
1514
			sc->beacon.bslot_aphy[i] = NULL;
1515 1516 1517
		}
	}

S
Sujith 已提交
1518
	sc->nvifs--;
1519 1520

	mutex_unlock(&sc->mutex);
1521 1522
}

1523
static void ath9k_enable_ps(struct ath_softc *sc)
1524
{
P
Pavel Roskin 已提交
1525 1526
	struct ath_hw *ah = sc->sc_ah;

1527
	sc->ps_enabled = true;
P
Pavel Roskin 已提交
1528 1529 1530 1531
	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);
1532
		}
1533
		ath9k_hw_setrxabort(ah, 1);
1534 1535 1536
	}
}

1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556
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);
		}
	}

}

1557
static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
1558
{
1559 1560
	struct ath_wiphy *aphy = hw->priv;
	struct ath_softc *sc = aphy->sc;
1561 1562
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
1563
	struct ieee80211_conf *conf = &hw->conf;
1564
	bool disable_radio;
1565

1566
	mutex_lock(&sc->mutex);
1567

1568 1569 1570 1571 1572 1573
	/*
	 * 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.
	 */
1574
	if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1575 1576 1577
		bool enable_radio;
		bool all_wiphys_idle;
		bool idle = !!(conf->flags & IEEE80211_CONF_IDLE);
1578 1579 1580

		spin_lock_bh(&sc->wiphy_lock);
		all_wiphys_idle =  ath9k_all_wiphys_idle(sc);
1581 1582
		ath9k_set_wiphy_idle(aphy, idle);

1583
		enable_radio = (!idle && all_wiphys_idle);
1584 1585 1586 1587 1588 1589 1590

		/*
		 * After we unlock here its possible another wiphy
		 * can be re-renabled so to account for that we will
		 * only disable the radio toward the end of this routine
		 * if by then all wiphys are still idle.
		 */
1591 1592
		spin_unlock_bh(&sc->wiphy_lock);

1593
		if (enable_radio) {
1594
			sc->ps_idle = false;
1595
			ath_radio_enable(sc, hw);
1596 1597
			ath_print(common, ATH_DBG_CONFIG,
				  "not-idle: enabling radio\n");
1598 1599 1600
		}
	}

1601 1602 1603 1604 1605 1606
	/*
	 * 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.
	 */
1607
	if (changed & IEEE80211_CONF_CHANGE_PS) {
1608 1609
		unsigned long flags;
		spin_lock_irqsave(&sc->sc_pm_lock, flags);
1610 1611
		if (conf->flags & IEEE80211_CONF_PS)
			ath9k_enable_ps(sc);
1612 1613
		else
			ath9k_disable_ps(sc);
1614
		spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
1615 1616
	}

S
Sujith 已提交
1617 1618 1619 1620 1621 1622 1623 1624
	if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
		if (conf->flags & IEEE80211_CONF_MONITOR) {
			ath_print(common, ATH_DBG_CONFIG,
				  "HW opmode set to Monitor mode\n");
			sc->sc_ah->opmode = NL80211_IFTYPE_MONITOR;
		}
	}

1625
	if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
1626
		struct ieee80211_channel *curchan = hw->conf.channel;
1627
		int pos = curchan->hw_value;
1628 1629 1630 1631 1632
		int old_pos = -1;
		unsigned long flags;

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

1634 1635
		aphy->chan_idx = pos;
		aphy->chan_is_ht = conf_is_ht(conf);
1636 1637 1638 1639
		if (hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)
			sc->sc_flags |= SC_OP_OFFCHANNEL;
		else
			sc->sc_flags &= ~SC_OP_OFFCHANNEL;
1640

1641 1642 1643 1644 1645 1646 1647 1648 1649 1650
		if (aphy->state == ATH_WIPHY_SCAN ||
		    aphy->state == ATH_WIPHY_ACTIVE)
			ath9k_wiphy_pause_all_forced(sc, aphy);
		else {
			/*
			 * Do not change operational channel based on a paused
			 * wiphy changes.
			 */
			goto skip_chan_change;
		}
1651

1652 1653
		ath_print(common, ATH_DBG_CONFIG, "Set channel: %d MHz\n",
			  curchan->center_freq);
1654

1655
		/* XXX: remove me eventualy */
1656
		ath9k_update_ichannel(sc, hw, &sc->sc_ah->channels[pos]);
1657

1658
		ath_update_chainmask(sc, conf_is_ht(conf));
S
Sujith 已提交
1659

1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684
		/* 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));
		}

1685
		if (ath_set_channel(sc, hw, &sc->sc_ah->channels[pos]) < 0) {
1686 1687
			ath_print(common, ATH_DBG_FATAL,
				  "Unable to set channel\n");
1688
			mutex_unlock(&sc->mutex);
1689 1690
			return -EINVAL;
		}
1691 1692 1693 1694 1695 1696 1697 1698

		/*
		 * 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 已提交
1699
	}
1700

1701
skip_chan_change:
1702
	if (changed & IEEE80211_CONF_CHANGE_POWER) {
S
Sujith 已提交
1703
		sc->config.txpowlimit = 2 * conf->power_level;
1704 1705
		ath_update_txpow(sc);
	}
1706

1707 1708 1709 1710
	spin_lock_bh(&sc->wiphy_lock);
	disable_radio = ath9k_all_wiphys_idle(sc);
	spin_unlock_bh(&sc->wiphy_lock);

1711
	if (disable_radio) {
1712
		ath_print(common, ATH_DBG_CONFIG, "idle: disabling radio\n");
1713
		sc->ps_idle = true;
1714
		ath_radio_disable(sc, hw);
1715 1716
	}

1717
	mutex_unlock(&sc->mutex);
1718

1719 1720 1721
	return 0;
}

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

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

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

S
Sujith 已提交
1745
	sc->rx.rxfilter = *total_flags;
1746
	ath9k_ps_wakeup(sc);
1747 1748
	rfilt = ath_calcrxfilter(sc);
	ath9k_hw_setrxfilter(sc->sc_ah, rfilt);
1749
	ath9k_ps_restore(sc);
1750

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

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

1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776
	ath_node_attach(sc, sta);

	return 0;
}

static int ath9k_sta_remove(struct ieee80211_hw *hw,
			    struct ieee80211_vif *vif,
			    struct ieee80211_sta *sta)
{
	struct ath_wiphy *aphy = hw->priv;
	struct ath_softc *sc = aphy->sc;

	ath_node_detach(sc, sta);

	return 0;
1777 1778
}

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

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

1791 1792
	mutex_lock(&sc->mutex);

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

1795 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;
	qnum = ath_get_hal_qnum(queue, sc);
1800

1801 1802 1803 1804 1805
	ath_print(common, ATH_DBG_CONFIG,
		  "Configure tx [queue/halq] [%d/%d],  "
		  "aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
		  queue, qnum, params->aifs, params->cw_min,
		  params->cw_max, params->txop);
1806

1807 1808
	ret = ath_txq_update(sc, qnum, &qi);
	if (ret)
1809
		ath_print(common, ATH_DBG_FATAL, "TXQ Update failed\n");
1810

1811
	if (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC)
1812
		if ((qnum == sc->tx.hwq_map[WME_AC_BE]) && !ret)
1813 1814
			ath_beaconq_config(sc);

1815 1816
	mutex_unlock(&sc->mutex);

1817 1818
	return ret;
}
1819

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

1831 1832 1833
	if (modparam_nohwcrypt)
		return -ENOSPC;

1834
	mutex_lock(&sc->mutex);
1835
	ath9k_ps_wakeup(sc);
1836
	ath_print(common, ATH_DBG_CONFIG, "Set HW Key\n");
1837

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

1860
	ath9k_ps_restore(sc);
1861 1862
	mutex_unlock(&sc->mutex);

1863 1864
	return ret;
}
1865

1866 1867 1868 1869 1870
static void ath9k_bss_info_changed(struct ieee80211_hw *hw,
				   struct ieee80211_vif *vif,
				   struct ieee80211_bss_conf *bss_conf,
				   u32 changed)
{
1871 1872
	struct ath_wiphy *aphy = hw->priv;
	struct ath_softc *sc = aphy->sc;
1873
	struct ath_hw *ah = sc->sc_ah;
1874
	struct ath_common *common = ath9k_hw_common(ah);
1875
	struct ath_vif *avp = (void *)vif->drv_priv;
1876
	int slottime;
S
Sujith 已提交
1877
	int error;
1878

1879 1880
	mutex_lock(&sc->mutex);

S
Sujith 已提交
1881 1882 1883 1884
	if (changed & BSS_CHANGED_BSSID) {
		/* Set BSSID */
		memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
		memcpy(avp->bssid, bss_conf->bssid, ETH_ALEN);
1885
		common->curaid = 0;
1886
		ath9k_hw_write_associd(ah);
1887

S
Sujith 已提交
1888 1889
		/* Set aggregation protection mode parameters */
		sc->config.ath_aggr_prot = 0;
1890

S
Sujith 已提交
1891 1892 1893
		/* Only legacy IBSS for now */
		if (vif->type == NL80211_IFTYPE_ADHOC)
			ath_update_chainmask(sc, 0);
1894

S
Sujith 已提交
1895 1896 1897
		ath_print(common, ATH_DBG_CONFIG,
			  "BSSID: %pM aid: 0x%x\n",
			  common->curbssid, common->curaid);
1898

S
Sujith 已提交
1899 1900 1901
		/* need to reconfigure the beacon */
		sc->sc_flags &= ~SC_OP_BEACONS ;
	}
1902

S
Sujith 已提交
1903 1904 1905 1906 1907 1908 1909
	/* 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);
		error = ath_beacon_alloc(aphy, vif);
		if (!error)
			ath_beacon_config(sc, vif);
1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928
	}

	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);
		}
1929 1930
	}

S
Sujith 已提交
1931 1932 1933
	/* Disable transmission of beacons */
	if ((changed & BSS_CHANGED_BEACON_ENABLED) && !bss_conf->enable_beacon)
		ath9k_hw_stoptxdma(sc->sc_ah, sc->beacon.beaconq);
1934

S
Sujith 已提交
1935 1936 1937 1938 1939 1940 1941 1942 1943
	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);
1944 1945 1946
			error = ath_beacon_alloc(aphy, vif);
			if (!error)
				ath_beacon_config(sc, vif);
S
Sujith 已提交
1947 1948
		} else {
			ath_beacon_config(sc, vif);
1949 1950 1951
		}
	}

1952
	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1953 1954
		ath_print(common, ATH_DBG_CONFIG, "BSS Changed PREAMBLE %d\n",
			  bss_conf->use_short_preamble);
1955 1956 1957 1958 1959
		if (bss_conf->use_short_preamble)
			sc->sc_flags |= SC_OP_PREAMBLE_SHORT;
		else
			sc->sc_flags &= ~SC_OP_PREAMBLE_SHORT;
	}
1960

1961
	if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1962 1963
		ath_print(common, ATH_DBG_CONFIG, "BSS Changed CTS PROT %d\n",
			  bss_conf->use_cts_prot);
1964 1965 1966 1967 1968 1969
		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;
	}
1970

1971
	if (changed & BSS_CHANGED_ASSOC) {
1972
		ath_print(common, ATH_DBG_CONFIG, "BSS Changed ASSOC %d\n",
1973
			bss_conf->assoc);
S
Sujith 已提交
1974
		ath9k_bss_assoc_info(sc, vif, bss_conf);
1975
	}
1976 1977

	mutex_unlock(&sc->mutex);
1978
}
1979

1980 1981 1982
static u64 ath9k_get_tsf(struct ieee80211_hw *hw)
{
	u64 tsf;
1983 1984
	struct ath_wiphy *aphy = hw->priv;
	struct ath_softc *sc = aphy->sc;
1985

1986 1987 1988
	mutex_lock(&sc->mutex);
	tsf = ath9k_hw_gettsf64(sc->sc_ah);
	mutex_unlock(&sc->mutex);
1989

1990 1991
	return tsf;
}
1992

1993 1994
static void ath9k_set_tsf(struct ieee80211_hw *hw, u64 tsf)
{
1995 1996
	struct ath_wiphy *aphy = hw->priv;
	struct ath_softc *sc = aphy->sc;
1997

1998 1999 2000
	mutex_lock(&sc->mutex);
	ath9k_hw_settsf64(sc->sc_ah, tsf);
	mutex_unlock(&sc->mutex);
2001 2002
}

2003 2004
static void ath9k_reset_tsf(struct ieee80211_hw *hw)
{
2005 2006
	struct ath_wiphy *aphy = hw->priv;
	struct ath_softc *sc = aphy->sc;
2007

2008
	mutex_lock(&sc->mutex);
2009 2010

	ath9k_ps_wakeup(sc);
2011
	ath9k_hw_reset_tsf(sc->sc_ah);
2012 2013
	ath9k_ps_restore(sc);

2014
	mutex_unlock(&sc->mutex);
2015
}
2016

2017
static int ath9k_ampdu_action(struct ieee80211_hw *hw,
2018
			      struct ieee80211_vif *vif,
2019 2020 2021
			      enum ieee80211_ampdu_mlme_action action,
			      struct ieee80211_sta *sta,
			      u16 tid, u16 *ssn)
2022
{
2023 2024
	struct ath_wiphy *aphy = hw->priv;
	struct ath_softc *sc = aphy->sc;
2025
	int ret = 0;
2026

2027 2028
	local_bh_disable();

2029 2030
	switch (action) {
	case IEEE80211_AMPDU_RX_START:
2031 2032
		if (!(sc->sc_flags & SC_OP_RXAGGR))
			ret = -ENOTSUPP;
2033 2034 2035 2036
		break;
	case IEEE80211_AMPDU_RX_STOP:
		break;
	case IEEE80211_AMPDU_TX_START:
2037
		ath9k_ps_wakeup(sc);
2038 2039 2040
		ret = ath_tx_aggr_start(sc, sta, tid, ssn);
		if (!ret)
			ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
2041
		ath9k_ps_restore(sc);
2042 2043
		break;
	case IEEE80211_AMPDU_TX_STOP:
2044
		ath9k_ps_wakeup(sc);
S
Sujith 已提交
2045
		ath_tx_aggr_stop(sc, sta, tid);
2046
		ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
2047
		ath9k_ps_restore(sc);
2048
		break;
2049
	case IEEE80211_AMPDU_TX_OPERATIONAL:
2050
		ath9k_ps_wakeup(sc);
2051
		ath_tx_aggr_resume(sc, sta, tid);
2052
		ath9k_ps_restore(sc);
2053
		break;
2054
	default:
2055 2056
		ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_FATAL,
			  "Unknown AMPDU action\n");
2057 2058
	}

2059 2060
	local_bh_enable();

2061
	return ret;
2062 2063
}

2064 2065 2066 2067 2068
static int ath9k_get_survey(struct ieee80211_hw *hw, int idx,
			     struct survey_info *survey)
{
	struct ath_wiphy *aphy = hw->priv;
	struct ath_softc *sc = aphy->sc;
2069
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
2070
	struct ieee80211_supported_band *sband;
2071 2072 2073 2074 2075 2076 2077
	struct ieee80211_channel *chan;
	unsigned long flags;
	int pos;

	spin_lock_irqsave(&common->cc_lock, flags);
	if (idx == 0)
		ath_update_survey_stats(sc);
2078 2079 2080 2081 2082 2083

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

2085 2086
	if (!sband)
		sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
2087

2088 2089 2090
	if (!sband || idx >= sband->n_channels) {
		spin_unlock_irqrestore(&common->cc_lock, flags);
		return -ENOENT;
2091
	}
2092

2093 2094 2095 2096 2097 2098
	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);

2099 2100 2101
	return 0;
}

2102 2103
static void ath9k_sw_scan_start(struct ieee80211_hw *hw)
{
2104 2105
	struct ath_wiphy *aphy = hw->priv;
	struct ath_softc *sc = aphy->sc;
2106

2107
	mutex_lock(&sc->mutex);
2108 2109
	if (ath9k_wiphy_scanning(sc)) {
		/*
2110 2111 2112 2113 2114
		 * There is a race here in mac80211 but fixing it requires
		 * we revisit how we handle the scan complete callback.
		 * After mac80211 fixes we will not have configured hardware
		 * to the home channel nor would we have configured the RX
		 * filter yet.
2115
		 */
2116
		mutex_unlock(&sc->mutex);
2117 2118 2119 2120 2121
		return;
	}

	aphy->state = ATH_WIPHY_SCAN;
	ath9k_wiphy_pause_all_forced(sc, aphy);
2122
	mutex_unlock(&sc->mutex);
2123 2124
}

2125 2126 2127 2128
/*
 * XXX: this requires a revisit after the driver
 * scan_complete gets moved to another place/removed in mac80211.
 */
2129 2130
static void ath9k_sw_scan_complete(struct ieee80211_hw *hw)
{
2131 2132
	struct ath_wiphy *aphy = hw->priv;
	struct ath_softc *sc = aphy->sc;
2133

2134
	mutex_lock(&sc->mutex);
2135
	aphy->state = ATH_WIPHY_ACTIVE;
2136
	mutex_unlock(&sc->mutex);
2137 2138
}

2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150
static void ath9k_set_coverage_class(struct ieee80211_hw *hw, u8 coverage_class)
{
	struct ath_wiphy *aphy = hw->priv;
	struct ath_softc *sc = aphy->sc;
	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);
}

2151
struct ieee80211_ops ath9k_ops = {
2152 2153 2154 2155 2156 2157 2158
	.tx 		    = ath9k_tx,
	.start 		    = ath9k_start,
	.stop 		    = ath9k_stop,
	.add_interface 	    = ath9k_add_interface,
	.remove_interface   = ath9k_remove_interface,
	.config 	    = ath9k_config,
	.configure_filter   = ath9k_configure_filter,
2159 2160
	.sta_add	    = ath9k_sta_add,
	.sta_remove	    = ath9k_sta_remove,
2161 2162 2163 2164
	.conf_tx 	    = ath9k_conf_tx,
	.bss_info_changed   = ath9k_bss_info_changed,
	.set_key            = ath9k_set_key,
	.get_tsf 	    = ath9k_get_tsf,
2165
	.set_tsf 	    = ath9k_set_tsf,
2166
	.reset_tsf 	    = ath9k_reset_tsf,
2167
	.ampdu_action       = ath9k_ampdu_action,
2168
	.get_survey	    = ath9k_get_survey,
2169 2170
	.sw_scan_start      = ath9k_sw_scan_start,
	.sw_scan_complete   = ath9k_sw_scan_complete,
J
Johannes Berg 已提交
2171
	.rfkill_poll        = ath9k_rfkill_poll_state,
2172
	.set_coverage_class = ath9k_set_coverage_class,
2173
};