blob: c0f478b0a9a271f29756f1f7ea89c4e7e8d8d7cd [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));
Rajkumar Manoharanc9ae6ab2012-06-04 16:28:41 +0530104 memset(&common->cc_ani, 0, sizeof(common->cc_ani));
Felix Fietkaufbb078f2010-11-03 01:36:51 +0100105 spin_unlock(&common->cc_lock);
106 }
Felix Fietkau898c9142010-10-12 14:02:53 +0200107
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -0700108 unlock:
109 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
110}
111
112void ath9k_ps_restore(struct ath_softc *sc)
113{
Felix Fietkau898c9142010-10-12 14:02:53 +0200114 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkauc6c539f2011-09-14 21:24:24 +0200115 enum ath9k_power_mode mode;
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -0700116 unsigned long flags;
Sujith Manoharanad128862012-04-24 10:23:20 +0530117 bool reset;
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -0700118
119 spin_lock_irqsave(&sc->sc_pm_lock, flags);
120 if (--sc->ps_usecount != 0)
121 goto unlock;
122
Sujith Manoharanad128862012-04-24 10:23:20 +0530123 if (sc->ps_idle) {
124 ath9k_hw_setrxabort(sc->sc_ah, 1);
125 ath9k_hw_stopdmarecv(sc->sc_ah, &reset);
Felix Fietkauc6c539f2011-09-14 21:24:24 +0200126 mode = ATH9K_PM_FULL_SLEEP;
Sujith Manoharanad128862012-04-24 10:23:20 +0530127 } else if (sc->ps_enabled &&
128 !(sc->ps_flags & (PS_WAIT_FOR_BEACON |
129 PS_WAIT_FOR_CAB |
130 PS_WAIT_FOR_PSPOLL_DATA |
131 PS_WAIT_FOR_TX_ACK))) {
Felix Fietkauc6c539f2011-09-14 21:24:24 +0200132 mode = ATH9K_PM_NETWORK_SLEEP;
Sujith Manoharanad128862012-04-24 10:23:20 +0530133 } else {
Felix Fietkauc6c539f2011-09-14 21:24:24 +0200134 goto unlock;
Sujith Manoharanad128862012-04-24 10:23:20 +0530135 }
Felix Fietkauc6c539f2011-09-14 21:24:24 +0200136
137 spin_lock(&common->cc_lock);
138 ath_hw_cycle_counters_update(common);
139 spin_unlock(&common->cc_lock);
140
Felix Fietkau1a8f0d392011-09-22 08:04:32 -0600141 ath9k_hw_setpower(sc->sc_ah, mode);
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -0700142
143 unlock:
144 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
145}
146
Felix Fietkau9adcf442011-09-03 01:40:26 +0200147static void __ath_cancel_work(struct ath_softc *sc)
148{
149 cancel_work_sync(&sc->paprd_work);
150 cancel_work_sync(&sc->hw_check_work);
151 cancel_delayed_work_sync(&sc->tx_complete_work);
152 cancel_delayed_work_sync(&sc->hw_pll_work);
153}
154
155static void ath_cancel_work(struct ath_softc *sc)
156{
157 __ath_cancel_work(sc);
158 cancel_work_sync(&sc->hw_reset_work);
159}
160
Sujith Manoharanaf68aba2012-06-04 20:23:43 +0530161static void ath_restart_work(struct ath_softc *sc)
162{
163 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
164
165 ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work, 0);
166
167 if (AR_SREV_9485(sc->sc_ah) || AR_SREV_9340(sc->sc_ah))
168 ieee80211_queue_delayed_work(sc->hw, &sc->hw_pll_work,
169 msecs_to_jiffies(ATH_PLL_WORK_INTERVAL));
170
171 ath_start_rx_poll(sc, 3);
172
173 if (!common->disable_ani)
174 ath_start_ani(common);
175}
176
Felix Fietkau9adcf442011-09-03 01:40:26 +0200177static bool ath_prepare_reset(struct ath_softc *sc, bool retry_tx, bool flush)
178{
179 struct ath_hw *ah = sc->sc_ah;
180 struct ath_common *common = ath9k_hw_common(ah);
Felix Fietkauceea2a52012-05-24 14:32:19 +0200181 bool ret = true;
Felix Fietkau9adcf442011-09-03 01:40:26 +0200182
183 ieee80211_stop_queues(sc->hw);
184
185 sc->hw_busy_count = 0;
186 del_timer_sync(&common->ani.timer);
Rajkumar Manoharan01e18912012-03-15 05:34:27 +0530187 del_timer_sync(&sc->rx_poll_timer);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200188
189 ath9k_debug_samp_bb_mac(sc);
190 ath9k_hw_disable_interrupts(ah);
191
Felix Fietkau9adcf442011-09-03 01:40:26 +0200192 if (!ath_stoprecv(sc))
193 ret = false;
194
Felix Fietkauceea2a52012-05-24 14:32:19 +0200195 if (!ath_drain_all_txq(sc, retry_tx))
196 ret = false;
197
Felix Fietkau9adcf442011-09-03 01:40:26 +0200198 if (!flush) {
199 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
Felix Fietkau34832882011-09-14 21:23:03 +0200200 ath_rx_tasklet(sc, 1, true);
201 ath_rx_tasklet(sc, 1, false);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200202 } else {
203 ath_flushrecv(sc);
204 }
205
206 return ret;
207}
208
209static bool ath_complete_reset(struct ath_softc *sc, bool start)
210{
211 struct ath_hw *ah = sc->sc_ah;
212 struct ath_common *common = ath9k_hw_common(ah);
Sujith Manoharan196fb862012-06-04 20:24:13 +0530213 unsigned long flags;
Felix Fietkau9adcf442011-09-03 01:40:26 +0200214
215 if (ath_startrecv(sc) != 0) {
216 ath_err(common, "Unable to restart recv logic\n");
217 return false;
218 }
219
220 ath9k_cmn_update_txpow(ah, sc->curtxpow,
221 sc->config.txpowlimit, &sc->curtxpow);
Sujith Manoharanb74713d2012-06-04 20:24:01 +0530222
223 clear_bit(SC_OP_HW_RESET, &sc->sc_flags);
Felix Fietkau72d874c2011-10-08 20:06:19 +0200224 ath9k_hw_set_interrupts(ah);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200225 ath9k_hw_enable_interrupts(ah);
226
Sujith Manoharan4cb54fa2012-06-04 16:27:52 +0530227 if (!(sc->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL) && start) {
Sujith Manoharan196fb862012-06-04 20:24:13 +0530228 if (!test_bit(SC_OP_BEACONS, &sc->sc_flags))
229 goto work;
Felix Fietkau9adcf442011-09-03 01:40:26 +0200230
Sujith Manoharan196fb862012-06-04 20:24:13 +0530231 ath_set_beacon(sc);
232
233 if (ah->opmode == NL80211_IFTYPE_STATION &&
234 test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) {
235 spin_lock_irqsave(&sc->sc_pm_lock, flags);
236 sc->ps_flags |= PS_BEACON_SYNC | PS_WAIT_FOR_BEACON;
237 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
238 }
239 work:
Sujith Manoharanaf68aba2012-06-04 20:23:43 +0530240 ath_restart_work(sc);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200241 }
242
Sujith Manoharan8da07832012-06-04 20:23:49 +0530243 if ((ah->caps.hw_caps & ATH9K_HW_CAP_ANT_DIV_COMB) && sc->ant_rx != 3)
244 ath_ant_comb_update(sc);
Felix Fietkau43c35282011-09-03 01:40:27 +0200245
Felix Fietkau9adcf442011-09-03 01:40:26 +0200246 ieee80211_wake_queues(sc->hw);
247
248 return true;
249}
250
251static int ath_reset_internal(struct ath_softc *sc, struct ath9k_channel *hchan,
252 bool retry_tx)
253{
254 struct ath_hw *ah = sc->sc_ah;
255 struct ath_common *common = ath9k_hw_common(ah);
256 struct ath9k_hw_cal_data *caldata = NULL;
257 bool fastcc = true;
258 bool flush = false;
259 int r;
260
261 __ath_cancel_work(sc);
262
263 spin_lock_bh(&sc->sc_pcu_lock);
264
Sujith Manoharan4cb54fa2012-06-04 16:27:52 +0530265 if (!(sc->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)) {
Felix Fietkau9adcf442011-09-03 01:40:26 +0200266 fastcc = false;
267 caldata = &sc->caldata;
268 }
269
270 if (!hchan) {
271 fastcc = false;
272 flush = true;
273 hchan = ah->curchan;
274 }
275
Felix Fietkau9adcf442011-09-03 01:40:26 +0200276 if (!ath_prepare_reset(sc, retry_tx, flush))
277 fastcc = false;
278
Joe Perchesd2182b62011-12-15 14:55:53 -0800279 ath_dbg(common, CONFIG, "Reset to %u MHz, HT40: %d fastcc: %d\n",
Sujith Manoharanfeced202012-01-30 14:21:42 +0530280 hchan->channel, IS_CHAN_HT40(hchan), fastcc);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200281
282 r = ath9k_hw_reset(ah, hchan, caldata, fastcc);
283 if (r) {
284 ath_err(common,
285 "Unable to reset channel, reset status %d\n", r);
286 goto out;
287 }
288
289 if (!ath_complete_reset(sc, true))
290 r = -EIO;
291
292out:
293 spin_unlock_bh(&sc->sc_pcu_lock);
294 return r;
295}
296
297
Sujithff37e332008-11-24 12:07:55 +0530298/*
299 * Set/change channels. If the channel is really being changed, it's done
300 * by reseting the chip. To accomplish this we must first cleanup any pending
301 * DMA, then restart stuff.
302*/
Mohammed Shafi Shajakhan5595f112011-05-19 18:08:57 +0530303static int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
Jouni Malinen0e2dedf2009-03-03 19:23:32 +0200304 struct ath9k_channel *hchan)
Sujithff37e332008-11-24 12:07:55 +0530305{
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800306 int r;
Sujithff37e332008-11-24 12:07:55 +0530307
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530308 if (test_bit(SC_OP_INVALID, &sc->sc_flags))
Sujithff37e332008-11-24 12:07:55 +0530309 return -EIO;
310
Felix Fietkau9adcf442011-09-03 01:40:26 +0200311 r = ath_reset_internal(sc, hchan, false);
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700312
Gabor Juhos39892792009-06-15 17:49:09 +0200313 return r;
Sujithff37e332008-11-24 12:07:55 +0530314}
315
Ben Greear7e1e3862011-11-03 11:33:13 -0700316static void ath_node_attach(struct ath_softc *sc, struct ieee80211_sta *sta,
317 struct ieee80211_vif *vif)
Sujithff37e332008-11-24 12:07:55 +0530318{
319 struct ath_node *an;
Sujithff37e332008-11-24 12:07:55 +0530320 an = (struct ath_node *)sta->drv_priv;
321
Ben Greear7f010c92011-01-09 23:11:49 -0800322#ifdef CONFIG_ATH9K_DEBUGFS
323 spin_lock(&sc->nodes_lock);
324 list_add(&an->list, &sc->nodes);
325 spin_unlock(&sc->nodes_lock);
Felix Fietkau156369f2011-12-14 22:08:04 +0100326#endif
Ben Greear7f010c92011-01-09 23:11:49 -0800327 an->sta = sta;
Ben Greear7e1e3862011-11-03 11:33:13 -0700328 an->vif = vif;
Sujith Manoharan3d4e20f2012-03-14 14:40:58 +0530329
Sujith Manoharana4d63672012-03-27 10:08:55 +0530330 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT) {
Sujithff37e332008-11-24 12:07:55 +0530331 ath_tx_node_init(sc, an);
Sujith9e98ac62009-07-23 15:32:34 +0530332 an->maxampdu = 1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
Sujith87792ef2009-03-30 15:28:48 +0530333 sta->ht_cap.ampdu_factor);
334 an->mpdudensity = parse_mpdudensity(sta->ht_cap.ampdu_density);
335 }
Sujithff37e332008-11-24 12:07:55 +0530336}
337
338static void ath_node_detach(struct ath_softc *sc, struct ieee80211_sta *sta)
339{
340 struct ath_node *an = (struct ath_node *)sta->drv_priv;
341
Ben Greear7f010c92011-01-09 23:11:49 -0800342#ifdef CONFIG_ATH9K_DEBUGFS
343 spin_lock(&sc->nodes_lock);
344 list_del(&an->list);
345 spin_unlock(&sc->nodes_lock);
346 an->sta = NULL;
347#endif
348
Sujith Manoharana4d63672012-03-27 10:08:55 +0530349 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT)
Sujithff37e332008-11-24 12:07:55 +0530350 ath_tx_node_cleanup(sc, an);
351}
352
Sujith55624202010-01-08 10:36:02 +0530353void ath9k_tasklet(unsigned long data)
Sujithff37e332008-11-24 12:07:55 +0530354{
355 struct ath_softc *sc = (struct ath_softc *)data;
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -0700356 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -0700357 struct ath_common *common = ath9k_hw_common(ah);
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530358 unsigned long flags;
Sujith17d79042009-02-09 13:27:03 +0530359 u32 status = sc->intrstatus;
Felix Fietkaub5c804752010-04-15 17:38:48 -0400360 u32 rxmask;
Sujithff37e332008-11-24 12:07:55 +0530361
Felix Fietkaue3927002011-09-14 21:23:01 +0200362 ath9k_ps_wakeup(sc);
363 spin_lock(&sc->sc_pcu_lock);
364
Rajkumar Manoharana4d86d92011-05-20 17:52:10 +0530365 if ((status & ATH9K_INT_FATAL) ||
366 (status & ATH9K_INT_BB_WATCHDOG)) {
Felix Fietkau030d6292011-10-07 02:28:13 +0200367#ifdef CONFIG_ATH9K_DEBUGFS
368 enum ath_reset_type type;
369
370 if (status & ATH9K_INT_FATAL)
371 type = RESET_TYPE_FATAL_INT;
372 else
373 type = RESET_TYPE_BB_WATCHDOG;
374
375 RESET_STAT_INC(sc, type);
376#endif
Sujith Manoharanb74713d2012-06-04 20:24:01 +0530377 set_bit(SC_OP_HW_RESET, &sc->sc_flags);
Felix Fietkau236de512011-09-03 01:40:25 +0200378 ieee80211_queue_work(sc->hw, &sc->hw_reset_work);
Felix Fietkaue3927002011-09-14 21:23:01 +0200379 goto out;
Sujithff37e332008-11-24 12:07:55 +0530380 }
381
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530382 spin_lock_irqsave(&sc->sc_pm_lock, flags);
Rajkumar Manoharan4105f802011-05-06 18:27:47 +0530383 if ((status & ATH9K_INT_TSFOOR) && sc->ps_enabled) {
384 /*
385 * TSF sync does not look correct; remain awake to sync with
386 * the next Beacon.
387 */
Joe Perchesd2182b62011-12-15 14:55:53 -0800388 ath_dbg(common, PS, "TSFOOR - Sync with next Beacon\n");
Rajkumar Manoharane8fe7332011-08-05 18:59:41 +0530389 sc->ps_flags |= PS_WAIT_FOR_BEACON | PS_BEACON_SYNC;
Rajkumar Manoharan4105f802011-05-06 18:27:47 +0530390 }
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530391 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
Rajkumar Manoharan4105f802011-05-06 18:27:47 +0530392
Felix Fietkaub5c804752010-04-15 17:38:48 -0400393 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
394 rxmask = (ATH9K_INT_RXHP | ATH9K_INT_RXLP | ATH9K_INT_RXEOL |
395 ATH9K_INT_RXORN);
396 else
397 rxmask = (ATH9K_INT_RX | ATH9K_INT_RXEOL | ATH9K_INT_RXORN);
398
399 if (status & rxmask) {
Felix Fietkaub5c804752010-04-15 17:38:48 -0400400 /* Check for high priority Rx first */
401 if ((ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) &&
402 (status & ATH9K_INT_RXHP))
403 ath_rx_tasklet(sc, 0, true);
404
405 ath_rx_tasklet(sc, 0, false);
Sujith063d8be2009-03-30 15:28:49 +0530406 }
407
Vasanthakumar Thiagarajane5003242010-04-15 17:39:36 -0400408 if (status & ATH9K_INT_TX) {
409 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
410 ath_tx_edma_tasklet(sc);
411 else
412 ath_tx_tasklet(sc);
413 }
Sujith063d8be2009-03-30 15:28:49 +0530414
Sujith Manoharan56ca0db2012-02-22 12:40:32 +0530415 ath9k_btcoex_handle_interrupt(sc, status);
Mohammed Shafi Shajakhan19686dd2011-11-30 10:41:28 +0530416
Felix Fietkaue3927002011-09-14 21:23:01 +0200417out:
Sujithff37e332008-11-24 12:07:55 +0530418 /* re-enable hardware interrupt */
Felix Fietkau4df30712010-11-08 20:54:47 +0100419 ath9k_hw_enable_interrupts(ah);
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700420
Senthil Balasubramanian52671e42010-12-23 21:06:57 +0530421 spin_unlock(&sc->sc_pcu_lock);
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400422 ath9k_ps_restore(sc);
Sujithff37e332008-11-24 12:07:55 +0530423}
424
Gabor Juhos6baff7f2009-01-14 20:17:06 +0100425irqreturn_t ath_isr(int irq, void *dev)
Sujithff37e332008-11-24 12:07:55 +0530426{
Sujith063d8be2009-03-30 15:28:49 +0530427#define SCHED_INTR ( \
428 ATH9K_INT_FATAL | \
Rajkumar Manoharana4d86d92011-05-20 17:52:10 +0530429 ATH9K_INT_BB_WATCHDOG | \
Sujith063d8be2009-03-30 15:28:49 +0530430 ATH9K_INT_RXORN | \
431 ATH9K_INT_RXEOL | \
432 ATH9K_INT_RX | \
Felix Fietkaub5c804752010-04-15 17:38:48 -0400433 ATH9K_INT_RXLP | \
434 ATH9K_INT_RXHP | \
Sujith063d8be2009-03-30 15:28:49 +0530435 ATH9K_INT_TX | \
436 ATH9K_INT_BMISS | \
437 ATH9K_INT_CST | \
Vasanthakumar Thiagarajanebb8e1d2009-09-01 17:46:32 +0530438 ATH9K_INT_TSFOOR | \
Mohammed Shafi Shajakhan40dc5392011-11-30 10:41:18 +0530439 ATH9K_INT_GENTIMER | \
440 ATH9K_INT_MCI)
Sujith063d8be2009-03-30 15:28:49 +0530441
Sujithff37e332008-11-24 12:07:55 +0530442 struct ath_softc *sc = dev;
Sujithcbe61d8a2009-02-09 13:27:12 +0530443 struct ath_hw *ah = sc->sc_ah;
Felix Fietkaub5bfc562010-10-08 22:13:53 +0200444 struct ath_common *common = ath9k_hw_common(ah);
Sujithff37e332008-11-24 12:07:55 +0530445 enum ath9k_int status;
446 bool sched = false;
447
Sujith063d8be2009-03-30 15:28:49 +0530448 /*
449 * The hardware is not ready/present, don't
450 * touch anything. Note this can happen early
451 * on if the IRQ is shared.
452 */
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530453 if (test_bit(SC_OP_INVALID, &sc->sc_flags))
Sujith063d8be2009-03-30 15:28:49 +0530454 return IRQ_NONE;
Sujithff37e332008-11-24 12:07:55 +0530455
Sujith063d8be2009-03-30 15:28:49 +0530456 /* shared irq, not for us */
Sujithff37e332008-11-24 12:07:55 +0530457
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400458 if (!ath9k_hw_intrpend(ah))
Sujith063d8be2009-03-30 15:28:49 +0530459 return IRQ_NONE;
Sujithff37e332008-11-24 12:07:55 +0530460
Sujith Manoharanb74713d2012-06-04 20:24:01 +0530461 if(test_bit(SC_OP_HW_RESET, &sc->sc_flags))
462 return IRQ_HANDLED;
463
Sujith063d8be2009-03-30 15:28:49 +0530464 /*
465 * Figure out the reason(s) for the interrupt. Note
466 * that the hal returns a pseudo-ISR that may include
467 * bits we haven't explicitly enabled so we mask the
468 * value to insure we only process bits we requested.
469 */
470 ath9k_hw_getisr(ah, &status); /* NB: clears ISR too */
Pavel Roskin30691682010-03-31 18:05:31 -0400471 status &= ah->imask; /* discard unasked-for bits */
Sujith063d8be2009-03-30 15:28:49 +0530472
473 /*
474 * If there are no status bits set, then this interrupt was not
475 * for me (should have been caught above).
476 */
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400477 if (!status)
Sujith063d8be2009-03-30 15:28:49 +0530478 return IRQ_NONE;
Sujith063d8be2009-03-30 15:28:49 +0530479
480 /* Cache the status */
481 sc->intrstatus = status;
482
483 if (status & SCHED_INTR)
484 sched = true;
485
486 /*
487 * If a FATAL or RXORN interrupt is received, we have to reset the
488 * chip immediately.
489 */
Felix Fietkaub5c804752010-04-15 17:38:48 -0400490 if ((status & ATH9K_INT_FATAL) || ((status & ATH9K_INT_RXORN) &&
491 !(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)))
Sujith063d8be2009-03-30 15:28:49 +0530492 goto chip_reset;
493
Luis R. Rodriguez08578b82010-05-13 13:33:44 -0400494 if ((ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) &&
495 (status & ATH9K_INT_BB_WATCHDOG)) {
Felix Fietkaub5bfc562010-10-08 22:13:53 +0200496
497 spin_lock(&common->cc_lock);
498 ath_hw_cycle_counters_update(common);
Luis R. Rodriguez08578b82010-05-13 13:33:44 -0400499 ar9003_hw_bb_watchdog_dbg_info(ah);
Felix Fietkaub5bfc562010-10-08 22:13:53 +0200500 spin_unlock(&common->cc_lock);
501
Luis R. Rodriguez08578b82010-05-13 13:33:44 -0400502 goto chip_reset;
503 }
504
Sujith063d8be2009-03-30 15:28:49 +0530505 if (status & ATH9K_INT_SWBA)
506 tasklet_schedule(&sc->bcon_tasklet);
507
508 if (status & ATH9K_INT_TXURN)
509 ath9k_hw_updatetxtriglevel(ah, true);
510
Rajkumar Manoharan0682c9b2011-08-13 10:28:09 +0530511 if (status & ATH9K_INT_RXEOL) {
512 ah->imask &= ~(ATH9K_INT_RXEOL | ATH9K_INT_RXORN);
Felix Fietkau72d874c2011-10-08 20:06:19 +0200513 ath9k_hw_set_interrupts(ah);
Felix Fietkaub5c804752010-04-15 17:38:48 -0400514 }
515
Sujith063d8be2009-03-30 15:28:49 +0530516 if (status & ATH9K_INT_MIB) {
517 /*
518 * Disable interrupts until we service the MIB
519 * interrupt; otherwise it will continue to
520 * fire.
521 */
Felix Fietkau4df30712010-11-08 20:54:47 +0100522 ath9k_hw_disable_interrupts(ah);
Sujith063d8be2009-03-30 15:28:49 +0530523 /*
524 * Let the hal handle the event. We assume
525 * it will clear whatever condition caused
526 * the interrupt.
527 */
Felix Fietkau88eac2d2010-10-12 16:08:03 +0200528 spin_lock(&common->cc_lock);
Felix Fietkaubfc472b2010-10-04 20:09:48 +0200529 ath9k_hw_proc_mib_event(ah);
Felix Fietkau88eac2d2010-10-12 16:08:03 +0200530 spin_unlock(&common->cc_lock);
Felix Fietkau4df30712010-11-08 20:54:47 +0100531 ath9k_hw_enable_interrupts(ah);
Sujith063d8be2009-03-30 15:28:49 +0530532 }
533
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400534 if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
535 if (status & ATH9K_INT_TIM_TIMER) {
Luis R. Rodriguezff9f0b62010-12-07 15:13:22 -0800536 if (ATH_DBG_WARN_ON_ONCE(sc->ps_idle))
537 goto chip_reset;
Sujith063d8be2009-03-30 15:28:49 +0530538 /* Clear RxAbort bit so that we can
539 * receive frames */
Luis R. Rodriguez9ecdef42009-09-09 21:10:09 -0700540 ath9k_setpower(sc, ATH9K_PM_AWAKE);
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530541 spin_lock(&sc->sc_pm_lock);
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400542 ath9k_hw_setrxabort(sc->sc_ah, 0);
Sujith1b04b932010-01-08 10:36:05 +0530543 sc->ps_flags |= PS_WAIT_FOR_BEACON;
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530544 spin_unlock(&sc->sc_pm_lock);
Sujith063d8be2009-03-30 15:28:49 +0530545 }
Sujith063d8be2009-03-30 15:28:49 +0530546
547chip_reset:
548
Sujith817e11d2008-12-07 21:42:44 +0530549 ath_debug_stat_interrupt(sc, status);
550
Sujithff37e332008-11-24 12:07:55 +0530551 if (sched) {
Felix Fietkau4df30712010-11-08 20:54:47 +0100552 /* turn off every interrupt */
553 ath9k_hw_disable_interrupts(ah);
Sujithff37e332008-11-24 12:07:55 +0530554 tasklet_schedule(&sc->intr_tq);
555 }
556
557 return IRQ_HANDLED;
Sujith063d8be2009-03-30 15:28:49 +0530558
559#undef SCHED_INTR
Sujithff37e332008-11-24 12:07:55 +0530560}
561
Felix Fietkau236de512011-09-03 01:40:25 +0200562static int ath_reset(struct ath_softc *sc, bool retry_tx)
Sujithff37e332008-11-24 12:07:55 +0530563{
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800564 int r;
Sujithff37e332008-11-24 12:07:55 +0530565
Felix Fietkau783cd012011-01-21 18:52:38 +0100566 ath9k_ps_wakeup(sc);
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700567
Felix Fietkau9adcf442011-09-03 01:40:26 +0200568 r = ath_reset_internal(sc, NULL, retry_tx);
Sujithff37e332008-11-24 12:07:55 +0530569
570 if (retry_tx) {
571 int i;
572 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
573 if (ATH_TXQ_SETUP(sc, i)) {
Sujithb77f4832008-12-07 21:44:03 +0530574 spin_lock_bh(&sc->tx.txq[i].axq_lock);
575 ath_txq_schedule(sc, &sc->tx.txq[i]);
576 spin_unlock_bh(&sc->tx.txq[i].axq_lock);
Sujithff37e332008-11-24 12:07:55 +0530577 }
578 }
579 }
580
Felix Fietkau783cd012011-01-21 18:52:38 +0100581 ath9k_ps_restore(sc);
Sujith2ab81d42009-12-14 16:34:56 +0530582
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800583 return r;
Sujithff37e332008-11-24 12:07:55 +0530584}
585
Felix Fietkau236de512011-09-03 01:40:25 +0200586void ath_reset_work(struct work_struct *work)
587{
588 struct ath_softc *sc = container_of(work, struct ath_softc, hw_reset_work);
589
Felix Fietkau236de512011-09-03 01:40:25 +0200590 ath_reset(sc, true);
Felix Fietkau236de512011-09-03 01:40:25 +0200591}
592
Sujithff37e332008-11-24 12:07:55 +0530593/**********************/
594/* mac80211 callbacks */
595/**********************/
596
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700597static int ath9k_start(struct ieee80211_hw *hw)
598{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100599 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -0700600 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -0700601 struct ath_common *common = ath9k_hw_common(ah);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700602 struct ieee80211_channel *curchan = hw->conf.channel;
Sujithff37e332008-11-24 12:07:55 +0530603 struct ath9k_channel *init_channel;
Vasanthakumar Thiagarajan82880a72009-06-13 14:50:24 +0530604 int r;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700605
Joe Perchesd2182b62011-12-15 14:55:53 -0800606 ath_dbg(common, CONFIG,
Joe Perches226afe62010-12-02 19:12:37 -0800607 "Starting driver with initial channel: %d MHz\n",
608 curchan->center_freq);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700609
Felix Fietkauf62d8162011-03-25 17:43:41 +0100610 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +0530611 mutex_lock(&sc->mutex);
612
Rajkumar Manoharanc344c9c2011-01-31 23:47:43 +0530613 init_channel = ath9k_cmn_get_curchannel(hw, ah);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700614
Sujithff37e332008-11-24 12:07:55 +0530615 /* Reset SERDES registers */
Stanislaw Gruszka84c87dc2011-08-05 13:10:32 +0200616 ath9k_hw_configpcipowersave(ah, false);
Sujithff37e332008-11-24 12:07:55 +0530617
618 /*
619 * The basic interface to setting the hardware in a good
620 * state is ``reset''. On return the hardware is known to
621 * be powered up and with interrupts disabled. This must
622 * be followed by initialization of the appropriate bits
623 * and then setup of the interrupt mask.
624 */
Luis R. Rodriguez4bdd1e92010-10-26 15:27:24 -0700625 spin_lock_bh(&sc->sc_pcu_lock);
Felix Fietkauc0c11742011-11-16 13:08:41 +0100626
627 atomic_set(&ah->intr_ref_cnt, -1);
628
Felix Fietkau20bd2a02010-07-31 00:12:00 +0200629 r = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800630 if (r) {
Joe Perches38002762010-12-02 19:12:36 -0800631 ath_err(common,
632 "Unable to reset hardware; reset status %d (freq %u MHz)\n",
633 r, curchan->center_freq);
Luis R. Rodriguez4bdd1e92010-10-26 15:27:24 -0700634 spin_unlock_bh(&sc->sc_pcu_lock);
Sujith141b38b2009-02-04 08:10:07 +0530635 goto mutex_unlock;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700636 }
Sujithff37e332008-11-24 12:07:55 +0530637
Sujithff37e332008-11-24 12:07:55 +0530638 /* Setup our intr mask. */
Felix Fietkaub5c804752010-04-15 17:38:48 -0400639 ah->imask = ATH9K_INT_TX | ATH9K_INT_RXEOL |
640 ATH9K_INT_RXORN | ATH9K_INT_FATAL |
641 ATH9K_INT_GLOBAL;
642
643 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
Luis R. Rodriguez08578b82010-05-13 13:33:44 -0400644 ah->imask |= ATH9K_INT_RXHP |
645 ATH9K_INT_RXLP |
646 ATH9K_INT_BB_WATCHDOG;
Felix Fietkaub5c804752010-04-15 17:38:48 -0400647 else
648 ah->imask |= ATH9K_INT_RX;
Sujithff37e332008-11-24 12:07:55 +0530649
Felix Fietkau364734f2010-09-14 20:22:44 +0200650 ah->imask |= ATH9K_INT_GTT;
Sujithff37e332008-11-24 12:07:55 +0530651
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -0700652 if (ah->caps.hw_caps & ATH9K_HW_CAP_HT)
Pavel Roskin30691682010-03-31 18:05:31 -0400653 ah->imask |= ATH9K_INT_CST;
Sujithff37e332008-11-24 12:07:55 +0530654
Sujith Manoharane270e772012-06-04 16:27:19 +0530655 ath_mci_enable(sc);
Mohammed Shafi Shajakhan40dc5392011-11-30 10:41:18 +0530656
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530657 clear_bit(SC_OP_INVALID, &sc->sc_flags);
Rajkumar Manoharan5f841b42010-10-27 18:31:15 +0530658 sc->sc_ah->is_monitoring = false;
Sujithff37e332008-11-24 12:07:55 +0530659
Felix Fietkau9adcf442011-09-03 01:40:26 +0200660 if (!ath_complete_reset(sc, false)) {
661 r = -EIO;
662 spin_unlock_bh(&sc->sc_pcu_lock);
663 goto mutex_unlock;
664 }
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700665
Felix Fietkauc0c11742011-11-16 13:08:41 +0100666 if (ah->led_pin >= 0) {
667 ath9k_hw_cfg_output(ah, ah->led_pin,
668 AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
669 ath9k_hw_set_gpio(ah, ah->led_pin, 0);
670 }
671
672 /*
673 * Reset key cache to sane defaults (all entries cleared) instead of
674 * semi-random values after suspend/resume.
675 */
676 ath9k_cmn_init_crypto(sc->sc_ah);
677
Felix Fietkau9adcf442011-09-03 01:40:26 +0200678 spin_unlock_bh(&sc->sc_pcu_lock);
Senthil Balasubramanian164ace32009-07-14 20:17:09 -0400679
Sujith Manoharandf198b12012-02-22 12:40:27 +0530680 ath9k_start_btcoex(sc);
Vasanthakumar Thiagarajan17739122009-08-26 21:08:50 +0530681
Vasanthakumar Thiagarajan8060e162010-12-06 04:27:42 -0800682 if (ah->caps.pcie_lcr_extsync_en && common->bus_ops->extn_synch_en)
683 common->bus_ops->extn_synch_en(common);
684
Sujith141b38b2009-02-04 08:10:07 +0530685mutex_unlock:
686 mutex_unlock(&sc->mutex);
687
Felix Fietkauf62d8162011-03-25 17:43:41 +0100688 ath9k_ps_restore(sc);
689
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800690 return r;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700691}
692
Johannes Berg7bb456832011-02-24 14:42:06 +0100693static void ath9k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700694{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100695 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -0700696 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Sujith528f0c62008-10-29 10:14:26 +0530697 struct ath_tx_control txctl;
Benoit Papillault1bc14882009-11-24 15:49:18 +0100698 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530699 unsigned long flags;
Sujith528f0c62008-10-29 10:14:26 +0530700
Gabor Juhos96148322009-07-24 17:27:21 +0200701 if (sc->ps_enabled) {
Jouni Malinendc8c4582009-05-19 17:01:42 +0300702 /*
703 * mac80211 does not set PM field for normal data frames, so we
704 * need to update that based on the current PS mode.
705 */
706 if (ieee80211_is_data(hdr->frame_control) &&
707 !ieee80211_is_nullfunc(hdr->frame_control) &&
708 !ieee80211_has_pm(hdr->frame_control)) {
Joe Perchesd2182b62011-12-15 14:55:53 -0800709 ath_dbg(common, PS,
Joe Perches226afe62010-12-02 19:12:37 -0800710 "Add PM=1 for a TX frame while in PS mode\n");
Jouni Malinendc8c4582009-05-19 17:01:42 +0300711 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
712 }
713 }
714
Sujith Manoharanad128862012-04-24 10:23:20 +0530715 if (unlikely(sc->sc_ah->power_mode == ATH9K_PM_NETWORK_SLEEP)) {
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300716 /*
717 * We are using PS-Poll and mac80211 can request TX while in
718 * power save mode. Need to wake up hardware for the TX to be
719 * completed and if needed, also for RX of buffered frames.
720 */
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300721 ath9k_ps_wakeup(sc);
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530722 spin_lock_irqsave(&sc->sc_pm_lock, flags);
Vasanthakumar Thiagarajanfdf76622010-05-17 18:57:55 -0700723 if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
724 ath9k_hw_setrxabort(sc->sc_ah, 0);
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300725 if (ieee80211_is_pspoll(hdr->frame_control)) {
Joe Perchesd2182b62011-12-15 14:55:53 -0800726 ath_dbg(common, PS,
Joe Perches226afe62010-12-02 19:12:37 -0800727 "Sending PS-Poll to pick a buffered frame\n");
Sujith1b04b932010-01-08 10:36:05 +0530728 sc->ps_flags |= PS_WAIT_FOR_PSPOLL_DATA;
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300729 } else {
Joe Perchesd2182b62011-12-15 14:55:53 -0800730 ath_dbg(common, PS, "Wake up to complete TX\n");
Sujith1b04b932010-01-08 10:36:05 +0530731 sc->ps_flags |= PS_WAIT_FOR_TX_ACK;
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300732 }
733 /*
734 * The actual restore operation will happen only after
Sujith Manoharanad128862012-04-24 10:23:20 +0530735 * the ps_flags bit is cleared. We are just dropping
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300736 * the ps_usecount here.
737 */
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530738 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300739 ath9k_ps_restore(sc);
740 }
741
Sujith Manoharanad128862012-04-24 10:23:20 +0530742 /*
743 * Cannot tx while the hardware is in full sleep, it first needs a full
744 * chip reset to recover from that
745 */
746 if (unlikely(sc->sc_ah->power_mode == ATH9K_PM_FULL_SLEEP)) {
747 ath_err(common, "TX while HW is in FULL_SLEEP mode\n");
748 goto exit;
749 }
750
Sujith528f0c62008-10-29 10:14:26 +0530751 memset(&txctl, 0, sizeof(struct ath_tx_control));
Felix Fietkau066dae92010-11-07 14:59:39 +0100752 txctl.txq = sc->tx.txq_map[skb_get_queue_mapping(skb)];
Sujith528f0c62008-10-29 10:14:26 +0530753
Joe Perchesd2182b62011-12-15 14:55:53 -0800754 ath_dbg(common, XMIT, "transmitting packet, skb: %p\n", skb);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700755
Jouni Malinenc52f33d2009-03-03 19:23:29 +0200756 if (ath_tx_start(hw, skb, &txctl) != 0) {
Joe Perchesd2182b62011-12-15 14:55:53 -0800757 ath_dbg(common, XMIT, "TX failed\n");
Ben Greeara5a0bca2012-04-03 09:16:55 -0700758 TX_STAT_INC(txctl.txq->axq_qnum, txfailed);
Sujith528f0c62008-10-29 10:14:26 +0530759 goto exit;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700760 }
761
Johannes Berg7bb456832011-02-24 14:42:06 +0100762 return;
Sujith528f0c62008-10-29 10:14:26 +0530763exit:
764 dev_kfree_skb_any(skb);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700765}
766
767static void ath9k_stop(struct ieee80211_hw *hw)
768{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100769 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -0700770 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -0700771 struct ath_common *common = ath9k_hw_common(ah);
Felix Fietkauc0c11742011-11-16 13:08:41 +0100772 bool prev_idle;
Sujith9c84b792008-10-29 10:17:13 +0530773
Sujith4c483812009-08-18 10:51:52 +0530774 mutex_lock(&sc->mutex);
775
Felix Fietkau9adcf442011-09-03 01:40:26 +0200776 ath_cancel_work(sc);
Rajkumar Manoharan01e18912012-03-15 05:34:27 +0530777 del_timer_sync(&sc->rx_poll_timer);
Luis R. Rodriguezc94dbff2009-07-27 11:53:04 -0700778
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530779 if (test_bit(SC_OP_INVALID, &sc->sc_flags)) {
Joe Perchesd2182b62011-12-15 14:55:53 -0800780 ath_dbg(common, ANY, "Device not present\n");
Sujith4c483812009-08-18 10:51:52 +0530781 mutex_unlock(&sc->mutex);
Sujith9c84b792008-10-29 10:17:13 +0530782 return;
783 }
784
Sujith3867cf62009-12-23 20:03:27 -0500785 /* Ensure HW is awake when we try to shut it down. */
786 ath9k_ps_wakeup(sc);
787
Sujith Manoharandf198b12012-02-22 12:40:27 +0530788 ath9k_stop_btcoex(sc);
Vasanthakumar Thiagarajan17739122009-08-26 21:08:50 +0530789
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700790 spin_lock_bh(&sc->sc_pcu_lock);
791
Stanislaw Gruszka203043f2011-01-25 14:08:40 +0100792 /* prevent tasklets to enable interrupts once we disable them */
793 ah->imask &= ~ATH9K_INT_GLOBAL;
794
Sujithff37e332008-11-24 12:07:55 +0530795 /* make sure h/w will not generate any interrupt
796 * before setting the invalid flag. */
Felix Fietkau4df30712010-11-08 20:54:47 +0100797 ath9k_hw_disable_interrupts(ah);
Sujithff37e332008-11-24 12:07:55 +0530798
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700799 spin_unlock_bh(&sc->sc_pcu_lock);
800
Stanislaw Gruszka203043f2011-01-25 14:08:40 +0100801 /* we can now sync irq and kill any running tasklets, since we already
802 * disabled interrupts and not holding a spin lock */
803 synchronize_irq(sc->irq);
804 tasklet_kill(&sc->intr_tq);
805 tasklet_kill(&sc->bcon_tasklet);
806
Felix Fietkauc0c11742011-11-16 13:08:41 +0100807 prev_idle = sc->ps_idle;
808 sc->ps_idle = true;
809
810 spin_lock_bh(&sc->sc_pcu_lock);
811
812 if (ah->led_pin >= 0) {
813 ath9k_hw_set_gpio(ah, ah->led_pin, 1);
814 ath9k_hw_cfg_gpio_input(ah, ah->led_pin);
815 }
816
817 ath_prepare_reset(sc, false, true);
818
819 if (sc->rx.frag) {
820 dev_kfree_skb_any(sc->rx.frag);
821 sc->rx.frag = NULL;
822 }
823
824 if (!ah->curchan)
825 ah->curchan = ath9k_cmn_get_curchannel(hw, ah);
826
827 ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
828 ath9k_hw_phy_disable(ah);
829
830 ath9k_hw_configpcipowersave(ah, true);
831
832 spin_unlock_bh(&sc->sc_pcu_lock);
833
Sujith3867cf62009-12-23 20:03:27 -0500834 ath9k_ps_restore(sc);
835
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530836 set_bit(SC_OP_INVALID, &sc->sc_flags);
Felix Fietkauc0c11742011-11-16 13:08:41 +0100837 sc->ps_idle = prev_idle;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700838
Sujith141b38b2009-02-04 08:10:07 +0530839 mutex_unlock(&sc->mutex);
840
Joe Perchesd2182b62011-12-15 14:55:53 -0800841 ath_dbg(common, CONFIG, "Driver halt\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700842}
843
Ben Greear48014162011-01-15 19:13:48 +0000844bool ath9k_uses_beacons(int type)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700845{
Ben Greear48014162011-01-15 19:13:48 +0000846 switch (type) {
Johannes Berg05c914f2008-09-11 00:01:58 +0200847 case NL80211_IFTYPE_AP:
Ben Greear48014162011-01-15 19:13:48 +0000848 case NL80211_IFTYPE_ADHOC:
Pat Erley9cb54122009-03-20 22:59:59 -0400849 case NL80211_IFTYPE_MESH_POINT:
Ben Greear48014162011-01-15 19:13:48 +0000850 return true;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700851 default:
Ben Greear48014162011-01-15 19:13:48 +0000852 return false;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700853 }
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700854}
855
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +0530856static void ath9k_reclaim_beacon(struct ath_softc *sc,
857 struct ieee80211_vif *vif)
858{
859 struct ath_vif *avp = (void *)vif->drv_priv;
860
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +0530861 ath9k_set_beaconing_status(sc, false);
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +0530862 ath_beacon_return(sc, avp);
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +0530863 ath9k_set_beaconing_status(sc, true);
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +0530864}
865
Ben Greear48014162011-01-15 19:13:48 +0000866static void ath9k_vif_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
867{
868 struct ath9k_vif_iter_data *iter_data = data;
869 int i;
870
871 if (iter_data->hw_macaddr)
872 for (i = 0; i < ETH_ALEN; i++)
873 iter_data->mask[i] &=
874 ~(iter_data->hw_macaddr[i] ^ mac[i]);
875
876 switch (vif->type) {
877 case NL80211_IFTYPE_AP:
878 iter_data->naps++;
879 break;
880 case NL80211_IFTYPE_STATION:
881 iter_data->nstations++;
882 break;
883 case NL80211_IFTYPE_ADHOC:
884 iter_data->nadhocs++;
885 break;
886 case NL80211_IFTYPE_MESH_POINT:
887 iter_data->nmeshes++;
888 break;
889 case NL80211_IFTYPE_WDS:
890 iter_data->nwds++;
891 break;
892 default:
Ben Greear48014162011-01-15 19:13:48 +0000893 break;
894 }
895}
896
897/* Called with sc->mutex held. */
898void ath9k_calculate_iter_data(struct ieee80211_hw *hw,
899 struct ieee80211_vif *vif,
900 struct ath9k_vif_iter_data *iter_data)
901{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100902 struct ath_softc *sc = hw->priv;
Ben Greear48014162011-01-15 19:13:48 +0000903 struct ath_hw *ah = sc->sc_ah;
904 struct ath_common *common = ath9k_hw_common(ah);
Ben Greear48014162011-01-15 19:13:48 +0000905
906 /*
907 * Use the hardware MAC address as reference, the hardware uses it
908 * together with the BSSID mask when matching addresses.
909 */
910 memset(iter_data, 0, sizeof(*iter_data));
911 iter_data->hw_macaddr = common->macaddr;
912 memset(&iter_data->mask, 0xff, ETH_ALEN);
913
914 if (vif)
915 ath9k_vif_iter(iter_data, vif->addr, vif);
916
917 /* Get list of all active MAC addresses */
Ben Greear48014162011-01-15 19:13:48 +0000918 ieee80211_iterate_active_interfaces_atomic(sc->hw, ath9k_vif_iter,
919 iter_data);
Ben Greear48014162011-01-15 19:13:48 +0000920}
921
922/* Called with sc->mutex held. */
923static void ath9k_calculate_summary_state(struct ieee80211_hw *hw,
924 struct ieee80211_vif *vif)
925{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100926 struct ath_softc *sc = hw->priv;
Ben Greear48014162011-01-15 19:13:48 +0000927 struct ath_hw *ah = sc->sc_ah;
928 struct ath_common *common = ath9k_hw_common(ah);
929 struct ath9k_vif_iter_data iter_data;
930
931 ath9k_calculate_iter_data(hw, vif, &iter_data);
932
933 /* Set BSSID mask. */
934 memcpy(common->bssidmask, iter_data.mask, ETH_ALEN);
935 ath_hw_setbssidmask(common);
936
937 /* Set op-mode & TSF */
938 if (iter_data.naps > 0) {
939 ath9k_hw_set_tsfadjust(ah, 1);
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530940 set_bit(SC_OP_TSF_RESET, &sc->sc_flags);
Ben Greear48014162011-01-15 19:13:48 +0000941 ah->opmode = NL80211_IFTYPE_AP;
942 } else {
943 ath9k_hw_set_tsfadjust(ah, 0);
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530944 clear_bit(SC_OP_TSF_RESET, &sc->sc_flags);
Ben Greear48014162011-01-15 19:13:48 +0000945
Javier Cardonafd5999c2011-05-03 16:57:19 -0700946 if (iter_data.nmeshes)
947 ah->opmode = NL80211_IFTYPE_MESH_POINT;
948 else if (iter_data.nwds)
Ben Greear48014162011-01-15 19:13:48 +0000949 ah->opmode = NL80211_IFTYPE_AP;
950 else if (iter_data.nadhocs)
951 ah->opmode = NL80211_IFTYPE_ADHOC;
952 else
953 ah->opmode = NL80211_IFTYPE_STATION;
954 }
955
956 /*
957 * Enable MIB interrupts when there are hardware phy counters.
958 */
959 if ((iter_data.nstations + iter_data.nadhocs + iter_data.nmeshes) > 0) {
960 if (ah->config.enable_ani)
961 ah->imask |= ATH9K_INT_MIB;
962 ah->imask |= ATH9K_INT_TSFOOR;
963 } else {
964 ah->imask &= ~ATH9K_INT_MIB;
965 ah->imask &= ~ATH9K_INT_TSFOOR;
966 }
967
Felix Fietkau72d874c2011-10-08 20:06:19 +0200968 ath9k_hw_set_interrupts(ah);
Ben Greear48014162011-01-15 19:13:48 +0000969
970 /* Set up ANI */
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +0530971 if (iter_data.naps > 0) {
Rajkumar Manoharan729da3902011-05-09 19:11:29 +0530972 sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +0530973
974 if (!common->disable_ani) {
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530975 set_bit(SC_OP_ANI_RUN, &sc->sc_flags);
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +0530976 ath_start_ani(common);
977 }
978
Rajkumar Manoharanf60c49b2011-04-08 17:06:25 +0530979 } else {
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530980 clear_bit(SC_OP_ANI_RUN, &sc->sc_flags);
Rajkumar Manoharanf60c49b2011-04-08 17:06:25 +0530981 del_timer_sync(&common->ani.timer);
Ben Greear48014162011-01-15 19:13:48 +0000982 }
983}
984
985/* Called with sc->mutex held, vif counts set up properly. */
986static void ath9k_do_vif_add_setup(struct ieee80211_hw *hw,
987 struct ieee80211_vif *vif)
988{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100989 struct ath_softc *sc = hw->priv;
Ben Greear48014162011-01-15 19:13:48 +0000990
991 ath9k_calculate_summary_state(hw, vif);
992
993 if (ath9k_uses_beacons(vif->type)) {
Rajkumar Manoharaned2578c2012-04-19 19:13:51 +0530994 /* Reserve a beacon slot for the vif */
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +0530995 ath9k_set_beaconing_status(sc, false);
Rajkumar Manoharaned2578c2012-04-19 19:13:51 +0530996 ath_beacon_alloc(sc, vif);
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +0530997 ath9k_set_beaconing_status(sc, true);
Ben Greear48014162011-01-15 19:13:48 +0000998 }
999}
1000
Ben Greear48014162011-01-15 19:13:48 +00001001static int ath9k_add_interface(struct ieee80211_hw *hw,
1002 struct ieee80211_vif *vif)
1003{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001004 struct ath_softc *sc = hw->priv;
Ben Greear48014162011-01-15 19:13:48 +00001005 struct ath_hw *ah = sc->sc_ah;
1006 struct ath_common *common = ath9k_hw_common(ah);
Ben Greear48014162011-01-15 19:13:48 +00001007 int ret = 0;
1008
Felix Fietkau96f372c2011-04-07 19:07:17 +02001009 ath9k_ps_wakeup(sc);
Ben Greear48014162011-01-15 19:13:48 +00001010 mutex_lock(&sc->mutex);
1011
1012 switch (vif->type) {
1013 case NL80211_IFTYPE_STATION:
1014 case NL80211_IFTYPE_WDS:
1015 case NL80211_IFTYPE_ADHOC:
1016 case NL80211_IFTYPE_AP:
1017 case NL80211_IFTYPE_MESH_POINT:
1018 break;
1019 default:
1020 ath_err(common, "Interface type %d not yet supported\n",
1021 vif->type);
1022 ret = -EOPNOTSUPP;
1023 goto out;
1024 }
1025
1026 if (ath9k_uses_beacons(vif->type)) {
1027 if (sc->nbcnvifs >= ATH_BCBUF) {
1028 ath_err(common, "Not enough beacon buffers when adding"
1029 " new interface of type: %i\n",
1030 vif->type);
1031 ret = -ENOBUFS;
1032 goto out;
1033 }
1034 }
1035
Rajkumar Manoharan59575d12011-04-04 22:56:16 +05301036 if ((ah->opmode == NL80211_IFTYPE_ADHOC) ||
1037 ((vif->type == NL80211_IFTYPE_ADHOC) &&
1038 sc->nvifs > 0)) {
Ben Greear48014162011-01-15 19:13:48 +00001039 ath_err(common, "Cannot create ADHOC interface when other"
1040 " interfaces already exist.\n");
1041 ret = -EINVAL;
1042 goto out;
1043 }
1044
Joe Perchesd2182b62011-12-15 14:55:53 -08001045 ath_dbg(common, CONFIG, "Attach a VIF of type: %d\n", vif->type);
Ben Greear48014162011-01-15 19:13:48 +00001046
Ben Greear48014162011-01-15 19:13:48 +00001047 sc->nvifs++;
1048
1049 ath9k_do_vif_add_setup(hw, vif);
1050out:
1051 mutex_unlock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001052 ath9k_ps_restore(sc);
Ben Greear48014162011-01-15 19:13:48 +00001053 return ret;
1054}
1055
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301056static int ath9k_change_interface(struct ieee80211_hw *hw,
1057 struct ieee80211_vif *vif,
1058 enum nl80211_iftype new_type,
1059 bool p2p)
1060{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001061 struct ath_softc *sc = hw->priv;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301062 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Dan Carpenter6dab55b2010-12-21 06:59:06 +03001063 int ret = 0;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301064
Joe Perchesd2182b62011-12-15 14:55:53 -08001065 ath_dbg(common, CONFIG, "Change Interface\n");
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301066 mutex_lock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001067 ath9k_ps_wakeup(sc);
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301068
Ben Greear48014162011-01-15 19:13:48 +00001069 /* See if new interface type is valid. */
1070 if ((new_type == NL80211_IFTYPE_ADHOC) &&
1071 (sc->nvifs > 1)) {
1072 ath_err(common, "When using ADHOC, it must be the only"
1073 " interface.\n");
1074 ret = -EINVAL;
1075 goto out;
1076 }
1077
1078 if (ath9k_uses_beacons(new_type) &&
1079 !ath9k_uses_beacons(vif->type)) {
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301080 if (sc->nbcnvifs >= ATH_BCBUF) {
1081 ath_err(common, "No beacon slot available\n");
Dan Carpenter6dab55b2010-12-21 06:59:06 +03001082 ret = -ENOBUFS;
1083 goto out;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301084 }
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301085 }
Ben Greear48014162011-01-15 19:13:48 +00001086
1087 /* Clean up old vif stuff */
1088 if (ath9k_uses_beacons(vif->type))
1089 ath9k_reclaim_beacon(sc, vif);
1090
1091 /* Add new settings */
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301092 vif->type = new_type;
1093 vif->p2p = p2p;
1094
Ben Greear48014162011-01-15 19:13:48 +00001095 ath9k_do_vif_add_setup(hw, vif);
Dan Carpenter6dab55b2010-12-21 06:59:06 +03001096out:
Felix Fietkau96f372c2011-04-07 19:07:17 +02001097 ath9k_ps_restore(sc);
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301098 mutex_unlock(&sc->mutex);
Dan Carpenter6dab55b2010-12-21 06:59:06 +03001099 return ret;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301100}
1101
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001102static void ath9k_remove_interface(struct ieee80211_hw *hw,
Johannes Berg1ed32e42009-12-23 13:15:45 +01001103 struct ieee80211_vif *vif)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001104{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001105 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -07001106 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001107
Joe Perchesd2182b62011-12-15 14:55:53 -08001108 ath_dbg(common, CONFIG, "Detach Interface\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001109
Felix Fietkau96f372c2011-04-07 19:07:17 +02001110 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301111 mutex_lock(&sc->mutex);
1112
Ben Greear48014162011-01-15 19:13:48 +00001113 sc->nvifs--;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001114
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001115 /* Reclaim beacon resources */
Ben Greear48014162011-01-15 19:13:48 +00001116 if (ath9k_uses_beacons(vif->type))
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301117 ath9k_reclaim_beacon(sc, vif);
Jouni Malinen2c3db3d2009-03-03 19:23:26 +02001118
Ben Greear48014162011-01-15 19:13:48 +00001119 ath9k_calculate_summary_state(hw, NULL);
Sujith141b38b2009-02-04 08:10:07 +05301120
1121 mutex_unlock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001122 ath9k_ps_restore(sc);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001123}
1124
Senthil Balasubramanianfbab7392010-10-05 20:36:40 +05301125static void ath9k_enable_ps(struct ath_softc *sc)
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301126{
Pavel Roskin30691682010-03-31 18:05:31 -04001127 struct ath_hw *ah = sc->sc_ah;
Sujith Manoharanad128862012-04-24 10:23:20 +05301128 struct ath_common *common = ath9k_hw_common(ah);
Pavel Roskin30691682010-03-31 18:05:31 -04001129
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301130 sc->ps_enabled = true;
Pavel Roskin30691682010-03-31 18:05:31 -04001131 if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP)) {
1132 if ((ah->imask & ATH9K_INT_TIM_TIMER) == 0) {
1133 ah->imask |= ATH9K_INT_TIM_TIMER;
Felix Fietkau72d874c2011-10-08 20:06:19 +02001134 ath9k_hw_set_interrupts(ah);
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301135 }
Vasanthakumar Thiagarajanfdf76622010-05-17 18:57:55 -07001136 ath9k_hw_setrxabort(ah, 1);
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301137 }
Sujith Manoharanad128862012-04-24 10:23:20 +05301138 ath_dbg(common, PS, "PowerSave enabled\n");
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301139}
1140
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301141static void ath9k_disable_ps(struct ath_softc *sc)
1142{
1143 struct ath_hw *ah = sc->sc_ah;
Sujith Manoharanad128862012-04-24 10:23:20 +05301144 struct ath_common *common = ath9k_hw_common(ah);
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301145
1146 sc->ps_enabled = false;
1147 ath9k_hw_setpower(ah, ATH9K_PM_AWAKE);
1148 if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP)) {
1149 ath9k_hw_setrxabort(ah, 0);
1150 sc->ps_flags &= ~(PS_WAIT_FOR_BEACON |
1151 PS_WAIT_FOR_CAB |
1152 PS_WAIT_FOR_PSPOLL_DATA |
1153 PS_WAIT_FOR_TX_ACK);
1154 if (ah->imask & ATH9K_INT_TIM_TIMER) {
1155 ah->imask &= ~ATH9K_INT_TIM_TIMER;
Felix Fietkau72d874c2011-10-08 20:06:19 +02001156 ath9k_hw_set_interrupts(ah);
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301157 }
1158 }
Sujith Manoharanad128862012-04-24 10:23:20 +05301159 ath_dbg(common, PS, "PowerSave disabled\n");
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301160}
1161
Johannes Berge8975582008-10-09 12:18:51 +02001162static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001163{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001164 struct ath_softc *sc = hw->priv;
Felix Fietkau34300982010-10-10 18:21:52 +02001165 struct ath_hw *ah = sc->sc_ah;
1166 struct ath_common *common = ath9k_hw_common(ah);
Johannes Berge8975582008-10-09 12:18:51 +02001167 struct ieee80211_conf *conf = &hw->conf;
Felix Fietkau75600ab2012-04-12 20:36:31 +02001168 bool reset_channel = false;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001169
Felix Fietkauc0c11742011-11-16 13:08:41 +01001170 ath9k_ps_wakeup(sc);
Sujithaa33de02008-12-18 11:40:16 +05301171 mutex_lock(&sc->mutex);
Sujith141b38b2009-02-04 08:10:07 +05301172
Felix Fietkaudaa1b6e2011-11-16 13:08:43 +01001173 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
Felix Fietkau7545daf2011-01-24 19:23:16 +01001174 sc->ps_idle = !!(conf->flags & IEEE80211_CONF_IDLE);
Felix Fietkaudaa1b6e2011-11-16 13:08:43 +01001175 if (sc->ps_idle)
1176 ath_cancel_work(sc);
Felix Fietkau75600ab2012-04-12 20:36:31 +02001177 else
1178 /*
1179 * The chip needs a reset to properly wake up from
1180 * full sleep
1181 */
1182 reset_channel = ah->chip_fullsleep;
Felix Fietkaudaa1b6e2011-11-16 13:08:43 +01001183 }
Luis R. Rodriguez64839172009-07-14 20:22:53 -04001184
Luis R. Rodrigueze7824a52009-11-24 02:53:25 -05001185 /*
1186 * We just prepare to enable PS. We have to wait until our AP has
1187 * ACK'd our null data frame to disable RX otherwise we'll ignore
1188 * those ACKs and end up retransmitting the same null data frames.
1189 * IEEE80211_CONF_CHANGE_PS is only passed by mac80211 for STA mode.
1190 */
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301191 if (changed & IEEE80211_CONF_CHANGE_PS) {
Luis R. Rodriguez8ab2cd02010-09-16 15:12:26 -04001192 unsigned long flags;
1193 spin_lock_irqsave(&sc->sc_pm_lock, flags);
Senthil Balasubramanianfbab7392010-10-05 20:36:40 +05301194 if (conf->flags & IEEE80211_CONF_PS)
1195 ath9k_enable_ps(sc);
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301196 else
1197 ath9k_disable_ps(sc);
Luis R. Rodriguez8ab2cd02010-09-16 15:12:26 -04001198 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301199 }
1200
Sujith199afd92010-01-08 10:36:13 +05301201 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1202 if (conf->flags & IEEE80211_CONF_MONITOR) {
Joe Perchesd2182b62011-12-15 14:55:53 -08001203 ath_dbg(common, CONFIG, "Monitor mode is enabled\n");
Rajkumar Manoharan5f841b42010-10-27 18:31:15 +05301204 sc->sc_ah->is_monitoring = true;
1205 } else {
Joe Perchesd2182b62011-12-15 14:55:53 -08001206 ath_dbg(common, CONFIG, "Monitor mode is disabled\n");
Rajkumar Manoharan5f841b42010-10-27 18:31:15 +05301207 sc->sc_ah->is_monitoring = false;
Sujith199afd92010-01-08 10:36:13 +05301208 }
1209 }
1210
Felix Fietkau75600ab2012-04-12 20:36:31 +02001211 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL) || reset_channel) {
Sujith99405f92008-11-24 12:08:35 +05301212 struct ieee80211_channel *curchan = hw->conf.channel;
Luis R. Rodriguez5f8e0772009-01-22 15:16:48 -08001213 int pos = curchan->hw_value;
Felix Fietkau34300982010-10-10 18:21:52 +02001214 int old_pos = -1;
1215 unsigned long flags;
1216
1217 if (ah->curchan)
1218 old_pos = ah->curchan - &ah->channels[0];
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001219
Joe Perchesd2182b62011-12-15 14:55:53 -08001220 ath_dbg(common, CONFIG, "Set channel: %d MHz type: %d\n",
Ben Greear8c79a612011-02-07 13:44:33 -08001221 curchan->center_freq, conf->channel_type);
Johannes Bergae5eb022008-10-14 16:58:37 +02001222
Felix Fietkau34300982010-10-10 18:21:52 +02001223 /* update survey stats for the old channel before switching */
1224 spin_lock_irqsave(&common->cc_lock, flags);
1225 ath_update_survey_stats(sc);
1226 spin_unlock_irqrestore(&common->cc_lock, flags);
1227
1228 /*
Rajkumar Manoharane338a852011-08-13 10:28:17 +05301229 * Preserve the current channel values, before updating
1230 * the same channel
1231 */
Rajkumar Manoharan1a19f772012-01-09 15:37:53 +05301232 if (ah->curchan && (old_pos == pos))
1233 ath9k_hw_getnf(ah, ah->curchan);
Rajkumar Manoharane338a852011-08-13 10:28:17 +05301234
1235 ath9k_cmn_update_ichannel(&sc->sc_ah->channels[pos],
1236 curchan, conf->channel_type);
1237
1238 /*
Felix Fietkau34300982010-10-10 18:21:52 +02001239 * If the operating channel changes, change the survey in-use flags
1240 * along with it.
1241 * Reset the survey data for the new channel, unless we're switching
1242 * back to the operating channel from an off-channel operation.
1243 */
1244 if (!(hw->conf.flags & IEEE80211_CONF_OFFCHANNEL) &&
1245 sc->cur_survey != &sc->survey[pos]) {
1246
1247 if (sc->cur_survey)
1248 sc->cur_survey->filled &= ~SURVEY_INFO_IN_USE;
1249
1250 sc->cur_survey = &sc->survey[pos];
1251
1252 memset(sc->cur_survey, 0, sizeof(struct survey_info));
1253 sc->cur_survey->filled |= SURVEY_INFO_IN_USE;
1254 } else if (!(sc->survey[pos].filled & SURVEY_INFO_IN_USE)) {
1255 memset(&sc->survey[pos], 0, sizeof(struct survey_info));
1256 }
1257
Jouni Malinen0e2dedf2009-03-03 19:23:32 +02001258 if (ath_set_channel(sc, hw, &sc->sc_ah->channels[pos]) < 0) {
Joe Perches38002762010-12-02 19:12:36 -08001259 ath_err(common, "Unable to set channel\n");
Sujithaa33de02008-12-18 11:40:16 +05301260 mutex_unlock(&sc->mutex);
Sujithe11602b2008-11-27 09:46:27 +05301261 return -EINVAL;
1262 }
Felix Fietkau34300982010-10-10 18:21:52 +02001263
1264 /*
1265 * The most recent snapshot of channel->noisefloor for the old
1266 * channel is only available after the hardware reset. Copy it to
1267 * the survey stats now.
1268 */
1269 if (old_pos >= 0)
1270 ath_update_survey_nf(sc, old_pos);
Sujith094d05d2008-12-12 11:57:43 +05301271 }
Sujith86b89ee2008-08-07 10:54:57 +05301272
Luis R. Rodriguezc9f6a652010-01-19 14:04:19 -05001273 if (changed & IEEE80211_CONF_CHANGE_POWER) {
Joe Perchesd2182b62011-12-15 14:55:53 -08001274 ath_dbg(common, CONFIG, "Set power: %d\n", conf->power_level);
Sujith17d79042009-02-09 13:27:03 +05301275 sc->config.txpowlimit = 2 * conf->power_level;
Rajkumar Manoharan5048e8c2011-01-31 23:47:44 +05301276 ath9k_cmn_update_txpow(ah, sc->curtxpow,
1277 sc->config.txpowlimit, &sc->curtxpow);
Luis R. Rodriguez64839172009-07-14 20:22:53 -04001278 }
1279
Sujithaa33de02008-12-18 11:40:16 +05301280 mutex_unlock(&sc->mutex);
Felix Fietkauc0c11742011-11-16 13:08:41 +01001281 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301282
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001283 return 0;
1284}
1285
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001286#define SUPPORTED_FILTERS \
1287 (FIF_PROMISC_IN_BSS | \
1288 FIF_ALLMULTI | \
1289 FIF_CONTROL | \
Luis R. Rodriguezaf6a3fc2009-08-08 21:55:16 -04001290 FIF_PSPOLL | \
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001291 FIF_OTHER_BSS | \
1292 FIF_BCN_PRBRESP_PROMISC | \
Jouni Malinen9c1d8e42010-10-13 17:29:31 +03001293 FIF_PROBE_REQ | \
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001294 FIF_FCSFAIL)
1295
Sujith7dcfdcd2008-08-11 14:03:13 +05301296/* FIXME: sc->sc_full_reset ? */
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001297static void ath9k_configure_filter(struct ieee80211_hw *hw,
1298 unsigned int changed_flags,
1299 unsigned int *total_flags,
Johannes Berg3ac64be2009-08-17 16:16:53 +02001300 u64 multicast)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001301{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001302 struct ath_softc *sc = hw->priv;
Sujith7dcfdcd2008-08-11 14:03:13 +05301303 u32 rfilt;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001304
1305 changed_flags &= SUPPORTED_FILTERS;
1306 *total_flags &= SUPPORTED_FILTERS;
1307
Sujithb77f4832008-12-07 21:44:03 +05301308 sc->rx.rxfilter = *total_flags;
Jouni Malinenaa68aea2009-05-19 17:01:41 +03001309 ath9k_ps_wakeup(sc);
Sujith7dcfdcd2008-08-11 14:03:13 +05301310 rfilt = ath_calcrxfilter(sc);
1311 ath9k_hw_setrxfilter(sc->sc_ah, rfilt);
Jouni Malinenaa68aea2009-05-19 17:01:41 +03001312 ath9k_ps_restore(sc);
Sujith7dcfdcd2008-08-11 14:03:13 +05301313
Joe Perchesd2182b62011-12-15 14:55:53 -08001314 ath_dbg(ath9k_hw_common(sc->sc_ah), CONFIG, "Set HW RX filter: 0x%x\n",
1315 rfilt);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001316}
1317
Johannes Berg4ca77862010-02-19 19:06:56 +01001318static int ath9k_sta_add(struct ieee80211_hw *hw,
1319 struct ieee80211_vif *vif,
1320 struct ieee80211_sta *sta)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001321{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001322 struct ath_softc *sc = hw->priv;
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001323 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1324 struct ath_node *an = (struct ath_node *) sta->drv_priv;
1325 struct ieee80211_key_conf ps_key = { };
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001326
Ben Greear7e1e3862011-11-03 11:33:13 -07001327 ath_node_attach(sc, sta, vif);
Felix Fietkauf59a59f2011-05-10 20:52:22 +02001328
1329 if (vif->type != NL80211_IFTYPE_AP &&
1330 vif->type != NL80211_IFTYPE_AP_VLAN)
1331 return 0;
1332
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001333 an->ps_key = ath_key_config(common, vif, sta, &ps_key);
Johannes Berg4ca77862010-02-19 19:06:56 +01001334
1335 return 0;
1336}
1337
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001338static void ath9k_del_ps_key(struct ath_softc *sc,
1339 struct ieee80211_vif *vif,
1340 struct ieee80211_sta *sta)
1341{
1342 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1343 struct ath_node *an = (struct ath_node *) sta->drv_priv;
1344 struct ieee80211_key_conf ps_key = { .hw_key_idx = an->ps_key };
1345
1346 if (!an->ps_key)
1347 return;
1348
1349 ath_key_delete(common, &ps_key);
1350}
1351
Johannes Berg4ca77862010-02-19 19:06:56 +01001352static int ath9k_sta_remove(struct ieee80211_hw *hw,
1353 struct ieee80211_vif *vif,
1354 struct ieee80211_sta *sta)
1355{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001356 struct ath_softc *sc = hw->priv;
Johannes Berg4ca77862010-02-19 19:06:56 +01001357
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001358 ath9k_del_ps_key(sc, vif, sta);
Johannes Berg4ca77862010-02-19 19:06:56 +01001359 ath_node_detach(sc, sta);
1360
1361 return 0;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001362}
1363
Felix Fietkau55195412011-04-17 23:28:09 +02001364static void ath9k_sta_notify(struct ieee80211_hw *hw,
1365 struct ieee80211_vif *vif,
1366 enum sta_notify_cmd cmd,
1367 struct ieee80211_sta *sta)
1368{
1369 struct ath_softc *sc = hw->priv;
1370 struct ath_node *an = (struct ath_node *) sta->drv_priv;
1371
Sujith Manoharan3d4e20f2012-03-14 14:40:58 +05301372 if (!sta->ht_cap.ht_supported)
Mohammed Shafi Shajakhanb25bfda2011-12-26 10:42:15 +05301373 return;
1374
Felix Fietkau55195412011-04-17 23:28:09 +02001375 switch (cmd) {
1376 case STA_NOTIFY_SLEEP:
1377 an->sleeping = true;
Johannes Berg042ec452011-09-29 16:04:26 +02001378 ath_tx_aggr_sleep(sta, sc, an);
Felix Fietkau55195412011-04-17 23:28:09 +02001379 break;
1380 case STA_NOTIFY_AWAKE:
1381 an->sleeping = false;
1382 ath_tx_aggr_wakeup(sc, an);
1383 break;
1384 }
1385}
1386
Eliad Peller8a3a3c82011-10-02 10:15:52 +02001387static int ath9k_conf_tx(struct ieee80211_hw *hw,
1388 struct ieee80211_vif *vif, u16 queue,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001389 const struct ieee80211_tx_queue_params *params)
1390{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001391 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -07001392 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkau066dae92010-11-07 14:59:39 +01001393 struct ath_txq *txq;
Sujithea9880f2008-08-07 10:53:10 +05301394 struct ath9k_tx_queue_info qi;
Felix Fietkau066dae92010-11-07 14:59:39 +01001395 int ret = 0;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001396
1397 if (queue >= WME_NUM_AC)
1398 return 0;
1399
Felix Fietkau066dae92010-11-07 14:59:39 +01001400 txq = sc->tx.txq_map[queue];
1401
Felix Fietkau96f372c2011-04-07 19:07:17 +02001402 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301403 mutex_lock(&sc->mutex);
1404
Sujith1ffb0612009-03-30 15:28:46 +05301405 memset(&qi, 0, sizeof(struct ath9k_tx_queue_info));
1406
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001407 qi.tqi_aifs = params->aifs;
1408 qi.tqi_cwmin = params->cw_min;
1409 qi.tqi_cwmax = params->cw_max;
1410 qi.tqi_burstTime = params->txop;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001411
Joe Perchesd2182b62011-12-15 14:55:53 -08001412 ath_dbg(common, CONFIG,
Joe Perches226afe62010-12-02 19:12:37 -08001413 "Configure tx [queue/halq] [%d/%d], aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
1414 queue, txq->axq_qnum, params->aifs, params->cw_min,
1415 params->cw_max, params->txop);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001416
Felix Fietkau066dae92010-11-07 14:59:39 +01001417 ret = ath_txq_update(sc, txq->axq_qnum, &qi);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001418 if (ret)
Joe Perches38002762010-12-02 19:12:36 -08001419 ath_err(common, "TXQ Update failed\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001420
Vivek Natarajan94db2932009-11-25 12:01:54 +05301421 if (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC)
Felix Fietkau066dae92010-11-07 14:59:39 +01001422 if (queue == WME_AC_BE && !ret)
Vivek Natarajan94db2932009-11-25 12:01:54 +05301423 ath_beaconq_config(sc);
1424
Sujith141b38b2009-02-04 08:10:07 +05301425 mutex_unlock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001426 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301427
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001428 return ret;
1429}
1430
1431static int ath9k_set_key(struct ieee80211_hw *hw,
1432 enum set_key_cmd cmd,
Johannes Bergdc822b52008-12-29 12:55:09 +01001433 struct ieee80211_vif *vif,
1434 struct ieee80211_sta *sta,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001435 struct ieee80211_key_conf *key)
1436{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001437 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -07001438 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001439 int ret = 0;
1440
John W. Linville3e6109c2011-01-05 09:39:17 -05001441 if (ath9k_modparam_nohwcrypt)
Jouni Malinenb3bd89c2009-02-24 13:42:01 +02001442 return -ENOSPC;
1443
Chun-Yeow Yeoh5bd5e9a2011-12-07 12:45:46 -08001444 if ((vif->type == NL80211_IFTYPE_ADHOC ||
1445 vif->type == NL80211_IFTYPE_MESH_POINT) &&
Jouni Malinencfdc9a82011-03-23 14:52:19 +02001446 (key->cipher == WLAN_CIPHER_SUITE_TKIP ||
1447 key->cipher == WLAN_CIPHER_SUITE_CCMP) &&
1448 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
1449 /*
1450 * For now, disable hw crypto for the RSN IBSS group keys. This
1451 * could be optimized in the future to use a modified key cache
1452 * design to support per-STA RX GTK, but until that gets
1453 * implemented, use of software crypto for group addressed
1454 * frames is a acceptable to allow RSN IBSS to be used.
1455 */
1456 return -EOPNOTSUPP;
1457 }
1458
Sujith141b38b2009-02-04 08:10:07 +05301459 mutex_lock(&sc->mutex);
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301460 ath9k_ps_wakeup(sc);
Joe Perchesd2182b62011-12-15 14:55:53 -08001461 ath_dbg(common, CONFIG, "Set HW Key\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001462
1463 switch (cmd) {
1464 case SET_KEY:
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001465 if (sta)
1466 ath9k_del_ps_key(sc, vif, sta);
1467
Bruno Randolf040e5392010-09-08 16:05:04 +09001468 ret = ath_key_config(common, vif, sta, key);
Jouni Malinen6ace2892008-12-17 13:32:17 +02001469 if (ret >= 0) {
1470 key->hw_key_idx = ret;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001471 /* push IV and Michael MIC generation to stack */
1472 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
Johannes Berg97359d12010-08-10 09:46:38 +02001473 if (key->cipher == WLAN_CIPHER_SUITE_TKIP)
Senthil Balasubramanian1b961752008-09-01 19:45:21 +05301474 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
Johannes Berg97359d12010-08-10 09:46:38 +02001475 if (sc->sc_ah->sw_mgmt_crypto &&
1476 key->cipher == WLAN_CIPHER_SUITE_CCMP)
Jouni Malinen0ced0e12009-01-08 13:32:13 +02001477 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT;
Jouni Malinen6ace2892008-12-17 13:32:17 +02001478 ret = 0;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001479 }
1480 break;
1481 case DISABLE_KEY:
Bruno Randolf040e5392010-09-08 16:05:04 +09001482 ath_key_delete(common, key);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001483 break;
1484 default:
1485 ret = -EINVAL;
1486 }
1487
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301488 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301489 mutex_unlock(&sc->mutex);
1490
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001491 return ret;
1492}
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301493static void ath9k_bss_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
1494{
1495 struct ath_softc *sc = data;
1496 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1497 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1498 struct ath_vif *avp = (void *)vif->drv_priv;
Sujith Manoharan07c15a32012-06-04 20:24:07 +05301499 unsigned long flags;
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301500 /*
1501 * Skip iteration if primary station vif's bss info
1502 * was not changed
1503 */
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301504 if (test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags))
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301505 return;
1506
1507 if (bss_conf->assoc) {
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301508 set_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags);
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301509 avp->primary_sta_vif = true;
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301510 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1511 common->curaid = bss_conf->aid;
1512 ath9k_hw_write_associd(sc->sc_ah);
Joe Perchesd2182b62011-12-15 14:55:53 -08001513 ath_dbg(common, CONFIG, "Bss Info ASSOC %d, bssid: %pM\n",
1514 bss_conf->aid, common->curbssid);
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301515 ath_beacon_config(sc, vif);
1516 /*
1517 * Request a re-configuration of Beacon related timers
1518 * on the receipt of the first Beacon frame (i.e.,
1519 * after time sync with the AP).
1520 */
Sujith Manoharan07c15a32012-06-04 20:24:07 +05301521 spin_lock_irqsave(&sc->sc_pm_lock, flags);
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301522 sc->ps_flags |= PS_BEACON_SYNC | PS_WAIT_FOR_BEACON;
Sujith Manoharan07c15a32012-06-04 20:24:07 +05301523 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
1524
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301525 /* Reset rssi stats */
1526 sc->last_rssi = ATH_RSSI_DUMMY_MARKER;
1527 sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
Rajkumar Manoharan99e4d432011-04-04 22:56:19 +05301528
Rajkumar Manoharan01e18912012-03-15 05:34:27 +05301529 ath_start_rx_poll(sc, 3);
1530
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +05301531 if (!common->disable_ani) {
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301532 set_bit(SC_OP_ANI_RUN, &sc->sc_flags);
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +05301533 ath_start_ani(common);
1534 }
1535
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301536 }
1537}
1538
1539static void ath9k_config_bss(struct ath_softc *sc, struct ieee80211_vif *vif)
1540{
1541 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1542 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1543 struct ath_vif *avp = (void *)vif->drv_priv;
1544
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301545 if (sc->sc_ah->opmode != NL80211_IFTYPE_STATION)
1546 return;
1547
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301548 /* Reconfigure bss info */
1549 if (avp->primary_sta_vif && !bss_conf->assoc) {
Joe Perchesd2182b62011-12-15 14:55:53 -08001550 ath_dbg(common, CONFIG, "Bss Info DISASSOC %d, bssid %pM\n",
Rajkumar Manoharan99e4d432011-04-04 22:56:19 +05301551 common->curaid, common->curbssid);
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301552 clear_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags);
1553 clear_bit(SC_OP_BEACONS, &sc->sc_flags);
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301554 avp->primary_sta_vif = false;
1555 memset(common->curbssid, 0, ETH_ALEN);
1556 common->curaid = 0;
1557 }
1558
1559 ieee80211_iterate_active_interfaces_atomic(
1560 sc->hw, ath9k_bss_iter, sc);
1561
1562 /*
1563 * None of station vifs are associated.
1564 * Clear bssid & aid
1565 */
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301566 if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) {
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301567 ath9k_hw_write_associd(sc->sc_ah);
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301568 clear_bit(SC_OP_ANI_RUN, &sc->sc_flags);
Rajkumar Manoharan99e4d432011-04-04 22:56:19 +05301569 del_timer_sync(&common->ani.timer);
Rajkumar Manoharan01e18912012-03-15 05:34:27 +05301570 del_timer_sync(&sc->rx_poll_timer);
Rajkumar Manoharand2c71c22011-09-15 19:02:54 +05301571 memset(&sc->caldata, 0, sizeof(sc->caldata));
Rajkumar Manoharan99e4d432011-04-04 22:56:19 +05301572 }
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301573}
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001574
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001575static void ath9k_bss_info_changed(struct ieee80211_hw *hw,
1576 struct ieee80211_vif *vif,
1577 struct ieee80211_bss_conf *bss_conf,
1578 u32 changed)
1579{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001580 struct ath_softc *sc = hw->priv;
Johannes Berg2d0ddec2009-04-23 16:13:26 +02001581 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguez15107182009-09-10 09:22:37 -07001582 struct ath_common *common = ath9k_hw_common(ah);
Johannes Berg2d0ddec2009-04-23 16:13:26 +02001583 struct ath_vif *avp = (void *)vif->drv_priv;
Felix Fietkau0005baf2010-01-15 02:33:40 +01001584 int slottime;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001585
Felix Fietkau96f372c2011-04-07 19:07:17 +02001586 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301587 mutex_lock(&sc->mutex);
1588
Rajkumar Manoharan9f619032012-03-10 05:06:49 +05301589 if (changed & BSS_CHANGED_ASSOC) {
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301590 ath9k_config_bss(sc, vif);
Sujithc6089cc2009-11-16 11:40:48 +05301591
Joe Perchesd2182b62011-12-15 14:55:53 -08001592 ath_dbg(common, CONFIG, "BSSID: %pM aid: 0x%x\n",
Joe Perches226afe62010-12-02 19:12:37 -08001593 common->curbssid, common->curaid);
Johannes Berg2d0ddec2009-04-23 16:13:26 +02001594 }
1595
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301596 if (changed & BSS_CHANGED_IBSS) {
1597 /* There can be only one vif available */
1598 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1599 common->curaid = bss_conf->aid;
1600 ath9k_hw_write_associd(sc->sc_ah);
1601
1602 if (bss_conf->ibss_joined) {
1603 sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +05301604
1605 if (!common->disable_ani) {
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301606 set_bit(SC_OP_ANI_RUN, &sc->sc_flags);
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +05301607 ath_start_ani(common);
1608 }
1609
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301610 } else {
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301611 clear_bit(SC_OP_ANI_RUN, &sc->sc_flags);
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301612 del_timer_sync(&common->ani.timer);
Rajkumar Manoharan01e18912012-03-15 05:34:27 +05301613 del_timer_sync(&sc->rx_poll_timer);
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301614 }
1615 }
1616
Rajkumar Manoharaned2578c2012-04-19 19:13:51 +05301617 /*
1618 * In case of AP mode, the HW TSF has to be reset
1619 * when the beacon interval changes.
1620 */
1621 if ((changed & BSS_CHANGED_BEACON_INT) &&
1622 (vif->type == NL80211_IFTYPE_AP))
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301623 set_bit(SC_OP_TSF_RESET, &sc->sc_flags);
Rajkumar Manoharaned2578c2012-04-19 19:13:51 +05301624
1625 /* Configure beaconing (AP, IBSS, MESH) */
1626 if (ath9k_uses_beacons(vif->type) &&
1627 ((changed & BSS_CHANGED_BEACON) ||
1628 (changed & BSS_CHANGED_BEACON_ENABLED) ||
1629 (changed & BSS_CHANGED_BEACON_INT))) {
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +05301630 ath9k_set_beaconing_status(sc, false);
Rajkumar Manoharaned2578c2012-04-19 19:13:51 +05301631 if (bss_conf->enable_beacon)
1632 ath_beacon_alloc(sc, vif);
1633 else
1634 avp->is_bslot_active = false;
1635 ath_beacon_config(sc, vif);
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +05301636 ath9k_set_beaconing_status(sc, true);
Johannes Berg2d0ddec2009-04-23 16:13:26 +02001637 }
1638
Felix Fietkau0005baf2010-01-15 02:33:40 +01001639 if (changed & BSS_CHANGED_ERP_SLOT) {
1640 if (bss_conf->use_short_slot)
1641 slottime = 9;
1642 else
1643 slottime = 20;
1644 if (vif->type == NL80211_IFTYPE_AP) {
1645 /*
1646 * Defer update, so that connected stations can adjust
1647 * their settings at the same time.
1648 * See beacon.c for more details
1649 */
1650 sc->beacon.slottime = slottime;
1651 sc->beacon.updateslot = UPDATE;
1652 } else {
1653 ah->slottime = slottime;
1654 ath9k_hw_init_global_settings(ah);
1655 }
1656 }
1657
Sujith141b38b2009-02-04 08:10:07 +05301658 mutex_unlock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001659 ath9k_ps_restore(sc);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001660}
1661
Eliad Peller37a41b42011-09-21 14:06:11 +03001662static u64 ath9k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001663{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001664 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001665 u64 tsf;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001666
Sujith141b38b2009-02-04 08:10:07 +05301667 mutex_lock(&sc->mutex);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05301668 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301669 tsf = ath9k_hw_gettsf64(sc->sc_ah);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05301670 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301671 mutex_unlock(&sc->mutex);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001672
1673 return tsf;
1674}
1675
Eliad Peller37a41b42011-09-21 14:06:11 +03001676static void ath9k_set_tsf(struct ieee80211_hw *hw,
1677 struct ieee80211_vif *vif,
1678 u64 tsf)
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01001679{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001680 struct ath_softc *sc = hw->priv;
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01001681
Sujith141b38b2009-02-04 08:10:07 +05301682 mutex_lock(&sc->mutex);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05301683 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301684 ath9k_hw_settsf64(sc->sc_ah, tsf);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05301685 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301686 mutex_unlock(&sc->mutex);
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01001687}
1688
Eliad Peller37a41b42011-09-21 14:06:11 +03001689static void ath9k_reset_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001690{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001691 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001692
Sujith141b38b2009-02-04 08:10:07 +05301693 mutex_lock(&sc->mutex);
Luis R. Rodriguez21526d52009-09-09 20:05:39 -07001694
1695 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301696 ath9k_hw_reset_tsf(sc->sc_ah);
Luis R. Rodriguez21526d52009-09-09 20:05:39 -07001697 ath9k_ps_restore(sc);
1698
Sujith141b38b2009-02-04 08:10:07 +05301699 mutex_unlock(&sc->mutex);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001700}
1701
1702static int ath9k_ampdu_action(struct ieee80211_hw *hw,
Johannes Bergc951ad32009-11-16 12:00:38 +01001703 struct ieee80211_vif *vif,
Sujith141b38b2009-02-04 08:10:07 +05301704 enum ieee80211_ampdu_mlme_action action,
1705 struct ieee80211_sta *sta,
Johannes Berg0b01f032011-01-18 13:51:05 +01001706 u16 tid, u16 *ssn, u8 buf_size)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001707{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001708 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001709 int ret = 0;
1710
Johannes Berg85ad1812010-06-10 10:21:49 +02001711 local_bh_disable();
1712
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001713 switch (action) {
1714 case IEEE80211_AMPDU_RX_START:
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001715 break;
1716 case IEEE80211_AMPDU_RX_STOP:
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001717 break;
1718 case IEEE80211_AMPDU_TX_START:
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001719 ath9k_ps_wakeup(sc);
Felix Fietkau231c3a12010-09-20 19:35:28 +02001720 ret = ath_tx_aggr_start(sc, sta, tid, ssn);
1721 if (!ret)
1722 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001723 ath9k_ps_restore(sc);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001724 break;
1725 case IEEE80211_AMPDU_TX_STOP:
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001726 ath9k_ps_wakeup(sc);
Sujithf83da962009-07-23 15:32:37 +05301727 ath_tx_aggr_stop(sc, sta, tid);
Johannes Bergc951ad32009-11-16 12:00:38 +01001728 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001729 ath9k_ps_restore(sc);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001730 break;
Johannes Bergb1720232009-03-23 17:28:39 +01001731 case IEEE80211_AMPDU_TX_OPERATIONAL:
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001732 ath9k_ps_wakeup(sc);
Sujith8469cde2008-10-29 10:19:28 +05301733 ath_tx_aggr_resume(sc, sta, tid);
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001734 ath9k_ps_restore(sc);
Sujith8469cde2008-10-29 10:19:28 +05301735 break;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001736 default:
Joe Perches38002762010-12-02 19:12:36 -08001737 ath_err(ath9k_hw_common(sc->sc_ah), "Unknown AMPDU action\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001738 }
1739
Johannes Berg85ad1812010-06-10 10:21:49 +02001740 local_bh_enable();
1741
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001742 return ret;
1743}
1744
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001745static int ath9k_get_survey(struct ieee80211_hw *hw, int idx,
1746 struct survey_info *survey)
1747{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001748 struct ath_softc *sc = hw->priv;
Felix Fietkau34300982010-10-10 18:21:52 +02001749 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkau39162db2010-09-29 19:12:06 +02001750 struct ieee80211_supported_band *sband;
Felix Fietkau34300982010-10-10 18:21:52 +02001751 struct ieee80211_channel *chan;
1752 unsigned long flags;
1753 int pos;
1754
1755 spin_lock_irqsave(&common->cc_lock, flags);
1756 if (idx == 0)
1757 ath_update_survey_stats(sc);
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001758
Felix Fietkau39162db2010-09-29 19:12:06 +02001759 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
1760 if (sband && idx >= sband->n_channels) {
1761 idx -= sband->n_channels;
1762 sband = NULL;
1763 }
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001764
Felix Fietkau39162db2010-09-29 19:12:06 +02001765 if (!sband)
1766 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
1767
Felix Fietkau34300982010-10-10 18:21:52 +02001768 if (!sband || idx >= sband->n_channels) {
1769 spin_unlock_irqrestore(&common->cc_lock, flags);
1770 return -ENOENT;
Felix Fietkau4f1a5a42010-09-29 17:15:28 +02001771 }
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001772
Felix Fietkau34300982010-10-10 18:21:52 +02001773 chan = &sband->channels[idx];
1774 pos = chan->hw_value;
1775 memcpy(survey, &sc->survey[pos], sizeof(*survey));
1776 survey->channel = chan;
1777 spin_unlock_irqrestore(&common->cc_lock, flags);
1778
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001779 return 0;
1780}
1781
Felix Fietkaue239d852010-01-15 02:34:58 +01001782static void ath9k_set_coverage_class(struct ieee80211_hw *hw, u8 coverage_class)
1783{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001784 struct ath_softc *sc = hw->priv;
Felix Fietkaue239d852010-01-15 02:34:58 +01001785 struct ath_hw *ah = sc->sc_ah;
1786
1787 mutex_lock(&sc->mutex);
1788 ah->coverage_class = coverage_class;
Mohammed Shafi Shajakhan8b2a38272011-08-24 21:38:07 +05301789
1790 ath9k_ps_wakeup(sc);
Felix Fietkaue239d852010-01-15 02:34:58 +01001791 ath9k_hw_init_global_settings(ah);
Mohammed Shafi Shajakhan8b2a38272011-08-24 21:38:07 +05301792 ath9k_ps_restore(sc);
1793
Felix Fietkaue239d852010-01-15 02:34:58 +01001794 mutex_unlock(&sc->mutex);
1795}
1796
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001797static void ath9k_flush(struct ieee80211_hw *hw, bool drop)
1798{
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001799 struct ath_softc *sc = hw->priv;
Mohammed Shafi Shajakhan99aa55b2011-05-06 20:43:11 +05301800 struct ath_hw *ah = sc->sc_ah;
1801 struct ath_common *common = ath9k_hw_common(ah);
Felix Fietkau86271e42011-03-11 21:38:19 +01001802 int timeout = 200; /* ms */
1803 int i, j;
Rajkumar Manoharan2f6fc352011-04-28 15:31:57 +05301804 bool drain_txq;
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001805
1806 mutex_lock(&sc->mutex);
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001807 cancel_delayed_work_sync(&sc->tx_complete_work);
1808
Mohammed Shafi Shajakhan6a6b3f32011-09-09 10:41:08 +05301809 if (ah->ah_flags & AH_UNPLUGGED) {
Joe Perchesd2182b62011-12-15 14:55:53 -08001810 ath_dbg(common, ANY, "Device has been unplugged!\n");
Mohammed Shafi Shajakhan6a6b3f32011-09-09 10:41:08 +05301811 mutex_unlock(&sc->mutex);
1812 return;
1813 }
1814
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301815 if (test_bit(SC_OP_INVALID, &sc->sc_flags)) {
Joe Perchesd2182b62011-12-15 14:55:53 -08001816 ath_dbg(common, ANY, "Device not present\n");
Mohammed Shafi Shajakhan99aa55b2011-05-06 20:43:11 +05301817 mutex_unlock(&sc->mutex);
1818 return;
1819 }
1820
Felix Fietkau86271e42011-03-11 21:38:19 +01001821 for (j = 0; j < timeout; j++) {
Mohammed Shafi Shajakhan108697c2011-05-13 20:59:42 +05301822 bool npend = false;
Felix Fietkau86271e42011-03-11 21:38:19 +01001823
1824 if (j)
1825 usleep_range(1000, 2000);
1826
1827 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
1828 if (!ATH_TXQ_SETUP(sc, i))
1829 continue;
1830
Mohammed Shafi Shajakhan108697c2011-05-13 20:59:42 +05301831 npend = ath9k_has_pending_frames(sc, &sc->tx.txq[i]);
1832
1833 if (npend)
1834 break;
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001835 }
1836
Felix Fietkau86271e42011-03-11 21:38:19 +01001837 if (!npend)
Felix Fietkau9df0d6a2011-11-16 13:08:42 +01001838 break;
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001839 }
1840
Felix Fietkau9df0d6a2011-11-16 13:08:42 +01001841 if (drop) {
1842 ath9k_ps_wakeup(sc);
1843 spin_lock_bh(&sc->sc_pcu_lock);
1844 drain_txq = ath_drain_all_txq(sc, false);
1845 spin_unlock_bh(&sc->sc_pcu_lock);
Felix Fietkau9adcf442011-09-03 01:40:26 +02001846
Felix Fietkau9df0d6a2011-11-16 13:08:42 +01001847 if (!drain_txq)
1848 ath_reset(sc, false);
Felix Fietkau9adcf442011-09-03 01:40:26 +02001849
Felix Fietkau9df0d6a2011-11-16 13:08:42 +01001850 ath9k_ps_restore(sc);
1851 ieee80211_wake_queues(hw);
1852 }
Senthil Balasubramaniand78f4b32011-03-23 23:07:22 +05301853
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001854 ieee80211_queue_delayed_work(hw, &sc->tx_complete_work, 0);
1855 mutex_unlock(&sc->mutex);
1856}
1857
Vivek Natarajan15b91e82011-04-06 11:41:11 +05301858static bool ath9k_tx_frames_pending(struct ieee80211_hw *hw)
1859{
1860 struct ath_softc *sc = hw->priv;
1861 int i;
1862
1863 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
1864 if (!ATH_TXQ_SETUP(sc, i))
1865 continue;
1866
1867 if (ath9k_has_pending_frames(sc, &sc->tx.txq[i]))
1868 return true;
1869 }
1870 return false;
1871}
1872
Mohammed Shafi Shajakhan5595f112011-05-19 18:08:57 +05301873static int ath9k_tx_last_beacon(struct ieee80211_hw *hw)
Felix Fietkauba4903f2011-05-17 21:09:54 +02001874{
1875 struct ath_softc *sc = hw->priv;
1876 struct ath_hw *ah = sc->sc_ah;
1877 struct ieee80211_vif *vif;
1878 struct ath_vif *avp;
1879 struct ath_buf *bf;
1880 struct ath_tx_status ts;
Felix Fietkau4286df62012-02-27 19:58:40 +01001881 bool edma = !!(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA);
Felix Fietkauba4903f2011-05-17 21:09:54 +02001882 int status;
1883
1884 vif = sc->beacon.bslot[0];
1885 if (!vif)
1886 return 0;
1887
1888 avp = (void *)vif->drv_priv;
1889 if (!avp->is_bslot_active)
1890 return 0;
1891
Felix Fietkau4286df62012-02-27 19:58:40 +01001892 if (!sc->beacon.tx_processed && !edma) {
Felix Fietkauba4903f2011-05-17 21:09:54 +02001893 tasklet_disable(&sc->bcon_tasklet);
1894
1895 bf = avp->av_bcbuf;
1896 if (!bf || !bf->bf_mpdu)
1897 goto skip;
1898
1899 status = ath9k_hw_txprocdesc(ah, bf->bf_desc, &ts);
1900 if (status == -EINPROGRESS)
1901 goto skip;
1902
1903 sc->beacon.tx_processed = true;
1904 sc->beacon.tx_last = !(ts.ts_status & ATH9K_TXERR_MASK);
1905
1906skip:
1907 tasklet_enable(&sc->bcon_tasklet);
1908 }
1909
1910 return sc->beacon.tx_last;
1911}
1912
Mohammed Shafi Shajakhan52c94f42011-08-20 17:21:42 +05301913static int ath9k_get_stats(struct ieee80211_hw *hw,
1914 struct ieee80211_low_level_stats *stats)
1915{
1916 struct ath_softc *sc = hw->priv;
1917 struct ath_hw *ah = sc->sc_ah;
1918 struct ath9k_mib_stats *mib_stats = &ah->ah_mibStats;
1919
1920 stats->dot11ACKFailureCount = mib_stats->ackrcv_bad;
1921 stats->dot11RTSFailureCount = mib_stats->rts_bad;
1922 stats->dot11FCSErrorCount = mib_stats->fcs_bad;
1923 stats->dot11RTSSuccessCount = mib_stats->rts_good;
1924 return 0;
1925}
1926
Felix Fietkau43c35282011-09-03 01:40:27 +02001927static u32 fill_chainmask(u32 cap, u32 new)
1928{
1929 u32 filled = 0;
1930 int i;
1931
1932 for (i = 0; cap && new; i++, cap >>= 1) {
1933 if (!(cap & BIT(0)))
1934 continue;
1935
1936 if (new & BIT(0))
1937 filled |= BIT(i);
1938
1939 new >>= 1;
1940 }
1941
1942 return filled;
1943}
1944
1945static int ath9k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
1946{
1947 struct ath_softc *sc = hw->priv;
1948 struct ath_hw *ah = sc->sc_ah;
1949
1950 if (!rx_ant || !tx_ant)
1951 return -EINVAL;
1952
1953 sc->ant_rx = rx_ant;
1954 sc->ant_tx = tx_ant;
1955
1956 if (ah->caps.rx_chainmask == 1)
1957 return 0;
1958
1959 /* AR9100 runs into calibration issues if not all rx chains are enabled */
1960 if (AR_SREV_9100(ah))
1961 ah->rxchainmask = 0x7;
1962 else
1963 ah->rxchainmask = fill_chainmask(ah->caps.rx_chainmask, rx_ant);
1964
1965 ah->txchainmask = fill_chainmask(ah->caps.tx_chainmask, tx_ant);
1966 ath9k_reload_chainmask_settings(sc);
1967
1968 return 0;
1969}
1970
1971static int ath9k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
1972{
1973 struct ath_softc *sc = hw->priv;
1974
1975 *tx_ant = sc->ant_tx;
1976 *rx_ant = sc->ant_rx;
1977 return 0;
1978}
1979
Ben Greearb90bd9d2012-05-15 15:33:25 -07001980#ifdef CONFIG_ATH9K_DEBUGFS
1981
1982/* Ethtool support for get-stats */
1983
1984#define AMKSTR(nm) #nm "_BE", #nm "_BK", #nm "_VI", #nm "_VO"
1985static const char ath9k_gstrings_stats[][ETH_GSTRING_LEN] = {
1986 "tx_pkts_nic",
1987 "tx_bytes_nic",
1988 "rx_pkts_nic",
1989 "rx_bytes_nic",
1990 AMKSTR(d_tx_pkts),
1991 AMKSTR(d_tx_bytes),
1992 AMKSTR(d_tx_mpdus_queued),
1993 AMKSTR(d_tx_mpdus_completed),
1994 AMKSTR(d_tx_mpdu_xretries),
1995 AMKSTR(d_tx_aggregates),
1996 AMKSTR(d_tx_ampdus_queued_hw),
1997 AMKSTR(d_tx_ampdus_queued_sw),
1998 AMKSTR(d_tx_ampdus_completed),
1999 AMKSTR(d_tx_ampdu_retries),
2000 AMKSTR(d_tx_ampdu_xretries),
2001 AMKSTR(d_tx_fifo_underrun),
2002 AMKSTR(d_tx_op_exceeded),
2003 AMKSTR(d_tx_timer_expiry),
2004 AMKSTR(d_tx_desc_cfg_err),
2005 AMKSTR(d_tx_data_underrun),
2006 AMKSTR(d_tx_delim_underrun),
2007
2008 "d_rx_decrypt_crc_err",
2009 "d_rx_phy_err",
2010 "d_rx_mic_err",
2011 "d_rx_pre_delim_crc_err",
2012 "d_rx_post_delim_crc_err",
2013 "d_rx_decrypt_busy_err",
2014
2015 "d_rx_phyerr_radar",
2016 "d_rx_phyerr_ofdm_timing",
2017 "d_rx_phyerr_cck_timing",
2018
2019};
2020#define ATH9K_SSTATS_LEN ARRAY_SIZE(ath9k_gstrings_stats)
2021
2022static void ath9k_get_et_strings(struct ieee80211_hw *hw,
2023 struct ieee80211_vif *vif,
2024 u32 sset, u8 *data)
2025{
2026 if (sset == ETH_SS_STATS)
2027 memcpy(data, *ath9k_gstrings_stats,
2028 sizeof(ath9k_gstrings_stats));
2029}
2030
2031static int ath9k_get_et_sset_count(struct ieee80211_hw *hw,
2032 struct ieee80211_vif *vif, int sset)
2033{
2034 if (sset == ETH_SS_STATS)
2035 return ATH9K_SSTATS_LEN;
2036 return 0;
2037}
2038
2039#define PR_QNUM(_n) (sc->tx.txq_map[_n]->axq_qnum)
2040#define AWDATA(elem) \
2041 do { \
2042 data[i++] = sc->debug.stats.txstats[PR_QNUM(WME_AC_BE)].elem; \
2043 data[i++] = sc->debug.stats.txstats[PR_QNUM(WME_AC_BK)].elem; \
2044 data[i++] = sc->debug.stats.txstats[PR_QNUM(WME_AC_VI)].elem; \
2045 data[i++] = sc->debug.stats.txstats[PR_QNUM(WME_AC_VO)].elem; \
2046 } while (0)
2047
2048#define AWDATA_RX(elem) \
2049 do { \
2050 data[i++] = sc->debug.stats.rxstats.elem; \
2051 } while (0)
2052
2053static void ath9k_get_et_stats(struct ieee80211_hw *hw,
2054 struct ieee80211_vif *vif,
2055 struct ethtool_stats *stats, u64 *data)
2056{
2057 struct ath_softc *sc = hw->priv;
2058 int i = 0;
2059
2060 data[i++] = (sc->debug.stats.txstats[PR_QNUM(WME_AC_BE)].tx_pkts_all +
2061 sc->debug.stats.txstats[PR_QNUM(WME_AC_BK)].tx_pkts_all +
2062 sc->debug.stats.txstats[PR_QNUM(WME_AC_VI)].tx_pkts_all +
2063 sc->debug.stats.txstats[PR_QNUM(WME_AC_VO)].tx_pkts_all);
2064 data[i++] = (sc->debug.stats.txstats[PR_QNUM(WME_AC_BE)].tx_bytes_all +
2065 sc->debug.stats.txstats[PR_QNUM(WME_AC_BK)].tx_bytes_all +
2066 sc->debug.stats.txstats[PR_QNUM(WME_AC_VI)].tx_bytes_all +
2067 sc->debug.stats.txstats[PR_QNUM(WME_AC_VO)].tx_bytes_all);
2068 AWDATA_RX(rx_pkts_all);
2069 AWDATA_RX(rx_bytes_all);
2070
2071 AWDATA(tx_pkts_all);
2072 AWDATA(tx_bytes_all);
2073 AWDATA(queued);
2074 AWDATA(completed);
2075 AWDATA(xretries);
2076 AWDATA(a_aggr);
2077 AWDATA(a_queued_hw);
2078 AWDATA(a_queued_sw);
2079 AWDATA(a_completed);
2080 AWDATA(a_retries);
2081 AWDATA(a_xretries);
2082 AWDATA(fifo_underrun);
2083 AWDATA(xtxop);
2084 AWDATA(timer_exp);
2085 AWDATA(desc_cfg_err);
2086 AWDATA(data_underrun);
2087 AWDATA(delim_underrun);
2088
2089 AWDATA_RX(decrypt_crc_err);
2090 AWDATA_RX(phy_err);
2091 AWDATA_RX(mic_err);
2092 AWDATA_RX(pre_delim_crc_err);
2093 AWDATA_RX(post_delim_crc_err);
2094 AWDATA_RX(decrypt_busy_err);
2095
2096 AWDATA_RX(phy_err_stats[ATH9K_PHYERR_RADAR]);
2097 AWDATA_RX(phy_err_stats[ATH9K_PHYERR_OFDM_TIMING]);
2098 AWDATA_RX(phy_err_stats[ATH9K_PHYERR_CCK_TIMING]);
2099
2100 WARN_ON(i != ATH9K_SSTATS_LEN);
2101}
2102
2103/* End of ethtool get-stats functions */
2104
2105#endif
2106
2107
Gabor Juhos6baff7f2009-01-14 20:17:06 +01002108struct ieee80211_ops ath9k_ops = {
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002109 .tx = ath9k_tx,
2110 .start = ath9k_start,
2111 .stop = ath9k_stop,
2112 .add_interface = ath9k_add_interface,
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05302113 .change_interface = ath9k_change_interface,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002114 .remove_interface = ath9k_remove_interface,
2115 .config = ath9k_config,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002116 .configure_filter = ath9k_configure_filter,
Johannes Berg4ca77862010-02-19 19:06:56 +01002117 .sta_add = ath9k_sta_add,
2118 .sta_remove = ath9k_sta_remove,
Felix Fietkau55195412011-04-17 23:28:09 +02002119 .sta_notify = ath9k_sta_notify,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002120 .conf_tx = ath9k_conf_tx,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002121 .bss_info_changed = ath9k_bss_info_changed,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002122 .set_key = ath9k_set_key,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002123 .get_tsf = ath9k_get_tsf,
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01002124 .set_tsf = ath9k_set_tsf,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002125 .reset_tsf = ath9k_reset_tsf,
Johannes Berg4233df62008-10-13 13:35:05 +02002126 .ampdu_action = ath9k_ampdu_action,
Benoit Papillault62dad5b2010-04-28 00:08:24 +02002127 .get_survey = ath9k_get_survey,
Johannes Berg3b319aa2009-06-13 14:50:26 +05302128 .rfkill_poll = ath9k_rfkill_poll_state,
Felix Fietkaue239d852010-01-15 02:34:58 +01002129 .set_coverage_class = ath9k_set_coverage_class,
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002130 .flush = ath9k_flush,
Vivek Natarajan15b91e82011-04-06 11:41:11 +05302131 .tx_frames_pending = ath9k_tx_frames_pending,
Mohammed Shafi Shajakhan52c94f42011-08-20 17:21:42 +05302132 .tx_last_beacon = ath9k_tx_last_beacon,
2133 .get_stats = ath9k_get_stats,
Felix Fietkau43c35282011-09-03 01:40:27 +02002134 .set_antenna = ath9k_set_antenna,
2135 .get_antenna = ath9k_get_antenna,
Ben Greearb90bd9d2012-05-15 15:33:25 -07002136
2137#ifdef CONFIG_ATH9K_DEBUGFS
2138 .get_et_sset_count = ath9k_get_et_sset_count,
2139 .get_et_stats = ath9k_get_et_stats,
2140 .get_et_strings = ath9k_get_et_strings,
2141#endif
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002142};