blob: e43c41cff25b87cc9087f6c0a695fb4f9626b06b [file] [log] [blame]
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001/*
Sujith Manoharan5b681382011-05-17 13:36:18 +05302 * Copyright (c) 2008-2011 Atheros Communications Inc.
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07003 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
Luis R. Rodriguezf078f202008-08-04 00:16:41 -070017#include <linux/nl80211.h>
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -080018#include <linux/delay.h>
Sujith394cf0a2009-02-09 13:26:54 +053019#include "ath9k.h"
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -070020#include "btcoex.h"
Luis R. Rodriguezf078f202008-08-04 00:16:41 -070021
Sujithff37e332008-11-24 12:07:55 +053022static u8 parse_mpdudensity(u8 mpdudensity)
23{
24 /*
25 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
26 * 0 for no restriction
27 * 1 for 1/4 us
28 * 2 for 1/2 us
29 * 3 for 1 us
30 * 4 for 2 us
31 * 5 for 4 us
32 * 6 for 8 us
33 * 7 for 16 us
34 */
35 switch (mpdudensity) {
36 case 0:
37 return 0;
38 case 1:
39 case 2:
40 case 3:
41 /* Our lower layer calculations limit our precision to
42 1 microsecond */
43 return 1;
44 case 4:
45 return 2;
46 case 5:
47 return 4;
48 case 6:
49 return 8;
50 case 7:
51 return 16;
52 default:
53 return 0;
54 }
55}
56
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -080057static bool ath9k_has_pending_frames(struct ath_softc *sc, struct ath_txq *txq)
58{
59 bool pending = false;
60
61 spin_lock_bh(&txq->axq_lock);
62
63 if (txq->axq_depth || !list_empty(&txq->axq_acq))
64 pending = true;
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -080065
66 spin_unlock_bh(&txq->axq_lock);
67 return pending;
68}
69
Mohammed Shafi Shajakhan6d79cb42011-05-19 17:40:46 +053070static bool ath9k_setpower(struct ath_softc *sc, enum ath9k_power_mode mode)
Luis R. Rodriguez8c77a562009-09-09 21:02:34 -070071{
72 unsigned long flags;
73 bool ret;
74
Luis R. Rodriguez9ecdef42009-09-09 21:10:09 -070075 spin_lock_irqsave(&sc->sc_pm_lock, flags);
76 ret = ath9k_hw_setpower(sc->sc_ah, mode);
77 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
Luis R. Rodriguez8c77a562009-09-09 21:02:34 -070078
79 return ret;
80}
81
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -070082void ath9k_ps_wakeup(struct ath_softc *sc)
83{
Felix Fietkau898c9142010-10-12 14:02:53 +020084 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -070085 unsigned long flags;
Felix Fietkaufbb078f2010-11-03 01:36:51 +010086 enum ath9k_power_mode power_mode;
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -070087
88 spin_lock_irqsave(&sc->sc_pm_lock, flags);
89 if (++sc->ps_usecount != 1)
90 goto unlock;
91
Felix Fietkaufbb078f2010-11-03 01:36:51 +010092 power_mode = sc->sc_ah->power_mode;
Luis R. Rodriguez9ecdef42009-09-09 21:10:09 -070093 ath9k_hw_setpower(sc->sc_ah, ATH9K_PM_AWAKE);
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -070094
Felix Fietkau898c9142010-10-12 14:02:53 +020095 /*
96 * While the hardware is asleep, the cycle counters contain no
97 * useful data. Better clear them now so that they don't mess up
98 * survey data results.
99 */
Felix Fietkaufbb078f2010-11-03 01:36:51 +0100100 if (power_mode != ATH9K_PM_AWAKE) {
101 spin_lock(&common->cc_lock);
102 ath_hw_cycle_counters_update(common);
103 memset(&common->cc_survey, 0, sizeof(common->cc_survey));
104 spin_unlock(&common->cc_lock);
105 }
Felix Fietkau898c9142010-10-12 14:02:53 +0200106
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -0700107 unlock:
108 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
109}
110
111void ath9k_ps_restore(struct ath_softc *sc)
112{
Felix Fietkau898c9142010-10-12 14:02:53 +0200113 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkauc6c539f2011-09-14 21:24:24 +0200114 enum ath9k_power_mode mode;
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -0700115 unsigned long flags;
116
117 spin_lock_irqsave(&sc->sc_pm_lock, flags);
118 if (--sc->ps_usecount != 0)
119 goto unlock;
120
Vivek Natarajan1dbfd9d2010-01-29 16:56:51 +0530121 if (sc->ps_idle)
Felix Fietkauc6c539f2011-09-14 21:24:24 +0200122 mode = ATH9K_PM_FULL_SLEEP;
Vivek Natarajan1dbfd9d2010-01-29 16:56:51 +0530123 else if (sc->ps_enabled &&
124 !(sc->ps_flags & (PS_WAIT_FOR_BEACON |
Sujith1b04b932010-01-08 10:36:05 +0530125 PS_WAIT_FOR_CAB |
126 PS_WAIT_FOR_PSPOLL_DATA |
127 PS_WAIT_FOR_TX_ACK)))
Felix Fietkauc6c539f2011-09-14 21:24:24 +0200128 mode = ATH9K_PM_NETWORK_SLEEP;
129 else
130 goto unlock;
131
132 spin_lock(&common->cc_lock);
133 ath_hw_cycle_counters_update(common);
134 spin_unlock(&common->cc_lock);
135
Felix Fietkau1a8f0d392011-09-22 08:04:32 -0600136 ath9k_hw_setpower(sc->sc_ah, mode);
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -0700137
138 unlock:
139 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
140}
141
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +0530142void ath_start_ani(struct ath_common *common)
Felix Fietkau5ee08652010-07-31 00:11:59 +0200143{
144 struct ath_hw *ah = common->ah;
145 unsigned long timestamp = jiffies_to_msecs(jiffies);
146 struct ath_softc *sc = (struct ath_softc *) common->priv;
147
148 if (!(sc->sc_flags & SC_OP_ANI_RUN))
149 return;
150
151 if (sc->sc_flags & SC_OP_OFFCHANNEL)
152 return;
153
154 common->ani.longcal_timer = timestamp;
155 common->ani.shortcal_timer = timestamp;
156 common->ani.checkani_timer = timestamp;
157
158 mod_timer(&common->ani.timer,
159 jiffies +
160 msecs_to_jiffies((u32)ah->config.ani_poll_interval));
161}
162
Felix Fietkau34300982010-10-10 18:21:52 +0200163static void ath_update_survey_nf(struct ath_softc *sc, int channel)
164{
165 struct ath_hw *ah = sc->sc_ah;
166 struct ath9k_channel *chan = &ah->channels[channel];
167 struct survey_info *survey = &sc->survey[channel];
168
169 if (chan->noisefloor) {
170 survey->filled |= SURVEY_INFO_NOISE_DBM;
Felix Fietkauf749b942011-07-28 14:08:57 +0200171 survey->noise = ath9k_hw_getchan_noise(ah, chan);
Felix Fietkau34300982010-10-10 18:21:52 +0200172 }
173}
174
Felix Fietkaucb8d61d2011-02-04 20:09:25 +0100175/*
176 * Updates the survey statistics and returns the busy time since last
177 * update in %, if the measurement duration was long enough for the
178 * result to be useful, -1 otherwise.
179 */
180static int ath_update_survey_stats(struct ath_softc *sc)
Felix Fietkau34300982010-10-10 18:21:52 +0200181{
182 struct ath_hw *ah = sc->sc_ah;
183 struct ath_common *common = ath9k_hw_common(ah);
184 int pos = ah->curchan - &ah->channels[0];
185 struct survey_info *survey = &sc->survey[pos];
186 struct ath_cycle_counters *cc = &common->cc_survey;
187 unsigned int div = common->clockrate * 1000;
Felix Fietkaucb8d61d2011-02-04 20:09:25 +0100188 int ret = 0;
Felix Fietkau34300982010-10-10 18:21:52 +0200189
Felix Fietkau08457352010-10-20 15:59:28 +0200190 if (!ah->curchan)
Felix Fietkaucb8d61d2011-02-04 20:09:25 +0100191 return -1;
Felix Fietkau08457352010-10-20 15:59:28 +0200192
Felix Fietkau898c9142010-10-12 14:02:53 +0200193 if (ah->power_mode == ATH9K_PM_AWAKE)
194 ath_hw_cycle_counters_update(common);
Felix Fietkau34300982010-10-10 18:21:52 +0200195
196 if (cc->cycles > 0) {
197 survey->filled |= SURVEY_INFO_CHANNEL_TIME |
198 SURVEY_INFO_CHANNEL_TIME_BUSY |
199 SURVEY_INFO_CHANNEL_TIME_RX |
200 SURVEY_INFO_CHANNEL_TIME_TX;
201 survey->channel_time += cc->cycles / div;
202 survey->channel_time_busy += cc->rx_busy / div;
203 survey->channel_time_rx += cc->rx_frame / div;
204 survey->channel_time_tx += cc->tx_frame / div;
205 }
Felix Fietkaucb8d61d2011-02-04 20:09:25 +0100206
207 if (cc->cycles < div)
208 return -1;
209
210 if (cc->cycles > 0)
211 ret = cc->rx_busy * 100 / cc->cycles;
212
Felix Fietkau34300982010-10-10 18:21:52 +0200213 memset(cc, 0, sizeof(*cc));
214
215 ath_update_survey_nf(sc, pos);
Felix Fietkaucb8d61d2011-02-04 20:09:25 +0100216
217 return ret;
Felix Fietkau34300982010-10-10 18:21:52 +0200218}
219
Felix Fietkau9adcf442011-09-03 01:40:26 +0200220static void __ath_cancel_work(struct ath_softc *sc)
221{
222 cancel_work_sync(&sc->paprd_work);
223 cancel_work_sync(&sc->hw_check_work);
224 cancel_delayed_work_sync(&sc->tx_complete_work);
225 cancel_delayed_work_sync(&sc->hw_pll_work);
226}
227
228static void ath_cancel_work(struct ath_softc *sc)
229{
230 __ath_cancel_work(sc);
231 cancel_work_sync(&sc->hw_reset_work);
232}
233
234static bool ath_prepare_reset(struct ath_softc *sc, bool retry_tx, bool flush)
235{
236 struct ath_hw *ah = sc->sc_ah;
237 struct ath_common *common = ath9k_hw_common(ah);
238 bool ret;
239
240 ieee80211_stop_queues(sc->hw);
241
242 sc->hw_busy_count = 0;
243 del_timer_sync(&common->ani.timer);
244
245 ath9k_debug_samp_bb_mac(sc);
246 ath9k_hw_disable_interrupts(ah);
247
248 ret = ath_drain_all_txq(sc, retry_tx);
249
250 if (!ath_stoprecv(sc))
251 ret = false;
252
253 if (!flush) {
254 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
Felix Fietkau34832882011-09-14 21:23:03 +0200255 ath_rx_tasklet(sc, 1, true);
256 ath_rx_tasklet(sc, 1, false);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200257 } else {
258 ath_flushrecv(sc);
259 }
260
261 return ret;
262}
263
264static bool ath_complete_reset(struct ath_softc *sc, bool start)
265{
266 struct ath_hw *ah = sc->sc_ah;
267 struct ath_common *common = ath9k_hw_common(ah);
268
269 if (ath_startrecv(sc) != 0) {
270 ath_err(common, "Unable to restart recv logic\n");
271 return false;
272 }
273
274 ath9k_cmn_update_txpow(ah, sc->curtxpow,
275 sc->config.txpowlimit, &sc->curtxpow);
Felix Fietkau72d874c2011-10-08 20:06:19 +0200276 ath9k_hw_set_interrupts(ah);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200277 ath9k_hw_enable_interrupts(ah);
278
279 if (!(sc->sc_flags & (SC_OP_OFFCHANNEL)) && start) {
280 if (sc->sc_flags & SC_OP_BEACONS)
281 ath_set_beacon(sc);
282
283 ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work, 0);
284 ieee80211_queue_delayed_work(sc->hw, &sc->hw_pll_work, HZ/2);
285 if (!common->disable_ani)
286 ath_start_ani(common);
287 }
288
Felix Fietkau43c35282011-09-03 01:40:27 +0200289 if (ath9k_hw_ops(ah)->antdiv_comb_conf_get && sc->ant_rx != 3) {
290 struct ath_hw_antcomb_conf div_ant_conf;
291 u8 lna_conf;
292
293 ath9k_hw_antdiv_comb_conf_get(ah, &div_ant_conf);
294
295 if (sc->ant_rx == 1)
296 lna_conf = ATH_ANT_DIV_COMB_LNA1;
297 else
298 lna_conf = ATH_ANT_DIV_COMB_LNA2;
299 div_ant_conf.main_lna_conf = lna_conf;
300 div_ant_conf.alt_lna_conf = lna_conf;
301
302 ath9k_hw_antdiv_comb_conf_set(ah, &div_ant_conf);
303 }
304
Felix Fietkau9adcf442011-09-03 01:40:26 +0200305 ieee80211_wake_queues(sc->hw);
306
307 return true;
308}
309
310static int ath_reset_internal(struct ath_softc *sc, struct ath9k_channel *hchan,
311 bool retry_tx)
312{
313 struct ath_hw *ah = sc->sc_ah;
314 struct ath_common *common = ath9k_hw_common(ah);
315 struct ath9k_hw_cal_data *caldata = NULL;
316 bool fastcc = true;
317 bool flush = false;
318 int r;
319
320 __ath_cancel_work(sc);
321
322 spin_lock_bh(&sc->sc_pcu_lock);
323
324 if (!(sc->sc_flags & SC_OP_OFFCHANNEL)) {
325 fastcc = false;
326 caldata = &sc->caldata;
327 }
328
329 if (!hchan) {
330 fastcc = false;
331 flush = true;
332 hchan = ah->curchan;
333 }
334
335 if (fastcc && !ath9k_hw_check_alive(ah))
336 fastcc = false;
337
338 if (!ath_prepare_reset(sc, retry_tx, flush))
339 fastcc = false;
340
341 ath_dbg(common, ATH_DBG_CONFIG,
342 "Reset to %u MHz, HT40: %d fastcc: %d\n",
343 hchan->channel, !!(hchan->channelFlags & (CHANNEL_HT40MINUS |
344 CHANNEL_HT40PLUS)),
345 fastcc);
346
347 r = ath9k_hw_reset(ah, hchan, caldata, fastcc);
348 if (r) {
349 ath_err(common,
350 "Unable to reset channel, reset status %d\n", r);
351 goto out;
352 }
353
354 if (!ath_complete_reset(sc, true))
355 r = -EIO;
356
357out:
358 spin_unlock_bh(&sc->sc_pcu_lock);
359 return r;
360}
361
362
Sujithff37e332008-11-24 12:07:55 +0530363/*
364 * Set/change channels. If the channel is really being changed, it's done
365 * by reseting the chip. To accomplish this we must first cleanup any pending
366 * DMA, then restart stuff.
367*/
Mohammed Shafi Shajakhan5595f112011-05-19 18:08:57 +0530368static int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
Jouni Malinen0e2dedf2009-03-03 19:23:32 +0200369 struct ath9k_channel *hchan)
Sujithff37e332008-11-24 12:07:55 +0530370{
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800371 int r;
Sujithff37e332008-11-24 12:07:55 +0530372
373 if (sc->sc_flags & SC_OP_INVALID)
374 return -EIO;
375
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +0530376 ath9k_ps_wakeup(sc);
377
Felix Fietkau9adcf442011-09-03 01:40:26 +0200378 r = ath_reset_internal(sc, hchan, false);
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700379
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +0530380 ath9k_ps_restore(sc);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200381
Gabor Juhos39892792009-06-15 17:49:09 +0200382 return r;
Sujithff37e332008-11-24 12:07:55 +0530383}
384
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400385static void ath_paprd_activate(struct ath_softc *sc)
386{
387 struct ath_hw *ah = sc->sc_ah;
Felix Fietkau20bd2a02010-07-31 00:12:00 +0200388 struct ath9k_hw_cal_data *caldata = ah->caldata;
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400389 int chain;
390
Felix Fietkau20bd2a02010-07-31 00:12:00 +0200391 if (!caldata || !caldata->paprd_done)
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400392 return;
393
394 ath9k_ps_wakeup(sc);
Felix Fietkauddfef7922010-07-30 21:02:11 +0200395 ar9003_paprd_enable(ah, false);
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400396 for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {
Felix Fietkau82b2d332011-09-03 01:40:23 +0200397 if (!(ah->txchainmask & BIT(chain)))
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400398 continue;
399
Felix Fietkau20bd2a02010-07-31 00:12:00 +0200400 ar9003_paprd_populate_single_table(ah, caldata, chain);
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400401 }
402
403 ar9003_paprd_enable(ah, true);
404 ath9k_ps_restore(sc);
405}
406
Felix Fietkau7607cbe2010-12-13 08:40:52 +0100407static bool ath_paprd_send_frame(struct ath_softc *sc, struct sk_buff *skb, int chain)
408{
409 struct ieee80211_hw *hw = sc->hw;
410 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
Mohammed Shafi Shajakhan479600772011-01-31 13:25:29 +0530411 struct ath_hw *ah = sc->sc_ah;
412 struct ath_common *common = ath9k_hw_common(ah);
Felix Fietkau7607cbe2010-12-13 08:40:52 +0100413 struct ath_tx_control txctl;
414 int time_left;
415
416 memset(&txctl, 0, sizeof(txctl));
417 txctl.txq = sc->tx.txq_map[WME_AC_BE];
418
419 memset(tx_info, 0, sizeof(*tx_info));
420 tx_info->band = hw->conf.channel->band;
421 tx_info->flags |= IEEE80211_TX_CTL_NO_ACK;
422 tx_info->control.rates[0].idx = 0;
423 tx_info->control.rates[0].count = 1;
424 tx_info->control.rates[0].flags = IEEE80211_TX_RC_MCS;
425 tx_info->control.rates[1].idx = -1;
426
427 init_completion(&sc->paprd_complete);
Felix Fietkau7607cbe2010-12-13 08:40:52 +0100428 txctl.paprd = BIT(chain);
Mohammed Shafi Shajakhan479600772011-01-31 13:25:29 +0530429
430 if (ath_tx_start(hw, skb, &txctl) != 0) {
Mohammed Shafi Shajakhand4bb17c2011-06-15 18:25:31 +0530431 ath_dbg(common, ATH_DBG_CALIBRATE, "PAPRD TX failed\n");
Mohammed Shafi Shajakhan479600772011-01-31 13:25:29 +0530432 dev_kfree_skb_any(skb);
Felix Fietkau7607cbe2010-12-13 08:40:52 +0100433 return false;
Mohammed Shafi Shajakhan479600772011-01-31 13:25:29 +0530434 }
Felix Fietkau7607cbe2010-12-13 08:40:52 +0100435
436 time_left = wait_for_completion_timeout(&sc->paprd_complete,
437 msecs_to_jiffies(ATH_PAPRD_TIMEOUT));
Felix Fietkau7607cbe2010-12-13 08:40:52 +0100438
439 if (!time_left)
Mohammed Shafi Shajakhand4bb17c2011-06-15 18:25:31 +0530440 ath_dbg(common, ATH_DBG_CALIBRATE,
Felix Fietkau7607cbe2010-12-13 08:40:52 +0100441 "Timeout waiting for paprd training on TX chain %d\n",
442 chain);
443
444 return !!time_left;
445}
446
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400447void ath_paprd_calibrate(struct work_struct *work)
448{
449 struct ath_softc *sc = container_of(work, struct ath_softc, paprd_work);
450 struct ieee80211_hw *hw = sc->hw;
451 struct ath_hw *ah = sc->sc_ah;
452 struct ieee80211_hdr *hdr;
453 struct sk_buff *skb = NULL;
Felix Fietkau20bd2a02010-07-31 00:12:00 +0200454 struct ath9k_hw_cal_data *caldata = ah->caldata;
Vasanthakumar Thiagarajan90945372010-09-20 22:54:46 -0700455 struct ath_common *common = ath9k_hw_common(ah);
Felix Fietkau066dae92010-11-07 14:59:39 +0100456 int ftype;
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400457 int chain_ok = 0;
458 int chain;
459 int len = 1800;
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400460
Felix Fietkau20bd2a02010-07-31 00:12:00 +0200461 if (!caldata)
462 return;
463
Mohammed Shafi Shajakhanb9424712011-05-24 15:29:52 +0530464 ath9k_ps_wakeup(sc);
465
Felix Fietkau1bf38662010-12-13 08:40:54 +0100466 if (ar9003_paprd_init_table(ah) < 0)
Mohammed Shafi Shajakhanb9424712011-05-24 15:29:52 +0530467 goto fail_paprd;
Felix Fietkau1bf38662010-12-13 08:40:54 +0100468
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400469 skb = alloc_skb(len, GFP_KERNEL);
470 if (!skb)
Mohammed Shafi Shajakhanb9424712011-05-24 15:29:52 +0530471 goto fail_paprd;
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400472
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400473 skb_put(skb, len);
474 memset(skb->data, 0, len);
475 hdr = (struct ieee80211_hdr *)skb->data;
476 ftype = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC;
477 hdr->frame_control = cpu_to_le16(ftype);
John W. Linvillea3d3da12010-07-20 13:15:31 -0400478 hdr->duration_id = cpu_to_le16(10);
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400479 memcpy(hdr->addr1, hw->wiphy->perm_addr, ETH_ALEN);
480 memcpy(hdr->addr2, hw->wiphy->perm_addr, ETH_ALEN);
481 memcpy(hdr->addr3, hw->wiphy->perm_addr, ETH_ALEN);
482
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400483 for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {
Felix Fietkau82b2d332011-09-03 01:40:23 +0200484 if (!(ah->txchainmask & BIT(chain)))
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400485 continue;
486
487 chain_ok = 0;
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400488
Felix Fietkau7607cbe2010-12-13 08:40:52 +0100489 ath_dbg(common, ATH_DBG_CALIBRATE,
490 "Sending PAPRD frame for thermal measurement "
491 "on chain %d\n", chain);
492 if (!ath_paprd_send_frame(sc, skb, chain))
Vasanthakumar Thiagarajanca369eb2010-06-24 02:42:44 -0700493 goto fail_paprd;
Felix Fietkau7607cbe2010-12-13 08:40:52 +0100494
495 ar9003_paprd_setup_gain_table(ah, chain);
496
497 ath_dbg(common, ATH_DBG_CALIBRATE,
498 "Sending PAPRD training frame on chain %d\n", chain);
499 if (!ath_paprd_send_frame(sc, skb, chain))
500 goto fail_paprd;
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400501
Mohammed Shafi Shajakhand4bb17c2011-06-15 18:25:31 +0530502 if (!ar9003_paprd_is_done(ah)) {
503 ath_dbg(common, ATH_DBG_CALIBRATE,
504 "PAPRD not yet done on chain %d\n", chain);
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400505 break;
Mohammed Shafi Shajakhand4bb17c2011-06-15 18:25:31 +0530506 }
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400507
Mohammed Shafi Shajakhand4bb17c2011-06-15 18:25:31 +0530508 if (ar9003_paprd_create_curve(ah, caldata, chain)) {
509 ath_dbg(common, ATH_DBG_CALIBRATE,
510 "PAPRD create curve failed on chain %d\n",
511 chain);
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400512 break;
Mohammed Shafi Shajakhand4bb17c2011-06-15 18:25:31 +0530513 }
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400514
515 chain_ok = 1;
516 }
517 kfree_skb(skb);
518
519 if (chain_ok) {
Felix Fietkau20bd2a02010-07-31 00:12:00 +0200520 caldata->paprd_done = true;
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400521 ath_paprd_activate(sc);
522 }
523
Vasanthakumar Thiagarajanca369eb2010-06-24 02:42:44 -0700524fail_paprd:
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400525 ath9k_ps_restore(sc);
526}
527
Sujithff37e332008-11-24 12:07:55 +0530528/*
529 * This routine performs the periodic noise floor calibration function
530 * that is used to adjust and optimize the chip performance. This
531 * takes environmental changes (location, temperature) into account.
532 * When the task is complete, it reschedules itself depending on the
533 * appropriate interval that was calculated.
534 */
Sujith55624202010-01-08 10:36:02 +0530535void ath_ani_calibrate(unsigned long data)
Sujithff37e332008-11-24 12:07:55 +0530536{
Sujith20977d32009-02-20 15:13:28 +0530537 struct ath_softc *sc = (struct ath_softc *)data;
538 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -0700539 struct ath_common *common = ath9k_hw_common(ah);
Sujithff37e332008-11-24 12:07:55 +0530540 bool longcal = false;
541 bool shortcal = false;
542 bool aniflag = false;
543 unsigned int timestamp = jiffies_to_msecs(jiffies);
Felix Fietkau60444742010-08-02 15:53:15 +0200544 u32 cal_interval, short_cal_interval, long_cal_interval;
Felix Fietkaub5bfc562010-10-08 22:13:53 +0200545 unsigned long flags;
Felix Fietkau60444742010-08-02 15:53:15 +0200546
547 if (ah->caldata && ah->caldata->nfcal_interference)
548 long_cal_interval = ATH_LONG_CALINTERVAL_INT;
549 else
550 long_cal_interval = ATH_LONG_CALINTERVAL;
Sujithff37e332008-11-24 12:07:55 +0530551
Sujith20977d32009-02-20 15:13:28 +0530552 short_cal_interval = (ah->opmode == NL80211_IFTYPE_AP) ?
553 ATH_AP_SHORT_CALINTERVAL : ATH_STA_SHORT_CALINTERVAL;
Sujithff37e332008-11-24 12:07:55 +0530554
Jouni Malinen1ffc1c62009-05-19 17:01:39 +0300555 /* Only calibrate if awake */
556 if (sc->sc_ah->power_mode != ATH9K_PM_AWAKE)
557 goto set_timer;
558
559 ath9k_ps_wakeup(sc);
560
Sujithff37e332008-11-24 12:07:55 +0530561 /* Long calibration runs independently of short calibration. */
Felix Fietkau60444742010-08-02 15:53:15 +0200562 if ((timestamp - common->ani.longcal_timer) >= long_cal_interval) {
Sujithff37e332008-11-24 12:07:55 +0530563 longcal = true;
Joe Perches226afe62010-12-02 19:12:37 -0800564 ath_dbg(common, ATH_DBG_ANI, "longcal @%lu\n", jiffies);
Luis R. Rodriguez3d536ac2009-11-03 17:07:04 -0800565 common->ani.longcal_timer = timestamp;
Sujithff37e332008-11-24 12:07:55 +0530566 }
567
Sujith17d79042009-02-09 13:27:03 +0530568 /* Short calibration applies only while caldone is false */
Luis R. Rodriguez3d536ac2009-11-03 17:07:04 -0800569 if (!common->ani.caldone) {
570 if ((timestamp - common->ani.shortcal_timer) >= short_cal_interval) {
Sujithff37e332008-11-24 12:07:55 +0530571 shortcal = true;
Joe Perches226afe62010-12-02 19:12:37 -0800572 ath_dbg(common, ATH_DBG_ANI,
573 "shortcal @%lu\n", jiffies);
Luis R. Rodriguez3d536ac2009-11-03 17:07:04 -0800574 common->ani.shortcal_timer = timestamp;
575 common->ani.resetcal_timer = timestamp;
Sujithff37e332008-11-24 12:07:55 +0530576 }
577 } else {
Luis R. Rodriguez3d536ac2009-11-03 17:07:04 -0800578 if ((timestamp - common->ani.resetcal_timer) >=
Sujithff37e332008-11-24 12:07:55 +0530579 ATH_RESTART_CALINTERVAL) {
Luis R. Rodriguez3d536ac2009-11-03 17:07:04 -0800580 common->ani.caldone = ath9k_hw_reset_calvalid(ah);
581 if (common->ani.caldone)
582 common->ani.resetcal_timer = timestamp;
Sujithff37e332008-11-24 12:07:55 +0530583 }
584 }
585
586 /* Verify whether we must check ANI */
Luis R. Rodrigueze36b27a2010-06-12 00:33:45 -0400587 if ((timestamp - common->ani.checkani_timer) >=
588 ah->config.ani_poll_interval) {
Sujithff37e332008-11-24 12:07:55 +0530589 aniflag = true;
Luis R. Rodriguez3d536ac2009-11-03 17:07:04 -0800590 common->ani.checkani_timer = timestamp;
Sujithff37e332008-11-24 12:07:55 +0530591 }
592
Mohammed Shafi Shajakhane62ddec2011-05-19 15:05:46 +0530593 /* Call ANI routine if necessary */
594 if (aniflag) {
595 spin_lock_irqsave(&common->cc_lock, flags);
596 ath9k_hw_ani_monitor(ah, ah->curchan);
597 ath_update_survey_stats(sc);
598 spin_unlock_irqrestore(&common->cc_lock, flags);
599 }
Sujithff37e332008-11-24 12:07:55 +0530600
Mohammed Shafi Shajakhane62ddec2011-05-19 15:05:46 +0530601 /* Perform calibration if necessary */
602 if (longcal || shortcal) {
603 common->ani.caldone =
604 ath9k_hw_calibrate(ah, ah->curchan,
Felix Fietkau82b2d332011-09-03 01:40:23 +0200605 ah->rxchainmask, longcal);
Sujithff37e332008-11-24 12:07:55 +0530606 }
607
Jouni Malinen1ffc1c62009-05-19 17:01:39 +0300608 ath9k_ps_restore(sc);
609
Sujith20977d32009-02-20 15:13:28 +0530610set_timer:
Sujithff37e332008-11-24 12:07:55 +0530611 /*
612 * Set timer interval based on previous results.
613 * The interval must be the shortest necessary to satisfy ANI,
614 * short calibration and long calibration.
615 */
Rajkumar Manoharancf3af742011-08-27 16:17:47 +0530616 ath9k_debug_samp_bb_mac(sc);
Sujithaac92072008-12-02 18:37:54 +0530617 cal_interval = ATH_LONG_CALINTERVAL;
Sujith2660b812009-02-09 13:27:26 +0530618 if (sc->sc_ah->config.enable_ani)
Luis R. Rodrigueze36b27a2010-06-12 00:33:45 -0400619 cal_interval = min(cal_interval,
620 (u32)ah->config.ani_poll_interval);
Luis R. Rodriguez3d536ac2009-11-03 17:07:04 -0800621 if (!common->ani.caldone)
Sujith20977d32009-02-20 15:13:28 +0530622 cal_interval = min(cal_interval, (u32)short_cal_interval);
Sujithff37e332008-11-24 12:07:55 +0530623
Luis R. Rodriguez3d536ac2009-11-03 17:07:04 -0800624 mod_timer(&common->ani.timer, jiffies + msecs_to_jiffies(cal_interval));
Felix Fietkau20bd2a02010-07-31 00:12:00 +0200625 if ((sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_PAPRD) && ah->caldata) {
626 if (!ah->caldata->paprd_done)
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400627 ieee80211_queue_work(sc->hw, &sc->paprd_work);
Vasanthakumar Thiagarajan45ef6a02010-12-15 07:30:53 -0800628 else if (!ah->paprd_table_write_done)
Felix Fietkau9f42c2b2010-06-12 00:34:01 -0400629 ath_paprd_activate(sc);
630 }
Sujithff37e332008-11-24 12:07:55 +0530631}
632
Ben Greear7e1e3862011-11-03 11:33:13 -0700633static void ath_node_attach(struct ath_softc *sc, struct ieee80211_sta *sta,
634 struct ieee80211_vif *vif)
Sujithff37e332008-11-24 12:07:55 +0530635{
636 struct ath_node *an;
Sujithff37e332008-11-24 12:07:55 +0530637 an = (struct ath_node *)sta->drv_priv;
638
Ben Greear7f010c92011-01-09 23:11:49 -0800639#ifdef CONFIG_ATH9K_DEBUGFS
640 spin_lock(&sc->nodes_lock);
641 list_add(&an->list, &sc->nodes);
642 spin_unlock(&sc->nodes_lock);
643 an->sta = sta;
Ben Greear7e1e3862011-11-03 11:33:13 -0700644 an->vif = vif;
Ben Greear7f010c92011-01-09 23:11:49 -0800645#endif
Sujith87792ef2009-03-30 15:28:48 +0530646 if (sc->sc_flags & SC_OP_TXAGGR) {
Sujithff37e332008-11-24 12:07:55 +0530647 ath_tx_node_init(sc, an);
Sujith9e98ac62009-07-23 15:32:34 +0530648 an->maxampdu = 1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
Sujith87792ef2009-03-30 15:28:48 +0530649 sta->ht_cap.ampdu_factor);
650 an->mpdudensity = parse_mpdudensity(sta->ht_cap.ampdu_density);
651 }
Sujithff37e332008-11-24 12:07:55 +0530652}
653
654static void ath_node_detach(struct ath_softc *sc, struct ieee80211_sta *sta)
655{
656 struct ath_node *an = (struct ath_node *)sta->drv_priv;
657
Ben Greear7f010c92011-01-09 23:11:49 -0800658#ifdef CONFIG_ATH9K_DEBUGFS
659 spin_lock(&sc->nodes_lock);
660 list_del(&an->list);
661 spin_unlock(&sc->nodes_lock);
662 an->sta = NULL;
663#endif
664
Sujithff37e332008-11-24 12:07:55 +0530665 if (sc->sc_flags & SC_OP_TXAGGR)
666 ath_tx_node_cleanup(sc, an);
667}
668
Senthil Balasubramanian9eab61c2011-04-22 11:32:11 +0530669
Sujith55624202010-01-08 10:36:02 +0530670void ath9k_tasklet(unsigned long data)
Sujithff37e332008-11-24 12:07:55 +0530671{
672 struct ath_softc *sc = (struct ath_softc *)data;
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -0700673 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -0700674 struct ath_common *common = ath9k_hw_common(ah);
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -0700675
Sujith17d79042009-02-09 13:27:03 +0530676 u32 status = sc->intrstatus;
Felix Fietkaub5c804752010-04-15 17:38:48 -0400677 u32 rxmask;
Sujithff37e332008-11-24 12:07:55 +0530678
Felix Fietkaue3927002011-09-14 21:23:01 +0200679 ath9k_ps_wakeup(sc);
680 spin_lock(&sc->sc_pcu_lock);
681
Rajkumar Manoharana4d86d92011-05-20 17:52:10 +0530682 if ((status & ATH9K_INT_FATAL) ||
683 (status & ATH9K_INT_BB_WATCHDOG)) {
Felix Fietkau030d6292011-10-07 02:28:13 +0200684#ifdef CONFIG_ATH9K_DEBUGFS
685 enum ath_reset_type type;
686
687 if (status & ATH9K_INT_FATAL)
688 type = RESET_TYPE_FATAL_INT;
689 else
690 type = RESET_TYPE_BB_WATCHDOG;
691
692 RESET_STAT_INC(sc, type);
693#endif
Felix Fietkau236de512011-09-03 01:40:25 +0200694 ieee80211_queue_work(sc->hw, &sc->hw_reset_work);
Felix Fietkaue3927002011-09-14 21:23:01 +0200695 goto out;
Sujithff37e332008-11-24 12:07:55 +0530696 }
697
Felix Fietkau8b3f4612011-01-10 17:05:50 -0700698 /*
699 * Only run the baseband hang check if beacons stop working in AP or
700 * IBSS mode, because it has a high false positive rate. For station
701 * mode it should not be necessary, since the upper layers will detect
702 * this through a beacon miss automatically and the following channel
703 * change will trigger a hardware reset anyway
704 */
705 if (ath9k_hw_numtxpending(ah, sc->beacon.beaconq) != 0 &&
706 !ath9k_hw_check_alive(ah))
Felix Fietkau347809f2010-07-02 00:09:52 +0200707 ieee80211_queue_work(sc->hw, &sc->hw_check_work);
708
Rajkumar Manoharan4105f802011-05-06 18:27:47 +0530709 if ((status & ATH9K_INT_TSFOOR) && sc->ps_enabled) {
710 /*
711 * TSF sync does not look correct; remain awake to sync with
712 * the next Beacon.
713 */
714 ath_dbg(common, ATH_DBG_PS,
715 "TSFOOR - Sync with next Beacon\n");
Rajkumar Manoharane8fe7332011-08-05 18:59:41 +0530716 sc->ps_flags |= PS_WAIT_FOR_BEACON | PS_BEACON_SYNC;
Rajkumar Manoharan4105f802011-05-06 18:27:47 +0530717 }
718
Felix Fietkaub5c804752010-04-15 17:38:48 -0400719 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
720 rxmask = (ATH9K_INT_RXHP | ATH9K_INT_RXLP | ATH9K_INT_RXEOL |
721 ATH9K_INT_RXORN);
722 else
723 rxmask = (ATH9K_INT_RX | ATH9K_INT_RXEOL | ATH9K_INT_RXORN);
724
725 if (status & rxmask) {
Felix Fietkaub5c804752010-04-15 17:38:48 -0400726 /* Check for high priority Rx first */
727 if ((ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) &&
728 (status & ATH9K_INT_RXHP))
729 ath_rx_tasklet(sc, 0, true);
730
731 ath_rx_tasklet(sc, 0, false);
Sujith063d8be2009-03-30 15:28:49 +0530732 }
733
Vasanthakumar Thiagarajane5003242010-04-15 17:39:36 -0400734 if (status & ATH9K_INT_TX) {
735 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
736 ath_tx_edma_tasklet(sc);
737 else
738 ath_tx_tasklet(sc);
739 }
Sujith063d8be2009-03-30 15:28:49 +0530740
Luis R. Rodriguez766ec4a2009-09-09 14:52:02 -0700741 if (ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
Vasanthakumar Thiagarajanebb8e1d2009-09-01 17:46:32 +0530742 if (status & ATH9K_INT_GENTIMER)
743 ath_gen_timer_isr(sc->sc_ah);
744
Felix Fietkaue3927002011-09-14 21:23:01 +0200745out:
Sujithff37e332008-11-24 12:07:55 +0530746 /* re-enable hardware interrupt */
Felix Fietkau4df30712010-11-08 20:54:47 +0100747 ath9k_hw_enable_interrupts(ah);
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700748
Senthil Balasubramanian52671e42010-12-23 21:06:57 +0530749 spin_unlock(&sc->sc_pcu_lock);
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400750 ath9k_ps_restore(sc);
Sujithff37e332008-11-24 12:07:55 +0530751}
752
Gabor Juhos6baff7f2009-01-14 20:17:06 +0100753irqreturn_t ath_isr(int irq, void *dev)
Sujithff37e332008-11-24 12:07:55 +0530754{
Sujith063d8be2009-03-30 15:28:49 +0530755#define SCHED_INTR ( \
756 ATH9K_INT_FATAL | \
Rajkumar Manoharana4d86d92011-05-20 17:52:10 +0530757 ATH9K_INT_BB_WATCHDOG | \
Sujith063d8be2009-03-30 15:28:49 +0530758 ATH9K_INT_RXORN | \
759 ATH9K_INT_RXEOL | \
760 ATH9K_INT_RX | \
Felix Fietkaub5c804752010-04-15 17:38:48 -0400761 ATH9K_INT_RXLP | \
762 ATH9K_INT_RXHP | \
Sujith063d8be2009-03-30 15:28:49 +0530763 ATH9K_INT_TX | \
764 ATH9K_INT_BMISS | \
765 ATH9K_INT_CST | \
Vasanthakumar Thiagarajanebb8e1d2009-09-01 17:46:32 +0530766 ATH9K_INT_TSFOOR | \
767 ATH9K_INT_GENTIMER)
Sujith063d8be2009-03-30 15:28:49 +0530768
Sujithff37e332008-11-24 12:07:55 +0530769 struct ath_softc *sc = dev;
Sujithcbe61d82009-02-09 13:27:12 +0530770 struct ath_hw *ah = sc->sc_ah;
Felix Fietkaub5bfc562010-10-08 22:13:53 +0200771 struct ath_common *common = ath9k_hw_common(ah);
Sujithff37e332008-11-24 12:07:55 +0530772 enum ath9k_int status;
773 bool sched = false;
774
Sujith063d8be2009-03-30 15:28:49 +0530775 /*
776 * The hardware is not ready/present, don't
777 * touch anything. Note this can happen early
778 * on if the IRQ is shared.
779 */
780 if (sc->sc_flags & SC_OP_INVALID)
781 return IRQ_NONE;
Sujithff37e332008-11-24 12:07:55 +0530782
Sujithff37e332008-11-24 12:07:55 +0530783
Sujith063d8be2009-03-30 15:28:49 +0530784 /* shared irq, not for us */
Sujithff37e332008-11-24 12:07:55 +0530785
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400786 if (!ath9k_hw_intrpend(ah))
Sujith063d8be2009-03-30 15:28:49 +0530787 return IRQ_NONE;
Sujithff37e332008-11-24 12:07:55 +0530788
Sujith063d8be2009-03-30 15:28:49 +0530789 /*
790 * Figure out the reason(s) for the interrupt. Note
791 * that the hal returns a pseudo-ISR that may include
792 * bits we haven't explicitly enabled so we mask the
793 * value to insure we only process bits we requested.
794 */
795 ath9k_hw_getisr(ah, &status); /* NB: clears ISR too */
Pavel Roskin30691682010-03-31 18:05:31 -0400796 status &= ah->imask; /* discard unasked-for bits */
Sujith063d8be2009-03-30 15:28:49 +0530797
798 /*
799 * If there are no status bits set, then this interrupt was not
800 * for me (should have been caught above).
801 */
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400802 if (!status)
Sujith063d8be2009-03-30 15:28:49 +0530803 return IRQ_NONE;
Sujith063d8be2009-03-30 15:28:49 +0530804
805 /* Cache the status */
806 sc->intrstatus = status;
807
808 if (status & SCHED_INTR)
809 sched = true;
810
811 /*
812 * If a FATAL or RXORN interrupt is received, we have to reset the
813 * chip immediately.
814 */
Felix Fietkaub5c804752010-04-15 17:38:48 -0400815 if ((status & ATH9K_INT_FATAL) || ((status & ATH9K_INT_RXORN) &&
816 !(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)))
Sujith063d8be2009-03-30 15:28:49 +0530817 goto chip_reset;
818
Luis R. Rodriguez08578b82010-05-13 13:33:44 -0400819 if ((ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) &&
820 (status & ATH9K_INT_BB_WATCHDOG)) {
Felix Fietkaub5bfc562010-10-08 22:13:53 +0200821
822 spin_lock(&common->cc_lock);
823 ath_hw_cycle_counters_update(common);
Luis R. Rodriguez08578b82010-05-13 13:33:44 -0400824 ar9003_hw_bb_watchdog_dbg_info(ah);
Felix Fietkaub5bfc562010-10-08 22:13:53 +0200825 spin_unlock(&common->cc_lock);
826
Luis R. Rodriguez08578b82010-05-13 13:33:44 -0400827 goto chip_reset;
828 }
829
Sujith063d8be2009-03-30 15:28:49 +0530830 if (status & ATH9K_INT_SWBA)
831 tasklet_schedule(&sc->bcon_tasklet);
832
833 if (status & ATH9K_INT_TXURN)
834 ath9k_hw_updatetxtriglevel(ah, true);
835
Rajkumar Manoharan0682c9b2011-08-13 10:28:09 +0530836 if (status & ATH9K_INT_RXEOL) {
837 ah->imask &= ~(ATH9K_INT_RXEOL | ATH9K_INT_RXORN);
Felix Fietkau72d874c2011-10-08 20:06:19 +0200838 ath9k_hw_set_interrupts(ah);
Felix Fietkaub5c804752010-04-15 17:38:48 -0400839 }
840
Sujith063d8be2009-03-30 15:28:49 +0530841 if (status & ATH9K_INT_MIB) {
842 /*
843 * Disable interrupts until we service the MIB
844 * interrupt; otherwise it will continue to
845 * fire.
846 */
Felix Fietkau4df30712010-11-08 20:54:47 +0100847 ath9k_hw_disable_interrupts(ah);
Sujith063d8be2009-03-30 15:28:49 +0530848 /*
849 * Let the hal handle the event. We assume
850 * it will clear whatever condition caused
851 * the interrupt.
852 */
Felix Fietkau88eac2d2010-10-12 16:08:03 +0200853 spin_lock(&common->cc_lock);
Felix Fietkaubfc472b2010-10-04 20:09:48 +0200854 ath9k_hw_proc_mib_event(ah);
Felix Fietkau88eac2d2010-10-12 16:08:03 +0200855 spin_unlock(&common->cc_lock);
Felix Fietkau4df30712010-11-08 20:54:47 +0100856 ath9k_hw_enable_interrupts(ah);
Sujith063d8be2009-03-30 15:28:49 +0530857 }
858
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400859 if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
860 if (status & ATH9K_INT_TIM_TIMER) {
Luis R. Rodriguezff9f0b62010-12-07 15:13:22 -0800861 if (ATH_DBG_WARN_ON_ONCE(sc->ps_idle))
862 goto chip_reset;
Sujith063d8be2009-03-30 15:28:49 +0530863 /* Clear RxAbort bit so that we can
864 * receive frames */
Luis R. Rodriguez9ecdef42009-09-09 21:10:09 -0700865 ath9k_setpower(sc, ATH9K_PM_AWAKE);
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400866 ath9k_hw_setrxabort(sc->sc_ah, 0);
Sujith1b04b932010-01-08 10:36:05 +0530867 sc->ps_flags |= PS_WAIT_FOR_BEACON;
Sujith063d8be2009-03-30 15:28:49 +0530868 }
Sujith063d8be2009-03-30 15:28:49 +0530869
870chip_reset:
871
Sujith817e11d2008-12-07 21:42:44 +0530872 ath_debug_stat_interrupt(sc, status);
873
Sujithff37e332008-11-24 12:07:55 +0530874 if (sched) {
Felix Fietkau4df30712010-11-08 20:54:47 +0100875 /* turn off every interrupt */
876 ath9k_hw_disable_interrupts(ah);
Sujithff37e332008-11-24 12:07:55 +0530877 tasklet_schedule(&sc->intr_tq);
878 }
879
880 return IRQ_HANDLED;
Sujith063d8be2009-03-30 15:28:49 +0530881
882#undef SCHED_INTR
Sujithff37e332008-11-24 12:07:55 +0530883}
884
Mohammed Shafi Shajakhan5595f112011-05-19 18:08:57 +0530885static void ath_radio_enable(struct ath_softc *sc, struct ieee80211_hw *hw)
Vasanthakumar Thiagarajan500c0642008-09-10 18:50:17 +0530886{
Sujithcbe61d82009-02-09 13:27:12 +0530887 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -0700888 struct ath_common *common = ath9k_hw_common(ah);
Luis R. Rodriguez68a89112009-11-02 14:35:42 -0800889 struct ieee80211_channel *channel = hw->conf.channel;
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800890 int r;
Vasanthakumar Thiagarajan500c0642008-09-10 18:50:17 +0530891
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +0530892 ath9k_ps_wakeup(sc);
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700893 spin_lock_bh(&sc->sc_pcu_lock);
Rajkumar Manoharane8fe7332011-08-05 18:59:41 +0530894 atomic_set(&ah->intr_ref_cnt, -1);
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700895
Stanislaw Gruszka84c87dc2011-08-05 13:10:32 +0200896 ath9k_hw_configpcipowersave(ah, false);
Sujithd2f5b3a2009-04-13 21:56:25 +0530897
Vasanthakumar Thiagarajan159cd462009-06-13 14:50:25 +0530898 if (!ah->curchan)
Rajkumar Manoharanc344c9c2011-01-31 23:47:43 +0530899 ah->curchan = ath9k_cmn_get_curchannel(sc->hw, ah);
Vasanthakumar Thiagarajan159cd462009-06-13 14:50:25 +0530900
Felix Fietkau20bd2a02010-07-31 00:12:00 +0200901 r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800902 if (r) {
Joe Perches38002762010-12-02 19:12:36 -0800903 ath_err(common,
904 "Unable to reset channel (%u MHz), reset status %d\n",
905 channel->center_freq, r);
Vasanthakumar Thiagarajan500c0642008-09-10 18:50:17 +0530906 }
Vasanthakumar Thiagarajan500c0642008-09-10 18:50:17 +0530907
Felix Fietkau9adcf442011-09-03 01:40:26 +0200908 ath_complete_reset(sc, true);
Vasanthakumar Thiagarajan500c0642008-09-10 18:50:17 +0530909
910 /* Enable LED */
Vivek Natarajan08fc5c12009-08-14 11:30:52 +0530911 ath9k_hw_cfg_output(ah, ah->led_pin,
Vasanthakumar Thiagarajan500c0642008-09-10 18:50:17 +0530912 AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
Vivek Natarajan08fc5c12009-08-14 11:30:52 +0530913 ath9k_hw_set_gpio(ah, ah->led_pin, 0);
Vasanthakumar Thiagarajan500c0642008-09-10 18:50:17 +0530914
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700915 spin_unlock_bh(&sc->sc_pcu_lock);
916
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +0530917 ath9k_ps_restore(sc);
Vasanthakumar Thiagarajan500c0642008-09-10 18:50:17 +0530918}
919
Luis R. Rodriguez68a89112009-11-02 14:35:42 -0800920void ath_radio_disable(struct ath_softc *sc, struct ieee80211_hw *hw)
Vasanthakumar Thiagarajan500c0642008-09-10 18:50:17 +0530921{
Sujithcbe61d82009-02-09 13:27:12 +0530922 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguez68a89112009-11-02 14:35:42 -0800923 struct ieee80211_channel *channel = hw->conf.channel;
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800924 int r;
Vasanthakumar Thiagarajan500c0642008-09-10 18:50:17 +0530925
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +0530926 ath9k_ps_wakeup(sc);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200927
928 ath_cancel_work(sc);
Vivek Natarajan7e3514f2011-02-25 17:31:02 +0530929
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700930 spin_lock_bh(&sc->sc_pcu_lock);
931
Vivek Natarajan982723d2010-06-23 12:08:29 +0530932 /*
933 * Keep the LED on when the radio is disabled
934 * during idle unassociated state.
935 */
936 if (!sc->ps_idle) {
937 ath9k_hw_set_gpio(ah, ah->led_pin, 1);
938 ath9k_hw_cfg_gpio_input(ah, ah->led_pin);
939 }
Vasanthakumar Thiagarajan500c0642008-09-10 18:50:17 +0530940
Felix Fietkau9adcf442011-09-03 01:40:26 +0200941 ath_prepare_reset(sc, false, true);
Vasanthakumar Thiagarajan500c0642008-09-10 18:50:17 +0530942
Vasanthakumar Thiagarajan159cd462009-06-13 14:50:25 +0530943 if (!ah->curchan)
Rajkumar Manoharanc344c9c2011-01-31 23:47:43 +0530944 ah->curchan = ath9k_cmn_get_curchannel(hw, ah);
Vasanthakumar Thiagarajan159cd462009-06-13 14:50:25 +0530945
Felix Fietkau20bd2a02010-07-31 00:12:00 +0200946 r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800947 if (r) {
Joe Perches38002762010-12-02 19:12:36 -0800948 ath_err(ath9k_hw_common(sc->sc_ah),
949 "Unable to reset channel (%u MHz), reset status %d\n",
950 channel->center_freq, r);
Vasanthakumar Thiagarajan500c0642008-09-10 18:50:17 +0530951 }
Vasanthakumar Thiagarajan500c0642008-09-10 18:50:17 +0530952
953 ath9k_hw_phy_disable(ah);
Luis R. Rodriguez5e848f72010-10-20 16:07:06 -0700954
Stanislaw Gruszka84c87dc2011-08-05 13:10:32 +0200955 ath9k_hw_configpcipowersave(ah, true);
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700956
957 spin_unlock_bh(&sc->sc_pcu_lock);
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +0530958 ath9k_ps_restore(sc);
Vasanthakumar Thiagarajan500c0642008-09-10 18:50:17 +0530959}
960
Felix Fietkau236de512011-09-03 01:40:25 +0200961static int ath_reset(struct ath_softc *sc, bool retry_tx)
Sujithff37e332008-11-24 12:07:55 +0530962{
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800963 int r;
Sujithff37e332008-11-24 12:07:55 +0530964
Felix Fietkau783cd012011-01-21 18:52:38 +0100965 ath9k_ps_wakeup(sc);
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700966
Felix Fietkau9adcf442011-09-03 01:40:26 +0200967 r = ath_reset_internal(sc, NULL, retry_tx);
Sujithff37e332008-11-24 12:07:55 +0530968
969 if (retry_tx) {
970 int i;
971 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
972 if (ATH_TXQ_SETUP(sc, i)) {
Sujithb77f4832008-12-07 21:44:03 +0530973 spin_lock_bh(&sc->tx.txq[i].axq_lock);
974 ath_txq_schedule(sc, &sc->tx.txq[i]);
975 spin_unlock_bh(&sc->tx.txq[i].axq_lock);
Sujithff37e332008-11-24 12:07:55 +0530976 }
977 }
978 }
979
Felix Fietkau783cd012011-01-21 18:52:38 +0100980 ath9k_ps_restore(sc);
Sujith2ab81d42009-12-14 16:34:56 +0530981
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800982 return r;
Sujithff37e332008-11-24 12:07:55 +0530983}
984
Felix Fietkau236de512011-09-03 01:40:25 +0200985void ath_reset_work(struct work_struct *work)
986{
987 struct ath_softc *sc = container_of(work, struct ath_softc, hw_reset_work);
988
Felix Fietkau236de512011-09-03 01:40:25 +0200989 ath_reset(sc, true);
Felix Fietkau236de512011-09-03 01:40:25 +0200990}
991
Felix Fietkaue8cfe9f82011-09-03 01:40:24 +0200992void ath_hw_check(struct work_struct *work)
993{
994 struct ath_softc *sc = container_of(work, struct ath_softc, hw_check_work);
995 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
996 unsigned long flags;
997 int busy;
998
999 ath9k_ps_wakeup(sc);
1000 if (ath9k_hw_check_alive(sc->sc_ah))
1001 goto out;
1002
1003 spin_lock_irqsave(&common->cc_lock, flags);
1004 busy = ath_update_survey_stats(sc);
1005 spin_unlock_irqrestore(&common->cc_lock, flags);
1006
1007 ath_dbg(common, ATH_DBG_RESET, "Possible baseband hang, "
1008 "busy=%d (try %d)\n", busy, sc->hw_busy_count + 1);
1009 if (busy >= 99) {
Felix Fietkau030d6292011-10-07 02:28:13 +02001010 if (++sc->hw_busy_count >= 3) {
1011 RESET_STAT_INC(sc, RESET_TYPE_BB_HANG);
Felix Fietkau9adcf442011-09-03 01:40:26 +02001012 ieee80211_queue_work(sc->hw, &sc->hw_reset_work);
Felix Fietkau030d6292011-10-07 02:28:13 +02001013 }
Felix Fietkaue8cfe9f82011-09-03 01:40:24 +02001014
1015 } else if (busy >= 0)
1016 sc->hw_busy_count = 0;
1017
1018out:
1019 ath9k_ps_restore(sc);
1020}
1021
1022static void ath_hw_pll_rx_hang_check(struct ath_softc *sc, u32 pll_sqsum)
1023{
1024 static int count;
1025 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1026
1027 if (pll_sqsum >= 0x40000) {
1028 count++;
1029 if (count == 3) {
1030 /* Rx is hung for more than 500ms. Reset it */
1031 ath_dbg(common, ATH_DBG_RESET,
1032 "Possible RX hang, resetting");
Felix Fietkau030d6292011-10-07 02:28:13 +02001033 RESET_STAT_INC(sc, RESET_TYPE_PLL_HANG);
Felix Fietkau9adcf442011-09-03 01:40:26 +02001034 ieee80211_queue_work(sc->hw, &sc->hw_reset_work);
Felix Fietkaue8cfe9f82011-09-03 01:40:24 +02001035 count = 0;
1036 }
1037 } else
1038 count = 0;
1039}
1040
1041void ath_hw_pll_work(struct work_struct *work)
1042{
1043 struct ath_softc *sc = container_of(work, struct ath_softc,
1044 hw_pll_work.work);
1045 u32 pll_sqsum;
1046
1047 if (AR_SREV_9485(sc->sc_ah)) {
1048
1049 ath9k_ps_wakeup(sc);
1050 pll_sqsum = ar9003_get_pll_sqsum_dvc(sc->sc_ah);
1051 ath9k_ps_restore(sc);
1052
1053 ath_hw_pll_rx_hang_check(sc, pll_sqsum);
1054
1055 ieee80211_queue_delayed_work(sc->hw, &sc->hw_pll_work, HZ/5);
1056 }
1057}
1058
Sujithff37e332008-11-24 12:07:55 +05301059/**********************/
1060/* mac80211 callbacks */
1061/**********************/
1062
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001063static int ath9k_start(struct ieee80211_hw *hw)
1064{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001065 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -07001066 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -07001067 struct ath_common *common = ath9k_hw_common(ah);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001068 struct ieee80211_channel *curchan = hw->conf.channel;
Sujithff37e332008-11-24 12:07:55 +05301069 struct ath9k_channel *init_channel;
Vasanthakumar Thiagarajan82880a72009-06-13 14:50:24 +05301070 int r;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001071
Joe Perches226afe62010-12-02 19:12:37 -08001072 ath_dbg(common, ATH_DBG_CONFIG,
1073 "Starting driver with initial channel: %d MHz\n",
1074 curchan->center_freq);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001075
Felix Fietkauf62d8162011-03-25 17:43:41 +01001076 ath9k_ps_wakeup(sc);
1077
Sujith141b38b2009-02-04 08:10:07 +05301078 mutex_lock(&sc->mutex);
1079
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001080 /* setup initial channel */
Vasanthakumar Thiagarajan82880a72009-06-13 14:50:24 +05301081 sc->chan_idx = curchan->hw_value;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001082
Rajkumar Manoharanc344c9c2011-01-31 23:47:43 +05301083 init_channel = ath9k_cmn_get_curchannel(hw, ah);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001084
Sujithff37e332008-11-24 12:07:55 +05301085 /* Reset SERDES registers */
Stanislaw Gruszka84c87dc2011-08-05 13:10:32 +02001086 ath9k_hw_configpcipowersave(ah, false);
Sujithff37e332008-11-24 12:07:55 +05301087
1088 /*
1089 * The basic interface to setting the hardware in a good
1090 * state is ``reset''. On return the hardware is known to
1091 * be powered up and with interrupts disabled. This must
1092 * be followed by initialization of the appropriate bits
1093 * and then setup of the interrupt mask.
1094 */
Luis R. Rodriguez4bdd1e92010-10-26 15:27:24 -07001095 spin_lock_bh(&sc->sc_pcu_lock);
Felix Fietkau20bd2a02010-07-31 00:12:00 +02001096 r = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -08001097 if (r) {
Joe Perches38002762010-12-02 19:12:36 -08001098 ath_err(common,
1099 "Unable to reset hardware; reset status %d (freq %u MHz)\n",
1100 r, curchan->center_freq);
Luis R. Rodriguez4bdd1e92010-10-26 15:27:24 -07001101 spin_unlock_bh(&sc->sc_pcu_lock);
Sujith141b38b2009-02-04 08:10:07 +05301102 goto mutex_unlock;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001103 }
Sujithff37e332008-11-24 12:07:55 +05301104
Sujithff37e332008-11-24 12:07:55 +05301105 /* Setup our intr mask. */
Felix Fietkaub5c804752010-04-15 17:38:48 -04001106 ah->imask = ATH9K_INT_TX | ATH9K_INT_RXEOL |
1107 ATH9K_INT_RXORN | ATH9K_INT_FATAL |
1108 ATH9K_INT_GLOBAL;
1109
1110 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
Luis R. Rodriguez08578b82010-05-13 13:33:44 -04001111 ah->imask |= ATH9K_INT_RXHP |
1112 ATH9K_INT_RXLP |
1113 ATH9K_INT_BB_WATCHDOG;
Felix Fietkaub5c804752010-04-15 17:38:48 -04001114 else
1115 ah->imask |= ATH9K_INT_RX;
Sujithff37e332008-11-24 12:07:55 +05301116
Felix Fietkau364734f2010-09-14 20:22:44 +02001117 ah->imask |= ATH9K_INT_GTT;
Sujithff37e332008-11-24 12:07:55 +05301118
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -07001119 if (ah->caps.hw_caps & ATH9K_HW_CAP_HT)
Pavel Roskin30691682010-03-31 18:05:31 -04001120 ah->imask |= ATH9K_INT_CST;
Sujithff37e332008-11-24 12:07:55 +05301121
Sujithff37e332008-11-24 12:07:55 +05301122 sc->sc_flags &= ~SC_OP_INVALID;
Rajkumar Manoharan5f841b42010-10-27 18:31:15 +05301123 sc->sc_ah->is_monitoring = false;
Sujithff37e332008-11-24 12:07:55 +05301124
1125 /* Disable BMISS interrupt when we're not associated */
Pavel Roskin30691682010-03-31 18:05:31 -04001126 ah->imask &= ~(ATH9K_INT_SWBA | ATH9K_INT_BMISS);
Sujithff37e332008-11-24 12:07:55 +05301127
Felix Fietkau9adcf442011-09-03 01:40:26 +02001128 if (!ath_complete_reset(sc, false)) {
1129 r = -EIO;
1130 spin_unlock_bh(&sc->sc_pcu_lock);
1131 goto mutex_unlock;
1132 }
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001133
Felix Fietkau9adcf442011-09-03 01:40:26 +02001134 spin_unlock_bh(&sc->sc_pcu_lock);
Senthil Balasubramanian164ace32009-07-14 20:17:09 -04001135
Luis R. Rodriguez766ec4a2009-09-09 14:52:02 -07001136 if ((ah->btcoex_hw.scheme != ATH_BTCOEX_CFG_NONE) &&
1137 !ah->btcoex_hw.enabled) {
Rajkumar Manoharan7dc181c2011-10-24 18:19:49 +05301138 if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_MCI))
1139 ath9k_hw_btcoex_set_weight(ah, AR_BT_COEX_WGHT,
1140 AR_STOMP_LOW_WLAN_WGHT);
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -07001141 ath9k_hw_btcoex_enable(ah);
Vasanthakumar Thiagarajanf985ad12009-08-26 21:08:43 +05301142
Luis R. Rodriguez766ec4a2009-09-09 14:52:02 -07001143 if (ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
Luis R. Rodriguez75d78392009-09-09 04:00:10 -07001144 ath9k_btcoex_timer_resume(sc);
Vasanthakumar Thiagarajan17739122009-08-26 21:08:50 +05301145 }
1146
Vasanthakumar Thiagarajan8060e162010-12-06 04:27:42 -08001147 if (ah->caps.pcie_lcr_extsync_en && common->bus_ops->extn_synch_en)
1148 common->bus_ops->extn_synch_en(common);
1149
Sujith141b38b2009-02-04 08:10:07 +05301150mutex_unlock:
1151 mutex_unlock(&sc->mutex);
1152
Felix Fietkauf62d8162011-03-25 17:43:41 +01001153 ath9k_ps_restore(sc);
1154
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -08001155 return r;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001156}
1157
Johannes Berg7bb45682011-02-24 14:42:06 +01001158static void ath9k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001159{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001160 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -07001161 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Sujith528f0c62008-10-29 10:14:26 +05301162 struct ath_tx_control txctl;
Benoit Papillault1bc14882009-11-24 15:49:18 +01001163 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
Sujith528f0c62008-10-29 10:14:26 +05301164
Gabor Juhos96148322009-07-24 17:27:21 +02001165 if (sc->ps_enabled) {
Jouni Malinendc8c4582009-05-19 17:01:42 +03001166 /*
1167 * mac80211 does not set PM field for normal data frames, so we
1168 * need to update that based on the current PS mode.
1169 */
1170 if (ieee80211_is_data(hdr->frame_control) &&
1171 !ieee80211_is_nullfunc(hdr->frame_control) &&
1172 !ieee80211_has_pm(hdr->frame_control)) {
Joe Perches226afe62010-12-02 19:12:37 -08001173 ath_dbg(common, ATH_DBG_PS,
1174 "Add PM=1 for a TX frame while in PS mode\n");
Jouni Malinendc8c4582009-05-19 17:01:42 +03001175 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
1176 }
1177 }
1178
Jouni Malinen9a23f9c2009-05-19 17:01:38 +03001179 if (unlikely(sc->sc_ah->power_mode != ATH9K_PM_AWAKE)) {
1180 /*
1181 * We are using PS-Poll and mac80211 can request TX while in
1182 * power save mode. Need to wake up hardware for the TX to be
1183 * completed and if needed, also for RX of buffered frames.
1184 */
Jouni Malinen9a23f9c2009-05-19 17:01:38 +03001185 ath9k_ps_wakeup(sc);
Vasanthakumar Thiagarajanfdf76622010-05-17 18:57:55 -07001186 if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
1187 ath9k_hw_setrxabort(sc->sc_ah, 0);
Jouni Malinen9a23f9c2009-05-19 17:01:38 +03001188 if (ieee80211_is_pspoll(hdr->frame_control)) {
Joe Perches226afe62010-12-02 19:12:37 -08001189 ath_dbg(common, ATH_DBG_PS,
1190 "Sending PS-Poll to pick a buffered frame\n");
Sujith1b04b932010-01-08 10:36:05 +05301191 sc->ps_flags |= PS_WAIT_FOR_PSPOLL_DATA;
Jouni Malinen9a23f9c2009-05-19 17:01:38 +03001192 } else {
Joe Perches226afe62010-12-02 19:12:37 -08001193 ath_dbg(common, ATH_DBG_PS,
1194 "Wake up to complete TX\n");
Sujith1b04b932010-01-08 10:36:05 +05301195 sc->ps_flags |= PS_WAIT_FOR_TX_ACK;
Jouni Malinen9a23f9c2009-05-19 17:01:38 +03001196 }
1197 /*
1198 * The actual restore operation will happen only after
1199 * the sc_flags bit is cleared. We are just dropping
1200 * the ps_usecount here.
1201 */
1202 ath9k_ps_restore(sc);
1203 }
1204
Sujith528f0c62008-10-29 10:14:26 +05301205 memset(&txctl, 0, sizeof(struct ath_tx_control));
Felix Fietkau066dae92010-11-07 14:59:39 +01001206 txctl.txq = sc->tx.txq_map[skb_get_queue_mapping(skb)];
Sujith528f0c62008-10-29 10:14:26 +05301207
Joe Perches226afe62010-12-02 19:12:37 -08001208 ath_dbg(common, ATH_DBG_XMIT, "transmitting packet, skb: %p\n", skb);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001209
Jouni Malinenc52f33d2009-03-03 19:23:29 +02001210 if (ath_tx_start(hw, skb, &txctl) != 0) {
Joe Perches226afe62010-12-02 19:12:37 -08001211 ath_dbg(common, ATH_DBG_XMIT, "TX failed\n");
Sujith528f0c62008-10-29 10:14:26 +05301212 goto exit;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001213 }
1214
Johannes Berg7bb45682011-02-24 14:42:06 +01001215 return;
Sujith528f0c62008-10-29 10:14:26 +05301216exit:
1217 dev_kfree_skb_any(skb);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001218}
1219
1220static void ath9k_stop(struct ieee80211_hw *hw)
1221{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001222 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -07001223 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -07001224 struct ath_common *common = ath9k_hw_common(ah);
Sujith9c84b792008-10-29 10:17:13 +05301225
Sujith4c483812009-08-18 10:51:52 +05301226 mutex_lock(&sc->mutex);
1227
Felix Fietkau9adcf442011-09-03 01:40:26 +02001228 ath_cancel_work(sc);
Luis R. Rodriguezc94dbff2009-07-27 11:53:04 -07001229
Sujith9c84b792008-10-29 10:17:13 +05301230 if (sc->sc_flags & SC_OP_INVALID) {
Joe Perches226afe62010-12-02 19:12:37 -08001231 ath_dbg(common, ATH_DBG_ANY, "Device not present\n");
Sujith4c483812009-08-18 10:51:52 +05301232 mutex_unlock(&sc->mutex);
Sujith9c84b792008-10-29 10:17:13 +05301233 return;
1234 }
1235
Sujith3867cf62009-12-23 20:03:27 -05001236 /* Ensure HW is awake when we try to shut it down. */
1237 ath9k_ps_wakeup(sc);
1238
Luis R. Rodriguez766ec4a2009-09-09 14:52:02 -07001239 if (ah->btcoex_hw.enabled) {
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -07001240 ath9k_hw_btcoex_disable(ah);
Luis R. Rodriguez766ec4a2009-09-09 14:52:02 -07001241 if (ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
Luis R. Rodriguez75d78392009-09-09 04:00:10 -07001242 ath9k_btcoex_timer_pause(sc);
Rajkumar Manoharan7dc181c2011-10-24 18:19:49 +05301243 ath_mci_flush_profile(&sc->btcoex.mci);
Vasanthakumar Thiagarajan17739122009-08-26 21:08:50 +05301244 }
1245
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -07001246 spin_lock_bh(&sc->sc_pcu_lock);
1247
Stanislaw Gruszka203043f2011-01-25 14:08:40 +01001248 /* prevent tasklets to enable interrupts once we disable them */
1249 ah->imask &= ~ATH9K_INT_GLOBAL;
1250
Sujithff37e332008-11-24 12:07:55 +05301251 /* make sure h/w will not generate any interrupt
1252 * before setting the invalid flag. */
Felix Fietkau4df30712010-11-08 20:54:47 +01001253 ath9k_hw_disable_interrupts(ah);
Sujithff37e332008-11-24 12:07:55 +05301254
1255 if (!(sc->sc_flags & SC_OP_INVALID)) {
Sujith043a0402009-01-16 21:38:47 +05301256 ath_drain_all_txq(sc, false);
Sujithff37e332008-11-24 12:07:55 +05301257 ath_stoprecv(sc);
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -07001258 ath9k_hw_phy_disable(ah);
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -07001259 } else
Sujithb77f4832008-12-07 21:44:03 +05301260 sc->rx.rxlink = NULL;
Sujithff37e332008-11-24 12:07:55 +05301261
Felix Fietkau0d955212011-01-26 18:23:27 +01001262 if (sc->rx.frag) {
1263 dev_kfree_skb_any(sc->rx.frag);
1264 sc->rx.frag = NULL;
1265 }
1266
Sujithff37e332008-11-24 12:07:55 +05301267 /* disable HAL and put h/w to sleep */
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -07001268 ath9k_hw_disable(ah);
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -07001269
1270 spin_unlock_bh(&sc->sc_pcu_lock);
1271
Stanislaw Gruszka203043f2011-01-25 14:08:40 +01001272 /* we can now sync irq and kill any running tasklets, since we already
1273 * disabled interrupts and not holding a spin lock */
1274 synchronize_irq(sc->irq);
1275 tasklet_kill(&sc->intr_tq);
1276 tasklet_kill(&sc->bcon_tasklet);
1277
Sujith3867cf62009-12-23 20:03:27 -05001278 ath9k_ps_restore(sc);
1279
Luis R. Rodrigueza08e7ad2010-12-07 15:13:20 -08001280 sc->ps_idle = true;
1281 ath_radio_disable(sc, hw);
Sujithff37e332008-11-24 12:07:55 +05301282
1283 sc->sc_flags |= SC_OP_INVALID;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001284
Sujith141b38b2009-02-04 08:10:07 +05301285 mutex_unlock(&sc->mutex);
1286
Joe Perches226afe62010-12-02 19:12:37 -08001287 ath_dbg(common, ATH_DBG_CONFIG, "Driver halt\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001288}
1289
Ben Greear48014162011-01-15 19:13:48 +00001290bool ath9k_uses_beacons(int type)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001291{
Ben Greear48014162011-01-15 19:13:48 +00001292 switch (type) {
Johannes Berg05c914f2008-09-11 00:01:58 +02001293 case NL80211_IFTYPE_AP:
Ben Greear48014162011-01-15 19:13:48 +00001294 case NL80211_IFTYPE_ADHOC:
Pat Erley9cb54122009-03-20 22:59:59 -04001295 case NL80211_IFTYPE_MESH_POINT:
Ben Greear48014162011-01-15 19:13:48 +00001296 return true;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001297 default:
Ben Greear48014162011-01-15 19:13:48 +00001298 return false;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001299 }
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001300}
1301
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301302static void ath9k_reclaim_beacon(struct ath_softc *sc,
1303 struct ieee80211_vif *vif)
1304{
1305 struct ath_vif *avp = (void *)vif->drv_priv;
1306
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +05301307 ath9k_set_beaconing_status(sc, false);
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301308 ath_beacon_return(sc, avp);
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +05301309 ath9k_set_beaconing_status(sc, true);
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301310 sc->sc_flags &= ~SC_OP_BEACONS;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301311}
1312
Ben Greear48014162011-01-15 19:13:48 +00001313static void ath9k_vif_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
1314{
1315 struct ath9k_vif_iter_data *iter_data = data;
1316 int i;
1317
1318 if (iter_data->hw_macaddr)
1319 for (i = 0; i < ETH_ALEN; i++)
1320 iter_data->mask[i] &=
1321 ~(iter_data->hw_macaddr[i] ^ mac[i]);
1322
1323 switch (vif->type) {
1324 case NL80211_IFTYPE_AP:
1325 iter_data->naps++;
1326 break;
1327 case NL80211_IFTYPE_STATION:
1328 iter_data->nstations++;
1329 break;
1330 case NL80211_IFTYPE_ADHOC:
1331 iter_data->nadhocs++;
1332 break;
1333 case NL80211_IFTYPE_MESH_POINT:
1334 iter_data->nmeshes++;
1335 break;
1336 case NL80211_IFTYPE_WDS:
1337 iter_data->nwds++;
1338 break;
1339 default:
1340 iter_data->nothers++;
1341 break;
1342 }
1343}
1344
1345/* Called with sc->mutex held. */
1346void ath9k_calculate_iter_data(struct ieee80211_hw *hw,
1347 struct ieee80211_vif *vif,
1348 struct ath9k_vif_iter_data *iter_data)
1349{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001350 struct ath_softc *sc = hw->priv;
Ben Greear48014162011-01-15 19:13:48 +00001351 struct ath_hw *ah = sc->sc_ah;
1352 struct ath_common *common = ath9k_hw_common(ah);
Ben Greear48014162011-01-15 19:13:48 +00001353
1354 /*
1355 * Use the hardware MAC address as reference, the hardware uses it
1356 * together with the BSSID mask when matching addresses.
1357 */
1358 memset(iter_data, 0, sizeof(*iter_data));
1359 iter_data->hw_macaddr = common->macaddr;
1360 memset(&iter_data->mask, 0xff, ETH_ALEN);
1361
1362 if (vif)
1363 ath9k_vif_iter(iter_data, vif->addr, vif);
1364
1365 /* Get list of all active MAC addresses */
Ben Greear48014162011-01-15 19:13:48 +00001366 ieee80211_iterate_active_interfaces_atomic(sc->hw, ath9k_vif_iter,
1367 iter_data);
Ben Greear48014162011-01-15 19:13:48 +00001368}
1369
1370/* Called with sc->mutex held. */
1371static void ath9k_calculate_summary_state(struct ieee80211_hw *hw,
1372 struct ieee80211_vif *vif)
1373{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001374 struct ath_softc *sc = hw->priv;
Ben Greear48014162011-01-15 19:13:48 +00001375 struct ath_hw *ah = sc->sc_ah;
1376 struct ath_common *common = ath9k_hw_common(ah);
1377 struct ath9k_vif_iter_data iter_data;
1378
1379 ath9k_calculate_iter_data(hw, vif, &iter_data);
1380
1381 /* Set BSSID mask. */
1382 memcpy(common->bssidmask, iter_data.mask, ETH_ALEN);
1383 ath_hw_setbssidmask(common);
1384
1385 /* Set op-mode & TSF */
1386 if (iter_data.naps > 0) {
1387 ath9k_hw_set_tsfadjust(ah, 1);
1388 sc->sc_flags |= SC_OP_TSF_RESET;
1389 ah->opmode = NL80211_IFTYPE_AP;
1390 } else {
1391 ath9k_hw_set_tsfadjust(ah, 0);
1392 sc->sc_flags &= ~SC_OP_TSF_RESET;
1393
Javier Cardonafd5999c2011-05-03 16:57:19 -07001394 if (iter_data.nmeshes)
1395 ah->opmode = NL80211_IFTYPE_MESH_POINT;
1396 else if (iter_data.nwds)
Ben Greear48014162011-01-15 19:13:48 +00001397 ah->opmode = NL80211_IFTYPE_AP;
1398 else if (iter_data.nadhocs)
1399 ah->opmode = NL80211_IFTYPE_ADHOC;
1400 else
1401 ah->opmode = NL80211_IFTYPE_STATION;
1402 }
1403
1404 /*
1405 * Enable MIB interrupts when there are hardware phy counters.
1406 */
1407 if ((iter_data.nstations + iter_data.nadhocs + iter_data.nmeshes) > 0) {
1408 if (ah->config.enable_ani)
1409 ah->imask |= ATH9K_INT_MIB;
1410 ah->imask |= ATH9K_INT_TSFOOR;
1411 } else {
1412 ah->imask &= ~ATH9K_INT_MIB;
1413 ah->imask &= ~ATH9K_INT_TSFOOR;
1414 }
1415
Felix Fietkau72d874c2011-10-08 20:06:19 +02001416 ath9k_hw_set_interrupts(ah);
Ben Greear48014162011-01-15 19:13:48 +00001417
1418 /* Set up ANI */
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301419 if (iter_data.naps > 0) {
Rajkumar Manoharan729da3902011-05-09 19:11:29 +05301420 sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +05301421
1422 if (!common->disable_ani) {
1423 sc->sc_flags |= SC_OP_ANI_RUN;
1424 ath_start_ani(common);
1425 }
1426
Rajkumar Manoharanf60c49b2011-04-08 17:06:25 +05301427 } else {
1428 sc->sc_flags &= ~SC_OP_ANI_RUN;
1429 del_timer_sync(&common->ani.timer);
Ben Greear48014162011-01-15 19:13:48 +00001430 }
1431}
1432
1433/* Called with sc->mutex held, vif counts set up properly. */
1434static void ath9k_do_vif_add_setup(struct ieee80211_hw *hw,
1435 struct ieee80211_vif *vif)
1436{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001437 struct ath_softc *sc = hw->priv;
Ben Greear48014162011-01-15 19:13:48 +00001438
1439 ath9k_calculate_summary_state(hw, vif);
1440
1441 if (ath9k_uses_beacons(vif->type)) {
1442 int error;
Ben Greear48014162011-01-15 19:13:48 +00001443 /* This may fail because upper levels do not have beacons
1444 * properly configured yet. That's OK, we assume it
1445 * will be properly configured and then we will be notified
1446 * in the info_changed method and set up beacons properly
1447 * there.
1448 */
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +05301449 ath9k_set_beaconing_status(sc, false);
Felix Fietkau9ac586152011-01-24 19:23:18 +01001450 error = ath_beacon_alloc(sc, vif);
Rajkumar Manoharan391bd1c2011-02-01 23:05:36 +05301451 if (!error)
Ben Greear48014162011-01-15 19:13:48 +00001452 ath_beacon_config(sc, vif);
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +05301453 ath9k_set_beaconing_status(sc, true);
Ben Greear48014162011-01-15 19:13:48 +00001454 }
1455}
1456
1457
1458static int ath9k_add_interface(struct ieee80211_hw *hw,
1459 struct ieee80211_vif *vif)
1460{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001461 struct ath_softc *sc = hw->priv;
Ben Greear48014162011-01-15 19:13:48 +00001462 struct ath_hw *ah = sc->sc_ah;
1463 struct ath_common *common = ath9k_hw_common(ah);
Ben Greear48014162011-01-15 19:13:48 +00001464 int ret = 0;
1465
Felix Fietkau96f372c2011-04-07 19:07:17 +02001466 ath9k_ps_wakeup(sc);
Ben Greear48014162011-01-15 19:13:48 +00001467 mutex_lock(&sc->mutex);
1468
1469 switch (vif->type) {
1470 case NL80211_IFTYPE_STATION:
1471 case NL80211_IFTYPE_WDS:
1472 case NL80211_IFTYPE_ADHOC:
1473 case NL80211_IFTYPE_AP:
1474 case NL80211_IFTYPE_MESH_POINT:
1475 break;
1476 default:
1477 ath_err(common, "Interface type %d not yet supported\n",
1478 vif->type);
1479 ret = -EOPNOTSUPP;
1480 goto out;
1481 }
1482
1483 if (ath9k_uses_beacons(vif->type)) {
1484 if (sc->nbcnvifs >= ATH_BCBUF) {
1485 ath_err(common, "Not enough beacon buffers when adding"
1486 " new interface of type: %i\n",
1487 vif->type);
1488 ret = -ENOBUFS;
1489 goto out;
1490 }
1491 }
1492
Rajkumar Manoharan59575d12011-04-04 22:56:16 +05301493 if ((ah->opmode == NL80211_IFTYPE_ADHOC) ||
1494 ((vif->type == NL80211_IFTYPE_ADHOC) &&
1495 sc->nvifs > 0)) {
Ben Greear48014162011-01-15 19:13:48 +00001496 ath_err(common, "Cannot create ADHOC interface when other"
1497 " interfaces already exist.\n");
1498 ret = -EINVAL;
1499 goto out;
1500 }
1501
1502 ath_dbg(common, ATH_DBG_CONFIG,
1503 "Attach a VIF of type: %d\n", vif->type);
1504
Ben Greear48014162011-01-15 19:13:48 +00001505 sc->nvifs++;
1506
1507 ath9k_do_vif_add_setup(hw, vif);
1508out:
1509 mutex_unlock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001510 ath9k_ps_restore(sc);
Ben Greear48014162011-01-15 19:13:48 +00001511 return ret;
1512}
1513
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301514static int ath9k_change_interface(struct ieee80211_hw *hw,
1515 struct ieee80211_vif *vif,
1516 enum nl80211_iftype new_type,
1517 bool p2p)
1518{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001519 struct ath_softc *sc = hw->priv;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301520 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Dan Carpenter6dab55b2010-12-21 06:59:06 +03001521 int ret = 0;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301522
1523 ath_dbg(common, ATH_DBG_CONFIG, "Change Interface\n");
1524 mutex_lock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001525 ath9k_ps_wakeup(sc);
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301526
Ben Greear48014162011-01-15 19:13:48 +00001527 /* See if new interface type is valid. */
1528 if ((new_type == NL80211_IFTYPE_ADHOC) &&
1529 (sc->nvifs > 1)) {
1530 ath_err(common, "When using ADHOC, it must be the only"
1531 " interface.\n");
1532 ret = -EINVAL;
1533 goto out;
1534 }
1535
1536 if (ath9k_uses_beacons(new_type) &&
1537 !ath9k_uses_beacons(vif->type)) {
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301538 if (sc->nbcnvifs >= ATH_BCBUF) {
1539 ath_err(common, "No beacon slot available\n");
Dan Carpenter6dab55b2010-12-21 06:59:06 +03001540 ret = -ENOBUFS;
1541 goto out;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301542 }
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301543 }
Ben Greear48014162011-01-15 19:13:48 +00001544
1545 /* Clean up old vif stuff */
1546 if (ath9k_uses_beacons(vif->type))
1547 ath9k_reclaim_beacon(sc, vif);
1548
1549 /* Add new settings */
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301550 vif->type = new_type;
1551 vif->p2p = p2p;
1552
Ben Greear48014162011-01-15 19:13:48 +00001553 ath9k_do_vif_add_setup(hw, vif);
Dan Carpenter6dab55b2010-12-21 06:59:06 +03001554out:
Felix Fietkau96f372c2011-04-07 19:07:17 +02001555 ath9k_ps_restore(sc);
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301556 mutex_unlock(&sc->mutex);
Dan Carpenter6dab55b2010-12-21 06:59:06 +03001557 return ret;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301558}
1559
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001560static void ath9k_remove_interface(struct ieee80211_hw *hw,
Johannes Berg1ed32e42009-12-23 13:15:45 +01001561 struct ieee80211_vif *vif)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001562{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001563 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -07001564 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001565
Joe Perches226afe62010-12-02 19:12:37 -08001566 ath_dbg(common, ATH_DBG_CONFIG, "Detach Interface\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001567
Felix Fietkau96f372c2011-04-07 19:07:17 +02001568 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301569 mutex_lock(&sc->mutex);
1570
Ben Greear48014162011-01-15 19:13:48 +00001571 sc->nvifs--;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001572
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001573 /* Reclaim beacon resources */
Ben Greear48014162011-01-15 19:13:48 +00001574 if (ath9k_uses_beacons(vif->type))
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301575 ath9k_reclaim_beacon(sc, vif);
Jouni Malinen2c3db3d2009-03-03 19:23:26 +02001576
Ben Greear48014162011-01-15 19:13:48 +00001577 ath9k_calculate_summary_state(hw, NULL);
Sujith141b38b2009-02-04 08:10:07 +05301578
1579 mutex_unlock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001580 ath9k_ps_restore(sc);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001581}
1582
Senthil Balasubramanianfbab7392010-10-05 20:36:40 +05301583static void ath9k_enable_ps(struct ath_softc *sc)
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301584{
Pavel Roskin30691682010-03-31 18:05:31 -04001585 struct ath_hw *ah = sc->sc_ah;
1586
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301587 sc->ps_enabled = true;
Pavel Roskin30691682010-03-31 18:05:31 -04001588 if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP)) {
1589 if ((ah->imask & ATH9K_INT_TIM_TIMER) == 0) {
1590 ah->imask |= ATH9K_INT_TIM_TIMER;
Felix Fietkau72d874c2011-10-08 20:06:19 +02001591 ath9k_hw_set_interrupts(ah);
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301592 }
Vasanthakumar Thiagarajanfdf76622010-05-17 18:57:55 -07001593 ath9k_hw_setrxabort(ah, 1);
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301594 }
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301595}
1596
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301597static void ath9k_disable_ps(struct ath_softc *sc)
1598{
1599 struct ath_hw *ah = sc->sc_ah;
1600
1601 sc->ps_enabled = false;
1602 ath9k_hw_setpower(ah, ATH9K_PM_AWAKE);
1603 if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP)) {
1604 ath9k_hw_setrxabort(ah, 0);
1605 sc->ps_flags &= ~(PS_WAIT_FOR_BEACON |
1606 PS_WAIT_FOR_CAB |
1607 PS_WAIT_FOR_PSPOLL_DATA |
1608 PS_WAIT_FOR_TX_ACK);
1609 if (ah->imask & ATH9K_INT_TIM_TIMER) {
1610 ah->imask &= ~ATH9K_INT_TIM_TIMER;
Felix Fietkau72d874c2011-10-08 20:06:19 +02001611 ath9k_hw_set_interrupts(ah);
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301612 }
1613 }
1614
1615}
1616
Johannes Berge8975582008-10-09 12:18:51 +02001617static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001618{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001619 struct ath_softc *sc = hw->priv;
Felix Fietkau34300982010-10-10 18:21:52 +02001620 struct ath_hw *ah = sc->sc_ah;
1621 struct ath_common *common = ath9k_hw_common(ah);
Johannes Berge8975582008-10-09 12:18:51 +02001622 struct ieee80211_conf *conf = &hw->conf;
Felix Fietkau7545daf2011-01-24 19:23:16 +01001623 bool disable_radio = false;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001624
Sujithaa33de02008-12-18 11:40:16 +05301625 mutex_lock(&sc->mutex);
Sujith141b38b2009-02-04 08:10:07 +05301626
Luis R. Rodriguez194b7c12009-10-29 10:41:15 -07001627 /*
1628 * Leave this as the first check because we need to turn on the
1629 * radio if it was disabled before prior to processing the rest
1630 * of the changes. Likewise we must only disable the radio towards
1631 * the end.
1632 */
Luis R. Rodriguez64839172009-07-14 20:22:53 -04001633 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
Felix Fietkau7545daf2011-01-24 19:23:16 +01001634 sc->ps_idle = !!(conf->flags & IEEE80211_CONF_IDLE);
1635 if (!sc->ps_idle) {
Luis R. Rodriguez68a89112009-11-02 14:35:42 -08001636 ath_radio_enable(sc, hw);
Joe Perches226afe62010-12-02 19:12:37 -08001637 ath_dbg(common, ATH_DBG_CONFIG,
1638 "not-idle: enabling radio\n");
Felix Fietkau7545daf2011-01-24 19:23:16 +01001639 } else {
1640 disable_radio = true;
Luis R. Rodriguez64839172009-07-14 20:22:53 -04001641 }
1642 }
1643
Luis R. Rodrigueze7824a52009-11-24 02:53:25 -05001644 /*
1645 * We just prepare to enable PS. We have to wait until our AP has
1646 * ACK'd our null data frame to disable RX otherwise we'll ignore
1647 * those ACKs and end up retransmitting the same null data frames.
1648 * IEEE80211_CONF_CHANGE_PS is only passed by mac80211 for STA mode.
1649 */
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301650 if (changed & IEEE80211_CONF_CHANGE_PS) {
Luis R. Rodriguez8ab2cd02010-09-16 15:12:26 -04001651 unsigned long flags;
1652 spin_lock_irqsave(&sc->sc_pm_lock, flags);
Senthil Balasubramanianfbab7392010-10-05 20:36:40 +05301653 if (conf->flags & IEEE80211_CONF_PS)
1654 ath9k_enable_ps(sc);
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301655 else
1656 ath9k_disable_ps(sc);
Luis R. Rodriguez8ab2cd02010-09-16 15:12:26 -04001657 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301658 }
1659
Sujith199afd92010-01-08 10:36:13 +05301660 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1661 if (conf->flags & IEEE80211_CONF_MONITOR) {
Joe Perches226afe62010-12-02 19:12:37 -08001662 ath_dbg(common, ATH_DBG_CONFIG,
1663 "Monitor mode is enabled\n");
Rajkumar Manoharan5f841b42010-10-27 18:31:15 +05301664 sc->sc_ah->is_monitoring = true;
1665 } else {
Joe Perches226afe62010-12-02 19:12:37 -08001666 ath_dbg(common, ATH_DBG_CONFIG,
1667 "Monitor mode is disabled\n");
Rajkumar Manoharan5f841b42010-10-27 18:31:15 +05301668 sc->sc_ah->is_monitoring = false;
Sujith199afd92010-01-08 10:36:13 +05301669 }
1670 }
1671
Johannes Berg47979382009-01-07 10:13:27 +01001672 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
Sujith99405f92008-11-24 12:08:35 +05301673 struct ieee80211_channel *curchan = hw->conf.channel;
Rajkumar Manoharane338a852011-08-13 10:28:17 +05301674 struct ath9k_channel old_chan;
Luis R. Rodriguez5f8e0772009-01-22 15:16:48 -08001675 int pos = curchan->hw_value;
Felix Fietkau34300982010-10-10 18:21:52 +02001676 int old_pos = -1;
1677 unsigned long flags;
1678
1679 if (ah->curchan)
1680 old_pos = ah->curchan - &ah->channels[0];
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001681
Felix Fietkau5ee08652010-07-31 00:11:59 +02001682 if (hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)
1683 sc->sc_flags |= SC_OP_OFFCHANNEL;
1684 else
1685 sc->sc_flags &= ~SC_OP_OFFCHANNEL;
Jouni Malinen0e2dedf2009-03-03 19:23:32 +02001686
Ben Greear8c79a612011-02-07 13:44:33 -08001687 ath_dbg(common, ATH_DBG_CONFIG,
1688 "Set channel: %d MHz type: %d\n",
1689 curchan->center_freq, conf->channel_type);
Johannes Bergae5eb022008-10-14 16:58:37 +02001690
Felix Fietkau34300982010-10-10 18:21:52 +02001691 /* update survey stats for the old channel before switching */
1692 spin_lock_irqsave(&common->cc_lock, flags);
1693 ath_update_survey_stats(sc);
1694 spin_unlock_irqrestore(&common->cc_lock, flags);
1695
1696 /*
Rajkumar Manoharane338a852011-08-13 10:28:17 +05301697 * Preserve the current channel values, before updating
1698 * the same channel
1699 */
1700 if (old_pos == pos) {
1701 memcpy(&old_chan, &sc->sc_ah->channels[pos],
1702 sizeof(struct ath9k_channel));
1703 ah->curchan = &old_chan;
1704 }
1705
1706 ath9k_cmn_update_ichannel(&sc->sc_ah->channels[pos],
1707 curchan, conf->channel_type);
1708
1709 /*
Felix Fietkau34300982010-10-10 18:21:52 +02001710 * If the operating channel changes, change the survey in-use flags
1711 * along with it.
1712 * Reset the survey data for the new channel, unless we're switching
1713 * back to the operating channel from an off-channel operation.
1714 */
1715 if (!(hw->conf.flags & IEEE80211_CONF_OFFCHANNEL) &&
1716 sc->cur_survey != &sc->survey[pos]) {
1717
1718 if (sc->cur_survey)
1719 sc->cur_survey->filled &= ~SURVEY_INFO_IN_USE;
1720
1721 sc->cur_survey = &sc->survey[pos];
1722
1723 memset(sc->cur_survey, 0, sizeof(struct survey_info));
1724 sc->cur_survey->filled |= SURVEY_INFO_IN_USE;
1725 } else if (!(sc->survey[pos].filled & SURVEY_INFO_IN_USE)) {
1726 memset(&sc->survey[pos], 0, sizeof(struct survey_info));
1727 }
1728
Jouni Malinen0e2dedf2009-03-03 19:23:32 +02001729 if (ath_set_channel(sc, hw, &sc->sc_ah->channels[pos]) < 0) {
Joe Perches38002762010-12-02 19:12:36 -08001730 ath_err(common, "Unable to set channel\n");
Sujithaa33de02008-12-18 11:40:16 +05301731 mutex_unlock(&sc->mutex);
Sujithe11602b2008-11-27 09:46:27 +05301732 return -EINVAL;
1733 }
Felix Fietkau34300982010-10-10 18:21:52 +02001734
1735 /*
1736 * The most recent snapshot of channel->noisefloor for the old
1737 * channel is only available after the hardware reset. Copy it to
1738 * the survey stats now.
1739 */
1740 if (old_pos >= 0)
1741 ath_update_survey_nf(sc, old_pos);
Sujith094d05d2008-12-12 11:57:43 +05301742 }
Sujith86b89ee2008-08-07 10:54:57 +05301743
Luis R. Rodriguezc9f6a652010-01-19 14:04:19 -05001744 if (changed & IEEE80211_CONF_CHANGE_POWER) {
Ben Greear603b3ee2011-02-07 13:44:37 -08001745 ath_dbg(common, ATH_DBG_CONFIG,
1746 "Set power: %d\n", conf->power_level);
Sujith17d79042009-02-09 13:27:03 +05301747 sc->config.txpowlimit = 2 * conf->power_level;
Felix Fietkau783cd012011-01-21 18:52:38 +01001748 ath9k_ps_wakeup(sc);
Rajkumar Manoharan5048e8c2011-01-31 23:47:44 +05301749 ath9k_cmn_update_txpow(ah, sc->curtxpow,
1750 sc->config.txpowlimit, &sc->curtxpow);
Felix Fietkau783cd012011-01-21 18:52:38 +01001751 ath9k_ps_restore(sc);
Luis R. Rodriguezc9f6a652010-01-19 14:04:19 -05001752 }
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001753
Luis R. Rodriguez64839172009-07-14 20:22:53 -04001754 if (disable_radio) {
Joe Perches226afe62010-12-02 19:12:37 -08001755 ath_dbg(common, ATH_DBG_CONFIG, "idle: disabling radio\n");
Luis R. Rodriguez68a89112009-11-02 14:35:42 -08001756 ath_radio_disable(sc, hw);
Luis R. Rodriguez64839172009-07-14 20:22:53 -04001757 }
1758
Sujithaa33de02008-12-18 11:40:16 +05301759 mutex_unlock(&sc->mutex);
Sujith141b38b2009-02-04 08:10:07 +05301760
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001761 return 0;
1762}
1763
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001764#define SUPPORTED_FILTERS \
1765 (FIF_PROMISC_IN_BSS | \
1766 FIF_ALLMULTI | \
1767 FIF_CONTROL | \
Luis R. Rodriguezaf6a3fc2009-08-08 21:55:16 -04001768 FIF_PSPOLL | \
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001769 FIF_OTHER_BSS | \
1770 FIF_BCN_PRBRESP_PROMISC | \
Jouni Malinen9c1d8e42010-10-13 17:29:31 +03001771 FIF_PROBE_REQ | \
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001772 FIF_FCSFAIL)
1773
Sujith7dcfdcd2008-08-11 14:03:13 +05301774/* FIXME: sc->sc_full_reset ? */
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001775static void ath9k_configure_filter(struct ieee80211_hw *hw,
1776 unsigned int changed_flags,
1777 unsigned int *total_flags,
Johannes Berg3ac64be2009-08-17 16:16:53 +02001778 u64 multicast)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001779{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001780 struct ath_softc *sc = hw->priv;
Sujith7dcfdcd2008-08-11 14:03:13 +05301781 u32 rfilt;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001782
1783 changed_flags &= SUPPORTED_FILTERS;
1784 *total_flags &= SUPPORTED_FILTERS;
1785
Sujithb77f4832008-12-07 21:44:03 +05301786 sc->rx.rxfilter = *total_flags;
Jouni Malinenaa68aea2009-05-19 17:01:41 +03001787 ath9k_ps_wakeup(sc);
Sujith7dcfdcd2008-08-11 14:03:13 +05301788 rfilt = ath_calcrxfilter(sc);
1789 ath9k_hw_setrxfilter(sc->sc_ah, rfilt);
Jouni Malinenaa68aea2009-05-19 17:01:41 +03001790 ath9k_ps_restore(sc);
Sujith7dcfdcd2008-08-11 14:03:13 +05301791
Joe Perches226afe62010-12-02 19:12:37 -08001792 ath_dbg(ath9k_hw_common(sc->sc_ah), ATH_DBG_CONFIG,
1793 "Set HW RX filter: 0x%x\n", rfilt);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001794}
1795
Johannes Berg4ca77862010-02-19 19:06:56 +01001796static int ath9k_sta_add(struct ieee80211_hw *hw,
1797 struct ieee80211_vif *vif,
1798 struct ieee80211_sta *sta)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001799{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001800 struct ath_softc *sc = hw->priv;
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001801 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1802 struct ath_node *an = (struct ath_node *) sta->drv_priv;
1803 struct ieee80211_key_conf ps_key = { };
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001804
Ben Greear7e1e3862011-11-03 11:33:13 -07001805 ath_node_attach(sc, sta, vif);
Felix Fietkauf59a59f2011-05-10 20:52:22 +02001806
1807 if (vif->type != NL80211_IFTYPE_AP &&
1808 vif->type != NL80211_IFTYPE_AP_VLAN)
1809 return 0;
1810
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001811 an->ps_key = ath_key_config(common, vif, sta, &ps_key);
Johannes Berg4ca77862010-02-19 19:06:56 +01001812
1813 return 0;
1814}
1815
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001816static void ath9k_del_ps_key(struct ath_softc *sc,
1817 struct ieee80211_vif *vif,
1818 struct ieee80211_sta *sta)
1819{
1820 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1821 struct ath_node *an = (struct ath_node *) sta->drv_priv;
1822 struct ieee80211_key_conf ps_key = { .hw_key_idx = an->ps_key };
1823
1824 if (!an->ps_key)
1825 return;
1826
1827 ath_key_delete(common, &ps_key);
1828}
1829
Johannes Berg4ca77862010-02-19 19:06:56 +01001830static int ath9k_sta_remove(struct ieee80211_hw *hw,
1831 struct ieee80211_vif *vif,
1832 struct ieee80211_sta *sta)
1833{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001834 struct ath_softc *sc = hw->priv;
Johannes Berg4ca77862010-02-19 19:06:56 +01001835
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001836 ath9k_del_ps_key(sc, vif, sta);
Johannes Berg4ca77862010-02-19 19:06:56 +01001837 ath_node_detach(sc, sta);
1838
1839 return 0;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001840}
1841
Felix Fietkau55195412011-04-17 23:28:09 +02001842static void ath9k_sta_notify(struct ieee80211_hw *hw,
1843 struct ieee80211_vif *vif,
1844 enum sta_notify_cmd cmd,
1845 struct ieee80211_sta *sta)
1846{
1847 struct ath_softc *sc = hw->priv;
1848 struct ath_node *an = (struct ath_node *) sta->drv_priv;
1849
1850 switch (cmd) {
1851 case STA_NOTIFY_SLEEP:
1852 an->sleeping = true;
Johannes Berg042ec452011-09-29 16:04:26 +02001853 ath_tx_aggr_sleep(sta, sc, an);
Felix Fietkau55195412011-04-17 23:28:09 +02001854 break;
1855 case STA_NOTIFY_AWAKE:
1856 an->sleeping = false;
1857 ath_tx_aggr_wakeup(sc, an);
1858 break;
1859 }
1860}
1861
Eliad Peller8a3a3c82011-10-02 10:15:52 +02001862static int ath9k_conf_tx(struct ieee80211_hw *hw,
1863 struct ieee80211_vif *vif, u16 queue,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001864 const struct ieee80211_tx_queue_params *params)
1865{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001866 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -07001867 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkau066dae92010-11-07 14:59:39 +01001868 struct ath_txq *txq;
Sujithea9880f2008-08-07 10:53:10 +05301869 struct ath9k_tx_queue_info qi;
Felix Fietkau066dae92010-11-07 14:59:39 +01001870 int ret = 0;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001871
1872 if (queue >= WME_NUM_AC)
1873 return 0;
1874
Felix Fietkau066dae92010-11-07 14:59:39 +01001875 txq = sc->tx.txq_map[queue];
1876
Felix Fietkau96f372c2011-04-07 19:07:17 +02001877 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301878 mutex_lock(&sc->mutex);
1879
Sujith1ffb0612009-03-30 15:28:46 +05301880 memset(&qi, 0, sizeof(struct ath9k_tx_queue_info));
1881
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001882 qi.tqi_aifs = params->aifs;
1883 qi.tqi_cwmin = params->cw_min;
1884 qi.tqi_cwmax = params->cw_max;
1885 qi.tqi_burstTime = params->txop;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001886
Joe Perches226afe62010-12-02 19:12:37 -08001887 ath_dbg(common, ATH_DBG_CONFIG,
1888 "Configure tx [queue/halq] [%d/%d], aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
1889 queue, txq->axq_qnum, params->aifs, params->cw_min,
1890 params->cw_max, params->txop);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001891
Felix Fietkau066dae92010-11-07 14:59:39 +01001892 ret = ath_txq_update(sc, txq->axq_qnum, &qi);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001893 if (ret)
Joe Perches38002762010-12-02 19:12:36 -08001894 ath_err(common, "TXQ Update failed\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001895
Vivek Natarajan94db2932009-11-25 12:01:54 +05301896 if (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC)
Felix Fietkau066dae92010-11-07 14:59:39 +01001897 if (queue == WME_AC_BE && !ret)
Vivek Natarajan94db2932009-11-25 12:01:54 +05301898 ath_beaconq_config(sc);
1899
Sujith141b38b2009-02-04 08:10:07 +05301900 mutex_unlock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001901 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301902
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001903 return ret;
1904}
1905
1906static int ath9k_set_key(struct ieee80211_hw *hw,
1907 enum set_key_cmd cmd,
Johannes Bergdc822b52008-12-29 12:55:09 +01001908 struct ieee80211_vif *vif,
1909 struct ieee80211_sta *sta,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001910 struct ieee80211_key_conf *key)
1911{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001912 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -07001913 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001914 int ret = 0;
1915
John W. Linville3e6109c2011-01-05 09:39:17 -05001916 if (ath9k_modparam_nohwcrypt)
Jouni Malinenb3bd89c2009-02-24 13:42:01 +02001917 return -ENOSPC;
1918
Jouni Malinencfdc9a82011-03-23 14:52:19 +02001919 if (vif->type == NL80211_IFTYPE_ADHOC &&
1920 (key->cipher == WLAN_CIPHER_SUITE_TKIP ||
1921 key->cipher == WLAN_CIPHER_SUITE_CCMP) &&
1922 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
1923 /*
1924 * For now, disable hw crypto for the RSN IBSS group keys. This
1925 * could be optimized in the future to use a modified key cache
1926 * design to support per-STA RX GTK, but until that gets
1927 * implemented, use of software crypto for group addressed
1928 * frames is a acceptable to allow RSN IBSS to be used.
1929 */
1930 return -EOPNOTSUPP;
1931 }
1932
Sujith141b38b2009-02-04 08:10:07 +05301933 mutex_lock(&sc->mutex);
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301934 ath9k_ps_wakeup(sc);
Joe Perches226afe62010-12-02 19:12:37 -08001935 ath_dbg(common, ATH_DBG_CONFIG, "Set HW Key\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001936
1937 switch (cmd) {
1938 case SET_KEY:
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001939 if (sta)
1940 ath9k_del_ps_key(sc, vif, sta);
1941
Bruno Randolf040e5392010-09-08 16:05:04 +09001942 ret = ath_key_config(common, vif, sta, key);
Jouni Malinen6ace2892008-12-17 13:32:17 +02001943 if (ret >= 0) {
1944 key->hw_key_idx = ret;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001945 /* push IV and Michael MIC generation to stack */
1946 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
Johannes Berg97359d12010-08-10 09:46:38 +02001947 if (key->cipher == WLAN_CIPHER_SUITE_TKIP)
Senthil Balasubramanian1b961752008-09-01 19:45:21 +05301948 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
Johannes Berg97359d12010-08-10 09:46:38 +02001949 if (sc->sc_ah->sw_mgmt_crypto &&
1950 key->cipher == WLAN_CIPHER_SUITE_CCMP)
Jouni Malinen0ced0e12009-01-08 13:32:13 +02001951 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT;
Jouni Malinen6ace2892008-12-17 13:32:17 +02001952 ret = 0;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001953 }
1954 break;
1955 case DISABLE_KEY:
Bruno Randolf040e5392010-09-08 16:05:04 +09001956 ath_key_delete(common, key);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001957 break;
1958 default:
1959 ret = -EINVAL;
1960 }
1961
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301962 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301963 mutex_unlock(&sc->mutex);
1964
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001965 return ret;
1966}
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301967static void ath9k_bss_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
1968{
1969 struct ath_softc *sc = data;
1970 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1971 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1972 struct ath_vif *avp = (void *)vif->drv_priv;
1973
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301974 /*
1975 * Skip iteration if primary station vif's bss info
1976 * was not changed
1977 */
1978 if (sc->sc_flags & SC_OP_PRIM_STA_VIF)
1979 return;
1980
1981 if (bss_conf->assoc) {
1982 sc->sc_flags |= SC_OP_PRIM_STA_VIF;
1983 avp->primary_sta_vif = true;
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301984 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1985 common->curaid = bss_conf->aid;
1986 ath9k_hw_write_associd(sc->sc_ah);
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301987 ath_dbg(common, ATH_DBG_CONFIG,
Rajkumar Manoharan99e4d432011-04-04 22:56:19 +05301988 "Bss Info ASSOC %d, bssid: %pM\n",
1989 bss_conf->aid, common->curbssid);
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301990 ath_beacon_config(sc, vif);
1991 /*
1992 * Request a re-configuration of Beacon related timers
1993 * on the receipt of the first Beacon frame (i.e.,
1994 * after time sync with the AP).
1995 */
1996 sc->ps_flags |= PS_BEACON_SYNC | PS_WAIT_FOR_BEACON;
1997 /* Reset rssi stats */
1998 sc->last_rssi = ATH_RSSI_DUMMY_MARKER;
1999 sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
Rajkumar Manoharan99e4d432011-04-04 22:56:19 +05302000
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +05302001 if (!common->disable_ani) {
2002 sc->sc_flags |= SC_OP_ANI_RUN;
2003 ath_start_ani(common);
2004 }
2005
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05302006 }
2007}
2008
2009static void ath9k_config_bss(struct ath_softc *sc, struct ieee80211_vif *vif)
2010{
2011 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
2012 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
2013 struct ath_vif *avp = (void *)vif->drv_priv;
2014
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05302015 if (sc->sc_ah->opmode != NL80211_IFTYPE_STATION)
2016 return;
2017
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05302018 /* Reconfigure bss info */
2019 if (avp->primary_sta_vif && !bss_conf->assoc) {
Rajkumar Manoharan99e4d432011-04-04 22:56:19 +05302020 ath_dbg(common, ATH_DBG_CONFIG,
2021 "Bss Info DISASSOC %d, bssid %pM\n",
2022 common->curaid, common->curbssid);
2023 sc->sc_flags &= ~(SC_OP_PRIM_STA_VIF | SC_OP_BEACONS);
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05302024 avp->primary_sta_vif = false;
2025 memset(common->curbssid, 0, ETH_ALEN);
2026 common->curaid = 0;
2027 }
2028
2029 ieee80211_iterate_active_interfaces_atomic(
2030 sc->hw, ath9k_bss_iter, sc);
2031
2032 /*
2033 * None of station vifs are associated.
2034 * Clear bssid & aid
2035 */
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05302036 if (!(sc->sc_flags & SC_OP_PRIM_STA_VIF)) {
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05302037 ath9k_hw_write_associd(sc->sc_ah);
Rajkumar Manoharan99e4d432011-04-04 22:56:19 +05302038 /* Stop ANI */
2039 sc->sc_flags &= ~SC_OP_ANI_RUN;
2040 del_timer_sync(&common->ani.timer);
Rajkumar Manoharand2c71c22011-09-15 19:02:54 +05302041 memset(&sc->caldata, 0, sizeof(sc->caldata));
Rajkumar Manoharan99e4d432011-04-04 22:56:19 +05302042 }
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05302043}
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002044
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002045static void ath9k_bss_info_changed(struct ieee80211_hw *hw,
2046 struct ieee80211_vif *vif,
2047 struct ieee80211_bss_conf *bss_conf,
2048 u32 changed)
2049{
Felix Fietkau9ac586152011-01-24 19:23:18 +01002050 struct ath_softc *sc = hw->priv;
Johannes Berg2d0ddec2009-04-23 16:13:26 +02002051 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguez15107182009-09-10 09:22:37 -07002052 struct ath_common *common = ath9k_hw_common(ah);
Johannes Berg2d0ddec2009-04-23 16:13:26 +02002053 struct ath_vif *avp = (void *)vif->drv_priv;
Felix Fietkau0005baf2010-01-15 02:33:40 +01002054 int slottime;
Sujithc6089cc2009-11-16 11:40:48 +05302055 int error;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002056
Felix Fietkau96f372c2011-04-07 19:07:17 +02002057 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05302058 mutex_lock(&sc->mutex);
2059
Sujithc6089cc2009-11-16 11:40:48 +05302060 if (changed & BSS_CHANGED_BSSID) {
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05302061 ath9k_config_bss(sc, vif);
Sujithc6089cc2009-11-16 11:40:48 +05302062
Joe Perches226afe62010-12-02 19:12:37 -08002063 ath_dbg(common, ATH_DBG_CONFIG, "BSSID: %pM aid: 0x%x\n",
2064 common->curbssid, common->curaid);
Johannes Berg2d0ddec2009-04-23 16:13:26 +02002065 }
2066
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05302067 if (changed & BSS_CHANGED_IBSS) {
2068 /* There can be only one vif available */
2069 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
2070 common->curaid = bss_conf->aid;
2071 ath9k_hw_write_associd(sc->sc_ah);
2072
2073 if (bss_conf->ibss_joined) {
2074 sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +05302075
2076 if (!common->disable_ani) {
2077 sc->sc_flags |= SC_OP_ANI_RUN;
2078 ath_start_ani(common);
2079 }
2080
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05302081 } else {
2082 sc->sc_flags &= ~SC_OP_ANI_RUN;
2083 del_timer_sync(&common->ani.timer);
2084 }
2085 }
2086
Sujithc6089cc2009-11-16 11:40:48 +05302087 /* Enable transmission of beacons (AP, IBSS, MESH) */
2088 if ((changed & BSS_CHANGED_BEACON) ||
2089 ((changed & BSS_CHANGED_BEACON_ENABLED) && bss_conf->enable_beacon)) {
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +05302090 ath9k_set_beaconing_status(sc, false);
Felix Fietkau9ac586152011-01-24 19:23:18 +01002091 error = ath_beacon_alloc(sc, vif);
Sujithc6089cc2009-11-16 11:40:48 +05302092 if (!error)
2093 ath_beacon_config(sc, vif);
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +05302094 ath9k_set_beaconing_status(sc, true);
Johannes Berg2d0ddec2009-04-23 16:13:26 +02002095 }
2096
Felix Fietkau0005baf2010-01-15 02:33:40 +01002097 if (changed & BSS_CHANGED_ERP_SLOT) {
2098 if (bss_conf->use_short_slot)
2099 slottime = 9;
2100 else
2101 slottime = 20;
2102 if (vif->type == NL80211_IFTYPE_AP) {
2103 /*
2104 * Defer update, so that connected stations can adjust
2105 * their settings at the same time.
2106 * See beacon.c for more details
2107 */
2108 sc->beacon.slottime = slottime;
2109 sc->beacon.updateslot = UPDATE;
2110 } else {
2111 ah->slottime = slottime;
2112 ath9k_hw_init_global_settings(ah);
2113 }
2114 }
2115
Sujithc6089cc2009-11-16 11:40:48 +05302116 /* Disable transmission of beacons */
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +05302117 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
2118 !bss_conf->enable_beacon) {
2119 ath9k_set_beaconing_status(sc, false);
2120 avp->is_bslot_active = false;
2121 ath9k_set_beaconing_status(sc, true);
2122 }
Sujithc6089cc2009-11-16 11:40:48 +05302123
2124 if (changed & BSS_CHANGED_BEACON_INT) {
Sujithc6089cc2009-11-16 11:40:48 +05302125 /*
2126 * In case of AP mode, the HW TSF has to be reset
2127 * when the beacon interval changes.
2128 */
2129 if (vif->type == NL80211_IFTYPE_AP) {
2130 sc->sc_flags |= SC_OP_TSF_RESET;
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +05302131 ath9k_set_beaconing_status(sc, false);
Felix Fietkau9ac586152011-01-24 19:23:18 +01002132 error = ath_beacon_alloc(sc, vif);
Johannes Berg2d0ddec2009-04-23 16:13:26 +02002133 if (!error)
2134 ath_beacon_config(sc, vif);
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +05302135 ath9k_set_beaconing_status(sc, true);
Rajkumar Manoharan99e4d432011-04-04 22:56:19 +05302136 } else
Sujithc6089cc2009-11-16 11:40:48 +05302137 ath_beacon_config(sc, vif);
Johannes Berg2d0ddec2009-04-23 16:13:26 +02002138 }
2139
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002140 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
Joe Perches226afe62010-12-02 19:12:37 -08002141 ath_dbg(common, ATH_DBG_CONFIG, "BSS Changed PREAMBLE %d\n",
2142 bss_conf->use_short_preamble);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002143 if (bss_conf->use_short_preamble)
Sujith672840a2008-08-11 14:05:08 +05302144 sc->sc_flags |= SC_OP_PREAMBLE_SHORT;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002145 else
Sujith672840a2008-08-11 14:05:08 +05302146 sc->sc_flags &= ~SC_OP_PREAMBLE_SHORT;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002147 }
2148
2149 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
Joe Perches226afe62010-12-02 19:12:37 -08002150 ath_dbg(common, ATH_DBG_CONFIG, "BSS Changed CTS PROT %d\n",
2151 bss_conf->use_cts_prot);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002152 if (bss_conf->use_cts_prot &&
2153 hw->conf.channel->band != IEEE80211_BAND_5GHZ)
Sujith672840a2008-08-11 14:05:08 +05302154 sc->sc_flags |= SC_OP_PROTECT_ENABLE;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002155 else
Sujith672840a2008-08-11 14:05:08 +05302156 sc->sc_flags &= ~SC_OP_PROTECT_ENABLE;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002157 }
2158
Sujith141b38b2009-02-04 08:10:07 +05302159 mutex_unlock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02002160 ath9k_ps_restore(sc);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002161}
2162
Eliad Peller37a41b42011-09-21 14:06:11 +03002163static u64 ath9k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002164{
Felix Fietkau9ac586152011-01-24 19:23:18 +01002165 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002166 u64 tsf;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002167
Sujith141b38b2009-02-04 08:10:07 +05302168 mutex_lock(&sc->mutex);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05302169 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05302170 tsf = ath9k_hw_gettsf64(sc->sc_ah);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05302171 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05302172 mutex_unlock(&sc->mutex);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002173
2174 return tsf;
2175}
2176
Eliad Peller37a41b42011-09-21 14:06:11 +03002177static void ath9k_set_tsf(struct ieee80211_hw *hw,
2178 struct ieee80211_vif *vif,
2179 u64 tsf)
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01002180{
Felix Fietkau9ac586152011-01-24 19:23:18 +01002181 struct ath_softc *sc = hw->priv;
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01002182
Sujith141b38b2009-02-04 08:10:07 +05302183 mutex_lock(&sc->mutex);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05302184 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05302185 ath9k_hw_settsf64(sc->sc_ah, tsf);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05302186 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05302187 mutex_unlock(&sc->mutex);
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01002188}
2189
Eliad Peller37a41b42011-09-21 14:06:11 +03002190static void ath9k_reset_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002191{
Felix Fietkau9ac586152011-01-24 19:23:18 +01002192 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002193
Sujith141b38b2009-02-04 08:10:07 +05302194 mutex_lock(&sc->mutex);
Luis R. Rodriguez21526d52009-09-09 20:05:39 -07002195
2196 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05302197 ath9k_hw_reset_tsf(sc->sc_ah);
Luis R. Rodriguez21526d52009-09-09 20:05:39 -07002198 ath9k_ps_restore(sc);
2199
Sujith141b38b2009-02-04 08:10:07 +05302200 mutex_unlock(&sc->mutex);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002201}
2202
2203static int ath9k_ampdu_action(struct ieee80211_hw *hw,
Johannes Bergc951ad32009-11-16 12:00:38 +01002204 struct ieee80211_vif *vif,
Sujith141b38b2009-02-04 08:10:07 +05302205 enum ieee80211_ampdu_mlme_action action,
2206 struct ieee80211_sta *sta,
Johannes Berg0b01f032011-01-18 13:51:05 +01002207 u16 tid, u16 *ssn, u8 buf_size)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002208{
Felix Fietkau9ac586152011-01-24 19:23:18 +01002209 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002210 int ret = 0;
2211
Johannes Berg85ad1812010-06-10 10:21:49 +02002212 local_bh_disable();
2213
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002214 switch (action) {
2215 case IEEE80211_AMPDU_RX_START:
Sujithdca3edb2008-10-29 10:19:01 +05302216 if (!(sc->sc_flags & SC_OP_RXAGGR))
2217 ret = -ENOTSUPP;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002218 break;
2219 case IEEE80211_AMPDU_RX_STOP:
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002220 break;
2221 case IEEE80211_AMPDU_TX_START:
Felix Fietkau71a3bf32010-11-14 15:20:11 +01002222 if (!(sc->sc_flags & SC_OP_TXAGGR))
2223 return -EOPNOTSUPP;
2224
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05002225 ath9k_ps_wakeup(sc);
Felix Fietkau231c3a12010-09-20 19:35:28 +02002226 ret = ath_tx_aggr_start(sc, sta, tid, ssn);
2227 if (!ret)
2228 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05002229 ath9k_ps_restore(sc);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002230 break;
2231 case IEEE80211_AMPDU_TX_STOP:
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05002232 ath9k_ps_wakeup(sc);
Sujithf83da962009-07-23 15:32:37 +05302233 ath_tx_aggr_stop(sc, sta, tid);
Johannes Bergc951ad32009-11-16 12:00:38 +01002234 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05002235 ath9k_ps_restore(sc);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002236 break;
Johannes Bergb1720232009-03-23 17:28:39 +01002237 case IEEE80211_AMPDU_TX_OPERATIONAL:
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05002238 ath9k_ps_wakeup(sc);
Sujith8469cde2008-10-29 10:19:28 +05302239 ath_tx_aggr_resume(sc, sta, tid);
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05002240 ath9k_ps_restore(sc);
Sujith8469cde2008-10-29 10:19:28 +05302241 break;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002242 default:
Joe Perches38002762010-12-02 19:12:36 -08002243 ath_err(ath9k_hw_common(sc->sc_ah), "Unknown AMPDU action\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002244 }
2245
Johannes Berg85ad1812010-06-10 10:21:49 +02002246 local_bh_enable();
2247
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002248 return ret;
2249}
2250
Benoit Papillault62dad5b2010-04-28 00:08:24 +02002251static int ath9k_get_survey(struct ieee80211_hw *hw, int idx,
2252 struct survey_info *survey)
2253{
Felix Fietkau9ac586152011-01-24 19:23:18 +01002254 struct ath_softc *sc = hw->priv;
Felix Fietkau34300982010-10-10 18:21:52 +02002255 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkau39162db2010-09-29 19:12:06 +02002256 struct ieee80211_supported_band *sband;
Felix Fietkau34300982010-10-10 18:21:52 +02002257 struct ieee80211_channel *chan;
2258 unsigned long flags;
2259 int pos;
2260
2261 spin_lock_irqsave(&common->cc_lock, flags);
2262 if (idx == 0)
2263 ath_update_survey_stats(sc);
Benoit Papillault62dad5b2010-04-28 00:08:24 +02002264
Felix Fietkau39162db2010-09-29 19:12:06 +02002265 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
2266 if (sband && idx >= sband->n_channels) {
2267 idx -= sband->n_channels;
2268 sband = NULL;
2269 }
Benoit Papillault62dad5b2010-04-28 00:08:24 +02002270
Felix Fietkau39162db2010-09-29 19:12:06 +02002271 if (!sband)
2272 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
2273
Felix Fietkau34300982010-10-10 18:21:52 +02002274 if (!sband || idx >= sband->n_channels) {
2275 spin_unlock_irqrestore(&common->cc_lock, flags);
2276 return -ENOENT;
Felix Fietkau4f1a5a42010-09-29 17:15:28 +02002277 }
Benoit Papillault62dad5b2010-04-28 00:08:24 +02002278
Felix Fietkau34300982010-10-10 18:21:52 +02002279 chan = &sband->channels[idx];
2280 pos = chan->hw_value;
2281 memcpy(survey, &sc->survey[pos], sizeof(*survey));
2282 survey->channel = chan;
2283 spin_unlock_irqrestore(&common->cc_lock, flags);
2284
Benoit Papillault62dad5b2010-04-28 00:08:24 +02002285 return 0;
2286}
2287
Felix Fietkaue239d852010-01-15 02:34:58 +01002288static void ath9k_set_coverage_class(struct ieee80211_hw *hw, u8 coverage_class)
2289{
Felix Fietkau9ac586152011-01-24 19:23:18 +01002290 struct ath_softc *sc = hw->priv;
Felix Fietkaue239d852010-01-15 02:34:58 +01002291 struct ath_hw *ah = sc->sc_ah;
2292
2293 mutex_lock(&sc->mutex);
2294 ah->coverage_class = coverage_class;
Mohammed Shafi Shajakhan8b2a38272011-08-24 21:38:07 +05302295
2296 ath9k_ps_wakeup(sc);
Felix Fietkaue239d852010-01-15 02:34:58 +01002297 ath9k_hw_init_global_settings(ah);
Mohammed Shafi Shajakhan8b2a38272011-08-24 21:38:07 +05302298 ath9k_ps_restore(sc);
2299
Felix Fietkaue239d852010-01-15 02:34:58 +01002300 mutex_unlock(&sc->mutex);
2301}
2302
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002303static void ath9k_flush(struct ieee80211_hw *hw, bool drop)
2304{
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002305 struct ath_softc *sc = hw->priv;
Mohammed Shafi Shajakhan99aa55b2011-05-06 20:43:11 +05302306 struct ath_hw *ah = sc->sc_ah;
2307 struct ath_common *common = ath9k_hw_common(ah);
Felix Fietkau86271e42011-03-11 21:38:19 +01002308 int timeout = 200; /* ms */
2309 int i, j;
Rajkumar Manoharan2f6fc352011-04-28 15:31:57 +05302310 bool drain_txq;
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002311
2312 mutex_lock(&sc->mutex);
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002313 cancel_delayed_work_sync(&sc->tx_complete_work);
2314
Mohammed Shafi Shajakhan6a6b3f32011-09-09 10:41:08 +05302315 if (ah->ah_flags & AH_UNPLUGGED) {
2316 ath_dbg(common, ATH_DBG_ANY, "Device has been unplugged!\n");
2317 mutex_unlock(&sc->mutex);
2318 return;
2319 }
2320
Mohammed Shafi Shajakhan99aa55b2011-05-06 20:43:11 +05302321 if (sc->sc_flags & SC_OP_INVALID) {
2322 ath_dbg(common, ATH_DBG_ANY, "Device not present\n");
2323 mutex_unlock(&sc->mutex);
2324 return;
2325 }
2326
Felix Fietkau86271e42011-03-11 21:38:19 +01002327 if (drop)
2328 timeout = 1;
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002329
Felix Fietkau86271e42011-03-11 21:38:19 +01002330 for (j = 0; j < timeout; j++) {
Mohammed Shafi Shajakhan108697c2011-05-13 20:59:42 +05302331 bool npend = false;
Felix Fietkau86271e42011-03-11 21:38:19 +01002332
2333 if (j)
2334 usleep_range(1000, 2000);
2335
2336 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
2337 if (!ATH_TXQ_SETUP(sc, i))
2338 continue;
2339
Mohammed Shafi Shajakhan108697c2011-05-13 20:59:42 +05302340 npend = ath9k_has_pending_frames(sc, &sc->tx.txq[i]);
2341
2342 if (npend)
2343 break;
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002344 }
2345
Felix Fietkau86271e42011-03-11 21:38:19 +01002346 if (!npend)
2347 goto out;
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002348 }
2349
Senthil Balasubramanian51513902011-04-22 11:32:10 +05302350 ath9k_ps_wakeup(sc);
Rajkumar Manoharan2f6fc352011-04-28 15:31:57 +05302351 spin_lock_bh(&sc->sc_pcu_lock);
2352 drain_txq = ath_drain_all_txq(sc, false);
Felix Fietkau9adcf442011-09-03 01:40:26 +02002353 spin_unlock_bh(&sc->sc_pcu_lock);
2354
Rajkumar Manoharan2f6fc352011-04-28 15:31:57 +05302355 if (!drain_txq)
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002356 ath_reset(sc, false);
Felix Fietkau9adcf442011-09-03 01:40:26 +02002357
Senthil Balasubramanian51513902011-04-22 11:32:10 +05302358 ath9k_ps_restore(sc);
Senthil Balasubramaniand78f4b32011-03-23 23:07:22 +05302359 ieee80211_wake_queues(hw);
2360
Felix Fietkau86271e42011-03-11 21:38:19 +01002361out:
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002362 ieee80211_queue_delayed_work(hw, &sc->tx_complete_work, 0);
2363 mutex_unlock(&sc->mutex);
2364}
2365
Vivek Natarajan15b91e82011-04-06 11:41:11 +05302366static bool ath9k_tx_frames_pending(struct ieee80211_hw *hw)
2367{
2368 struct ath_softc *sc = hw->priv;
2369 int i;
2370
2371 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
2372 if (!ATH_TXQ_SETUP(sc, i))
2373 continue;
2374
2375 if (ath9k_has_pending_frames(sc, &sc->tx.txq[i]))
2376 return true;
2377 }
2378 return false;
2379}
2380
Mohammed Shafi Shajakhan5595f112011-05-19 18:08:57 +05302381static int ath9k_tx_last_beacon(struct ieee80211_hw *hw)
Felix Fietkauba4903f2011-05-17 21:09:54 +02002382{
2383 struct ath_softc *sc = hw->priv;
2384 struct ath_hw *ah = sc->sc_ah;
2385 struct ieee80211_vif *vif;
2386 struct ath_vif *avp;
2387 struct ath_buf *bf;
2388 struct ath_tx_status ts;
2389 int status;
2390
2391 vif = sc->beacon.bslot[0];
2392 if (!vif)
2393 return 0;
2394
2395 avp = (void *)vif->drv_priv;
2396 if (!avp->is_bslot_active)
2397 return 0;
2398
2399 if (!sc->beacon.tx_processed) {
2400 tasklet_disable(&sc->bcon_tasklet);
2401
2402 bf = avp->av_bcbuf;
2403 if (!bf || !bf->bf_mpdu)
2404 goto skip;
2405
2406 status = ath9k_hw_txprocdesc(ah, bf->bf_desc, &ts);
2407 if (status == -EINPROGRESS)
2408 goto skip;
2409
2410 sc->beacon.tx_processed = true;
2411 sc->beacon.tx_last = !(ts.ts_status & ATH9K_TXERR_MASK);
2412
2413skip:
2414 tasklet_enable(&sc->bcon_tasklet);
2415 }
2416
2417 return sc->beacon.tx_last;
2418}
2419
Mohammed Shafi Shajakhan52c94f42011-08-20 17:21:42 +05302420static int ath9k_get_stats(struct ieee80211_hw *hw,
2421 struct ieee80211_low_level_stats *stats)
2422{
2423 struct ath_softc *sc = hw->priv;
2424 struct ath_hw *ah = sc->sc_ah;
2425 struct ath9k_mib_stats *mib_stats = &ah->ah_mibStats;
2426
2427 stats->dot11ACKFailureCount = mib_stats->ackrcv_bad;
2428 stats->dot11RTSFailureCount = mib_stats->rts_bad;
2429 stats->dot11FCSErrorCount = mib_stats->fcs_bad;
2430 stats->dot11RTSSuccessCount = mib_stats->rts_good;
2431 return 0;
2432}
2433
Felix Fietkau43c35282011-09-03 01:40:27 +02002434static u32 fill_chainmask(u32 cap, u32 new)
2435{
2436 u32 filled = 0;
2437 int i;
2438
2439 for (i = 0; cap && new; i++, cap >>= 1) {
2440 if (!(cap & BIT(0)))
2441 continue;
2442
2443 if (new & BIT(0))
2444 filled |= BIT(i);
2445
2446 new >>= 1;
2447 }
2448
2449 return filled;
2450}
2451
2452static int ath9k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
2453{
2454 struct ath_softc *sc = hw->priv;
2455 struct ath_hw *ah = sc->sc_ah;
2456
2457 if (!rx_ant || !tx_ant)
2458 return -EINVAL;
2459
2460 sc->ant_rx = rx_ant;
2461 sc->ant_tx = tx_ant;
2462
2463 if (ah->caps.rx_chainmask == 1)
2464 return 0;
2465
2466 /* AR9100 runs into calibration issues if not all rx chains are enabled */
2467 if (AR_SREV_9100(ah))
2468 ah->rxchainmask = 0x7;
2469 else
2470 ah->rxchainmask = fill_chainmask(ah->caps.rx_chainmask, rx_ant);
2471
2472 ah->txchainmask = fill_chainmask(ah->caps.tx_chainmask, tx_ant);
2473 ath9k_reload_chainmask_settings(sc);
2474
2475 return 0;
2476}
2477
2478static int ath9k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
2479{
2480 struct ath_softc *sc = hw->priv;
2481
2482 *tx_ant = sc->ant_tx;
2483 *rx_ant = sc->ant_rx;
2484 return 0;
2485}
2486
Gabor Juhos6baff7f2009-01-14 20:17:06 +01002487struct ieee80211_ops ath9k_ops = {
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002488 .tx = ath9k_tx,
2489 .start = ath9k_start,
2490 .stop = ath9k_stop,
2491 .add_interface = ath9k_add_interface,
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05302492 .change_interface = ath9k_change_interface,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002493 .remove_interface = ath9k_remove_interface,
2494 .config = ath9k_config,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002495 .configure_filter = ath9k_configure_filter,
Johannes Berg4ca77862010-02-19 19:06:56 +01002496 .sta_add = ath9k_sta_add,
2497 .sta_remove = ath9k_sta_remove,
Felix Fietkau55195412011-04-17 23:28:09 +02002498 .sta_notify = ath9k_sta_notify,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002499 .conf_tx = ath9k_conf_tx,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002500 .bss_info_changed = ath9k_bss_info_changed,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002501 .set_key = ath9k_set_key,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002502 .get_tsf = ath9k_get_tsf,
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01002503 .set_tsf = ath9k_set_tsf,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002504 .reset_tsf = ath9k_reset_tsf,
Johannes Berg4233df62008-10-13 13:35:05 +02002505 .ampdu_action = ath9k_ampdu_action,
Benoit Papillault62dad5b2010-04-28 00:08:24 +02002506 .get_survey = ath9k_get_survey,
Johannes Berg3b319aa2009-06-13 14:50:26 +05302507 .rfkill_poll = ath9k_rfkill_poll_state,
Felix Fietkaue239d852010-01-15 02:34:58 +01002508 .set_coverage_class = ath9k_set_coverage_class,
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002509 .flush = ath9k_flush,
Vivek Natarajan15b91e82011-04-06 11:41:11 +05302510 .tx_frames_pending = ath9k_tx_frames_pending,
Mohammed Shafi Shajakhan52c94f42011-08-20 17:21:42 +05302511 .tx_last_beacon = ath9k_tx_last_beacon,
2512 .get_stats = ath9k_get_stats,
Felix Fietkau43c35282011-09-03 01:40:27 +02002513 .set_antenna = ath9k_set_antenna,
2514 .get_antenna = ath9k_get_antenna,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002515};