blob: 248e5b24acfaeb2dbbf7fa0bf9177303d68ace69 [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
Sven Eckelmann313eb872012-06-25 07:15:22 +020022u8 ath9k_parse_mpdudensity(u8 mpdudensity)
Sujithff37e332008-11-24 12:07:55 +053023{
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;
Rajkumar Manoharan08d4df42012-07-01 19:53:54 +0530133 if (ath9k_hw_btcoex_is_enabled(sc->sc_ah))
134 ath9k_btcoex_stop_gen_timer(sc);
Sujith Manoharanad128862012-04-24 10:23:20 +0530135 } else {
Felix Fietkauc6c539f2011-09-14 21:24:24 +0200136 goto unlock;
Sujith Manoharanad128862012-04-24 10:23:20 +0530137 }
Felix Fietkauc6c539f2011-09-14 21:24:24 +0200138
139 spin_lock(&common->cc_lock);
140 ath_hw_cycle_counters_update(common);
141 spin_unlock(&common->cc_lock);
142
Felix Fietkau1a8f0d392011-09-22 08:04:32 -0600143 ath9k_hw_setpower(sc->sc_ah, mode);
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -0700144
145 unlock:
146 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
147}
148
Felix Fietkau9adcf442011-09-03 01:40:26 +0200149static void __ath_cancel_work(struct ath_softc *sc)
150{
151 cancel_work_sync(&sc->paprd_work);
152 cancel_work_sync(&sc->hw_check_work);
153 cancel_delayed_work_sync(&sc->tx_complete_work);
154 cancel_delayed_work_sync(&sc->hw_pll_work);
Sujith Manoharanfad29cd2012-06-25 13:54:22 +0530155
Sujith Manoharanbf525922012-06-27 14:15:59 +0530156#ifdef CONFIG_ATH9K_BTCOEX_SUPPORT
Sujith Manoharanfad29cd2012-06-25 13:54:22 +0530157 if (ath9k_hw_mci_is_enabled(sc->sc_ah))
158 cancel_work_sync(&sc->mci_work);
Sujith Manoharanbf525922012-06-27 14:15:59 +0530159#endif
Felix Fietkau9adcf442011-09-03 01:40:26 +0200160}
161
162static void ath_cancel_work(struct ath_softc *sc)
163{
164 __ath_cancel_work(sc);
165 cancel_work_sync(&sc->hw_reset_work);
166}
167
Sujith Manoharanaf68aba2012-06-04 20:23:43 +0530168static void ath_restart_work(struct ath_softc *sc)
169{
170 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
171
172 ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work, 0);
173
Gabor Juhosc12b6022012-07-03 19:13:32 +0200174 if (AR_SREV_9340(sc->sc_ah) || AR_SREV_9485(sc->sc_ah) ||
175 AR_SREV_9550(sc->sc_ah))
Sujith Manoharanaf68aba2012-06-04 20:23:43 +0530176 ieee80211_queue_delayed_work(sc->hw, &sc->hw_pll_work,
177 msecs_to_jiffies(ATH_PLL_WORK_INTERVAL));
178
179 ath_start_rx_poll(sc, 3);
180
181 if (!common->disable_ani)
182 ath_start_ani(common);
183}
184
Felix Fietkau9adcf442011-09-03 01:40:26 +0200185static bool ath_prepare_reset(struct ath_softc *sc, bool retry_tx, bool flush)
186{
187 struct ath_hw *ah = sc->sc_ah;
188 struct ath_common *common = ath9k_hw_common(ah);
Felix Fietkauceea2a52012-05-24 14:32:19 +0200189 bool ret = true;
Felix Fietkau9adcf442011-09-03 01:40:26 +0200190
191 ieee80211_stop_queues(sc->hw);
192
193 sc->hw_busy_count = 0;
194 del_timer_sync(&common->ani.timer);
Rajkumar Manoharan01e18912012-03-15 05:34:27 +0530195 del_timer_sync(&sc->rx_poll_timer);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200196
197 ath9k_debug_samp_bb_mac(sc);
198 ath9k_hw_disable_interrupts(ah);
199
Felix Fietkau9adcf442011-09-03 01:40:26 +0200200 if (!ath_stoprecv(sc))
201 ret = false;
202
Felix Fietkauceea2a52012-05-24 14:32:19 +0200203 if (!ath_drain_all_txq(sc, retry_tx))
204 ret = false;
205
Felix Fietkau9adcf442011-09-03 01:40:26 +0200206 if (!flush) {
207 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
Felix Fietkau34832882011-09-14 21:23:03 +0200208 ath_rx_tasklet(sc, 1, true);
209 ath_rx_tasklet(sc, 1, false);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200210 } else {
211 ath_flushrecv(sc);
212 }
213
214 return ret;
215}
216
217static bool ath_complete_reset(struct ath_softc *sc, bool start)
218{
219 struct ath_hw *ah = sc->sc_ah;
220 struct ath_common *common = ath9k_hw_common(ah);
Sujith Manoharan196fb862012-06-04 20:24:13 +0530221 unsigned long flags;
Felix Fietkau9adcf442011-09-03 01:40:26 +0200222
223 if (ath_startrecv(sc) != 0) {
224 ath_err(common, "Unable to restart recv logic\n");
225 return false;
226 }
227
228 ath9k_cmn_update_txpow(ah, sc->curtxpow,
229 sc->config.txpowlimit, &sc->curtxpow);
Sujith Manoharanb74713d2012-06-04 20:24:01 +0530230
231 clear_bit(SC_OP_HW_RESET, &sc->sc_flags);
Felix Fietkau72d874c2011-10-08 20:06:19 +0200232 ath9k_hw_set_interrupts(ah);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200233 ath9k_hw_enable_interrupts(ah);
234
Sujith Manoharan4cb54fa2012-06-04 16:27:52 +0530235 if (!(sc->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL) && start) {
Sujith Manoharan196fb862012-06-04 20:24:13 +0530236 if (!test_bit(SC_OP_BEACONS, &sc->sc_flags))
237 goto work;
Felix Fietkau9adcf442011-09-03 01:40:26 +0200238
Sujith Manoharan196fb862012-06-04 20:24:13 +0530239 ath_set_beacon(sc);
240
241 if (ah->opmode == NL80211_IFTYPE_STATION &&
242 test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) {
243 spin_lock_irqsave(&sc->sc_pm_lock, flags);
244 sc->ps_flags |= PS_BEACON_SYNC | PS_WAIT_FOR_BEACON;
245 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
246 }
247 work:
Sujith Manoharanaf68aba2012-06-04 20:23:43 +0530248 ath_restart_work(sc);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200249 }
250
Sujith Manoharan8da07832012-06-04 20:23:49 +0530251 if ((ah->caps.hw_caps & ATH9K_HW_CAP_ANT_DIV_COMB) && sc->ant_rx != 3)
252 ath_ant_comb_update(sc);
Felix Fietkau43c35282011-09-03 01:40:27 +0200253
Felix Fietkau9adcf442011-09-03 01:40:26 +0200254 ieee80211_wake_queues(sc->hw);
255
256 return true;
257}
258
259static int ath_reset_internal(struct ath_softc *sc, struct ath9k_channel *hchan,
260 bool retry_tx)
261{
262 struct ath_hw *ah = sc->sc_ah;
263 struct ath_common *common = ath9k_hw_common(ah);
264 struct ath9k_hw_cal_data *caldata = NULL;
265 bool fastcc = true;
266 bool flush = false;
267 int r;
268
269 __ath_cancel_work(sc);
270
271 spin_lock_bh(&sc->sc_pcu_lock);
272
Sujith Manoharan4cb54fa2012-06-04 16:27:52 +0530273 if (!(sc->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)) {
Felix Fietkau9adcf442011-09-03 01:40:26 +0200274 fastcc = false;
275 caldata = &sc->caldata;
276 }
277
278 if (!hchan) {
279 fastcc = false;
280 flush = true;
281 hchan = ah->curchan;
282 }
283
Felix Fietkau9adcf442011-09-03 01:40:26 +0200284 if (!ath_prepare_reset(sc, retry_tx, flush))
285 fastcc = false;
286
Joe Perchesd2182b62011-12-15 14:55:53 -0800287 ath_dbg(common, CONFIG, "Reset to %u MHz, HT40: %d fastcc: %d\n",
Sujith Manoharanfeced202012-01-30 14:21:42 +0530288 hchan->channel, IS_CHAN_HT40(hchan), fastcc);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200289
290 r = ath9k_hw_reset(ah, hchan, caldata, fastcc);
291 if (r) {
292 ath_err(common,
293 "Unable to reset channel, reset status %d\n", r);
294 goto out;
295 }
296
297 if (!ath_complete_reset(sc, true))
298 r = -EIO;
299
300out:
301 spin_unlock_bh(&sc->sc_pcu_lock);
302 return r;
303}
304
305
Sujithff37e332008-11-24 12:07:55 +0530306/*
307 * Set/change channels. If the channel is really being changed, it's done
308 * by reseting the chip. To accomplish this we must first cleanup any pending
309 * DMA, then restart stuff.
310*/
Mohammed Shafi Shajakhan5595f112011-05-19 18:08:57 +0530311static int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
Jouni Malinen0e2dedf2009-03-03 19:23:32 +0200312 struct ath9k_channel *hchan)
Sujithff37e332008-11-24 12:07:55 +0530313{
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800314 int r;
Sujithff37e332008-11-24 12:07:55 +0530315
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530316 if (test_bit(SC_OP_INVALID, &sc->sc_flags))
Sujithff37e332008-11-24 12:07:55 +0530317 return -EIO;
318
Felix Fietkau9adcf442011-09-03 01:40:26 +0200319 r = ath_reset_internal(sc, hchan, false);
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700320
Gabor Juhos39892792009-06-15 17:49:09 +0200321 return r;
Sujithff37e332008-11-24 12:07:55 +0530322}
323
Ben Greear7e1e3862011-11-03 11:33:13 -0700324static void ath_node_attach(struct ath_softc *sc, struct ieee80211_sta *sta,
325 struct ieee80211_vif *vif)
Sujithff37e332008-11-24 12:07:55 +0530326{
327 struct ath_node *an;
Sven Eckelmann313eb872012-06-25 07:15:22 +0200328 u8 density;
Sujithff37e332008-11-24 12:07:55 +0530329 an = (struct ath_node *)sta->drv_priv;
330
Ben Greear7f010c92011-01-09 23:11:49 -0800331#ifdef CONFIG_ATH9K_DEBUGFS
332 spin_lock(&sc->nodes_lock);
333 list_add(&an->list, &sc->nodes);
334 spin_unlock(&sc->nodes_lock);
Felix Fietkau156369f2011-12-14 22:08:04 +0100335#endif
Ben Greear7f010c92011-01-09 23:11:49 -0800336 an->sta = sta;
Ben Greear7e1e3862011-11-03 11:33:13 -0700337 an->vif = vif;
Sujith Manoharan3d4e20f2012-03-14 14:40:58 +0530338
Sujith Manoharana4d63672012-03-27 10:08:55 +0530339 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT) {
Sujithff37e332008-11-24 12:07:55 +0530340 ath_tx_node_init(sc, an);
Sujith9e98ac62009-07-23 15:32:34 +0530341 an->maxampdu = 1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
Sujith87792ef2009-03-30 15:28:48 +0530342 sta->ht_cap.ampdu_factor);
Sven Eckelmann313eb872012-06-25 07:15:22 +0200343 density = ath9k_parse_mpdudensity(sta->ht_cap.ampdu_density);
344 an->mpdudensity = density;
Sujith87792ef2009-03-30 15:28:48 +0530345 }
Sujithff37e332008-11-24 12:07:55 +0530346}
347
348static void ath_node_detach(struct ath_softc *sc, struct ieee80211_sta *sta)
349{
350 struct ath_node *an = (struct ath_node *)sta->drv_priv;
351
Ben Greear7f010c92011-01-09 23:11:49 -0800352#ifdef CONFIG_ATH9K_DEBUGFS
353 spin_lock(&sc->nodes_lock);
354 list_del(&an->list);
355 spin_unlock(&sc->nodes_lock);
356 an->sta = NULL;
357#endif
358
Sujith Manoharana4d63672012-03-27 10:08:55 +0530359 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT)
Sujithff37e332008-11-24 12:07:55 +0530360 ath_tx_node_cleanup(sc, an);
361}
362
Sujith55624202010-01-08 10:36:02 +0530363void ath9k_tasklet(unsigned long data)
Sujithff37e332008-11-24 12:07:55 +0530364{
365 struct ath_softc *sc = (struct ath_softc *)data;
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -0700366 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -0700367 struct ath_common *common = ath9k_hw_common(ah);
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530368 unsigned long flags;
Sujith17d79042009-02-09 13:27:03 +0530369 u32 status = sc->intrstatus;
Felix Fietkaub5c804752010-04-15 17:38:48 -0400370 u32 rxmask;
Sujithff37e332008-11-24 12:07:55 +0530371
Felix Fietkaue3927002011-09-14 21:23:01 +0200372 ath9k_ps_wakeup(sc);
373 spin_lock(&sc->sc_pcu_lock);
374
Rajkumar Manoharana4d86d92011-05-20 17:52:10 +0530375 if ((status & ATH9K_INT_FATAL) ||
376 (status & ATH9K_INT_BB_WATCHDOG)) {
Felix Fietkau030d6292011-10-07 02:28:13 +0200377#ifdef CONFIG_ATH9K_DEBUGFS
378 enum ath_reset_type type;
379
380 if (status & ATH9K_INT_FATAL)
381 type = RESET_TYPE_FATAL_INT;
382 else
383 type = RESET_TYPE_BB_WATCHDOG;
384
385 RESET_STAT_INC(sc, type);
386#endif
Sujith Manoharanb74713d2012-06-04 20:24:01 +0530387 set_bit(SC_OP_HW_RESET, &sc->sc_flags);
Felix Fietkau236de512011-09-03 01:40:25 +0200388 ieee80211_queue_work(sc->hw, &sc->hw_reset_work);
Felix Fietkaue3927002011-09-14 21:23:01 +0200389 goto out;
Sujithff37e332008-11-24 12:07:55 +0530390 }
391
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530392 spin_lock_irqsave(&sc->sc_pm_lock, flags);
Rajkumar Manoharan4105f802011-05-06 18:27:47 +0530393 if ((status & ATH9K_INT_TSFOOR) && sc->ps_enabled) {
394 /*
395 * TSF sync does not look correct; remain awake to sync with
396 * the next Beacon.
397 */
Joe Perchesd2182b62011-12-15 14:55:53 -0800398 ath_dbg(common, PS, "TSFOOR - Sync with next Beacon\n");
Rajkumar Manoharane8fe7332011-08-05 18:59:41 +0530399 sc->ps_flags |= PS_WAIT_FOR_BEACON | PS_BEACON_SYNC;
Rajkumar Manoharan4105f802011-05-06 18:27:47 +0530400 }
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530401 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
Rajkumar Manoharan4105f802011-05-06 18:27:47 +0530402
Felix Fietkaub5c804752010-04-15 17:38:48 -0400403 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
404 rxmask = (ATH9K_INT_RXHP | ATH9K_INT_RXLP | ATH9K_INT_RXEOL |
405 ATH9K_INT_RXORN);
406 else
407 rxmask = (ATH9K_INT_RX | ATH9K_INT_RXEOL | ATH9K_INT_RXORN);
408
409 if (status & rxmask) {
Felix Fietkaub5c804752010-04-15 17:38:48 -0400410 /* Check for high priority Rx first */
411 if ((ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) &&
412 (status & ATH9K_INT_RXHP))
413 ath_rx_tasklet(sc, 0, true);
414
415 ath_rx_tasklet(sc, 0, false);
Sujith063d8be2009-03-30 15:28:49 +0530416 }
417
Vasanthakumar Thiagarajane5003242010-04-15 17:39:36 -0400418 if (status & ATH9K_INT_TX) {
419 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
420 ath_tx_edma_tasklet(sc);
421 else
422 ath_tx_tasklet(sc);
423 }
Sujith063d8be2009-03-30 15:28:49 +0530424
Sujith Manoharan56ca0db2012-02-22 12:40:32 +0530425 ath9k_btcoex_handle_interrupt(sc, status);
Mohammed Shafi Shajakhan19686dd2011-11-30 10:41:28 +0530426
Felix Fietkaue3927002011-09-14 21:23:01 +0200427out:
Sujithff37e332008-11-24 12:07:55 +0530428 /* re-enable hardware interrupt */
Felix Fietkau4df30712010-11-08 20:54:47 +0100429 ath9k_hw_enable_interrupts(ah);
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700430
Senthil Balasubramanian52671e42010-12-23 21:06:57 +0530431 spin_unlock(&sc->sc_pcu_lock);
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400432 ath9k_ps_restore(sc);
Sujithff37e332008-11-24 12:07:55 +0530433}
434
Gabor Juhos6baff7f2009-01-14 20:17:06 +0100435irqreturn_t ath_isr(int irq, void *dev)
Sujithff37e332008-11-24 12:07:55 +0530436{
Sujith063d8be2009-03-30 15:28:49 +0530437#define SCHED_INTR ( \
438 ATH9K_INT_FATAL | \
Rajkumar Manoharana4d86d92011-05-20 17:52:10 +0530439 ATH9K_INT_BB_WATCHDOG | \
Sujith063d8be2009-03-30 15:28:49 +0530440 ATH9K_INT_RXORN | \
441 ATH9K_INT_RXEOL | \
442 ATH9K_INT_RX | \
Felix Fietkaub5c804752010-04-15 17:38:48 -0400443 ATH9K_INT_RXLP | \
444 ATH9K_INT_RXHP | \
Sujith063d8be2009-03-30 15:28:49 +0530445 ATH9K_INT_TX | \
446 ATH9K_INT_BMISS | \
447 ATH9K_INT_CST | \
Vasanthakumar Thiagarajanebb8e1d2009-09-01 17:46:32 +0530448 ATH9K_INT_TSFOOR | \
Mohammed Shafi Shajakhan40dc5392011-11-30 10:41:18 +0530449 ATH9K_INT_GENTIMER | \
450 ATH9K_INT_MCI)
Sujith063d8be2009-03-30 15:28:49 +0530451
Sujithff37e332008-11-24 12:07:55 +0530452 struct ath_softc *sc = dev;
Sujithcbe61d8a2009-02-09 13:27:12 +0530453 struct ath_hw *ah = sc->sc_ah;
Felix Fietkaub5bfc562010-10-08 22:13:53 +0200454 struct ath_common *common = ath9k_hw_common(ah);
Sujithff37e332008-11-24 12:07:55 +0530455 enum ath9k_int status;
456 bool sched = false;
457
Sujith063d8be2009-03-30 15:28:49 +0530458 /*
459 * The hardware is not ready/present, don't
460 * touch anything. Note this can happen early
461 * on if the IRQ is shared.
462 */
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530463 if (test_bit(SC_OP_INVALID, &sc->sc_flags))
Sujith063d8be2009-03-30 15:28:49 +0530464 return IRQ_NONE;
Sujithff37e332008-11-24 12:07:55 +0530465
Sujith063d8be2009-03-30 15:28:49 +0530466 /* shared irq, not for us */
Sujithff37e332008-11-24 12:07:55 +0530467
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400468 if (!ath9k_hw_intrpend(ah))
Sujith063d8be2009-03-30 15:28:49 +0530469 return IRQ_NONE;
Sujithff37e332008-11-24 12:07:55 +0530470
Sujith Manoharanb74713d2012-06-04 20:24:01 +0530471 if(test_bit(SC_OP_HW_RESET, &sc->sc_flags))
472 return IRQ_HANDLED;
473
Sujith063d8be2009-03-30 15:28:49 +0530474 /*
475 * Figure out the reason(s) for the interrupt. Note
476 * that the hal returns a pseudo-ISR that may include
477 * bits we haven't explicitly enabled so we mask the
478 * value to insure we only process bits we requested.
479 */
480 ath9k_hw_getisr(ah, &status); /* NB: clears ISR too */
Pavel Roskin30691682010-03-31 18:05:31 -0400481 status &= ah->imask; /* discard unasked-for bits */
Sujith063d8be2009-03-30 15:28:49 +0530482
483 /*
484 * If there are no status bits set, then this interrupt was not
485 * for me (should have been caught above).
486 */
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400487 if (!status)
Sujith063d8be2009-03-30 15:28:49 +0530488 return IRQ_NONE;
Sujith063d8be2009-03-30 15:28:49 +0530489
490 /* Cache the status */
491 sc->intrstatus = status;
492
493 if (status & SCHED_INTR)
494 sched = true;
495
496 /*
497 * If a FATAL or RXORN interrupt is received, we have to reset the
498 * chip immediately.
499 */
Felix Fietkaub5c804752010-04-15 17:38:48 -0400500 if ((status & ATH9K_INT_FATAL) || ((status & ATH9K_INT_RXORN) &&
501 !(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)))
Sujith063d8be2009-03-30 15:28:49 +0530502 goto chip_reset;
503
Luis R. Rodriguez08578b82010-05-13 13:33:44 -0400504 if ((ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) &&
505 (status & ATH9K_INT_BB_WATCHDOG)) {
Felix Fietkaub5bfc562010-10-08 22:13:53 +0200506
507 spin_lock(&common->cc_lock);
508 ath_hw_cycle_counters_update(common);
Luis R. Rodriguez08578b82010-05-13 13:33:44 -0400509 ar9003_hw_bb_watchdog_dbg_info(ah);
Felix Fietkaub5bfc562010-10-08 22:13:53 +0200510 spin_unlock(&common->cc_lock);
511
Luis R. Rodriguez08578b82010-05-13 13:33:44 -0400512 goto chip_reset;
513 }
514
Sujith063d8be2009-03-30 15:28:49 +0530515 if (status & ATH9K_INT_SWBA)
516 tasklet_schedule(&sc->bcon_tasklet);
517
518 if (status & ATH9K_INT_TXURN)
519 ath9k_hw_updatetxtriglevel(ah, true);
520
Rajkumar Manoharan0682c9b2011-08-13 10:28:09 +0530521 if (status & ATH9K_INT_RXEOL) {
522 ah->imask &= ~(ATH9K_INT_RXEOL | ATH9K_INT_RXORN);
Felix Fietkau72d874c2011-10-08 20:06:19 +0200523 ath9k_hw_set_interrupts(ah);
Felix Fietkaub5c804752010-04-15 17:38:48 -0400524 }
525
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400526 if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
527 if (status & ATH9K_INT_TIM_TIMER) {
Luis R. Rodriguezff9f0b62010-12-07 15:13:22 -0800528 if (ATH_DBG_WARN_ON_ONCE(sc->ps_idle))
529 goto chip_reset;
Sujith063d8be2009-03-30 15:28:49 +0530530 /* Clear RxAbort bit so that we can
531 * receive frames */
Luis R. Rodriguez9ecdef42009-09-09 21:10:09 -0700532 ath9k_setpower(sc, ATH9K_PM_AWAKE);
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530533 spin_lock(&sc->sc_pm_lock);
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400534 ath9k_hw_setrxabort(sc->sc_ah, 0);
Sujith1b04b932010-01-08 10:36:05 +0530535 sc->ps_flags |= PS_WAIT_FOR_BEACON;
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530536 spin_unlock(&sc->sc_pm_lock);
Sujith063d8be2009-03-30 15:28:49 +0530537 }
Sujith063d8be2009-03-30 15:28:49 +0530538
539chip_reset:
540
Sujith817e11d2008-12-07 21:42:44 +0530541 ath_debug_stat_interrupt(sc, status);
542
Sujithff37e332008-11-24 12:07:55 +0530543 if (sched) {
Felix Fietkau4df30712010-11-08 20:54:47 +0100544 /* turn off every interrupt */
545 ath9k_hw_disable_interrupts(ah);
Sujithff37e332008-11-24 12:07:55 +0530546 tasklet_schedule(&sc->intr_tq);
547 }
548
549 return IRQ_HANDLED;
Sujith063d8be2009-03-30 15:28:49 +0530550
551#undef SCHED_INTR
Sujithff37e332008-11-24 12:07:55 +0530552}
553
Felix Fietkau236de512011-09-03 01:40:25 +0200554static int ath_reset(struct ath_softc *sc, bool retry_tx)
Sujithff37e332008-11-24 12:07:55 +0530555{
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800556 int r;
Sujithff37e332008-11-24 12:07:55 +0530557
Felix Fietkau783cd012011-01-21 18:52:38 +0100558 ath9k_ps_wakeup(sc);
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700559
Felix Fietkau9adcf442011-09-03 01:40:26 +0200560 r = ath_reset_internal(sc, NULL, retry_tx);
Sujithff37e332008-11-24 12:07:55 +0530561
562 if (retry_tx) {
563 int i;
564 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
565 if (ATH_TXQ_SETUP(sc, i)) {
Sujithb77f4832008-12-07 21:44:03 +0530566 spin_lock_bh(&sc->tx.txq[i].axq_lock);
567 ath_txq_schedule(sc, &sc->tx.txq[i]);
568 spin_unlock_bh(&sc->tx.txq[i].axq_lock);
Sujithff37e332008-11-24 12:07:55 +0530569 }
570 }
571 }
572
Felix Fietkau783cd012011-01-21 18:52:38 +0100573 ath9k_ps_restore(sc);
Sujith2ab81d42009-12-14 16:34:56 +0530574
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800575 return r;
Sujithff37e332008-11-24 12:07:55 +0530576}
577
Felix Fietkau236de512011-09-03 01:40:25 +0200578void ath_reset_work(struct work_struct *work)
579{
580 struct ath_softc *sc = container_of(work, struct ath_softc, hw_reset_work);
581
Felix Fietkau236de512011-09-03 01:40:25 +0200582 ath_reset(sc, true);
Felix Fietkau236de512011-09-03 01:40:25 +0200583}
584
Sujithff37e332008-11-24 12:07:55 +0530585/**********************/
586/* mac80211 callbacks */
587/**********************/
588
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700589static int ath9k_start(struct ieee80211_hw *hw)
590{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100591 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -0700592 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -0700593 struct ath_common *common = ath9k_hw_common(ah);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700594 struct ieee80211_channel *curchan = hw->conf.channel;
Sujithff37e332008-11-24 12:07:55 +0530595 struct ath9k_channel *init_channel;
Vasanthakumar Thiagarajan82880a72009-06-13 14:50:24 +0530596 int r;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700597
Joe Perchesd2182b62011-12-15 14:55:53 -0800598 ath_dbg(common, CONFIG,
Joe Perches226afe62010-12-02 19:12:37 -0800599 "Starting driver with initial channel: %d MHz\n",
600 curchan->center_freq);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700601
Felix Fietkauf62d8162011-03-25 17:43:41 +0100602 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +0530603 mutex_lock(&sc->mutex);
604
Rajkumar Manoharanc344c9c2011-01-31 23:47:43 +0530605 init_channel = ath9k_cmn_get_curchannel(hw, ah);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700606
Sujithff37e332008-11-24 12:07:55 +0530607 /* Reset SERDES registers */
Stanislaw Gruszka84c87dc2011-08-05 13:10:32 +0200608 ath9k_hw_configpcipowersave(ah, false);
Sujithff37e332008-11-24 12:07:55 +0530609
610 /*
611 * The basic interface to setting the hardware in a good
612 * state is ``reset''. On return the hardware is known to
613 * be powered up and with interrupts disabled. This must
614 * be followed by initialization of the appropriate bits
615 * and then setup of the interrupt mask.
616 */
Luis R. Rodriguez4bdd1e92010-10-26 15:27:24 -0700617 spin_lock_bh(&sc->sc_pcu_lock);
Felix Fietkauc0c11742011-11-16 13:08:41 +0100618
619 atomic_set(&ah->intr_ref_cnt, -1);
620
Felix Fietkau20bd2a02010-07-31 00:12:00 +0200621 r = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800622 if (r) {
Joe Perches38002762010-12-02 19:12:36 -0800623 ath_err(common,
624 "Unable to reset hardware; reset status %d (freq %u MHz)\n",
625 r, curchan->center_freq);
Luis R. Rodriguez4bdd1e92010-10-26 15:27:24 -0700626 spin_unlock_bh(&sc->sc_pcu_lock);
Sujith141b38b2009-02-04 08:10:07 +0530627 goto mutex_unlock;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700628 }
Sujithff37e332008-11-24 12:07:55 +0530629
Sujithff37e332008-11-24 12:07:55 +0530630 /* Setup our intr mask. */
Felix Fietkaub5c804752010-04-15 17:38:48 -0400631 ah->imask = ATH9K_INT_TX | ATH9K_INT_RXEOL |
632 ATH9K_INT_RXORN | ATH9K_INT_FATAL |
633 ATH9K_INT_GLOBAL;
634
635 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
Luis R. Rodriguez08578b82010-05-13 13:33:44 -0400636 ah->imask |= ATH9K_INT_RXHP |
637 ATH9K_INT_RXLP |
638 ATH9K_INT_BB_WATCHDOG;
Felix Fietkaub5c804752010-04-15 17:38:48 -0400639 else
640 ah->imask |= ATH9K_INT_RX;
Sujithff37e332008-11-24 12:07:55 +0530641
Felix Fietkau364734f2010-09-14 20:22:44 +0200642 ah->imask |= ATH9K_INT_GTT;
Sujithff37e332008-11-24 12:07:55 +0530643
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -0700644 if (ah->caps.hw_caps & ATH9K_HW_CAP_HT)
Pavel Roskin30691682010-03-31 18:05:31 -0400645 ah->imask |= ATH9K_INT_CST;
Sujithff37e332008-11-24 12:07:55 +0530646
Sujith Manoharane270e772012-06-04 16:27:19 +0530647 ath_mci_enable(sc);
Mohammed Shafi Shajakhan40dc5392011-11-30 10:41:18 +0530648
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530649 clear_bit(SC_OP_INVALID, &sc->sc_flags);
Rajkumar Manoharan5f841b42010-10-27 18:31:15 +0530650 sc->sc_ah->is_monitoring = false;
Sujithff37e332008-11-24 12:07:55 +0530651
Felix Fietkau9adcf442011-09-03 01:40:26 +0200652 if (!ath_complete_reset(sc, false)) {
653 r = -EIO;
654 spin_unlock_bh(&sc->sc_pcu_lock);
655 goto mutex_unlock;
656 }
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700657
Felix Fietkauc0c11742011-11-16 13:08:41 +0100658 if (ah->led_pin >= 0) {
659 ath9k_hw_cfg_output(ah, ah->led_pin,
660 AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
661 ath9k_hw_set_gpio(ah, ah->led_pin, 0);
662 }
663
664 /*
665 * Reset key cache to sane defaults (all entries cleared) instead of
666 * semi-random values after suspend/resume.
667 */
668 ath9k_cmn_init_crypto(sc->sc_ah);
669
Felix Fietkau9adcf442011-09-03 01:40:26 +0200670 spin_unlock_bh(&sc->sc_pcu_lock);
Senthil Balasubramanian164ace32009-07-14 20:17:09 -0400671
Vasanthakumar Thiagarajan8060e162010-12-06 04:27:42 -0800672 if (ah->caps.pcie_lcr_extsync_en && common->bus_ops->extn_synch_en)
673 common->bus_ops->extn_synch_en(common);
674
Sujith141b38b2009-02-04 08:10:07 +0530675mutex_unlock:
676 mutex_unlock(&sc->mutex);
677
Felix Fietkauf62d8162011-03-25 17:43:41 +0100678 ath9k_ps_restore(sc);
679
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800680 return r;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700681}
682
Johannes Berg7bb456832011-02-24 14:42:06 +0100683static void ath9k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700684{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100685 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -0700686 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Sujith528f0c62008-10-29 10:14:26 +0530687 struct ath_tx_control txctl;
Benoit Papillault1bc14882009-11-24 15:49:18 +0100688 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530689 unsigned long flags;
Sujith528f0c62008-10-29 10:14:26 +0530690
Gabor Juhos96148322009-07-24 17:27:21 +0200691 if (sc->ps_enabled) {
Jouni Malinendc8c4582009-05-19 17:01:42 +0300692 /*
693 * mac80211 does not set PM field for normal data frames, so we
694 * need to update that based on the current PS mode.
695 */
696 if (ieee80211_is_data(hdr->frame_control) &&
697 !ieee80211_is_nullfunc(hdr->frame_control) &&
698 !ieee80211_has_pm(hdr->frame_control)) {
Joe Perchesd2182b62011-12-15 14:55:53 -0800699 ath_dbg(common, PS,
Joe Perches226afe62010-12-02 19:12:37 -0800700 "Add PM=1 for a TX frame while in PS mode\n");
Jouni Malinendc8c4582009-05-19 17:01:42 +0300701 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
702 }
703 }
704
Sujith Manoharanad128862012-04-24 10:23:20 +0530705 if (unlikely(sc->sc_ah->power_mode == ATH9K_PM_NETWORK_SLEEP)) {
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300706 /*
707 * We are using PS-Poll and mac80211 can request TX while in
708 * power save mode. Need to wake up hardware for the TX to be
709 * completed and if needed, also for RX of buffered frames.
710 */
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300711 ath9k_ps_wakeup(sc);
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530712 spin_lock_irqsave(&sc->sc_pm_lock, flags);
Vasanthakumar Thiagarajanfdf76622010-05-17 18:57:55 -0700713 if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
714 ath9k_hw_setrxabort(sc->sc_ah, 0);
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300715 if (ieee80211_is_pspoll(hdr->frame_control)) {
Joe Perchesd2182b62011-12-15 14:55:53 -0800716 ath_dbg(common, PS,
Joe Perches226afe62010-12-02 19:12:37 -0800717 "Sending PS-Poll to pick a buffered frame\n");
Sujith1b04b932010-01-08 10:36:05 +0530718 sc->ps_flags |= PS_WAIT_FOR_PSPOLL_DATA;
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300719 } else {
Joe Perchesd2182b62011-12-15 14:55:53 -0800720 ath_dbg(common, PS, "Wake up to complete TX\n");
Sujith1b04b932010-01-08 10:36:05 +0530721 sc->ps_flags |= PS_WAIT_FOR_TX_ACK;
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300722 }
723 /*
724 * The actual restore operation will happen only after
Sujith Manoharanad128862012-04-24 10:23:20 +0530725 * the ps_flags bit is cleared. We are just dropping
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300726 * the ps_usecount here.
727 */
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530728 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300729 ath9k_ps_restore(sc);
730 }
731
Sujith Manoharanad128862012-04-24 10:23:20 +0530732 /*
733 * Cannot tx while the hardware is in full sleep, it first needs a full
734 * chip reset to recover from that
735 */
736 if (unlikely(sc->sc_ah->power_mode == ATH9K_PM_FULL_SLEEP)) {
737 ath_err(common, "TX while HW is in FULL_SLEEP mode\n");
738 goto exit;
739 }
740
Sujith528f0c62008-10-29 10:14:26 +0530741 memset(&txctl, 0, sizeof(struct ath_tx_control));
Felix Fietkau066dae92010-11-07 14:59:39 +0100742 txctl.txq = sc->tx.txq_map[skb_get_queue_mapping(skb)];
Sujith528f0c62008-10-29 10:14:26 +0530743
Joe Perchesd2182b62011-12-15 14:55:53 -0800744 ath_dbg(common, XMIT, "transmitting packet, skb: %p\n", skb);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700745
Jouni Malinenc52f33d2009-03-03 19:23:29 +0200746 if (ath_tx_start(hw, skb, &txctl) != 0) {
Joe Perchesd2182b62011-12-15 14:55:53 -0800747 ath_dbg(common, XMIT, "TX failed\n");
Ben Greeara5a0bca2012-04-03 09:16:55 -0700748 TX_STAT_INC(txctl.txq->axq_qnum, txfailed);
Sujith528f0c62008-10-29 10:14:26 +0530749 goto exit;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700750 }
751
Johannes Berg7bb456832011-02-24 14:42:06 +0100752 return;
Sujith528f0c62008-10-29 10:14:26 +0530753exit:
754 dev_kfree_skb_any(skb);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700755}
756
757static void ath9k_stop(struct ieee80211_hw *hw)
758{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100759 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -0700760 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -0700761 struct ath_common *common = ath9k_hw_common(ah);
Felix Fietkauc0c11742011-11-16 13:08:41 +0100762 bool prev_idle;
Sujith9c84b792008-10-29 10:17:13 +0530763
Sujith4c483812009-08-18 10:51:52 +0530764 mutex_lock(&sc->mutex);
765
Felix Fietkau9adcf442011-09-03 01:40:26 +0200766 ath_cancel_work(sc);
Rajkumar Manoharan01e18912012-03-15 05:34:27 +0530767 del_timer_sync(&sc->rx_poll_timer);
Luis R. Rodriguezc94dbff2009-07-27 11:53:04 -0700768
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530769 if (test_bit(SC_OP_INVALID, &sc->sc_flags)) {
Joe Perchesd2182b62011-12-15 14:55:53 -0800770 ath_dbg(common, ANY, "Device not present\n");
Sujith4c483812009-08-18 10:51:52 +0530771 mutex_unlock(&sc->mutex);
Sujith9c84b792008-10-29 10:17:13 +0530772 return;
773 }
774
Sujith3867cf62009-12-23 20:03:27 -0500775 /* Ensure HW is awake when we try to shut it down. */
776 ath9k_ps_wakeup(sc);
777
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700778 spin_lock_bh(&sc->sc_pcu_lock);
779
Stanislaw Gruszka203043f2011-01-25 14:08:40 +0100780 /* prevent tasklets to enable interrupts once we disable them */
781 ah->imask &= ~ATH9K_INT_GLOBAL;
782
Sujithff37e332008-11-24 12:07:55 +0530783 /* make sure h/w will not generate any interrupt
784 * before setting the invalid flag. */
Felix Fietkau4df30712010-11-08 20:54:47 +0100785 ath9k_hw_disable_interrupts(ah);
Sujithff37e332008-11-24 12:07:55 +0530786
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700787 spin_unlock_bh(&sc->sc_pcu_lock);
788
Stanislaw Gruszka203043f2011-01-25 14:08:40 +0100789 /* we can now sync irq and kill any running tasklets, since we already
790 * disabled interrupts and not holding a spin lock */
791 synchronize_irq(sc->irq);
792 tasklet_kill(&sc->intr_tq);
793 tasklet_kill(&sc->bcon_tasklet);
794
Felix Fietkauc0c11742011-11-16 13:08:41 +0100795 prev_idle = sc->ps_idle;
796 sc->ps_idle = true;
797
798 spin_lock_bh(&sc->sc_pcu_lock);
799
800 if (ah->led_pin >= 0) {
801 ath9k_hw_set_gpio(ah, ah->led_pin, 1);
802 ath9k_hw_cfg_gpio_input(ah, ah->led_pin);
803 }
804
805 ath_prepare_reset(sc, false, true);
806
807 if (sc->rx.frag) {
808 dev_kfree_skb_any(sc->rx.frag);
809 sc->rx.frag = NULL;
810 }
811
812 if (!ah->curchan)
813 ah->curchan = ath9k_cmn_get_curchannel(hw, ah);
814
815 ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
816 ath9k_hw_phy_disable(ah);
817
818 ath9k_hw_configpcipowersave(ah, true);
819
820 spin_unlock_bh(&sc->sc_pcu_lock);
821
Sujith3867cf62009-12-23 20:03:27 -0500822 ath9k_ps_restore(sc);
823
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530824 set_bit(SC_OP_INVALID, &sc->sc_flags);
Felix Fietkauc0c11742011-11-16 13:08:41 +0100825 sc->ps_idle = prev_idle;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700826
Sujith141b38b2009-02-04 08:10:07 +0530827 mutex_unlock(&sc->mutex);
828
Joe Perchesd2182b62011-12-15 14:55:53 -0800829 ath_dbg(common, CONFIG, "Driver halt\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700830}
831
Ben Greear48014162011-01-15 19:13:48 +0000832bool ath9k_uses_beacons(int type)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700833{
Ben Greear48014162011-01-15 19:13:48 +0000834 switch (type) {
Johannes Berg05c914f2008-09-11 00:01:58 +0200835 case NL80211_IFTYPE_AP:
Ben Greear48014162011-01-15 19:13:48 +0000836 case NL80211_IFTYPE_ADHOC:
Pat Erley9cb54122009-03-20 22:59:59 -0400837 case NL80211_IFTYPE_MESH_POINT:
Ben Greear48014162011-01-15 19:13:48 +0000838 return true;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700839 default:
Ben Greear48014162011-01-15 19:13:48 +0000840 return false;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700841 }
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700842}
843
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +0530844static void ath9k_reclaim_beacon(struct ath_softc *sc,
845 struct ieee80211_vif *vif)
846{
847 struct ath_vif *avp = (void *)vif->drv_priv;
848
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +0530849 ath9k_set_beaconing_status(sc, false);
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +0530850 ath_beacon_return(sc, avp);
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +0530851 ath9k_set_beaconing_status(sc, true);
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +0530852}
853
Ben Greear48014162011-01-15 19:13:48 +0000854static void ath9k_vif_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
855{
856 struct ath9k_vif_iter_data *iter_data = data;
857 int i;
858
859 if (iter_data->hw_macaddr)
860 for (i = 0; i < ETH_ALEN; i++)
861 iter_data->mask[i] &=
862 ~(iter_data->hw_macaddr[i] ^ mac[i]);
863
864 switch (vif->type) {
865 case NL80211_IFTYPE_AP:
866 iter_data->naps++;
867 break;
868 case NL80211_IFTYPE_STATION:
869 iter_data->nstations++;
870 break;
871 case NL80211_IFTYPE_ADHOC:
872 iter_data->nadhocs++;
873 break;
874 case NL80211_IFTYPE_MESH_POINT:
875 iter_data->nmeshes++;
876 break;
877 case NL80211_IFTYPE_WDS:
878 iter_data->nwds++;
879 break;
880 default:
Ben Greear48014162011-01-15 19:13:48 +0000881 break;
882 }
883}
884
885/* Called with sc->mutex held. */
886void ath9k_calculate_iter_data(struct ieee80211_hw *hw,
887 struct ieee80211_vif *vif,
888 struct ath9k_vif_iter_data *iter_data)
889{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100890 struct ath_softc *sc = hw->priv;
Ben Greear48014162011-01-15 19:13:48 +0000891 struct ath_hw *ah = sc->sc_ah;
892 struct ath_common *common = ath9k_hw_common(ah);
Ben Greear48014162011-01-15 19:13:48 +0000893
894 /*
895 * Use the hardware MAC address as reference, the hardware uses it
896 * together with the BSSID mask when matching addresses.
897 */
898 memset(iter_data, 0, sizeof(*iter_data));
899 iter_data->hw_macaddr = common->macaddr;
900 memset(&iter_data->mask, 0xff, ETH_ALEN);
901
902 if (vif)
903 ath9k_vif_iter(iter_data, vif->addr, vif);
904
905 /* Get list of all active MAC addresses */
Ben Greear48014162011-01-15 19:13:48 +0000906 ieee80211_iterate_active_interfaces_atomic(sc->hw, ath9k_vif_iter,
907 iter_data);
Ben Greear48014162011-01-15 19:13:48 +0000908}
909
910/* Called with sc->mutex held. */
911static void ath9k_calculate_summary_state(struct ieee80211_hw *hw,
912 struct ieee80211_vif *vif)
913{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100914 struct ath_softc *sc = hw->priv;
Ben Greear48014162011-01-15 19:13:48 +0000915 struct ath_hw *ah = sc->sc_ah;
916 struct ath_common *common = ath9k_hw_common(ah);
917 struct ath9k_vif_iter_data iter_data;
918
919 ath9k_calculate_iter_data(hw, vif, &iter_data);
920
921 /* Set BSSID mask. */
922 memcpy(common->bssidmask, iter_data.mask, ETH_ALEN);
923 ath_hw_setbssidmask(common);
924
925 /* Set op-mode & TSF */
926 if (iter_data.naps > 0) {
927 ath9k_hw_set_tsfadjust(ah, 1);
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530928 set_bit(SC_OP_TSF_RESET, &sc->sc_flags);
Ben Greear48014162011-01-15 19:13:48 +0000929 ah->opmode = NL80211_IFTYPE_AP;
930 } else {
931 ath9k_hw_set_tsfadjust(ah, 0);
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530932 clear_bit(SC_OP_TSF_RESET, &sc->sc_flags);
Ben Greear48014162011-01-15 19:13:48 +0000933
Javier Cardonafd5999c2011-05-03 16:57:19 -0700934 if (iter_data.nmeshes)
935 ah->opmode = NL80211_IFTYPE_MESH_POINT;
936 else if (iter_data.nwds)
Ben Greear48014162011-01-15 19:13:48 +0000937 ah->opmode = NL80211_IFTYPE_AP;
938 else if (iter_data.nadhocs)
939 ah->opmode = NL80211_IFTYPE_ADHOC;
940 else
941 ah->opmode = NL80211_IFTYPE_STATION;
942 }
943
944 /*
945 * Enable MIB interrupts when there are hardware phy counters.
946 */
Felix Fietkau198823f2012-06-15 15:25:25 +0200947 if ((iter_data.nstations + iter_data.nadhocs + iter_data.nmeshes) > 0)
Ben Greear48014162011-01-15 19:13:48 +0000948 ah->imask |= ATH9K_INT_TSFOOR;
Felix Fietkau198823f2012-06-15 15:25:25 +0200949 else
Ben Greear48014162011-01-15 19:13:48 +0000950 ah->imask &= ~ATH9K_INT_TSFOOR;
Ben Greear48014162011-01-15 19:13:48 +0000951
Felix Fietkau72d874c2011-10-08 20:06:19 +0200952 ath9k_hw_set_interrupts(ah);
Ben Greear48014162011-01-15 19:13:48 +0000953
954 /* Set up ANI */
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +0530955 if (iter_data.naps > 0) {
Rajkumar Manoharan729da3902011-05-09 19:11:29 +0530956 sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +0530957
958 if (!common->disable_ani) {
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530959 set_bit(SC_OP_ANI_RUN, &sc->sc_flags);
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +0530960 ath_start_ani(common);
961 }
962
Rajkumar Manoharanf60c49b2011-04-08 17:06:25 +0530963 } else {
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530964 clear_bit(SC_OP_ANI_RUN, &sc->sc_flags);
Rajkumar Manoharanf60c49b2011-04-08 17:06:25 +0530965 del_timer_sync(&common->ani.timer);
Ben Greear48014162011-01-15 19:13:48 +0000966 }
967}
968
969/* Called with sc->mutex held, vif counts set up properly. */
970static void ath9k_do_vif_add_setup(struct ieee80211_hw *hw,
971 struct ieee80211_vif *vif)
972{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100973 struct ath_softc *sc = hw->priv;
Ben Greear48014162011-01-15 19:13:48 +0000974
975 ath9k_calculate_summary_state(hw, vif);
976
977 if (ath9k_uses_beacons(vif->type)) {
Rajkumar Manoharaned2578c2012-04-19 19:13:51 +0530978 /* Reserve a beacon slot for the vif */
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +0530979 ath9k_set_beaconing_status(sc, false);
Rajkumar Manoharaned2578c2012-04-19 19:13:51 +0530980 ath_beacon_alloc(sc, vif);
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +0530981 ath9k_set_beaconing_status(sc, true);
Ben Greear48014162011-01-15 19:13:48 +0000982 }
983}
984
Ben Greear48014162011-01-15 19:13:48 +0000985static int ath9k_add_interface(struct ieee80211_hw *hw,
986 struct ieee80211_vif *vif)
987{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100988 struct ath_softc *sc = hw->priv;
Ben Greear48014162011-01-15 19:13:48 +0000989 struct ath_hw *ah = sc->sc_ah;
990 struct ath_common *common = ath9k_hw_common(ah);
Ben Greear48014162011-01-15 19:13:48 +0000991 int ret = 0;
992
Felix Fietkau96f372c2011-04-07 19:07:17 +0200993 ath9k_ps_wakeup(sc);
Ben Greear48014162011-01-15 19:13:48 +0000994 mutex_lock(&sc->mutex);
995
996 switch (vif->type) {
997 case NL80211_IFTYPE_STATION:
998 case NL80211_IFTYPE_WDS:
999 case NL80211_IFTYPE_ADHOC:
1000 case NL80211_IFTYPE_AP:
1001 case NL80211_IFTYPE_MESH_POINT:
1002 break;
1003 default:
1004 ath_err(common, "Interface type %d not yet supported\n",
1005 vif->type);
1006 ret = -EOPNOTSUPP;
1007 goto out;
1008 }
1009
1010 if (ath9k_uses_beacons(vif->type)) {
1011 if (sc->nbcnvifs >= ATH_BCBUF) {
1012 ath_err(common, "Not enough beacon buffers when adding"
1013 " new interface of type: %i\n",
1014 vif->type);
1015 ret = -ENOBUFS;
1016 goto out;
1017 }
1018 }
1019
Joe Perchesd2182b62011-12-15 14:55:53 -08001020 ath_dbg(common, CONFIG, "Attach a VIF of type: %d\n", vif->type);
Ben Greear48014162011-01-15 19:13:48 +00001021
Ben Greear48014162011-01-15 19:13:48 +00001022 sc->nvifs++;
1023
1024 ath9k_do_vif_add_setup(hw, vif);
1025out:
1026 mutex_unlock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001027 ath9k_ps_restore(sc);
Ben Greear48014162011-01-15 19:13:48 +00001028 return ret;
1029}
1030
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301031static int ath9k_change_interface(struct ieee80211_hw *hw,
1032 struct ieee80211_vif *vif,
1033 enum nl80211_iftype new_type,
1034 bool p2p)
1035{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001036 struct ath_softc *sc = hw->priv;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301037 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Dan Carpenter6dab55b2010-12-21 06:59:06 +03001038 int ret = 0;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301039
Joe Perchesd2182b62011-12-15 14:55:53 -08001040 ath_dbg(common, CONFIG, "Change Interface\n");
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301041 mutex_lock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001042 ath9k_ps_wakeup(sc);
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301043
Ben Greear48014162011-01-15 19:13:48 +00001044 if (ath9k_uses_beacons(new_type) &&
1045 !ath9k_uses_beacons(vif->type)) {
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301046 if (sc->nbcnvifs >= ATH_BCBUF) {
1047 ath_err(common, "No beacon slot available\n");
Dan Carpenter6dab55b2010-12-21 06:59:06 +03001048 ret = -ENOBUFS;
1049 goto out;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301050 }
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301051 }
Ben Greear48014162011-01-15 19:13:48 +00001052
1053 /* Clean up old vif stuff */
1054 if (ath9k_uses_beacons(vif->type))
1055 ath9k_reclaim_beacon(sc, vif);
1056
1057 /* Add new settings */
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301058 vif->type = new_type;
1059 vif->p2p = p2p;
1060
Ben Greear48014162011-01-15 19:13:48 +00001061 ath9k_do_vif_add_setup(hw, vif);
Dan Carpenter6dab55b2010-12-21 06:59:06 +03001062out:
Felix Fietkau96f372c2011-04-07 19:07:17 +02001063 ath9k_ps_restore(sc);
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301064 mutex_unlock(&sc->mutex);
Dan Carpenter6dab55b2010-12-21 06:59:06 +03001065 return ret;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301066}
1067
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001068static void ath9k_remove_interface(struct ieee80211_hw *hw,
Johannes Berg1ed32e42009-12-23 13:15:45 +01001069 struct ieee80211_vif *vif)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001070{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001071 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -07001072 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001073
Joe Perchesd2182b62011-12-15 14:55:53 -08001074 ath_dbg(common, CONFIG, "Detach Interface\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001075
Felix Fietkau96f372c2011-04-07 19:07:17 +02001076 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301077 mutex_lock(&sc->mutex);
1078
Ben Greear48014162011-01-15 19:13:48 +00001079 sc->nvifs--;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001080
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001081 /* Reclaim beacon resources */
Ben Greear48014162011-01-15 19:13:48 +00001082 if (ath9k_uses_beacons(vif->type))
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301083 ath9k_reclaim_beacon(sc, vif);
Jouni Malinen2c3db3d2009-03-03 19:23:26 +02001084
Ben Greear48014162011-01-15 19:13:48 +00001085 ath9k_calculate_summary_state(hw, NULL);
Sujith141b38b2009-02-04 08:10:07 +05301086
1087 mutex_unlock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001088 ath9k_ps_restore(sc);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001089}
1090
Senthil Balasubramanianfbab7392010-10-05 20:36:40 +05301091static void ath9k_enable_ps(struct ath_softc *sc)
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301092{
Pavel Roskin30691682010-03-31 18:05:31 -04001093 struct ath_hw *ah = sc->sc_ah;
Sujith Manoharanad128862012-04-24 10:23:20 +05301094 struct ath_common *common = ath9k_hw_common(ah);
Pavel Roskin30691682010-03-31 18:05:31 -04001095
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301096 sc->ps_enabled = true;
Pavel Roskin30691682010-03-31 18:05:31 -04001097 if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP)) {
1098 if ((ah->imask & ATH9K_INT_TIM_TIMER) == 0) {
1099 ah->imask |= ATH9K_INT_TIM_TIMER;
Felix Fietkau72d874c2011-10-08 20:06:19 +02001100 ath9k_hw_set_interrupts(ah);
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301101 }
Vasanthakumar Thiagarajanfdf76622010-05-17 18:57:55 -07001102 ath9k_hw_setrxabort(ah, 1);
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301103 }
Sujith Manoharanad128862012-04-24 10:23:20 +05301104 ath_dbg(common, PS, "PowerSave enabled\n");
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301105}
1106
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301107static void ath9k_disable_ps(struct ath_softc *sc)
1108{
1109 struct ath_hw *ah = sc->sc_ah;
Sujith Manoharanad128862012-04-24 10:23:20 +05301110 struct ath_common *common = ath9k_hw_common(ah);
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301111
1112 sc->ps_enabled = false;
1113 ath9k_hw_setpower(ah, ATH9K_PM_AWAKE);
1114 if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP)) {
1115 ath9k_hw_setrxabort(ah, 0);
1116 sc->ps_flags &= ~(PS_WAIT_FOR_BEACON |
1117 PS_WAIT_FOR_CAB |
1118 PS_WAIT_FOR_PSPOLL_DATA |
1119 PS_WAIT_FOR_TX_ACK);
1120 if (ah->imask & ATH9K_INT_TIM_TIMER) {
1121 ah->imask &= ~ATH9K_INT_TIM_TIMER;
Felix Fietkau72d874c2011-10-08 20:06:19 +02001122 ath9k_hw_set_interrupts(ah);
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301123 }
1124 }
Sujith Manoharanad128862012-04-24 10:23:20 +05301125 ath_dbg(common, PS, "PowerSave disabled\n");
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301126}
1127
Johannes Berge8975582008-10-09 12:18:51 +02001128static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001129{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001130 struct ath_softc *sc = hw->priv;
Felix Fietkau34300982010-10-10 18:21:52 +02001131 struct ath_hw *ah = sc->sc_ah;
1132 struct ath_common *common = ath9k_hw_common(ah);
Johannes Berge8975582008-10-09 12:18:51 +02001133 struct ieee80211_conf *conf = &hw->conf;
Felix Fietkau75600ab2012-04-12 20:36:31 +02001134 bool reset_channel = false;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001135
Felix Fietkauc0c11742011-11-16 13:08:41 +01001136 ath9k_ps_wakeup(sc);
Sujithaa33de02008-12-18 11:40:16 +05301137 mutex_lock(&sc->mutex);
Sujith141b38b2009-02-04 08:10:07 +05301138
Felix Fietkaudaa1b6e2011-11-16 13:08:43 +01001139 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
Felix Fietkau7545daf2011-01-24 19:23:16 +01001140 sc->ps_idle = !!(conf->flags & IEEE80211_CONF_IDLE);
Rajkumar Manoharanb73f3e72012-07-01 19:53:53 +05301141 if (sc->ps_idle) {
Felix Fietkaudaa1b6e2011-11-16 13:08:43 +01001142 ath_cancel_work(sc);
Rajkumar Manoharanb73f3e72012-07-01 19:53:53 +05301143 ath9k_stop_btcoex(sc);
1144 } else {
1145 ath9k_start_btcoex(sc);
Felix Fietkau75600ab2012-04-12 20:36:31 +02001146 /*
1147 * The chip needs a reset to properly wake up from
1148 * full sleep
1149 */
1150 reset_channel = ah->chip_fullsleep;
Rajkumar Manoharanb73f3e72012-07-01 19:53:53 +05301151 }
Felix Fietkaudaa1b6e2011-11-16 13:08:43 +01001152 }
Luis R. Rodriguez64839172009-07-14 20:22:53 -04001153
Luis R. Rodrigueze7824a52009-11-24 02:53:25 -05001154 /*
1155 * We just prepare to enable PS. We have to wait until our AP has
1156 * ACK'd our null data frame to disable RX otherwise we'll ignore
1157 * those ACKs and end up retransmitting the same null data frames.
1158 * IEEE80211_CONF_CHANGE_PS is only passed by mac80211 for STA mode.
1159 */
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301160 if (changed & IEEE80211_CONF_CHANGE_PS) {
Luis R. Rodriguez8ab2cd02010-09-16 15:12:26 -04001161 unsigned long flags;
1162 spin_lock_irqsave(&sc->sc_pm_lock, flags);
Senthil Balasubramanianfbab7392010-10-05 20:36:40 +05301163 if (conf->flags & IEEE80211_CONF_PS)
1164 ath9k_enable_ps(sc);
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301165 else
1166 ath9k_disable_ps(sc);
Luis R. Rodriguez8ab2cd02010-09-16 15:12:26 -04001167 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301168 }
1169
Sujith199afd92010-01-08 10:36:13 +05301170 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1171 if (conf->flags & IEEE80211_CONF_MONITOR) {
Joe Perchesd2182b62011-12-15 14:55:53 -08001172 ath_dbg(common, CONFIG, "Monitor mode is enabled\n");
Rajkumar Manoharan5f841b42010-10-27 18:31:15 +05301173 sc->sc_ah->is_monitoring = true;
1174 } else {
Joe Perchesd2182b62011-12-15 14:55:53 -08001175 ath_dbg(common, CONFIG, "Monitor mode is disabled\n");
Rajkumar Manoharan5f841b42010-10-27 18:31:15 +05301176 sc->sc_ah->is_monitoring = false;
Sujith199afd92010-01-08 10:36:13 +05301177 }
1178 }
1179
Felix Fietkau75600ab2012-04-12 20:36:31 +02001180 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL) || reset_channel) {
Sujith99405f92008-11-24 12:08:35 +05301181 struct ieee80211_channel *curchan = hw->conf.channel;
Luis R. Rodriguez5f8e0772009-01-22 15:16:48 -08001182 int pos = curchan->hw_value;
Felix Fietkau34300982010-10-10 18:21:52 +02001183 int old_pos = -1;
1184 unsigned long flags;
1185
1186 if (ah->curchan)
1187 old_pos = ah->curchan - &ah->channels[0];
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001188
Joe Perchesd2182b62011-12-15 14:55:53 -08001189 ath_dbg(common, CONFIG, "Set channel: %d MHz type: %d\n",
Ben Greear8c79a612011-02-07 13:44:33 -08001190 curchan->center_freq, conf->channel_type);
Johannes Bergae5eb022008-10-14 16:58:37 +02001191
Felix Fietkau34300982010-10-10 18:21:52 +02001192 /* update survey stats for the old channel before switching */
1193 spin_lock_irqsave(&common->cc_lock, flags);
1194 ath_update_survey_stats(sc);
1195 spin_unlock_irqrestore(&common->cc_lock, flags);
1196
1197 /*
Rajkumar Manoharane338a852011-08-13 10:28:17 +05301198 * Preserve the current channel values, before updating
1199 * the same channel
1200 */
Rajkumar Manoharan1a19f772012-01-09 15:37:53 +05301201 if (ah->curchan && (old_pos == pos))
1202 ath9k_hw_getnf(ah, ah->curchan);
Rajkumar Manoharane338a852011-08-13 10:28:17 +05301203
1204 ath9k_cmn_update_ichannel(&sc->sc_ah->channels[pos],
1205 curchan, conf->channel_type);
1206
1207 /*
Felix Fietkau34300982010-10-10 18:21:52 +02001208 * If the operating channel changes, change the survey in-use flags
1209 * along with it.
1210 * Reset the survey data for the new channel, unless we're switching
1211 * back to the operating channel from an off-channel operation.
1212 */
1213 if (!(hw->conf.flags & IEEE80211_CONF_OFFCHANNEL) &&
1214 sc->cur_survey != &sc->survey[pos]) {
1215
1216 if (sc->cur_survey)
1217 sc->cur_survey->filled &= ~SURVEY_INFO_IN_USE;
1218
1219 sc->cur_survey = &sc->survey[pos];
1220
1221 memset(sc->cur_survey, 0, sizeof(struct survey_info));
1222 sc->cur_survey->filled |= SURVEY_INFO_IN_USE;
1223 } else if (!(sc->survey[pos].filled & SURVEY_INFO_IN_USE)) {
1224 memset(&sc->survey[pos], 0, sizeof(struct survey_info));
1225 }
1226
Jouni Malinen0e2dedf2009-03-03 19:23:32 +02001227 if (ath_set_channel(sc, hw, &sc->sc_ah->channels[pos]) < 0) {
Joe Perches38002762010-12-02 19:12:36 -08001228 ath_err(common, "Unable to set channel\n");
Sujithaa33de02008-12-18 11:40:16 +05301229 mutex_unlock(&sc->mutex);
Rajkumar Manoharan8389fb32012-06-11 12:19:30 +05301230 ath9k_ps_restore(sc);
Sujithe11602b2008-11-27 09:46:27 +05301231 return -EINVAL;
1232 }
Felix Fietkau34300982010-10-10 18:21:52 +02001233
1234 /*
1235 * The most recent snapshot of channel->noisefloor for the old
1236 * channel is only available after the hardware reset. Copy it to
1237 * the survey stats now.
1238 */
1239 if (old_pos >= 0)
1240 ath_update_survey_nf(sc, old_pos);
Sujith094d05d2008-12-12 11:57:43 +05301241 }
Sujith86b89ee2008-08-07 10:54:57 +05301242
Luis R. Rodriguezc9f6a652010-01-19 14:04:19 -05001243 if (changed & IEEE80211_CONF_CHANGE_POWER) {
Joe Perchesd2182b62011-12-15 14:55:53 -08001244 ath_dbg(common, CONFIG, "Set power: %d\n", conf->power_level);
Sujith17d79042009-02-09 13:27:03 +05301245 sc->config.txpowlimit = 2 * conf->power_level;
Rajkumar Manoharan5048e8c2011-01-31 23:47:44 +05301246 ath9k_cmn_update_txpow(ah, sc->curtxpow,
1247 sc->config.txpowlimit, &sc->curtxpow);
Luis R. Rodriguez64839172009-07-14 20:22:53 -04001248 }
1249
Sujithaa33de02008-12-18 11:40:16 +05301250 mutex_unlock(&sc->mutex);
Felix Fietkauc0c11742011-11-16 13:08:41 +01001251 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301252
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001253 return 0;
1254}
1255
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001256#define SUPPORTED_FILTERS \
1257 (FIF_PROMISC_IN_BSS | \
1258 FIF_ALLMULTI | \
1259 FIF_CONTROL | \
Luis R. Rodriguezaf6a3fc2009-08-08 21:55:16 -04001260 FIF_PSPOLL | \
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001261 FIF_OTHER_BSS | \
1262 FIF_BCN_PRBRESP_PROMISC | \
Jouni Malinen9c1d8e42010-10-13 17:29:31 +03001263 FIF_PROBE_REQ | \
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001264 FIF_FCSFAIL)
1265
Sujith7dcfdcd2008-08-11 14:03:13 +05301266/* FIXME: sc->sc_full_reset ? */
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001267static void ath9k_configure_filter(struct ieee80211_hw *hw,
1268 unsigned int changed_flags,
1269 unsigned int *total_flags,
Johannes Berg3ac64be2009-08-17 16:16:53 +02001270 u64 multicast)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001271{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001272 struct ath_softc *sc = hw->priv;
Sujith7dcfdcd2008-08-11 14:03:13 +05301273 u32 rfilt;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001274
1275 changed_flags &= SUPPORTED_FILTERS;
1276 *total_flags &= SUPPORTED_FILTERS;
1277
Sujithb77f4832008-12-07 21:44:03 +05301278 sc->rx.rxfilter = *total_flags;
Jouni Malinenaa68aea2009-05-19 17:01:41 +03001279 ath9k_ps_wakeup(sc);
Sujith7dcfdcd2008-08-11 14:03:13 +05301280 rfilt = ath_calcrxfilter(sc);
1281 ath9k_hw_setrxfilter(sc->sc_ah, rfilt);
Jouni Malinenaa68aea2009-05-19 17:01:41 +03001282 ath9k_ps_restore(sc);
Sujith7dcfdcd2008-08-11 14:03:13 +05301283
Joe Perchesd2182b62011-12-15 14:55:53 -08001284 ath_dbg(ath9k_hw_common(sc->sc_ah), CONFIG, "Set HW RX filter: 0x%x\n",
1285 rfilt);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001286}
1287
Johannes Berg4ca77862010-02-19 19:06:56 +01001288static int ath9k_sta_add(struct ieee80211_hw *hw,
1289 struct ieee80211_vif *vif,
1290 struct ieee80211_sta *sta)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001291{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001292 struct ath_softc *sc = hw->priv;
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001293 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1294 struct ath_node *an = (struct ath_node *) sta->drv_priv;
1295 struct ieee80211_key_conf ps_key = { };
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001296
Ben Greear7e1e3862011-11-03 11:33:13 -07001297 ath_node_attach(sc, sta, vif);
Felix Fietkauf59a59f2011-05-10 20:52:22 +02001298
1299 if (vif->type != NL80211_IFTYPE_AP &&
1300 vif->type != NL80211_IFTYPE_AP_VLAN)
1301 return 0;
1302
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001303 an->ps_key = ath_key_config(common, vif, sta, &ps_key);
Johannes Berg4ca77862010-02-19 19:06:56 +01001304
1305 return 0;
1306}
1307
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001308static void ath9k_del_ps_key(struct ath_softc *sc,
1309 struct ieee80211_vif *vif,
1310 struct ieee80211_sta *sta)
1311{
1312 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1313 struct ath_node *an = (struct ath_node *) sta->drv_priv;
1314 struct ieee80211_key_conf ps_key = { .hw_key_idx = an->ps_key };
1315
1316 if (!an->ps_key)
1317 return;
1318
1319 ath_key_delete(common, &ps_key);
1320}
1321
Johannes Berg4ca77862010-02-19 19:06:56 +01001322static int ath9k_sta_remove(struct ieee80211_hw *hw,
1323 struct ieee80211_vif *vif,
1324 struct ieee80211_sta *sta)
1325{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001326 struct ath_softc *sc = hw->priv;
Johannes Berg4ca77862010-02-19 19:06:56 +01001327
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001328 ath9k_del_ps_key(sc, vif, sta);
Johannes Berg4ca77862010-02-19 19:06:56 +01001329 ath_node_detach(sc, sta);
1330
1331 return 0;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001332}
1333
Felix Fietkau55195412011-04-17 23:28:09 +02001334static void ath9k_sta_notify(struct ieee80211_hw *hw,
1335 struct ieee80211_vif *vif,
1336 enum sta_notify_cmd cmd,
1337 struct ieee80211_sta *sta)
1338{
1339 struct ath_softc *sc = hw->priv;
1340 struct ath_node *an = (struct ath_node *) sta->drv_priv;
1341
Sujith Manoharan3d4e20f2012-03-14 14:40:58 +05301342 if (!sta->ht_cap.ht_supported)
Mohammed Shafi Shajakhanb25bfda2011-12-26 10:42:15 +05301343 return;
1344
Felix Fietkau55195412011-04-17 23:28:09 +02001345 switch (cmd) {
1346 case STA_NOTIFY_SLEEP:
1347 an->sleeping = true;
Johannes Berg042ec452011-09-29 16:04:26 +02001348 ath_tx_aggr_sleep(sta, sc, an);
Felix Fietkau55195412011-04-17 23:28:09 +02001349 break;
1350 case STA_NOTIFY_AWAKE:
1351 an->sleeping = false;
1352 ath_tx_aggr_wakeup(sc, an);
1353 break;
1354 }
1355}
1356
Eliad Peller8a3a3c82011-10-02 10:15:52 +02001357static int ath9k_conf_tx(struct ieee80211_hw *hw,
1358 struct ieee80211_vif *vif, u16 queue,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001359 const struct ieee80211_tx_queue_params *params)
1360{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001361 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -07001362 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkau066dae92010-11-07 14:59:39 +01001363 struct ath_txq *txq;
Sujithea9880f2008-08-07 10:53:10 +05301364 struct ath9k_tx_queue_info qi;
Felix Fietkau066dae92010-11-07 14:59:39 +01001365 int ret = 0;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001366
1367 if (queue >= WME_NUM_AC)
1368 return 0;
1369
Felix Fietkau066dae92010-11-07 14:59:39 +01001370 txq = sc->tx.txq_map[queue];
1371
Felix Fietkau96f372c2011-04-07 19:07:17 +02001372 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301373 mutex_lock(&sc->mutex);
1374
Sujith1ffb0612009-03-30 15:28:46 +05301375 memset(&qi, 0, sizeof(struct ath9k_tx_queue_info));
1376
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001377 qi.tqi_aifs = params->aifs;
1378 qi.tqi_cwmin = params->cw_min;
1379 qi.tqi_cwmax = params->cw_max;
1380 qi.tqi_burstTime = params->txop;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001381
Joe Perchesd2182b62011-12-15 14:55:53 -08001382 ath_dbg(common, CONFIG,
Joe Perches226afe62010-12-02 19:12:37 -08001383 "Configure tx [queue/halq] [%d/%d], aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
1384 queue, txq->axq_qnum, params->aifs, params->cw_min,
1385 params->cw_max, params->txop);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001386
Felix Fietkau066dae92010-11-07 14:59:39 +01001387 ret = ath_txq_update(sc, txq->axq_qnum, &qi);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001388 if (ret)
Joe Perches38002762010-12-02 19:12:36 -08001389 ath_err(common, "TXQ Update failed\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001390
Vivek Natarajan94db2932009-11-25 12:01:54 +05301391 if (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC)
Felix Fietkau066dae92010-11-07 14:59:39 +01001392 if (queue == WME_AC_BE && !ret)
Vivek Natarajan94db2932009-11-25 12:01:54 +05301393 ath_beaconq_config(sc);
1394
Sujith141b38b2009-02-04 08:10:07 +05301395 mutex_unlock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001396 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301397
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001398 return ret;
1399}
1400
1401static int ath9k_set_key(struct ieee80211_hw *hw,
1402 enum set_key_cmd cmd,
Johannes Bergdc822b52008-12-29 12:55:09 +01001403 struct ieee80211_vif *vif,
1404 struct ieee80211_sta *sta,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001405 struct ieee80211_key_conf *key)
1406{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001407 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -07001408 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001409 int ret = 0;
1410
John W. Linville3e6109c2011-01-05 09:39:17 -05001411 if (ath9k_modparam_nohwcrypt)
Jouni Malinenb3bd89c2009-02-24 13:42:01 +02001412 return -ENOSPC;
1413
Chun-Yeow Yeoh5bd5e9a2011-12-07 12:45:46 -08001414 if ((vif->type == NL80211_IFTYPE_ADHOC ||
1415 vif->type == NL80211_IFTYPE_MESH_POINT) &&
Jouni Malinencfdc9a82011-03-23 14:52:19 +02001416 (key->cipher == WLAN_CIPHER_SUITE_TKIP ||
1417 key->cipher == WLAN_CIPHER_SUITE_CCMP) &&
1418 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
1419 /*
1420 * For now, disable hw crypto for the RSN IBSS group keys. This
1421 * could be optimized in the future to use a modified key cache
1422 * design to support per-STA RX GTK, but until that gets
1423 * implemented, use of software crypto for group addressed
1424 * frames is a acceptable to allow RSN IBSS to be used.
1425 */
1426 return -EOPNOTSUPP;
1427 }
1428
Sujith141b38b2009-02-04 08:10:07 +05301429 mutex_lock(&sc->mutex);
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301430 ath9k_ps_wakeup(sc);
Joe Perchesd2182b62011-12-15 14:55:53 -08001431 ath_dbg(common, CONFIG, "Set HW Key\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001432
1433 switch (cmd) {
1434 case SET_KEY:
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001435 if (sta)
1436 ath9k_del_ps_key(sc, vif, sta);
1437
Bruno Randolf040e5392010-09-08 16:05:04 +09001438 ret = ath_key_config(common, vif, sta, key);
Jouni Malinen6ace2892008-12-17 13:32:17 +02001439 if (ret >= 0) {
1440 key->hw_key_idx = ret;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001441 /* push IV and Michael MIC generation to stack */
1442 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
Johannes Berg97359d12010-08-10 09:46:38 +02001443 if (key->cipher == WLAN_CIPHER_SUITE_TKIP)
Senthil Balasubramanian1b961752008-09-01 19:45:21 +05301444 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
Johannes Berg97359d12010-08-10 09:46:38 +02001445 if (sc->sc_ah->sw_mgmt_crypto &&
1446 key->cipher == WLAN_CIPHER_SUITE_CCMP)
Jouni Malinen0ced0e12009-01-08 13:32:13 +02001447 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT;
Jouni Malinen6ace2892008-12-17 13:32:17 +02001448 ret = 0;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001449 }
1450 break;
1451 case DISABLE_KEY:
Bruno Randolf040e5392010-09-08 16:05:04 +09001452 ath_key_delete(common, key);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001453 break;
1454 default:
1455 ret = -EINVAL;
1456 }
1457
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301458 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301459 mutex_unlock(&sc->mutex);
1460
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001461 return ret;
1462}
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301463static void ath9k_bss_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
1464{
1465 struct ath_softc *sc = data;
1466 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1467 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1468 struct ath_vif *avp = (void *)vif->drv_priv;
Sujith Manoharan07c15a32012-06-04 20:24:07 +05301469 unsigned long flags;
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301470 /*
1471 * Skip iteration if primary station vif's bss info
1472 * was not changed
1473 */
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301474 if (test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags))
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301475 return;
1476
1477 if (bss_conf->assoc) {
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301478 set_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags);
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301479 avp->primary_sta_vif = true;
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301480 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1481 common->curaid = bss_conf->aid;
1482 ath9k_hw_write_associd(sc->sc_ah);
Joe Perchesd2182b62011-12-15 14:55:53 -08001483 ath_dbg(common, CONFIG, "Bss Info ASSOC %d, bssid: %pM\n",
1484 bss_conf->aid, common->curbssid);
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301485 ath_beacon_config(sc, vif);
1486 /*
1487 * Request a re-configuration of Beacon related timers
1488 * on the receipt of the first Beacon frame (i.e.,
1489 * after time sync with the AP).
1490 */
Sujith Manoharan07c15a32012-06-04 20:24:07 +05301491 spin_lock_irqsave(&sc->sc_pm_lock, flags);
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301492 sc->ps_flags |= PS_BEACON_SYNC | PS_WAIT_FOR_BEACON;
Sujith Manoharan07c15a32012-06-04 20:24:07 +05301493 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
1494
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301495 /* Reset rssi stats */
1496 sc->last_rssi = ATH_RSSI_DUMMY_MARKER;
1497 sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
Rajkumar Manoharan99e4d432011-04-04 22:56:19 +05301498
Rajkumar Manoharan01e18912012-03-15 05:34:27 +05301499 ath_start_rx_poll(sc, 3);
1500
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +05301501 if (!common->disable_ani) {
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301502 set_bit(SC_OP_ANI_RUN, &sc->sc_flags);
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +05301503 ath_start_ani(common);
1504 }
1505
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301506 }
1507}
1508
1509static void ath9k_config_bss(struct ath_softc *sc, struct ieee80211_vif *vif)
1510{
1511 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1512 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1513 struct ath_vif *avp = (void *)vif->drv_priv;
1514
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301515 if (sc->sc_ah->opmode != NL80211_IFTYPE_STATION)
1516 return;
1517
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301518 /* Reconfigure bss info */
1519 if (avp->primary_sta_vif && !bss_conf->assoc) {
Joe Perchesd2182b62011-12-15 14:55:53 -08001520 ath_dbg(common, CONFIG, "Bss Info DISASSOC %d, bssid %pM\n",
Rajkumar Manoharan99e4d432011-04-04 22:56:19 +05301521 common->curaid, common->curbssid);
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301522 clear_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags);
1523 clear_bit(SC_OP_BEACONS, &sc->sc_flags);
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301524 avp->primary_sta_vif = false;
1525 memset(common->curbssid, 0, ETH_ALEN);
1526 common->curaid = 0;
1527 }
1528
1529 ieee80211_iterate_active_interfaces_atomic(
1530 sc->hw, ath9k_bss_iter, sc);
1531
1532 /*
1533 * None of station vifs are associated.
1534 * Clear bssid & aid
1535 */
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301536 if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) {
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301537 ath9k_hw_write_associd(sc->sc_ah);
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301538 clear_bit(SC_OP_ANI_RUN, &sc->sc_flags);
Rajkumar Manoharan99e4d432011-04-04 22:56:19 +05301539 del_timer_sync(&common->ani.timer);
Rajkumar Manoharan01e18912012-03-15 05:34:27 +05301540 del_timer_sync(&sc->rx_poll_timer);
Rajkumar Manoharand2c71c22011-09-15 19:02:54 +05301541 memset(&sc->caldata, 0, sizeof(sc->caldata));
Rajkumar Manoharan99e4d432011-04-04 22:56:19 +05301542 }
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301543}
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001544
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001545static void ath9k_bss_info_changed(struct ieee80211_hw *hw,
1546 struct ieee80211_vif *vif,
1547 struct ieee80211_bss_conf *bss_conf,
1548 u32 changed)
1549{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001550 struct ath_softc *sc = hw->priv;
Johannes Berg2d0ddec2009-04-23 16:13:26 +02001551 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguez15107182009-09-10 09:22:37 -07001552 struct ath_common *common = ath9k_hw_common(ah);
Johannes Berg2d0ddec2009-04-23 16:13:26 +02001553 struct ath_vif *avp = (void *)vif->drv_priv;
Felix Fietkau0005baf2010-01-15 02:33:40 +01001554 int slottime;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001555
Felix Fietkau96f372c2011-04-07 19:07:17 +02001556 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301557 mutex_lock(&sc->mutex);
1558
Rajkumar Manoharan9f619032012-03-10 05:06:49 +05301559 if (changed & BSS_CHANGED_ASSOC) {
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301560 ath9k_config_bss(sc, vif);
Sujithc6089cc2009-11-16 11:40:48 +05301561
Joe Perchesd2182b62011-12-15 14:55:53 -08001562 ath_dbg(common, CONFIG, "BSSID: %pM aid: 0x%x\n",
Joe Perches226afe62010-12-02 19:12:37 -08001563 common->curbssid, common->curaid);
Johannes Berg2d0ddec2009-04-23 16:13:26 +02001564 }
1565
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301566 if (changed & BSS_CHANGED_IBSS) {
1567 /* There can be only one vif available */
1568 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1569 common->curaid = bss_conf->aid;
1570 ath9k_hw_write_associd(sc->sc_ah);
1571
1572 if (bss_conf->ibss_joined) {
1573 sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +05301574
1575 if (!common->disable_ani) {
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301576 set_bit(SC_OP_ANI_RUN, &sc->sc_flags);
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +05301577 ath_start_ani(common);
1578 }
1579
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301580 } else {
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301581 clear_bit(SC_OP_ANI_RUN, &sc->sc_flags);
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301582 del_timer_sync(&common->ani.timer);
Rajkumar Manoharan01e18912012-03-15 05:34:27 +05301583 del_timer_sync(&sc->rx_poll_timer);
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301584 }
1585 }
1586
Rajkumar Manoharaned2578c2012-04-19 19:13:51 +05301587 /*
1588 * In case of AP mode, the HW TSF has to be reset
1589 * when the beacon interval changes.
1590 */
1591 if ((changed & BSS_CHANGED_BEACON_INT) &&
1592 (vif->type == NL80211_IFTYPE_AP))
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301593 set_bit(SC_OP_TSF_RESET, &sc->sc_flags);
Rajkumar Manoharaned2578c2012-04-19 19:13:51 +05301594
1595 /* Configure beaconing (AP, IBSS, MESH) */
1596 if (ath9k_uses_beacons(vif->type) &&
1597 ((changed & BSS_CHANGED_BEACON) ||
1598 (changed & BSS_CHANGED_BEACON_ENABLED) ||
1599 (changed & BSS_CHANGED_BEACON_INT))) {
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +05301600 ath9k_set_beaconing_status(sc, false);
Rajkumar Manoharaned2578c2012-04-19 19:13:51 +05301601 if (bss_conf->enable_beacon)
1602 ath_beacon_alloc(sc, vif);
1603 else
1604 avp->is_bslot_active = false;
1605 ath_beacon_config(sc, vif);
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +05301606 ath9k_set_beaconing_status(sc, true);
Johannes Berg2d0ddec2009-04-23 16:13:26 +02001607 }
1608
Felix Fietkau0005baf2010-01-15 02:33:40 +01001609 if (changed & BSS_CHANGED_ERP_SLOT) {
1610 if (bss_conf->use_short_slot)
1611 slottime = 9;
1612 else
1613 slottime = 20;
1614 if (vif->type == NL80211_IFTYPE_AP) {
1615 /*
1616 * Defer update, so that connected stations can adjust
1617 * their settings at the same time.
1618 * See beacon.c for more details
1619 */
1620 sc->beacon.slottime = slottime;
1621 sc->beacon.updateslot = UPDATE;
1622 } else {
1623 ah->slottime = slottime;
1624 ath9k_hw_init_global_settings(ah);
1625 }
1626 }
1627
Sujith141b38b2009-02-04 08:10:07 +05301628 mutex_unlock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001629 ath9k_ps_restore(sc);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001630}
1631
Eliad Peller37a41b42011-09-21 14:06:11 +03001632static u64 ath9k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001633{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001634 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001635 u64 tsf;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001636
Sujith141b38b2009-02-04 08:10:07 +05301637 mutex_lock(&sc->mutex);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05301638 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301639 tsf = ath9k_hw_gettsf64(sc->sc_ah);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05301640 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301641 mutex_unlock(&sc->mutex);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001642
1643 return tsf;
1644}
1645
Eliad Peller37a41b42011-09-21 14:06:11 +03001646static void ath9k_set_tsf(struct ieee80211_hw *hw,
1647 struct ieee80211_vif *vif,
1648 u64 tsf)
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01001649{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001650 struct ath_softc *sc = hw->priv;
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01001651
Sujith141b38b2009-02-04 08:10:07 +05301652 mutex_lock(&sc->mutex);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05301653 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301654 ath9k_hw_settsf64(sc->sc_ah, tsf);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05301655 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301656 mutex_unlock(&sc->mutex);
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01001657}
1658
Eliad Peller37a41b42011-09-21 14:06:11 +03001659static void ath9k_reset_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001660{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001661 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001662
Sujith141b38b2009-02-04 08:10:07 +05301663 mutex_lock(&sc->mutex);
Luis R. Rodriguez21526d52009-09-09 20:05:39 -07001664
1665 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301666 ath9k_hw_reset_tsf(sc->sc_ah);
Luis R. Rodriguez21526d52009-09-09 20:05:39 -07001667 ath9k_ps_restore(sc);
1668
Sujith141b38b2009-02-04 08:10:07 +05301669 mutex_unlock(&sc->mutex);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001670}
1671
1672static int ath9k_ampdu_action(struct ieee80211_hw *hw,
Johannes Bergc951ad32009-11-16 12:00:38 +01001673 struct ieee80211_vif *vif,
Sujith141b38b2009-02-04 08:10:07 +05301674 enum ieee80211_ampdu_mlme_action action,
1675 struct ieee80211_sta *sta,
Johannes Berg0b01f032011-01-18 13:51:05 +01001676 u16 tid, u16 *ssn, u8 buf_size)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001677{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001678 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001679 int ret = 0;
1680
Johannes Berg85ad1812010-06-10 10:21:49 +02001681 local_bh_disable();
1682
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001683 switch (action) {
1684 case IEEE80211_AMPDU_RX_START:
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001685 break;
1686 case IEEE80211_AMPDU_RX_STOP:
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001687 break;
1688 case IEEE80211_AMPDU_TX_START:
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001689 ath9k_ps_wakeup(sc);
Felix Fietkau231c3a12010-09-20 19:35:28 +02001690 ret = ath_tx_aggr_start(sc, sta, tid, ssn);
1691 if (!ret)
1692 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001693 ath9k_ps_restore(sc);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001694 break;
1695 case IEEE80211_AMPDU_TX_STOP:
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001696 ath9k_ps_wakeup(sc);
Sujithf83da962009-07-23 15:32:37 +05301697 ath_tx_aggr_stop(sc, sta, tid);
Johannes Bergc951ad32009-11-16 12:00:38 +01001698 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001699 ath9k_ps_restore(sc);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001700 break;
Johannes Bergb1720232009-03-23 17:28:39 +01001701 case IEEE80211_AMPDU_TX_OPERATIONAL:
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001702 ath9k_ps_wakeup(sc);
Sujith8469cde2008-10-29 10:19:28 +05301703 ath_tx_aggr_resume(sc, sta, tid);
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001704 ath9k_ps_restore(sc);
Sujith8469cde2008-10-29 10:19:28 +05301705 break;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001706 default:
Joe Perches38002762010-12-02 19:12:36 -08001707 ath_err(ath9k_hw_common(sc->sc_ah), "Unknown AMPDU action\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001708 }
1709
Johannes Berg85ad1812010-06-10 10:21:49 +02001710 local_bh_enable();
1711
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001712 return ret;
1713}
1714
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001715static int ath9k_get_survey(struct ieee80211_hw *hw, int idx,
1716 struct survey_info *survey)
1717{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001718 struct ath_softc *sc = hw->priv;
Felix Fietkau34300982010-10-10 18:21:52 +02001719 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkau39162db2010-09-29 19:12:06 +02001720 struct ieee80211_supported_band *sband;
Felix Fietkau34300982010-10-10 18:21:52 +02001721 struct ieee80211_channel *chan;
1722 unsigned long flags;
1723 int pos;
1724
1725 spin_lock_irqsave(&common->cc_lock, flags);
1726 if (idx == 0)
1727 ath_update_survey_stats(sc);
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001728
Felix Fietkau39162db2010-09-29 19:12:06 +02001729 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
1730 if (sband && idx >= sband->n_channels) {
1731 idx -= sband->n_channels;
1732 sband = NULL;
1733 }
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001734
Felix Fietkau39162db2010-09-29 19:12:06 +02001735 if (!sband)
1736 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
1737
Felix Fietkau34300982010-10-10 18:21:52 +02001738 if (!sband || idx >= sband->n_channels) {
1739 spin_unlock_irqrestore(&common->cc_lock, flags);
1740 return -ENOENT;
Felix Fietkau4f1a5a42010-09-29 17:15:28 +02001741 }
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001742
Felix Fietkau34300982010-10-10 18:21:52 +02001743 chan = &sband->channels[idx];
1744 pos = chan->hw_value;
1745 memcpy(survey, &sc->survey[pos], sizeof(*survey));
1746 survey->channel = chan;
1747 spin_unlock_irqrestore(&common->cc_lock, flags);
1748
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001749 return 0;
1750}
1751
Felix Fietkaue239d852010-01-15 02:34:58 +01001752static void ath9k_set_coverage_class(struct ieee80211_hw *hw, u8 coverage_class)
1753{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001754 struct ath_softc *sc = hw->priv;
Felix Fietkaue239d852010-01-15 02:34:58 +01001755 struct ath_hw *ah = sc->sc_ah;
1756
1757 mutex_lock(&sc->mutex);
1758 ah->coverage_class = coverage_class;
Mohammed Shafi Shajakhan8b2a38272011-08-24 21:38:07 +05301759
1760 ath9k_ps_wakeup(sc);
Felix Fietkaue239d852010-01-15 02:34:58 +01001761 ath9k_hw_init_global_settings(ah);
Mohammed Shafi Shajakhan8b2a38272011-08-24 21:38:07 +05301762 ath9k_ps_restore(sc);
1763
Felix Fietkaue239d852010-01-15 02:34:58 +01001764 mutex_unlock(&sc->mutex);
1765}
1766
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001767static void ath9k_flush(struct ieee80211_hw *hw, bool drop)
1768{
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001769 struct ath_softc *sc = hw->priv;
Mohammed Shafi Shajakhan99aa55b2011-05-06 20:43:11 +05301770 struct ath_hw *ah = sc->sc_ah;
1771 struct ath_common *common = ath9k_hw_common(ah);
Felix Fietkau86271e42011-03-11 21:38:19 +01001772 int timeout = 200; /* ms */
1773 int i, j;
Rajkumar Manoharan2f6fc352011-04-28 15:31:57 +05301774 bool drain_txq;
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001775
1776 mutex_lock(&sc->mutex);
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001777 cancel_delayed_work_sync(&sc->tx_complete_work);
1778
Mohammed Shafi Shajakhan6a6b3f32011-09-09 10:41:08 +05301779 if (ah->ah_flags & AH_UNPLUGGED) {
Joe Perchesd2182b62011-12-15 14:55:53 -08001780 ath_dbg(common, ANY, "Device has been unplugged!\n");
Mohammed Shafi Shajakhan6a6b3f32011-09-09 10:41:08 +05301781 mutex_unlock(&sc->mutex);
1782 return;
1783 }
1784
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301785 if (test_bit(SC_OP_INVALID, &sc->sc_flags)) {
Joe Perchesd2182b62011-12-15 14:55:53 -08001786 ath_dbg(common, ANY, "Device not present\n");
Mohammed Shafi Shajakhan99aa55b2011-05-06 20:43:11 +05301787 mutex_unlock(&sc->mutex);
1788 return;
1789 }
1790
Felix Fietkau86271e42011-03-11 21:38:19 +01001791 for (j = 0; j < timeout; j++) {
Mohammed Shafi Shajakhan108697c2011-05-13 20:59:42 +05301792 bool npend = false;
Felix Fietkau86271e42011-03-11 21:38:19 +01001793
1794 if (j)
1795 usleep_range(1000, 2000);
1796
1797 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
1798 if (!ATH_TXQ_SETUP(sc, i))
1799 continue;
1800
Mohammed Shafi Shajakhan108697c2011-05-13 20:59:42 +05301801 npend = ath9k_has_pending_frames(sc, &sc->tx.txq[i]);
1802
1803 if (npend)
1804 break;
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001805 }
1806
Felix Fietkau86271e42011-03-11 21:38:19 +01001807 if (!npend)
Felix Fietkau9df0d6a2011-11-16 13:08:42 +01001808 break;
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001809 }
1810
Felix Fietkau9df0d6a2011-11-16 13:08:42 +01001811 if (drop) {
1812 ath9k_ps_wakeup(sc);
1813 spin_lock_bh(&sc->sc_pcu_lock);
1814 drain_txq = ath_drain_all_txq(sc, false);
1815 spin_unlock_bh(&sc->sc_pcu_lock);
Felix Fietkau9adcf442011-09-03 01:40:26 +02001816
Felix Fietkau9df0d6a2011-11-16 13:08:42 +01001817 if (!drain_txq)
1818 ath_reset(sc, false);
Felix Fietkau9adcf442011-09-03 01:40:26 +02001819
Felix Fietkau9df0d6a2011-11-16 13:08:42 +01001820 ath9k_ps_restore(sc);
1821 ieee80211_wake_queues(hw);
1822 }
Senthil Balasubramaniand78f4b32011-03-23 23:07:22 +05301823
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001824 ieee80211_queue_delayed_work(hw, &sc->tx_complete_work, 0);
1825 mutex_unlock(&sc->mutex);
1826}
1827
Vivek Natarajan15b91e82011-04-06 11:41:11 +05301828static bool ath9k_tx_frames_pending(struct ieee80211_hw *hw)
1829{
1830 struct ath_softc *sc = hw->priv;
1831 int i;
1832
1833 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
1834 if (!ATH_TXQ_SETUP(sc, i))
1835 continue;
1836
1837 if (ath9k_has_pending_frames(sc, &sc->tx.txq[i]))
1838 return true;
1839 }
1840 return false;
1841}
1842
Mohammed Shafi Shajakhan5595f112011-05-19 18:08:57 +05301843static int ath9k_tx_last_beacon(struct ieee80211_hw *hw)
Felix Fietkauba4903f2011-05-17 21:09:54 +02001844{
1845 struct ath_softc *sc = hw->priv;
1846 struct ath_hw *ah = sc->sc_ah;
1847 struct ieee80211_vif *vif;
1848 struct ath_vif *avp;
1849 struct ath_buf *bf;
1850 struct ath_tx_status ts;
Felix Fietkau4286df62012-02-27 19:58:40 +01001851 bool edma = !!(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA);
Felix Fietkauba4903f2011-05-17 21:09:54 +02001852 int status;
1853
1854 vif = sc->beacon.bslot[0];
1855 if (!vif)
1856 return 0;
1857
1858 avp = (void *)vif->drv_priv;
1859 if (!avp->is_bslot_active)
1860 return 0;
1861
Felix Fietkau4286df62012-02-27 19:58:40 +01001862 if (!sc->beacon.tx_processed && !edma) {
Felix Fietkauba4903f2011-05-17 21:09:54 +02001863 tasklet_disable(&sc->bcon_tasklet);
1864
1865 bf = avp->av_bcbuf;
1866 if (!bf || !bf->bf_mpdu)
1867 goto skip;
1868
1869 status = ath9k_hw_txprocdesc(ah, bf->bf_desc, &ts);
1870 if (status == -EINPROGRESS)
1871 goto skip;
1872
1873 sc->beacon.tx_processed = true;
1874 sc->beacon.tx_last = !(ts.ts_status & ATH9K_TXERR_MASK);
1875
1876skip:
1877 tasklet_enable(&sc->bcon_tasklet);
1878 }
1879
1880 return sc->beacon.tx_last;
1881}
1882
Mohammed Shafi Shajakhan52c94f42011-08-20 17:21:42 +05301883static int ath9k_get_stats(struct ieee80211_hw *hw,
1884 struct ieee80211_low_level_stats *stats)
1885{
1886 struct ath_softc *sc = hw->priv;
1887 struct ath_hw *ah = sc->sc_ah;
1888 struct ath9k_mib_stats *mib_stats = &ah->ah_mibStats;
1889
1890 stats->dot11ACKFailureCount = mib_stats->ackrcv_bad;
1891 stats->dot11RTSFailureCount = mib_stats->rts_bad;
1892 stats->dot11FCSErrorCount = mib_stats->fcs_bad;
1893 stats->dot11RTSSuccessCount = mib_stats->rts_good;
1894 return 0;
1895}
1896
Felix Fietkau43c35282011-09-03 01:40:27 +02001897static u32 fill_chainmask(u32 cap, u32 new)
1898{
1899 u32 filled = 0;
1900 int i;
1901
1902 for (i = 0; cap && new; i++, cap >>= 1) {
1903 if (!(cap & BIT(0)))
1904 continue;
1905
1906 if (new & BIT(0))
1907 filled |= BIT(i);
1908
1909 new >>= 1;
1910 }
1911
1912 return filled;
1913}
1914
1915static int ath9k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
1916{
1917 struct ath_softc *sc = hw->priv;
1918 struct ath_hw *ah = sc->sc_ah;
1919
1920 if (!rx_ant || !tx_ant)
1921 return -EINVAL;
1922
1923 sc->ant_rx = rx_ant;
1924 sc->ant_tx = tx_ant;
1925
1926 if (ah->caps.rx_chainmask == 1)
1927 return 0;
1928
1929 /* AR9100 runs into calibration issues if not all rx chains are enabled */
1930 if (AR_SREV_9100(ah))
1931 ah->rxchainmask = 0x7;
1932 else
1933 ah->rxchainmask = fill_chainmask(ah->caps.rx_chainmask, rx_ant);
1934
1935 ah->txchainmask = fill_chainmask(ah->caps.tx_chainmask, tx_ant);
1936 ath9k_reload_chainmask_settings(sc);
1937
1938 return 0;
1939}
1940
1941static int ath9k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
1942{
1943 struct ath_softc *sc = hw->priv;
1944
1945 *tx_ant = sc->ant_tx;
1946 *rx_ant = sc->ant_rx;
1947 return 0;
1948}
1949
Ben Greearb90bd9d2012-05-15 15:33:25 -07001950#ifdef CONFIG_ATH9K_DEBUGFS
1951
1952/* Ethtool support for get-stats */
1953
1954#define AMKSTR(nm) #nm "_BE", #nm "_BK", #nm "_VI", #nm "_VO"
1955static const char ath9k_gstrings_stats[][ETH_GSTRING_LEN] = {
1956 "tx_pkts_nic",
1957 "tx_bytes_nic",
1958 "rx_pkts_nic",
1959 "rx_bytes_nic",
1960 AMKSTR(d_tx_pkts),
1961 AMKSTR(d_tx_bytes),
1962 AMKSTR(d_tx_mpdus_queued),
1963 AMKSTR(d_tx_mpdus_completed),
1964 AMKSTR(d_tx_mpdu_xretries),
1965 AMKSTR(d_tx_aggregates),
1966 AMKSTR(d_tx_ampdus_queued_hw),
1967 AMKSTR(d_tx_ampdus_queued_sw),
1968 AMKSTR(d_tx_ampdus_completed),
1969 AMKSTR(d_tx_ampdu_retries),
1970 AMKSTR(d_tx_ampdu_xretries),
1971 AMKSTR(d_tx_fifo_underrun),
1972 AMKSTR(d_tx_op_exceeded),
1973 AMKSTR(d_tx_timer_expiry),
1974 AMKSTR(d_tx_desc_cfg_err),
1975 AMKSTR(d_tx_data_underrun),
1976 AMKSTR(d_tx_delim_underrun),
1977
1978 "d_rx_decrypt_crc_err",
1979 "d_rx_phy_err",
1980 "d_rx_mic_err",
1981 "d_rx_pre_delim_crc_err",
1982 "d_rx_post_delim_crc_err",
1983 "d_rx_decrypt_busy_err",
1984
1985 "d_rx_phyerr_radar",
1986 "d_rx_phyerr_ofdm_timing",
1987 "d_rx_phyerr_cck_timing",
1988
1989};
1990#define ATH9K_SSTATS_LEN ARRAY_SIZE(ath9k_gstrings_stats)
1991
1992static void ath9k_get_et_strings(struct ieee80211_hw *hw,
1993 struct ieee80211_vif *vif,
1994 u32 sset, u8 *data)
1995{
1996 if (sset == ETH_SS_STATS)
1997 memcpy(data, *ath9k_gstrings_stats,
1998 sizeof(ath9k_gstrings_stats));
1999}
2000
2001static int ath9k_get_et_sset_count(struct ieee80211_hw *hw,
2002 struct ieee80211_vif *vif, int sset)
2003{
2004 if (sset == ETH_SS_STATS)
2005 return ATH9K_SSTATS_LEN;
2006 return 0;
2007}
2008
2009#define PR_QNUM(_n) (sc->tx.txq_map[_n]->axq_qnum)
2010#define AWDATA(elem) \
2011 do { \
2012 data[i++] = sc->debug.stats.txstats[PR_QNUM(WME_AC_BE)].elem; \
2013 data[i++] = sc->debug.stats.txstats[PR_QNUM(WME_AC_BK)].elem; \
2014 data[i++] = sc->debug.stats.txstats[PR_QNUM(WME_AC_VI)].elem; \
2015 data[i++] = sc->debug.stats.txstats[PR_QNUM(WME_AC_VO)].elem; \
2016 } while (0)
2017
2018#define AWDATA_RX(elem) \
2019 do { \
2020 data[i++] = sc->debug.stats.rxstats.elem; \
2021 } while (0)
2022
2023static void ath9k_get_et_stats(struct ieee80211_hw *hw,
2024 struct ieee80211_vif *vif,
2025 struct ethtool_stats *stats, u64 *data)
2026{
2027 struct ath_softc *sc = hw->priv;
2028 int i = 0;
2029
2030 data[i++] = (sc->debug.stats.txstats[PR_QNUM(WME_AC_BE)].tx_pkts_all +
2031 sc->debug.stats.txstats[PR_QNUM(WME_AC_BK)].tx_pkts_all +
2032 sc->debug.stats.txstats[PR_QNUM(WME_AC_VI)].tx_pkts_all +
2033 sc->debug.stats.txstats[PR_QNUM(WME_AC_VO)].tx_pkts_all);
2034 data[i++] = (sc->debug.stats.txstats[PR_QNUM(WME_AC_BE)].tx_bytes_all +
2035 sc->debug.stats.txstats[PR_QNUM(WME_AC_BK)].tx_bytes_all +
2036 sc->debug.stats.txstats[PR_QNUM(WME_AC_VI)].tx_bytes_all +
2037 sc->debug.stats.txstats[PR_QNUM(WME_AC_VO)].tx_bytes_all);
2038 AWDATA_RX(rx_pkts_all);
2039 AWDATA_RX(rx_bytes_all);
2040
2041 AWDATA(tx_pkts_all);
2042 AWDATA(tx_bytes_all);
2043 AWDATA(queued);
2044 AWDATA(completed);
2045 AWDATA(xretries);
2046 AWDATA(a_aggr);
2047 AWDATA(a_queued_hw);
2048 AWDATA(a_queued_sw);
2049 AWDATA(a_completed);
2050 AWDATA(a_retries);
2051 AWDATA(a_xretries);
2052 AWDATA(fifo_underrun);
2053 AWDATA(xtxop);
2054 AWDATA(timer_exp);
2055 AWDATA(desc_cfg_err);
2056 AWDATA(data_underrun);
2057 AWDATA(delim_underrun);
2058
2059 AWDATA_RX(decrypt_crc_err);
2060 AWDATA_RX(phy_err);
2061 AWDATA_RX(mic_err);
2062 AWDATA_RX(pre_delim_crc_err);
2063 AWDATA_RX(post_delim_crc_err);
2064 AWDATA_RX(decrypt_busy_err);
2065
2066 AWDATA_RX(phy_err_stats[ATH9K_PHYERR_RADAR]);
2067 AWDATA_RX(phy_err_stats[ATH9K_PHYERR_OFDM_TIMING]);
2068 AWDATA_RX(phy_err_stats[ATH9K_PHYERR_CCK_TIMING]);
2069
2070 WARN_ON(i != ATH9K_SSTATS_LEN);
2071}
2072
2073/* End of ethtool get-stats functions */
2074
2075#endif
2076
2077
Gabor Juhos6baff7f2009-01-14 20:17:06 +01002078struct ieee80211_ops ath9k_ops = {
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002079 .tx = ath9k_tx,
2080 .start = ath9k_start,
2081 .stop = ath9k_stop,
2082 .add_interface = ath9k_add_interface,
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05302083 .change_interface = ath9k_change_interface,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002084 .remove_interface = ath9k_remove_interface,
2085 .config = ath9k_config,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002086 .configure_filter = ath9k_configure_filter,
Johannes Berg4ca77862010-02-19 19:06:56 +01002087 .sta_add = ath9k_sta_add,
2088 .sta_remove = ath9k_sta_remove,
Felix Fietkau55195412011-04-17 23:28:09 +02002089 .sta_notify = ath9k_sta_notify,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002090 .conf_tx = ath9k_conf_tx,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002091 .bss_info_changed = ath9k_bss_info_changed,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002092 .set_key = ath9k_set_key,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002093 .get_tsf = ath9k_get_tsf,
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01002094 .set_tsf = ath9k_set_tsf,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002095 .reset_tsf = ath9k_reset_tsf,
Johannes Berg4233df62008-10-13 13:35:05 +02002096 .ampdu_action = ath9k_ampdu_action,
Benoit Papillault62dad5b2010-04-28 00:08:24 +02002097 .get_survey = ath9k_get_survey,
Johannes Berg3b319aa2009-06-13 14:50:26 +05302098 .rfkill_poll = ath9k_rfkill_poll_state,
Felix Fietkaue239d852010-01-15 02:34:58 +01002099 .set_coverage_class = ath9k_set_coverage_class,
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002100 .flush = ath9k_flush,
Vivek Natarajan15b91e82011-04-06 11:41:11 +05302101 .tx_frames_pending = ath9k_tx_frames_pending,
Mohammed Shafi Shajakhan52c94f42011-08-20 17:21:42 +05302102 .tx_last_beacon = ath9k_tx_last_beacon,
2103 .get_stats = ath9k_get_stats,
Felix Fietkau43c35282011-09-03 01:40:27 +02002104 .set_antenna = ath9k_set_antenna,
2105 .get_antenna = ath9k_get_antenna,
Ben Greearb90bd9d2012-05-15 15:33:25 -07002106
2107#ifdef CONFIG_ATH9K_DEBUGFS
2108 .get_et_sset_count = ath9k_get_et_sset_count,
2109 .get_et_stats = ath9k_get_et_stats,
2110 .get_et_strings = ath9k_get_et_strings,
2111#endif
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002112};