blob: 34d6f26c6bc74d474c682a3521af78068a5f5606 [file] [log] [blame]
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001/*
Sujith Manoharan5b681382011-05-17 13:36:18 +05302 * Copyright (c) 2008-2011 Atheros Communications Inc.
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07003 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
Luis R. Rodriguezf078f202008-08-04 00:16:41 -070017#include <linux/nl80211.h>
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -080018#include <linux/delay.h>
Sujith394cf0a2009-02-09 13:26:54 +053019#include "ath9k.h"
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -070020#include "btcoex.h"
Luis R. Rodriguezf078f202008-08-04 00:16:41 -070021
Sujithff37e332008-11-24 12:07:55 +053022static u8 parse_mpdudensity(u8 mpdudensity)
23{
24 /*
25 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
26 * 0 for no restriction
27 * 1 for 1/4 us
28 * 2 for 1/2 us
29 * 3 for 1 us
30 * 4 for 2 us
31 * 5 for 4 us
32 * 6 for 8 us
33 * 7 for 16 us
34 */
35 switch (mpdudensity) {
36 case 0:
37 return 0;
38 case 1:
39 case 2:
40 case 3:
41 /* Our lower layer calculations limit our precision to
42 1 microsecond */
43 return 1;
44 case 4:
45 return 2;
46 case 5:
47 return 4;
48 case 6:
49 return 8;
50 case 7:
51 return 16;
52 default:
53 return 0;
54 }
55}
56
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -080057static bool ath9k_has_pending_frames(struct ath_softc *sc, struct ath_txq *txq)
58{
59 bool pending = false;
60
61 spin_lock_bh(&txq->axq_lock);
62
63 if (txq->axq_depth || !list_empty(&txq->axq_acq))
64 pending = true;
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -080065
66 spin_unlock_bh(&txq->axq_lock);
67 return pending;
68}
69
Mohammed Shafi Shajakhan6d79cb42011-05-19 17:40:46 +053070static bool ath9k_setpower(struct ath_softc *sc, enum ath9k_power_mode mode)
Luis R. Rodriguez8c77a562009-09-09 21:02:34 -070071{
72 unsigned long flags;
73 bool ret;
74
Luis R. Rodriguez9ecdef42009-09-09 21:10:09 -070075 spin_lock_irqsave(&sc->sc_pm_lock, flags);
76 ret = ath9k_hw_setpower(sc->sc_ah, mode);
77 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
Luis R. Rodriguez8c77a562009-09-09 21:02:34 -070078
79 return ret;
80}
81
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -070082void ath9k_ps_wakeup(struct ath_softc *sc)
83{
Felix Fietkau898c9142010-10-12 14:02:53 +020084 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -070085 unsigned long flags;
Felix Fietkaufbb078f2010-11-03 01:36:51 +010086 enum ath9k_power_mode power_mode;
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -070087
88 spin_lock_irqsave(&sc->sc_pm_lock, flags);
89 if (++sc->ps_usecount != 1)
90 goto unlock;
91
Felix Fietkaufbb078f2010-11-03 01:36:51 +010092 power_mode = sc->sc_ah->power_mode;
Luis R. Rodriguez9ecdef42009-09-09 21:10:09 -070093 ath9k_hw_setpower(sc->sc_ah, ATH9K_PM_AWAKE);
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -070094
Felix Fietkau898c9142010-10-12 14:02:53 +020095 /*
96 * While the hardware is asleep, the cycle counters contain no
97 * useful data. Better clear them now so that they don't mess up
98 * survey data results.
99 */
Felix Fietkaufbb078f2010-11-03 01:36:51 +0100100 if (power_mode != ATH9K_PM_AWAKE) {
101 spin_lock(&common->cc_lock);
102 ath_hw_cycle_counters_update(common);
103 memset(&common->cc_survey, 0, sizeof(common->cc_survey));
Rajkumar Manoharanc9ae6ab2012-06-04 16:28:41 +0530104 memset(&common->cc_ani, 0, sizeof(common->cc_ani));
Felix Fietkaufbb078f2010-11-03 01:36:51 +0100105 spin_unlock(&common->cc_lock);
106 }
Felix Fietkau898c9142010-10-12 14:02:53 +0200107
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -0700108 unlock:
109 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
110}
111
112void ath9k_ps_restore(struct ath_softc *sc)
113{
Felix Fietkau898c9142010-10-12 14:02:53 +0200114 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkauc6c539f2011-09-14 21:24:24 +0200115 enum ath9k_power_mode mode;
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -0700116 unsigned long flags;
Sujith Manoharanad128862012-04-24 10:23:20 +0530117 bool reset;
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -0700118
119 spin_lock_irqsave(&sc->sc_pm_lock, flags);
120 if (--sc->ps_usecount != 0)
121 goto unlock;
122
Sujith Manoharanad128862012-04-24 10:23:20 +0530123 if (sc->ps_idle) {
124 ath9k_hw_setrxabort(sc->sc_ah, 1);
125 ath9k_hw_stopdmarecv(sc->sc_ah, &reset);
Felix Fietkauc6c539f2011-09-14 21:24:24 +0200126 mode = ATH9K_PM_FULL_SLEEP;
Sujith Manoharanad128862012-04-24 10:23:20 +0530127 } else if (sc->ps_enabled &&
128 !(sc->ps_flags & (PS_WAIT_FOR_BEACON |
129 PS_WAIT_FOR_CAB |
130 PS_WAIT_FOR_PSPOLL_DATA |
131 PS_WAIT_FOR_TX_ACK))) {
Felix Fietkauc6c539f2011-09-14 21:24:24 +0200132 mode = ATH9K_PM_NETWORK_SLEEP;
Sujith Manoharanad128862012-04-24 10:23:20 +0530133 } else {
Felix Fietkauc6c539f2011-09-14 21:24:24 +0200134 goto unlock;
Sujith Manoharanad128862012-04-24 10:23:20 +0530135 }
Felix Fietkauc6c539f2011-09-14 21:24:24 +0200136
137 spin_lock(&common->cc_lock);
138 ath_hw_cycle_counters_update(common);
139 spin_unlock(&common->cc_lock);
140
Felix Fietkau1a8f0d392011-09-22 08:04:32 -0600141 ath9k_hw_setpower(sc->sc_ah, mode);
Luis R. Rodrigueza91d75a2009-09-09 20:29:18 -0700142
143 unlock:
144 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
145}
146
Felix Fietkau9adcf442011-09-03 01:40:26 +0200147static void __ath_cancel_work(struct ath_softc *sc)
148{
149 cancel_work_sync(&sc->paprd_work);
150 cancel_work_sync(&sc->hw_check_work);
151 cancel_delayed_work_sync(&sc->tx_complete_work);
152 cancel_delayed_work_sync(&sc->hw_pll_work);
153}
154
155static void ath_cancel_work(struct ath_softc *sc)
156{
157 __ath_cancel_work(sc);
158 cancel_work_sync(&sc->hw_reset_work);
159}
160
Sujith Manoharanaf68aba2012-06-04 20:23:43 +0530161static void ath_restart_work(struct ath_softc *sc)
162{
163 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
164
165 ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work, 0);
166
167 if (AR_SREV_9485(sc->sc_ah) || AR_SREV_9340(sc->sc_ah))
168 ieee80211_queue_delayed_work(sc->hw, &sc->hw_pll_work,
169 msecs_to_jiffies(ATH_PLL_WORK_INTERVAL));
170
171 ath_start_rx_poll(sc, 3);
172
173 if (!common->disable_ani)
174 ath_start_ani(common);
175}
176
Felix Fietkau9adcf442011-09-03 01:40:26 +0200177static bool ath_prepare_reset(struct ath_softc *sc, bool retry_tx, bool flush)
178{
179 struct ath_hw *ah = sc->sc_ah;
180 struct ath_common *common = ath9k_hw_common(ah);
Felix Fietkauceea2a52012-05-24 14:32:19 +0200181 bool ret = true;
Felix Fietkau9adcf442011-09-03 01:40:26 +0200182
183 ieee80211_stop_queues(sc->hw);
184
185 sc->hw_busy_count = 0;
186 del_timer_sync(&common->ani.timer);
Rajkumar Manoharan01e18912012-03-15 05:34:27 +0530187 del_timer_sync(&sc->rx_poll_timer);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200188
189 ath9k_debug_samp_bb_mac(sc);
190 ath9k_hw_disable_interrupts(ah);
191
Felix Fietkau9adcf442011-09-03 01:40:26 +0200192 if (!ath_stoprecv(sc))
193 ret = false;
194
Felix Fietkauceea2a52012-05-24 14:32:19 +0200195 if (!ath_drain_all_txq(sc, retry_tx))
196 ret = false;
197
Felix Fietkau9adcf442011-09-03 01:40:26 +0200198 if (!flush) {
199 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
Felix Fietkau34832882011-09-14 21:23:03 +0200200 ath_rx_tasklet(sc, 1, true);
201 ath_rx_tasklet(sc, 1, false);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200202 } else {
203 ath_flushrecv(sc);
204 }
205
206 return ret;
207}
208
209static bool ath_complete_reset(struct ath_softc *sc, bool start)
210{
211 struct ath_hw *ah = sc->sc_ah;
212 struct ath_common *common = ath9k_hw_common(ah);
213
214 if (ath_startrecv(sc) != 0) {
215 ath_err(common, "Unable to restart recv logic\n");
216 return false;
217 }
218
219 ath9k_cmn_update_txpow(ah, sc->curtxpow,
220 sc->config.txpowlimit, &sc->curtxpow);
Sujith Manoharanb74713d2012-06-04 20:24:01 +0530221
222 clear_bit(SC_OP_HW_RESET, &sc->sc_flags);
Felix Fietkau72d874c2011-10-08 20:06:19 +0200223 ath9k_hw_set_interrupts(ah);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200224 ath9k_hw_enable_interrupts(ah);
225
Sujith Manoharan4cb54fa2012-06-04 16:27:52 +0530226 if (!(sc->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL) && start) {
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530227 if (test_bit(SC_OP_BEACONS, &sc->sc_flags))
Felix Fietkau9adcf442011-09-03 01:40:26 +0200228 ath_set_beacon(sc);
229
Sujith Manoharanaf68aba2012-06-04 20:23:43 +0530230 ath_restart_work(sc);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200231 }
232
Sujith Manoharan8da07832012-06-04 20:23:49 +0530233 if ((ah->caps.hw_caps & ATH9K_HW_CAP_ANT_DIV_COMB) && sc->ant_rx != 3)
234 ath_ant_comb_update(sc);
Felix Fietkau43c35282011-09-03 01:40:27 +0200235
Felix Fietkau9adcf442011-09-03 01:40:26 +0200236 ieee80211_wake_queues(sc->hw);
237
238 return true;
239}
240
241static int ath_reset_internal(struct ath_softc *sc, struct ath9k_channel *hchan,
242 bool retry_tx)
243{
244 struct ath_hw *ah = sc->sc_ah;
245 struct ath_common *common = ath9k_hw_common(ah);
246 struct ath9k_hw_cal_data *caldata = NULL;
247 bool fastcc = true;
248 bool flush = false;
249 int r;
250
251 __ath_cancel_work(sc);
252
253 spin_lock_bh(&sc->sc_pcu_lock);
254
Sujith Manoharan4cb54fa2012-06-04 16:27:52 +0530255 if (!(sc->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)) {
Felix Fietkau9adcf442011-09-03 01:40:26 +0200256 fastcc = false;
257 caldata = &sc->caldata;
258 }
259
260 if (!hchan) {
261 fastcc = false;
262 flush = true;
263 hchan = ah->curchan;
264 }
265
Felix Fietkau9adcf442011-09-03 01:40:26 +0200266 if (!ath_prepare_reset(sc, retry_tx, flush))
267 fastcc = false;
268
Joe Perchesd2182b62011-12-15 14:55:53 -0800269 ath_dbg(common, CONFIG, "Reset to %u MHz, HT40: %d fastcc: %d\n",
Sujith Manoharanfeced202012-01-30 14:21:42 +0530270 hchan->channel, IS_CHAN_HT40(hchan), fastcc);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200271
272 r = ath9k_hw_reset(ah, hchan, caldata, fastcc);
273 if (r) {
274 ath_err(common,
275 "Unable to reset channel, reset status %d\n", r);
276 goto out;
277 }
278
279 if (!ath_complete_reset(sc, true))
280 r = -EIO;
281
282out:
283 spin_unlock_bh(&sc->sc_pcu_lock);
284 return r;
285}
286
287
Sujithff37e332008-11-24 12:07:55 +0530288/*
289 * Set/change channels. If the channel is really being changed, it's done
290 * by reseting the chip. To accomplish this we must first cleanup any pending
291 * DMA, then restart stuff.
292*/
Mohammed Shafi Shajakhan5595f112011-05-19 18:08:57 +0530293static int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
Jouni Malinen0e2dedf2009-03-03 19:23:32 +0200294 struct ath9k_channel *hchan)
Sujithff37e332008-11-24 12:07:55 +0530295{
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800296 int r;
Sujithff37e332008-11-24 12:07:55 +0530297
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530298 if (test_bit(SC_OP_INVALID, &sc->sc_flags))
Sujithff37e332008-11-24 12:07:55 +0530299 return -EIO;
300
Felix Fietkau9adcf442011-09-03 01:40:26 +0200301 r = ath_reset_internal(sc, hchan, false);
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700302
Gabor Juhos39892792009-06-15 17:49:09 +0200303 return r;
Sujithff37e332008-11-24 12:07:55 +0530304}
305
Ben Greear7e1e3862011-11-03 11:33:13 -0700306static void ath_node_attach(struct ath_softc *sc, struct ieee80211_sta *sta,
307 struct ieee80211_vif *vif)
Sujithff37e332008-11-24 12:07:55 +0530308{
309 struct ath_node *an;
Sujithff37e332008-11-24 12:07:55 +0530310 an = (struct ath_node *)sta->drv_priv;
311
Ben Greear7f010c92011-01-09 23:11:49 -0800312#ifdef CONFIG_ATH9K_DEBUGFS
313 spin_lock(&sc->nodes_lock);
314 list_add(&an->list, &sc->nodes);
315 spin_unlock(&sc->nodes_lock);
Felix Fietkau156369f2011-12-14 22:08:04 +0100316#endif
Ben Greear7f010c92011-01-09 23:11:49 -0800317 an->sta = sta;
Ben Greear7e1e3862011-11-03 11:33:13 -0700318 an->vif = vif;
Sujith Manoharan3d4e20f2012-03-14 14:40:58 +0530319
Sujith Manoharana4d63672012-03-27 10:08:55 +0530320 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT) {
Sujithff37e332008-11-24 12:07:55 +0530321 ath_tx_node_init(sc, an);
Sujith9e98ac62009-07-23 15:32:34 +0530322 an->maxampdu = 1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
Sujith87792ef2009-03-30 15:28:48 +0530323 sta->ht_cap.ampdu_factor);
324 an->mpdudensity = parse_mpdudensity(sta->ht_cap.ampdu_density);
325 }
Sujithff37e332008-11-24 12:07:55 +0530326}
327
328static void ath_node_detach(struct ath_softc *sc, struct ieee80211_sta *sta)
329{
330 struct ath_node *an = (struct ath_node *)sta->drv_priv;
331
Ben Greear7f010c92011-01-09 23:11:49 -0800332#ifdef CONFIG_ATH9K_DEBUGFS
333 spin_lock(&sc->nodes_lock);
334 list_del(&an->list);
335 spin_unlock(&sc->nodes_lock);
336 an->sta = NULL;
337#endif
338
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_cleanup(sc, an);
341}
342
Sujith55624202010-01-08 10:36:02 +0530343void ath9k_tasklet(unsigned long data)
Sujithff37e332008-11-24 12:07:55 +0530344{
345 struct ath_softc *sc = (struct ath_softc *)data;
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -0700346 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -0700347 struct ath_common *common = ath9k_hw_common(ah);
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -0700348
Sujith17d79042009-02-09 13:27:03 +0530349 u32 status = sc->intrstatus;
Felix Fietkaub5c804752010-04-15 17:38:48 -0400350 u32 rxmask;
Sujithff37e332008-11-24 12:07:55 +0530351
Felix Fietkaue3927002011-09-14 21:23:01 +0200352 ath9k_ps_wakeup(sc);
353 spin_lock(&sc->sc_pcu_lock);
354
Rajkumar Manoharana4d86d92011-05-20 17:52:10 +0530355 if ((status & ATH9K_INT_FATAL) ||
356 (status & ATH9K_INT_BB_WATCHDOG)) {
Felix Fietkau030d6292011-10-07 02:28:13 +0200357#ifdef CONFIG_ATH9K_DEBUGFS
358 enum ath_reset_type type;
359
360 if (status & ATH9K_INT_FATAL)
361 type = RESET_TYPE_FATAL_INT;
362 else
363 type = RESET_TYPE_BB_WATCHDOG;
364
365 RESET_STAT_INC(sc, type);
366#endif
Sujith Manoharanb74713d2012-06-04 20:24:01 +0530367 set_bit(SC_OP_HW_RESET, &sc->sc_flags);
Felix Fietkau236de512011-09-03 01:40:25 +0200368 ieee80211_queue_work(sc->hw, &sc->hw_reset_work);
Felix Fietkaue3927002011-09-14 21:23:01 +0200369 goto out;
Sujithff37e332008-11-24 12:07:55 +0530370 }
371
Rajkumar Manoharan4105f802011-05-06 18:27:47 +0530372 if ((status & ATH9K_INT_TSFOOR) && sc->ps_enabled) {
373 /*
374 * TSF sync does not look correct; remain awake to sync with
375 * the next Beacon.
376 */
Joe Perchesd2182b62011-12-15 14:55:53 -0800377 ath_dbg(common, PS, "TSFOOR - Sync with next Beacon\n");
Rajkumar Manoharane8fe7332011-08-05 18:59:41 +0530378 sc->ps_flags |= PS_WAIT_FOR_BEACON | PS_BEACON_SYNC;
Rajkumar Manoharan4105f802011-05-06 18:27:47 +0530379 }
380
Felix Fietkaub5c804752010-04-15 17:38:48 -0400381 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
382 rxmask = (ATH9K_INT_RXHP | ATH9K_INT_RXLP | ATH9K_INT_RXEOL |
383 ATH9K_INT_RXORN);
384 else
385 rxmask = (ATH9K_INT_RX | ATH9K_INT_RXEOL | ATH9K_INT_RXORN);
386
387 if (status & rxmask) {
Felix Fietkaub5c804752010-04-15 17:38:48 -0400388 /* Check for high priority Rx first */
389 if ((ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) &&
390 (status & ATH9K_INT_RXHP))
391 ath_rx_tasklet(sc, 0, true);
392
393 ath_rx_tasklet(sc, 0, false);
Sujith063d8be2009-03-30 15:28:49 +0530394 }
395
Vasanthakumar Thiagarajane5003242010-04-15 17:39:36 -0400396 if (status & ATH9K_INT_TX) {
397 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
398 ath_tx_edma_tasklet(sc);
399 else
400 ath_tx_tasklet(sc);
401 }
Sujith063d8be2009-03-30 15:28:49 +0530402
Sujith Manoharan56ca0db2012-02-22 12:40:32 +0530403 ath9k_btcoex_handle_interrupt(sc, status);
Mohammed Shafi Shajakhan19686dd2011-11-30 10:41:28 +0530404
Felix Fietkaue3927002011-09-14 21:23:01 +0200405out:
Sujithff37e332008-11-24 12:07:55 +0530406 /* re-enable hardware interrupt */
Felix Fietkau4df30712010-11-08 20:54:47 +0100407 ath9k_hw_enable_interrupts(ah);
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700408
Senthil Balasubramanian52671e42010-12-23 21:06:57 +0530409 spin_unlock(&sc->sc_pcu_lock);
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400410 ath9k_ps_restore(sc);
Sujithff37e332008-11-24 12:07:55 +0530411}
412
Gabor Juhos6baff7f2009-01-14 20:17:06 +0100413irqreturn_t ath_isr(int irq, void *dev)
Sujithff37e332008-11-24 12:07:55 +0530414{
Sujith063d8be2009-03-30 15:28:49 +0530415#define SCHED_INTR ( \
416 ATH9K_INT_FATAL | \
Rajkumar Manoharana4d86d92011-05-20 17:52:10 +0530417 ATH9K_INT_BB_WATCHDOG | \
Sujith063d8be2009-03-30 15:28:49 +0530418 ATH9K_INT_RXORN | \
419 ATH9K_INT_RXEOL | \
420 ATH9K_INT_RX | \
Felix Fietkaub5c804752010-04-15 17:38:48 -0400421 ATH9K_INT_RXLP | \
422 ATH9K_INT_RXHP | \
Sujith063d8be2009-03-30 15:28:49 +0530423 ATH9K_INT_TX | \
424 ATH9K_INT_BMISS | \
425 ATH9K_INT_CST | \
Vasanthakumar Thiagarajanebb8e1d2009-09-01 17:46:32 +0530426 ATH9K_INT_TSFOOR | \
Mohammed Shafi Shajakhan40dc5392011-11-30 10:41:18 +0530427 ATH9K_INT_GENTIMER | \
428 ATH9K_INT_MCI)
Sujith063d8be2009-03-30 15:28:49 +0530429
Sujithff37e332008-11-24 12:07:55 +0530430 struct ath_softc *sc = dev;
Sujithcbe61d8a2009-02-09 13:27:12 +0530431 struct ath_hw *ah = sc->sc_ah;
Felix Fietkaub5bfc562010-10-08 22:13:53 +0200432 struct ath_common *common = ath9k_hw_common(ah);
Sujithff37e332008-11-24 12:07:55 +0530433 enum ath9k_int status;
434 bool sched = false;
435
Sujith063d8be2009-03-30 15:28:49 +0530436 /*
437 * The hardware is not ready/present, don't
438 * touch anything. Note this can happen early
439 * on if the IRQ is shared.
440 */
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530441 if (test_bit(SC_OP_INVALID, &sc->sc_flags))
Sujith063d8be2009-03-30 15:28:49 +0530442 return IRQ_NONE;
Sujithff37e332008-11-24 12:07:55 +0530443
Sujith063d8be2009-03-30 15:28:49 +0530444 /* shared irq, not for us */
Sujithff37e332008-11-24 12:07:55 +0530445
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400446 if (!ath9k_hw_intrpend(ah))
Sujith063d8be2009-03-30 15:28:49 +0530447 return IRQ_NONE;
Sujithff37e332008-11-24 12:07:55 +0530448
Sujith Manoharanb74713d2012-06-04 20:24:01 +0530449 if(test_bit(SC_OP_HW_RESET, &sc->sc_flags))
450 return IRQ_HANDLED;
451
Sujith063d8be2009-03-30 15:28:49 +0530452 /*
453 * Figure out the reason(s) for the interrupt. Note
454 * that the hal returns a pseudo-ISR that may include
455 * bits we haven't explicitly enabled so we mask the
456 * value to insure we only process bits we requested.
457 */
458 ath9k_hw_getisr(ah, &status); /* NB: clears ISR too */
Pavel Roskin30691682010-03-31 18:05:31 -0400459 status &= ah->imask; /* discard unasked-for bits */
Sujith063d8be2009-03-30 15:28:49 +0530460
461 /*
462 * If there are no status bits set, then this interrupt was not
463 * for me (should have been caught above).
464 */
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400465 if (!status)
Sujith063d8be2009-03-30 15:28:49 +0530466 return IRQ_NONE;
Sujith063d8be2009-03-30 15:28:49 +0530467
468 /* Cache the status */
469 sc->intrstatus = status;
470
471 if (status & SCHED_INTR)
472 sched = true;
473
474 /*
475 * If a FATAL or RXORN interrupt is received, we have to reset the
476 * chip immediately.
477 */
Felix Fietkaub5c804752010-04-15 17:38:48 -0400478 if ((status & ATH9K_INT_FATAL) || ((status & ATH9K_INT_RXORN) &&
479 !(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)))
Sujith063d8be2009-03-30 15:28:49 +0530480 goto chip_reset;
481
Luis R. Rodriguez08578b82010-05-13 13:33:44 -0400482 if ((ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) &&
483 (status & ATH9K_INT_BB_WATCHDOG)) {
Felix Fietkaub5bfc562010-10-08 22:13:53 +0200484
485 spin_lock(&common->cc_lock);
486 ath_hw_cycle_counters_update(common);
Luis R. Rodriguez08578b82010-05-13 13:33:44 -0400487 ar9003_hw_bb_watchdog_dbg_info(ah);
Felix Fietkaub5bfc562010-10-08 22:13:53 +0200488 spin_unlock(&common->cc_lock);
489
Luis R. Rodriguez08578b82010-05-13 13:33:44 -0400490 goto chip_reset;
491 }
492
Sujith063d8be2009-03-30 15:28:49 +0530493 if (status & ATH9K_INT_SWBA)
494 tasklet_schedule(&sc->bcon_tasklet);
495
496 if (status & ATH9K_INT_TXURN)
497 ath9k_hw_updatetxtriglevel(ah, true);
498
Rajkumar Manoharan0682c9b2011-08-13 10:28:09 +0530499 if (status & ATH9K_INT_RXEOL) {
500 ah->imask &= ~(ATH9K_INT_RXEOL | ATH9K_INT_RXORN);
Felix Fietkau72d874c2011-10-08 20:06:19 +0200501 ath9k_hw_set_interrupts(ah);
Felix Fietkaub5c804752010-04-15 17:38:48 -0400502 }
503
Sujith063d8be2009-03-30 15:28:49 +0530504 if (status & ATH9K_INT_MIB) {
505 /*
506 * Disable interrupts until we service the MIB
507 * interrupt; otherwise it will continue to
508 * fire.
509 */
Felix Fietkau4df30712010-11-08 20:54:47 +0100510 ath9k_hw_disable_interrupts(ah);
Sujith063d8be2009-03-30 15:28:49 +0530511 /*
512 * Let the hal handle the event. We assume
513 * it will clear whatever condition caused
514 * the interrupt.
515 */
Felix Fietkau88eac2d2010-10-12 16:08:03 +0200516 spin_lock(&common->cc_lock);
Felix Fietkaubfc472b2010-10-04 20:09:48 +0200517 ath9k_hw_proc_mib_event(ah);
Felix Fietkau88eac2d2010-10-12 16:08:03 +0200518 spin_unlock(&common->cc_lock);
Felix Fietkau4df30712010-11-08 20:54:47 +0100519 ath9k_hw_enable_interrupts(ah);
Sujith063d8be2009-03-30 15:28:49 +0530520 }
521
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400522 if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
523 if (status & ATH9K_INT_TIM_TIMER) {
Luis R. Rodriguezff9f0b62010-12-07 15:13:22 -0800524 if (ATH_DBG_WARN_ON_ONCE(sc->ps_idle))
525 goto chip_reset;
Sujith063d8be2009-03-30 15:28:49 +0530526 /* Clear RxAbort bit so that we can
527 * receive frames */
Luis R. Rodriguez9ecdef42009-09-09 21:10:09 -0700528 ath9k_setpower(sc, ATH9K_PM_AWAKE);
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400529 ath9k_hw_setrxabort(sc->sc_ah, 0);
Sujith1b04b932010-01-08 10:36:05 +0530530 sc->ps_flags |= PS_WAIT_FOR_BEACON;
Sujith063d8be2009-03-30 15:28:49 +0530531 }
Sujith063d8be2009-03-30 15:28:49 +0530532
533chip_reset:
534
Sujith817e11d2008-12-07 21:42:44 +0530535 ath_debug_stat_interrupt(sc, status);
536
Sujithff37e332008-11-24 12:07:55 +0530537 if (sched) {
Felix Fietkau4df30712010-11-08 20:54:47 +0100538 /* turn off every interrupt */
539 ath9k_hw_disable_interrupts(ah);
Sujithff37e332008-11-24 12:07:55 +0530540 tasklet_schedule(&sc->intr_tq);
541 }
542
543 return IRQ_HANDLED;
Sujith063d8be2009-03-30 15:28:49 +0530544
545#undef SCHED_INTR
Sujithff37e332008-11-24 12:07:55 +0530546}
547
Felix Fietkau236de512011-09-03 01:40:25 +0200548static int ath_reset(struct ath_softc *sc, bool retry_tx)
Sujithff37e332008-11-24 12:07:55 +0530549{
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800550 int r;
Sujithff37e332008-11-24 12:07:55 +0530551
Felix Fietkau783cd012011-01-21 18:52:38 +0100552 ath9k_ps_wakeup(sc);
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700553
Felix Fietkau9adcf442011-09-03 01:40:26 +0200554 r = ath_reset_internal(sc, NULL, retry_tx);
Sujithff37e332008-11-24 12:07:55 +0530555
556 if (retry_tx) {
557 int i;
558 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
559 if (ATH_TXQ_SETUP(sc, i)) {
Sujithb77f4832008-12-07 21:44:03 +0530560 spin_lock_bh(&sc->tx.txq[i].axq_lock);
561 ath_txq_schedule(sc, &sc->tx.txq[i]);
562 spin_unlock_bh(&sc->tx.txq[i].axq_lock);
Sujithff37e332008-11-24 12:07:55 +0530563 }
564 }
565 }
566
Felix Fietkau783cd012011-01-21 18:52:38 +0100567 ath9k_ps_restore(sc);
Sujith2ab81d42009-12-14 16:34:56 +0530568
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800569 return r;
Sujithff37e332008-11-24 12:07:55 +0530570}
571
Felix Fietkau236de512011-09-03 01:40:25 +0200572void ath_reset_work(struct work_struct *work)
573{
574 struct ath_softc *sc = container_of(work, struct ath_softc, hw_reset_work);
575
Felix Fietkau236de512011-09-03 01:40:25 +0200576 ath_reset(sc, true);
Felix Fietkau236de512011-09-03 01:40:25 +0200577}
578
Sujithff37e332008-11-24 12:07:55 +0530579/**********************/
580/* mac80211 callbacks */
581/**********************/
582
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700583static int ath9k_start(struct ieee80211_hw *hw)
584{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100585 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -0700586 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -0700587 struct ath_common *common = ath9k_hw_common(ah);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700588 struct ieee80211_channel *curchan = hw->conf.channel;
Sujithff37e332008-11-24 12:07:55 +0530589 struct ath9k_channel *init_channel;
Vasanthakumar Thiagarajan82880a72009-06-13 14:50:24 +0530590 int r;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700591
Joe Perchesd2182b62011-12-15 14:55:53 -0800592 ath_dbg(common, CONFIG,
Joe Perches226afe62010-12-02 19:12:37 -0800593 "Starting driver with initial channel: %d MHz\n",
594 curchan->center_freq);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700595
Felix Fietkauf62d8162011-03-25 17:43:41 +0100596 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +0530597 mutex_lock(&sc->mutex);
598
Rajkumar Manoharanc344c9c2011-01-31 23:47:43 +0530599 init_channel = ath9k_cmn_get_curchannel(hw, ah);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700600
Sujithff37e332008-11-24 12:07:55 +0530601 /* Reset SERDES registers */
Stanislaw Gruszka84c87dc2011-08-05 13:10:32 +0200602 ath9k_hw_configpcipowersave(ah, false);
Sujithff37e332008-11-24 12:07:55 +0530603
604 /*
605 * The basic interface to setting the hardware in a good
606 * state is ``reset''. On return the hardware is known to
607 * be powered up and with interrupts disabled. This must
608 * be followed by initialization of the appropriate bits
609 * and then setup of the interrupt mask.
610 */
Luis R. Rodriguez4bdd1e92010-10-26 15:27:24 -0700611 spin_lock_bh(&sc->sc_pcu_lock);
Felix Fietkauc0c11742011-11-16 13:08:41 +0100612
613 atomic_set(&ah->intr_ref_cnt, -1);
614
Felix Fietkau20bd2a02010-07-31 00:12:00 +0200615 r = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800616 if (r) {
Joe Perches38002762010-12-02 19:12:36 -0800617 ath_err(common,
618 "Unable to reset hardware; reset status %d (freq %u MHz)\n",
619 r, curchan->center_freq);
Luis R. Rodriguez4bdd1e92010-10-26 15:27:24 -0700620 spin_unlock_bh(&sc->sc_pcu_lock);
Sujith141b38b2009-02-04 08:10:07 +0530621 goto mutex_unlock;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700622 }
Sujithff37e332008-11-24 12:07:55 +0530623
Sujithff37e332008-11-24 12:07:55 +0530624 /* Setup our intr mask. */
Felix Fietkaub5c804752010-04-15 17:38:48 -0400625 ah->imask = ATH9K_INT_TX | ATH9K_INT_RXEOL |
626 ATH9K_INT_RXORN | ATH9K_INT_FATAL |
627 ATH9K_INT_GLOBAL;
628
629 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
Luis R. Rodriguez08578b82010-05-13 13:33:44 -0400630 ah->imask |= ATH9K_INT_RXHP |
631 ATH9K_INT_RXLP |
632 ATH9K_INT_BB_WATCHDOG;
Felix Fietkaub5c804752010-04-15 17:38:48 -0400633 else
634 ah->imask |= ATH9K_INT_RX;
Sujithff37e332008-11-24 12:07:55 +0530635
Felix Fietkau364734f2010-09-14 20:22:44 +0200636 ah->imask |= ATH9K_INT_GTT;
Sujithff37e332008-11-24 12:07:55 +0530637
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -0700638 if (ah->caps.hw_caps & ATH9K_HW_CAP_HT)
Pavel Roskin30691682010-03-31 18:05:31 -0400639 ah->imask |= ATH9K_INT_CST;
Sujithff37e332008-11-24 12:07:55 +0530640
Sujith Manoharane270e772012-06-04 16:27:19 +0530641 ath_mci_enable(sc);
Mohammed Shafi Shajakhan40dc5392011-11-30 10:41:18 +0530642
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530643 clear_bit(SC_OP_INVALID, &sc->sc_flags);
Rajkumar Manoharan5f841b42010-10-27 18:31:15 +0530644 sc->sc_ah->is_monitoring = false;
Sujithff37e332008-11-24 12:07:55 +0530645
Felix Fietkau9adcf442011-09-03 01:40:26 +0200646 if (!ath_complete_reset(sc, false)) {
647 r = -EIO;
648 spin_unlock_bh(&sc->sc_pcu_lock);
649 goto mutex_unlock;
650 }
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700651
Felix Fietkauc0c11742011-11-16 13:08:41 +0100652 if (ah->led_pin >= 0) {
653 ath9k_hw_cfg_output(ah, ah->led_pin,
654 AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
655 ath9k_hw_set_gpio(ah, ah->led_pin, 0);
656 }
657
658 /*
659 * Reset key cache to sane defaults (all entries cleared) instead of
660 * semi-random values after suspend/resume.
661 */
662 ath9k_cmn_init_crypto(sc->sc_ah);
663
Felix Fietkau9adcf442011-09-03 01:40:26 +0200664 spin_unlock_bh(&sc->sc_pcu_lock);
Senthil Balasubramanian164ace32009-07-14 20:17:09 -0400665
Sujith Manoharandf198b12012-02-22 12:40:27 +0530666 ath9k_start_btcoex(sc);
Vasanthakumar Thiagarajan17739122009-08-26 21:08:50 +0530667
Vasanthakumar Thiagarajan8060e162010-12-06 04:27:42 -0800668 if (ah->caps.pcie_lcr_extsync_en && common->bus_ops->extn_synch_en)
669 common->bus_ops->extn_synch_en(common);
670
Sujith141b38b2009-02-04 08:10:07 +0530671mutex_unlock:
672 mutex_unlock(&sc->mutex);
673
Felix Fietkauf62d8162011-03-25 17:43:41 +0100674 ath9k_ps_restore(sc);
675
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800676 return r;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700677}
678
Johannes Berg7bb456832011-02-24 14:42:06 +0100679static void ath9k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700680{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100681 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -0700682 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Sujith528f0c62008-10-29 10:14:26 +0530683 struct ath_tx_control txctl;
Benoit Papillault1bc14882009-11-24 15:49:18 +0100684 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
Sujith528f0c62008-10-29 10:14:26 +0530685
Gabor Juhos96148322009-07-24 17:27:21 +0200686 if (sc->ps_enabled) {
Jouni Malinendc8c4582009-05-19 17:01:42 +0300687 /*
688 * mac80211 does not set PM field for normal data frames, so we
689 * need to update that based on the current PS mode.
690 */
691 if (ieee80211_is_data(hdr->frame_control) &&
692 !ieee80211_is_nullfunc(hdr->frame_control) &&
693 !ieee80211_has_pm(hdr->frame_control)) {
Joe Perchesd2182b62011-12-15 14:55:53 -0800694 ath_dbg(common, PS,
Joe Perches226afe62010-12-02 19:12:37 -0800695 "Add PM=1 for a TX frame while in PS mode\n");
Jouni Malinendc8c4582009-05-19 17:01:42 +0300696 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
697 }
698 }
699
Sujith Manoharanad128862012-04-24 10:23:20 +0530700 if (unlikely(sc->sc_ah->power_mode == ATH9K_PM_NETWORK_SLEEP)) {
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300701 /*
702 * We are using PS-Poll and mac80211 can request TX while in
703 * power save mode. Need to wake up hardware for the TX to be
704 * completed and if needed, also for RX of buffered frames.
705 */
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300706 ath9k_ps_wakeup(sc);
Vasanthakumar Thiagarajanfdf76622010-05-17 18:57:55 -0700707 if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
708 ath9k_hw_setrxabort(sc->sc_ah, 0);
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300709 if (ieee80211_is_pspoll(hdr->frame_control)) {
Joe Perchesd2182b62011-12-15 14:55:53 -0800710 ath_dbg(common, PS,
Joe Perches226afe62010-12-02 19:12:37 -0800711 "Sending PS-Poll to pick a buffered frame\n");
Sujith1b04b932010-01-08 10:36:05 +0530712 sc->ps_flags |= PS_WAIT_FOR_PSPOLL_DATA;
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300713 } else {
Joe Perchesd2182b62011-12-15 14:55:53 -0800714 ath_dbg(common, PS, "Wake up to complete TX\n");
Sujith1b04b932010-01-08 10:36:05 +0530715 sc->ps_flags |= PS_WAIT_FOR_TX_ACK;
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300716 }
717 /*
718 * The actual restore operation will happen only after
Sujith Manoharanad128862012-04-24 10:23:20 +0530719 * the ps_flags bit is cleared. We are just dropping
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300720 * the ps_usecount here.
721 */
722 ath9k_ps_restore(sc);
723 }
724
Sujith Manoharanad128862012-04-24 10:23:20 +0530725 /*
726 * Cannot tx while the hardware is in full sleep, it first needs a full
727 * chip reset to recover from that
728 */
729 if (unlikely(sc->sc_ah->power_mode == ATH9K_PM_FULL_SLEEP)) {
730 ath_err(common, "TX while HW is in FULL_SLEEP mode\n");
731 goto exit;
732 }
733
Sujith528f0c62008-10-29 10:14:26 +0530734 memset(&txctl, 0, sizeof(struct ath_tx_control));
Felix Fietkau066dae92010-11-07 14:59:39 +0100735 txctl.txq = sc->tx.txq_map[skb_get_queue_mapping(skb)];
Sujith528f0c62008-10-29 10:14:26 +0530736
Joe Perchesd2182b62011-12-15 14:55:53 -0800737 ath_dbg(common, XMIT, "transmitting packet, skb: %p\n", skb);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700738
Jouni Malinenc52f33d2009-03-03 19:23:29 +0200739 if (ath_tx_start(hw, skb, &txctl) != 0) {
Joe Perchesd2182b62011-12-15 14:55:53 -0800740 ath_dbg(common, XMIT, "TX failed\n");
Ben Greeara5a0bca2012-04-03 09:16:55 -0700741 TX_STAT_INC(txctl.txq->axq_qnum, txfailed);
Sujith528f0c62008-10-29 10:14:26 +0530742 goto exit;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700743 }
744
Johannes Berg7bb456832011-02-24 14:42:06 +0100745 return;
Sujith528f0c62008-10-29 10:14:26 +0530746exit:
747 dev_kfree_skb_any(skb);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700748}
749
750static void ath9k_stop(struct ieee80211_hw *hw)
751{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100752 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -0700753 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -0700754 struct ath_common *common = ath9k_hw_common(ah);
Felix Fietkauc0c11742011-11-16 13:08:41 +0100755 bool prev_idle;
Sujith9c84b792008-10-29 10:17:13 +0530756
Sujith4c483812009-08-18 10:51:52 +0530757 mutex_lock(&sc->mutex);
758
Felix Fietkau9adcf442011-09-03 01:40:26 +0200759 ath_cancel_work(sc);
Rajkumar Manoharan01e18912012-03-15 05:34:27 +0530760 del_timer_sync(&sc->rx_poll_timer);
Luis R. Rodriguezc94dbff2009-07-27 11:53:04 -0700761
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530762 if (test_bit(SC_OP_INVALID, &sc->sc_flags)) {
Joe Perchesd2182b62011-12-15 14:55:53 -0800763 ath_dbg(common, ANY, "Device not present\n");
Sujith4c483812009-08-18 10:51:52 +0530764 mutex_unlock(&sc->mutex);
Sujith9c84b792008-10-29 10:17:13 +0530765 return;
766 }
767
Sujith3867cf62009-12-23 20:03:27 -0500768 /* Ensure HW is awake when we try to shut it down. */
769 ath9k_ps_wakeup(sc);
770
Sujith Manoharandf198b12012-02-22 12:40:27 +0530771 ath9k_stop_btcoex(sc);
Vasanthakumar Thiagarajan17739122009-08-26 21:08:50 +0530772
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700773 spin_lock_bh(&sc->sc_pcu_lock);
774
Stanislaw Gruszka203043f2011-01-25 14:08:40 +0100775 /* prevent tasklets to enable interrupts once we disable them */
776 ah->imask &= ~ATH9K_INT_GLOBAL;
777
Sujithff37e332008-11-24 12:07:55 +0530778 /* make sure h/w will not generate any interrupt
779 * before setting the invalid flag. */
Felix Fietkau4df30712010-11-08 20:54:47 +0100780 ath9k_hw_disable_interrupts(ah);
Sujithff37e332008-11-24 12:07:55 +0530781
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700782 spin_unlock_bh(&sc->sc_pcu_lock);
783
Stanislaw Gruszka203043f2011-01-25 14:08:40 +0100784 /* we can now sync irq and kill any running tasklets, since we already
785 * disabled interrupts and not holding a spin lock */
786 synchronize_irq(sc->irq);
787 tasklet_kill(&sc->intr_tq);
788 tasklet_kill(&sc->bcon_tasklet);
789
Felix Fietkauc0c11742011-11-16 13:08:41 +0100790 prev_idle = sc->ps_idle;
791 sc->ps_idle = true;
792
793 spin_lock_bh(&sc->sc_pcu_lock);
794
795 if (ah->led_pin >= 0) {
796 ath9k_hw_set_gpio(ah, ah->led_pin, 1);
797 ath9k_hw_cfg_gpio_input(ah, ah->led_pin);
798 }
799
800 ath_prepare_reset(sc, false, true);
801
802 if (sc->rx.frag) {
803 dev_kfree_skb_any(sc->rx.frag);
804 sc->rx.frag = NULL;
805 }
806
807 if (!ah->curchan)
808 ah->curchan = ath9k_cmn_get_curchannel(hw, ah);
809
810 ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
811 ath9k_hw_phy_disable(ah);
812
813 ath9k_hw_configpcipowersave(ah, true);
814
815 spin_unlock_bh(&sc->sc_pcu_lock);
816
Sujith3867cf62009-12-23 20:03:27 -0500817 ath9k_ps_restore(sc);
818
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530819 set_bit(SC_OP_INVALID, &sc->sc_flags);
Felix Fietkauc0c11742011-11-16 13:08:41 +0100820 sc->ps_idle = prev_idle;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700821
Sujith141b38b2009-02-04 08:10:07 +0530822 mutex_unlock(&sc->mutex);
823
Joe Perchesd2182b62011-12-15 14:55:53 -0800824 ath_dbg(common, CONFIG, "Driver halt\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700825}
826
Ben Greear48014162011-01-15 19:13:48 +0000827bool ath9k_uses_beacons(int type)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700828{
Ben Greear48014162011-01-15 19:13:48 +0000829 switch (type) {
Johannes Berg05c914f2008-09-11 00:01:58 +0200830 case NL80211_IFTYPE_AP:
Ben Greear48014162011-01-15 19:13:48 +0000831 case NL80211_IFTYPE_ADHOC:
Pat Erley9cb54122009-03-20 22:59:59 -0400832 case NL80211_IFTYPE_MESH_POINT:
Ben Greear48014162011-01-15 19:13:48 +0000833 return true;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700834 default:
Ben Greear48014162011-01-15 19:13:48 +0000835 return false;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700836 }
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700837}
838
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +0530839static void ath9k_reclaim_beacon(struct ath_softc *sc,
840 struct ieee80211_vif *vif)
841{
842 struct ath_vif *avp = (void *)vif->drv_priv;
843
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +0530844 ath9k_set_beaconing_status(sc, false);
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +0530845 ath_beacon_return(sc, avp);
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +0530846 ath9k_set_beaconing_status(sc, true);
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +0530847}
848
Ben Greear48014162011-01-15 19:13:48 +0000849static void ath9k_vif_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
850{
851 struct ath9k_vif_iter_data *iter_data = data;
852 int i;
853
854 if (iter_data->hw_macaddr)
855 for (i = 0; i < ETH_ALEN; i++)
856 iter_data->mask[i] &=
857 ~(iter_data->hw_macaddr[i] ^ mac[i]);
858
859 switch (vif->type) {
860 case NL80211_IFTYPE_AP:
861 iter_data->naps++;
862 break;
863 case NL80211_IFTYPE_STATION:
864 iter_data->nstations++;
865 break;
866 case NL80211_IFTYPE_ADHOC:
867 iter_data->nadhocs++;
868 break;
869 case NL80211_IFTYPE_MESH_POINT:
870 iter_data->nmeshes++;
871 break;
872 case NL80211_IFTYPE_WDS:
873 iter_data->nwds++;
874 break;
875 default:
Ben Greear48014162011-01-15 19:13:48 +0000876 break;
877 }
878}
879
880/* Called with sc->mutex held. */
881void ath9k_calculate_iter_data(struct ieee80211_hw *hw,
882 struct ieee80211_vif *vif,
883 struct ath9k_vif_iter_data *iter_data)
884{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100885 struct ath_softc *sc = hw->priv;
Ben Greear48014162011-01-15 19:13:48 +0000886 struct ath_hw *ah = sc->sc_ah;
887 struct ath_common *common = ath9k_hw_common(ah);
Ben Greear48014162011-01-15 19:13:48 +0000888
889 /*
890 * Use the hardware MAC address as reference, the hardware uses it
891 * together with the BSSID mask when matching addresses.
892 */
893 memset(iter_data, 0, sizeof(*iter_data));
894 iter_data->hw_macaddr = common->macaddr;
895 memset(&iter_data->mask, 0xff, ETH_ALEN);
896
897 if (vif)
898 ath9k_vif_iter(iter_data, vif->addr, vif);
899
900 /* Get list of all active MAC addresses */
Ben Greear48014162011-01-15 19:13:48 +0000901 ieee80211_iterate_active_interfaces_atomic(sc->hw, ath9k_vif_iter,
902 iter_data);
Ben Greear48014162011-01-15 19:13:48 +0000903}
904
905/* Called with sc->mutex held. */
906static void ath9k_calculate_summary_state(struct ieee80211_hw *hw,
907 struct ieee80211_vif *vif)
908{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100909 struct ath_softc *sc = hw->priv;
Ben Greear48014162011-01-15 19:13:48 +0000910 struct ath_hw *ah = sc->sc_ah;
911 struct ath_common *common = ath9k_hw_common(ah);
912 struct ath9k_vif_iter_data iter_data;
913
914 ath9k_calculate_iter_data(hw, vif, &iter_data);
915
916 /* Set BSSID mask. */
917 memcpy(common->bssidmask, iter_data.mask, ETH_ALEN);
918 ath_hw_setbssidmask(common);
919
920 /* Set op-mode & TSF */
921 if (iter_data.naps > 0) {
922 ath9k_hw_set_tsfadjust(ah, 1);
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530923 set_bit(SC_OP_TSF_RESET, &sc->sc_flags);
Ben Greear48014162011-01-15 19:13:48 +0000924 ah->opmode = NL80211_IFTYPE_AP;
925 } else {
926 ath9k_hw_set_tsfadjust(ah, 0);
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530927 clear_bit(SC_OP_TSF_RESET, &sc->sc_flags);
Ben Greear48014162011-01-15 19:13:48 +0000928
Javier Cardonafd5999c2011-05-03 16:57:19 -0700929 if (iter_data.nmeshes)
930 ah->opmode = NL80211_IFTYPE_MESH_POINT;
931 else if (iter_data.nwds)
Ben Greear48014162011-01-15 19:13:48 +0000932 ah->opmode = NL80211_IFTYPE_AP;
933 else if (iter_data.nadhocs)
934 ah->opmode = NL80211_IFTYPE_ADHOC;
935 else
936 ah->opmode = NL80211_IFTYPE_STATION;
937 }
938
939 /*
940 * Enable MIB interrupts when there are hardware phy counters.
941 */
942 if ((iter_data.nstations + iter_data.nadhocs + iter_data.nmeshes) > 0) {
943 if (ah->config.enable_ani)
944 ah->imask |= ATH9K_INT_MIB;
945 ah->imask |= ATH9K_INT_TSFOOR;
946 } else {
947 ah->imask &= ~ATH9K_INT_MIB;
948 ah->imask &= ~ATH9K_INT_TSFOOR;
949 }
950
Felix Fietkau72d874c2011-10-08 20:06:19 +0200951 ath9k_hw_set_interrupts(ah);
Ben Greear48014162011-01-15 19:13:48 +0000952
953 /* Set up ANI */
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +0530954 if (iter_data.naps > 0) {
Rajkumar Manoharan729da3902011-05-09 19:11:29 +0530955 sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +0530956
957 if (!common->disable_ani) {
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530958 set_bit(SC_OP_ANI_RUN, &sc->sc_flags);
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +0530959 ath_start_ani(common);
960 }
961
Rajkumar Manoharanf60c49b2011-04-08 17:06:25 +0530962 } else {
Sujith Manoharan781b14a2012-06-04 20:23:55 +0530963 clear_bit(SC_OP_ANI_RUN, &sc->sc_flags);
Rajkumar Manoharanf60c49b2011-04-08 17:06:25 +0530964 del_timer_sync(&common->ani.timer);
Ben Greear48014162011-01-15 19:13:48 +0000965 }
966}
967
968/* Called with sc->mutex held, vif counts set up properly. */
969static void ath9k_do_vif_add_setup(struct ieee80211_hw *hw,
970 struct ieee80211_vif *vif)
971{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100972 struct ath_softc *sc = hw->priv;
Ben Greear48014162011-01-15 19:13:48 +0000973
974 ath9k_calculate_summary_state(hw, vif);
975
976 if (ath9k_uses_beacons(vif->type)) {
Rajkumar Manoharaned2578c2012-04-19 19:13:51 +0530977 /* Reserve a beacon slot for the vif */
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +0530978 ath9k_set_beaconing_status(sc, false);
Rajkumar Manoharaned2578c2012-04-19 19:13:51 +0530979 ath_beacon_alloc(sc, vif);
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +0530980 ath9k_set_beaconing_status(sc, true);
Ben Greear48014162011-01-15 19:13:48 +0000981 }
982}
983
Ben Greear48014162011-01-15 19:13:48 +0000984static int ath9k_add_interface(struct ieee80211_hw *hw,
985 struct ieee80211_vif *vif)
986{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100987 struct ath_softc *sc = hw->priv;
Ben Greear48014162011-01-15 19:13:48 +0000988 struct ath_hw *ah = sc->sc_ah;
989 struct ath_common *common = ath9k_hw_common(ah);
Ben Greear48014162011-01-15 19:13:48 +0000990 int ret = 0;
991
Felix Fietkau96f372c2011-04-07 19:07:17 +0200992 ath9k_ps_wakeup(sc);
Ben Greear48014162011-01-15 19:13:48 +0000993 mutex_lock(&sc->mutex);
994
995 switch (vif->type) {
996 case NL80211_IFTYPE_STATION:
997 case NL80211_IFTYPE_WDS:
998 case NL80211_IFTYPE_ADHOC:
999 case NL80211_IFTYPE_AP:
1000 case NL80211_IFTYPE_MESH_POINT:
1001 break;
1002 default:
1003 ath_err(common, "Interface type %d not yet supported\n",
1004 vif->type);
1005 ret = -EOPNOTSUPP;
1006 goto out;
1007 }
1008
1009 if (ath9k_uses_beacons(vif->type)) {
1010 if (sc->nbcnvifs >= ATH_BCBUF) {
1011 ath_err(common, "Not enough beacon buffers when adding"
1012 " new interface of type: %i\n",
1013 vif->type);
1014 ret = -ENOBUFS;
1015 goto out;
1016 }
1017 }
1018
Rajkumar Manoharan59575d12011-04-04 22:56:16 +05301019 if ((ah->opmode == NL80211_IFTYPE_ADHOC) ||
1020 ((vif->type == NL80211_IFTYPE_ADHOC) &&
1021 sc->nvifs > 0)) {
Ben Greear48014162011-01-15 19:13:48 +00001022 ath_err(common, "Cannot create ADHOC interface when other"
1023 " interfaces already exist.\n");
1024 ret = -EINVAL;
1025 goto out;
1026 }
1027
Joe Perchesd2182b62011-12-15 14:55:53 -08001028 ath_dbg(common, CONFIG, "Attach a VIF of type: %d\n", vif->type);
Ben Greear48014162011-01-15 19:13:48 +00001029
Ben Greear48014162011-01-15 19:13:48 +00001030 sc->nvifs++;
1031
1032 ath9k_do_vif_add_setup(hw, vif);
1033out:
1034 mutex_unlock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001035 ath9k_ps_restore(sc);
Ben Greear48014162011-01-15 19:13:48 +00001036 return ret;
1037}
1038
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301039static int ath9k_change_interface(struct ieee80211_hw *hw,
1040 struct ieee80211_vif *vif,
1041 enum nl80211_iftype new_type,
1042 bool p2p)
1043{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001044 struct ath_softc *sc = hw->priv;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301045 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Dan Carpenter6dab55b2010-12-21 06:59:06 +03001046 int ret = 0;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301047
Joe Perchesd2182b62011-12-15 14:55:53 -08001048 ath_dbg(common, CONFIG, "Change Interface\n");
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301049 mutex_lock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001050 ath9k_ps_wakeup(sc);
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301051
Ben Greear48014162011-01-15 19:13:48 +00001052 /* See if new interface type is valid. */
1053 if ((new_type == NL80211_IFTYPE_ADHOC) &&
1054 (sc->nvifs > 1)) {
1055 ath_err(common, "When using ADHOC, it must be the only"
1056 " interface.\n");
1057 ret = -EINVAL;
1058 goto out;
1059 }
1060
1061 if (ath9k_uses_beacons(new_type) &&
1062 !ath9k_uses_beacons(vif->type)) {
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301063 if (sc->nbcnvifs >= ATH_BCBUF) {
1064 ath_err(common, "No beacon slot available\n");
Dan Carpenter6dab55b2010-12-21 06:59:06 +03001065 ret = -ENOBUFS;
1066 goto out;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301067 }
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301068 }
Ben Greear48014162011-01-15 19:13:48 +00001069
1070 /* Clean up old vif stuff */
1071 if (ath9k_uses_beacons(vif->type))
1072 ath9k_reclaim_beacon(sc, vif);
1073
1074 /* Add new settings */
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301075 vif->type = new_type;
1076 vif->p2p = p2p;
1077
Ben Greear48014162011-01-15 19:13:48 +00001078 ath9k_do_vif_add_setup(hw, vif);
Dan Carpenter6dab55b2010-12-21 06:59:06 +03001079out:
Felix Fietkau96f372c2011-04-07 19:07:17 +02001080 ath9k_ps_restore(sc);
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301081 mutex_unlock(&sc->mutex);
Dan Carpenter6dab55b2010-12-21 06:59:06 +03001082 return ret;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301083}
1084
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001085static void ath9k_remove_interface(struct ieee80211_hw *hw,
Johannes Berg1ed32e42009-12-23 13:15:45 +01001086 struct ieee80211_vif *vif)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001087{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001088 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -07001089 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001090
Joe Perchesd2182b62011-12-15 14:55:53 -08001091 ath_dbg(common, CONFIG, "Detach Interface\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001092
Felix Fietkau96f372c2011-04-07 19:07:17 +02001093 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301094 mutex_lock(&sc->mutex);
1095
Ben Greear48014162011-01-15 19:13:48 +00001096 sc->nvifs--;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001097
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001098 /* Reclaim beacon resources */
Ben Greear48014162011-01-15 19:13:48 +00001099 if (ath9k_uses_beacons(vif->type))
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301100 ath9k_reclaim_beacon(sc, vif);
Jouni Malinen2c3db3d2009-03-03 19:23:26 +02001101
Ben Greear48014162011-01-15 19:13:48 +00001102 ath9k_calculate_summary_state(hw, NULL);
Sujith141b38b2009-02-04 08:10:07 +05301103
1104 mutex_unlock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001105 ath9k_ps_restore(sc);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001106}
1107
Senthil Balasubramanianfbab7392010-10-05 20:36:40 +05301108static void ath9k_enable_ps(struct ath_softc *sc)
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301109{
Pavel Roskin30691682010-03-31 18:05:31 -04001110 struct ath_hw *ah = sc->sc_ah;
Sujith Manoharanad128862012-04-24 10:23:20 +05301111 struct ath_common *common = ath9k_hw_common(ah);
Pavel Roskin30691682010-03-31 18:05:31 -04001112
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301113 sc->ps_enabled = true;
Pavel Roskin30691682010-03-31 18:05:31 -04001114 if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP)) {
1115 if ((ah->imask & ATH9K_INT_TIM_TIMER) == 0) {
1116 ah->imask |= ATH9K_INT_TIM_TIMER;
Felix Fietkau72d874c2011-10-08 20:06:19 +02001117 ath9k_hw_set_interrupts(ah);
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301118 }
Vasanthakumar Thiagarajanfdf76622010-05-17 18:57:55 -07001119 ath9k_hw_setrxabort(ah, 1);
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301120 }
Sujith Manoharanad128862012-04-24 10:23:20 +05301121 ath_dbg(common, PS, "PowerSave enabled\n");
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301122}
1123
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301124static void ath9k_disable_ps(struct ath_softc *sc)
1125{
1126 struct ath_hw *ah = sc->sc_ah;
Sujith Manoharanad128862012-04-24 10:23:20 +05301127 struct ath_common *common = ath9k_hw_common(ah);
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301128
1129 sc->ps_enabled = false;
1130 ath9k_hw_setpower(ah, ATH9K_PM_AWAKE);
1131 if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP)) {
1132 ath9k_hw_setrxabort(ah, 0);
1133 sc->ps_flags &= ~(PS_WAIT_FOR_BEACON |
1134 PS_WAIT_FOR_CAB |
1135 PS_WAIT_FOR_PSPOLL_DATA |
1136 PS_WAIT_FOR_TX_ACK);
1137 if (ah->imask & ATH9K_INT_TIM_TIMER) {
1138 ah->imask &= ~ATH9K_INT_TIM_TIMER;
Felix Fietkau72d874c2011-10-08 20:06:19 +02001139 ath9k_hw_set_interrupts(ah);
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301140 }
1141 }
Sujith Manoharanad128862012-04-24 10:23:20 +05301142 ath_dbg(common, PS, "PowerSave disabled\n");
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301143}
1144
Johannes Berge8975582008-10-09 12:18:51 +02001145static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001146{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001147 struct ath_softc *sc = hw->priv;
Felix Fietkau34300982010-10-10 18:21:52 +02001148 struct ath_hw *ah = sc->sc_ah;
1149 struct ath_common *common = ath9k_hw_common(ah);
Johannes Berge8975582008-10-09 12:18:51 +02001150 struct ieee80211_conf *conf = &hw->conf;
Felix Fietkau75600ab2012-04-12 20:36:31 +02001151 bool reset_channel = false;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001152
Felix Fietkauc0c11742011-11-16 13:08:41 +01001153 ath9k_ps_wakeup(sc);
Sujithaa33de02008-12-18 11:40:16 +05301154 mutex_lock(&sc->mutex);
Sujith141b38b2009-02-04 08:10:07 +05301155
Felix Fietkaudaa1b6e2011-11-16 13:08:43 +01001156 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
Felix Fietkau7545daf2011-01-24 19:23:16 +01001157 sc->ps_idle = !!(conf->flags & IEEE80211_CONF_IDLE);
Felix Fietkaudaa1b6e2011-11-16 13:08:43 +01001158 if (sc->ps_idle)
1159 ath_cancel_work(sc);
Felix Fietkau75600ab2012-04-12 20:36:31 +02001160 else
1161 /*
1162 * The chip needs a reset to properly wake up from
1163 * full sleep
1164 */
1165 reset_channel = ah->chip_fullsleep;
Felix Fietkaudaa1b6e2011-11-16 13:08:43 +01001166 }
Luis R. Rodriguez64839172009-07-14 20:22:53 -04001167
Luis R. Rodrigueze7824a52009-11-24 02:53:25 -05001168 /*
1169 * We just prepare to enable PS. We have to wait until our AP has
1170 * ACK'd our null data frame to disable RX otherwise we'll ignore
1171 * those ACKs and end up retransmitting the same null data frames.
1172 * IEEE80211_CONF_CHANGE_PS is only passed by mac80211 for STA mode.
1173 */
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301174 if (changed & IEEE80211_CONF_CHANGE_PS) {
Luis R. Rodriguez8ab2cd02010-09-16 15:12:26 -04001175 unsigned long flags;
1176 spin_lock_irqsave(&sc->sc_pm_lock, flags);
Senthil Balasubramanianfbab7392010-10-05 20:36:40 +05301177 if (conf->flags & IEEE80211_CONF_PS)
1178 ath9k_enable_ps(sc);
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301179 else
1180 ath9k_disable_ps(sc);
Luis R. Rodriguez8ab2cd02010-09-16 15:12:26 -04001181 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301182 }
1183
Sujith199afd92010-01-08 10:36:13 +05301184 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1185 if (conf->flags & IEEE80211_CONF_MONITOR) {
Joe Perchesd2182b62011-12-15 14:55:53 -08001186 ath_dbg(common, CONFIG, "Monitor mode is enabled\n");
Rajkumar Manoharan5f841b42010-10-27 18:31:15 +05301187 sc->sc_ah->is_monitoring = true;
1188 } else {
Joe Perchesd2182b62011-12-15 14:55:53 -08001189 ath_dbg(common, CONFIG, "Monitor mode is disabled\n");
Rajkumar Manoharan5f841b42010-10-27 18:31:15 +05301190 sc->sc_ah->is_monitoring = false;
Sujith199afd92010-01-08 10:36:13 +05301191 }
1192 }
1193
Felix Fietkau75600ab2012-04-12 20:36:31 +02001194 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL) || reset_channel) {
Sujith99405f92008-11-24 12:08:35 +05301195 struct ieee80211_channel *curchan = hw->conf.channel;
Luis R. Rodriguez5f8e0772009-01-22 15:16:48 -08001196 int pos = curchan->hw_value;
Felix Fietkau34300982010-10-10 18:21:52 +02001197 int old_pos = -1;
1198 unsigned long flags;
1199
1200 if (ah->curchan)
1201 old_pos = ah->curchan - &ah->channels[0];
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001202
Joe Perchesd2182b62011-12-15 14:55:53 -08001203 ath_dbg(common, CONFIG, "Set channel: %d MHz type: %d\n",
Ben Greear8c79a612011-02-07 13:44:33 -08001204 curchan->center_freq, conf->channel_type);
Johannes Bergae5eb022008-10-14 16:58:37 +02001205
Felix Fietkau34300982010-10-10 18:21:52 +02001206 /* update survey stats for the old channel before switching */
1207 spin_lock_irqsave(&common->cc_lock, flags);
1208 ath_update_survey_stats(sc);
1209 spin_unlock_irqrestore(&common->cc_lock, flags);
1210
1211 /*
Rajkumar Manoharane338a852011-08-13 10:28:17 +05301212 * Preserve the current channel values, before updating
1213 * the same channel
1214 */
Rajkumar Manoharan1a19f772012-01-09 15:37:53 +05301215 if (ah->curchan && (old_pos == pos))
1216 ath9k_hw_getnf(ah, ah->curchan);
Rajkumar Manoharane338a852011-08-13 10:28:17 +05301217
1218 ath9k_cmn_update_ichannel(&sc->sc_ah->channels[pos],
1219 curchan, conf->channel_type);
1220
1221 /*
Felix Fietkau34300982010-10-10 18:21:52 +02001222 * If the operating channel changes, change the survey in-use flags
1223 * along with it.
1224 * Reset the survey data for the new channel, unless we're switching
1225 * back to the operating channel from an off-channel operation.
1226 */
1227 if (!(hw->conf.flags & IEEE80211_CONF_OFFCHANNEL) &&
1228 sc->cur_survey != &sc->survey[pos]) {
1229
1230 if (sc->cur_survey)
1231 sc->cur_survey->filled &= ~SURVEY_INFO_IN_USE;
1232
1233 sc->cur_survey = &sc->survey[pos];
1234
1235 memset(sc->cur_survey, 0, sizeof(struct survey_info));
1236 sc->cur_survey->filled |= SURVEY_INFO_IN_USE;
1237 } else if (!(sc->survey[pos].filled & SURVEY_INFO_IN_USE)) {
1238 memset(&sc->survey[pos], 0, sizeof(struct survey_info));
1239 }
1240
Jouni Malinen0e2dedf2009-03-03 19:23:32 +02001241 if (ath_set_channel(sc, hw, &sc->sc_ah->channels[pos]) < 0) {
Joe Perches38002762010-12-02 19:12:36 -08001242 ath_err(common, "Unable to set channel\n");
Sujithaa33de02008-12-18 11:40:16 +05301243 mutex_unlock(&sc->mutex);
Sujithe11602b2008-11-27 09:46:27 +05301244 return -EINVAL;
1245 }
Felix Fietkau34300982010-10-10 18:21:52 +02001246
1247 /*
1248 * The most recent snapshot of channel->noisefloor for the old
1249 * channel is only available after the hardware reset. Copy it to
1250 * the survey stats now.
1251 */
1252 if (old_pos >= 0)
1253 ath_update_survey_nf(sc, old_pos);
Sujith094d05d2008-12-12 11:57:43 +05301254 }
Sujith86b89ee2008-08-07 10:54:57 +05301255
Luis R. Rodriguezc9f6a652010-01-19 14:04:19 -05001256 if (changed & IEEE80211_CONF_CHANGE_POWER) {
Joe Perchesd2182b62011-12-15 14:55:53 -08001257 ath_dbg(common, CONFIG, "Set power: %d\n", conf->power_level);
Sujith17d79042009-02-09 13:27:03 +05301258 sc->config.txpowlimit = 2 * conf->power_level;
Rajkumar Manoharan5048e8c2011-01-31 23:47:44 +05301259 ath9k_cmn_update_txpow(ah, sc->curtxpow,
1260 sc->config.txpowlimit, &sc->curtxpow);
Luis R. Rodriguez64839172009-07-14 20:22:53 -04001261 }
1262
Sujithaa33de02008-12-18 11:40:16 +05301263 mutex_unlock(&sc->mutex);
Felix Fietkauc0c11742011-11-16 13:08:41 +01001264 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301265
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001266 return 0;
1267}
1268
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001269#define SUPPORTED_FILTERS \
1270 (FIF_PROMISC_IN_BSS | \
1271 FIF_ALLMULTI | \
1272 FIF_CONTROL | \
Luis R. Rodriguezaf6a3fc2009-08-08 21:55:16 -04001273 FIF_PSPOLL | \
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001274 FIF_OTHER_BSS | \
1275 FIF_BCN_PRBRESP_PROMISC | \
Jouni Malinen9c1d8e42010-10-13 17:29:31 +03001276 FIF_PROBE_REQ | \
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001277 FIF_FCSFAIL)
1278
Sujith7dcfdcd2008-08-11 14:03:13 +05301279/* FIXME: sc->sc_full_reset ? */
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001280static void ath9k_configure_filter(struct ieee80211_hw *hw,
1281 unsigned int changed_flags,
1282 unsigned int *total_flags,
Johannes Berg3ac64be2009-08-17 16:16:53 +02001283 u64 multicast)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001284{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001285 struct ath_softc *sc = hw->priv;
Sujith7dcfdcd2008-08-11 14:03:13 +05301286 u32 rfilt;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001287
1288 changed_flags &= SUPPORTED_FILTERS;
1289 *total_flags &= SUPPORTED_FILTERS;
1290
Sujithb77f4832008-12-07 21:44:03 +05301291 sc->rx.rxfilter = *total_flags;
Jouni Malinenaa68aea2009-05-19 17:01:41 +03001292 ath9k_ps_wakeup(sc);
Sujith7dcfdcd2008-08-11 14:03:13 +05301293 rfilt = ath_calcrxfilter(sc);
1294 ath9k_hw_setrxfilter(sc->sc_ah, rfilt);
Jouni Malinenaa68aea2009-05-19 17:01:41 +03001295 ath9k_ps_restore(sc);
Sujith7dcfdcd2008-08-11 14:03:13 +05301296
Joe Perchesd2182b62011-12-15 14:55:53 -08001297 ath_dbg(ath9k_hw_common(sc->sc_ah), CONFIG, "Set HW RX filter: 0x%x\n",
1298 rfilt);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001299}
1300
Johannes Berg4ca77862010-02-19 19:06:56 +01001301static int ath9k_sta_add(struct ieee80211_hw *hw,
1302 struct ieee80211_vif *vif,
1303 struct ieee80211_sta *sta)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001304{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001305 struct ath_softc *sc = hw->priv;
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001306 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1307 struct ath_node *an = (struct ath_node *) sta->drv_priv;
1308 struct ieee80211_key_conf ps_key = { };
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001309
Ben Greear7e1e3862011-11-03 11:33:13 -07001310 ath_node_attach(sc, sta, vif);
Felix Fietkauf59a59f2011-05-10 20:52:22 +02001311
1312 if (vif->type != NL80211_IFTYPE_AP &&
1313 vif->type != NL80211_IFTYPE_AP_VLAN)
1314 return 0;
1315
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001316 an->ps_key = ath_key_config(common, vif, sta, &ps_key);
Johannes Berg4ca77862010-02-19 19:06:56 +01001317
1318 return 0;
1319}
1320
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001321static void ath9k_del_ps_key(struct ath_softc *sc,
1322 struct ieee80211_vif *vif,
1323 struct ieee80211_sta *sta)
1324{
1325 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1326 struct ath_node *an = (struct ath_node *) sta->drv_priv;
1327 struct ieee80211_key_conf ps_key = { .hw_key_idx = an->ps_key };
1328
1329 if (!an->ps_key)
1330 return;
1331
1332 ath_key_delete(common, &ps_key);
1333}
1334
Johannes Berg4ca77862010-02-19 19:06:56 +01001335static int ath9k_sta_remove(struct ieee80211_hw *hw,
1336 struct ieee80211_vif *vif,
1337 struct ieee80211_sta *sta)
1338{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001339 struct ath_softc *sc = hw->priv;
Johannes Berg4ca77862010-02-19 19:06:56 +01001340
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001341 ath9k_del_ps_key(sc, vif, sta);
Johannes Berg4ca77862010-02-19 19:06:56 +01001342 ath_node_detach(sc, sta);
1343
1344 return 0;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001345}
1346
Felix Fietkau55195412011-04-17 23:28:09 +02001347static void ath9k_sta_notify(struct ieee80211_hw *hw,
1348 struct ieee80211_vif *vif,
1349 enum sta_notify_cmd cmd,
1350 struct ieee80211_sta *sta)
1351{
1352 struct ath_softc *sc = hw->priv;
1353 struct ath_node *an = (struct ath_node *) sta->drv_priv;
1354
Sujith Manoharan3d4e20f2012-03-14 14:40:58 +05301355 if (!sta->ht_cap.ht_supported)
Mohammed Shafi Shajakhanb25bfda2011-12-26 10:42:15 +05301356 return;
1357
Felix Fietkau55195412011-04-17 23:28:09 +02001358 switch (cmd) {
1359 case STA_NOTIFY_SLEEP:
1360 an->sleeping = true;
Johannes Berg042ec452011-09-29 16:04:26 +02001361 ath_tx_aggr_sleep(sta, sc, an);
Felix Fietkau55195412011-04-17 23:28:09 +02001362 break;
1363 case STA_NOTIFY_AWAKE:
1364 an->sleeping = false;
1365 ath_tx_aggr_wakeup(sc, an);
1366 break;
1367 }
1368}
1369
Eliad Peller8a3a3c82011-10-02 10:15:52 +02001370static int ath9k_conf_tx(struct ieee80211_hw *hw,
1371 struct ieee80211_vif *vif, u16 queue,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001372 const struct ieee80211_tx_queue_params *params)
1373{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001374 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -07001375 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkau066dae92010-11-07 14:59:39 +01001376 struct ath_txq *txq;
Sujithea9880f2008-08-07 10:53:10 +05301377 struct ath9k_tx_queue_info qi;
Felix Fietkau066dae92010-11-07 14:59:39 +01001378 int ret = 0;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001379
1380 if (queue >= WME_NUM_AC)
1381 return 0;
1382
Felix Fietkau066dae92010-11-07 14:59:39 +01001383 txq = sc->tx.txq_map[queue];
1384
Felix Fietkau96f372c2011-04-07 19:07:17 +02001385 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301386 mutex_lock(&sc->mutex);
1387
Sujith1ffb0612009-03-30 15:28:46 +05301388 memset(&qi, 0, sizeof(struct ath9k_tx_queue_info));
1389
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001390 qi.tqi_aifs = params->aifs;
1391 qi.tqi_cwmin = params->cw_min;
1392 qi.tqi_cwmax = params->cw_max;
1393 qi.tqi_burstTime = params->txop;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001394
Joe Perchesd2182b62011-12-15 14:55:53 -08001395 ath_dbg(common, CONFIG,
Joe Perches226afe62010-12-02 19:12:37 -08001396 "Configure tx [queue/halq] [%d/%d], aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
1397 queue, txq->axq_qnum, params->aifs, params->cw_min,
1398 params->cw_max, params->txop);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001399
Felix Fietkau066dae92010-11-07 14:59:39 +01001400 ret = ath_txq_update(sc, txq->axq_qnum, &qi);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001401 if (ret)
Joe Perches38002762010-12-02 19:12:36 -08001402 ath_err(common, "TXQ Update failed\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001403
Vivek Natarajan94db2932009-11-25 12:01:54 +05301404 if (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC)
Felix Fietkau066dae92010-11-07 14:59:39 +01001405 if (queue == WME_AC_BE && !ret)
Vivek Natarajan94db2932009-11-25 12:01:54 +05301406 ath_beaconq_config(sc);
1407
Sujith141b38b2009-02-04 08:10:07 +05301408 mutex_unlock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001409 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301410
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001411 return ret;
1412}
1413
1414static int ath9k_set_key(struct ieee80211_hw *hw,
1415 enum set_key_cmd cmd,
Johannes Bergdc822b52008-12-29 12:55:09 +01001416 struct ieee80211_vif *vif,
1417 struct ieee80211_sta *sta,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001418 struct ieee80211_key_conf *key)
1419{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001420 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -07001421 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001422 int ret = 0;
1423
John W. Linville3e6109c2011-01-05 09:39:17 -05001424 if (ath9k_modparam_nohwcrypt)
Jouni Malinenb3bd89c2009-02-24 13:42:01 +02001425 return -ENOSPC;
1426
Chun-Yeow Yeoh5bd5e9a2011-12-07 12:45:46 -08001427 if ((vif->type == NL80211_IFTYPE_ADHOC ||
1428 vif->type == NL80211_IFTYPE_MESH_POINT) &&
Jouni Malinencfdc9a82011-03-23 14:52:19 +02001429 (key->cipher == WLAN_CIPHER_SUITE_TKIP ||
1430 key->cipher == WLAN_CIPHER_SUITE_CCMP) &&
1431 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
1432 /*
1433 * For now, disable hw crypto for the RSN IBSS group keys. This
1434 * could be optimized in the future to use a modified key cache
1435 * design to support per-STA RX GTK, but until that gets
1436 * implemented, use of software crypto for group addressed
1437 * frames is a acceptable to allow RSN IBSS to be used.
1438 */
1439 return -EOPNOTSUPP;
1440 }
1441
Sujith141b38b2009-02-04 08:10:07 +05301442 mutex_lock(&sc->mutex);
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301443 ath9k_ps_wakeup(sc);
Joe Perchesd2182b62011-12-15 14:55:53 -08001444 ath_dbg(common, CONFIG, "Set HW Key\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001445
1446 switch (cmd) {
1447 case SET_KEY:
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001448 if (sta)
1449 ath9k_del_ps_key(sc, vif, sta);
1450
Bruno Randolf040e5392010-09-08 16:05:04 +09001451 ret = ath_key_config(common, vif, sta, key);
Jouni Malinen6ace2892008-12-17 13:32:17 +02001452 if (ret >= 0) {
1453 key->hw_key_idx = ret;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001454 /* push IV and Michael MIC generation to stack */
1455 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
Johannes Berg97359d12010-08-10 09:46:38 +02001456 if (key->cipher == WLAN_CIPHER_SUITE_TKIP)
Senthil Balasubramanian1b961752008-09-01 19:45:21 +05301457 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
Johannes Berg97359d12010-08-10 09:46:38 +02001458 if (sc->sc_ah->sw_mgmt_crypto &&
1459 key->cipher == WLAN_CIPHER_SUITE_CCMP)
Jouni Malinen0ced0e12009-01-08 13:32:13 +02001460 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT;
Jouni Malinen6ace2892008-12-17 13:32:17 +02001461 ret = 0;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001462 }
1463 break;
1464 case DISABLE_KEY:
Bruno Randolf040e5392010-09-08 16:05:04 +09001465 ath_key_delete(common, key);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001466 break;
1467 default:
1468 ret = -EINVAL;
1469 }
1470
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301471 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301472 mutex_unlock(&sc->mutex);
1473
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001474 return ret;
1475}
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301476static void ath9k_bss_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
1477{
1478 struct ath_softc *sc = data;
1479 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1480 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1481 struct ath_vif *avp = (void *)vif->drv_priv;
1482
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301483 /*
1484 * Skip iteration if primary station vif's bss info
1485 * was not changed
1486 */
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301487 if (test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags))
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301488 return;
1489
1490 if (bss_conf->assoc) {
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301491 set_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags);
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301492 avp->primary_sta_vif = true;
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301493 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1494 common->curaid = bss_conf->aid;
1495 ath9k_hw_write_associd(sc->sc_ah);
Joe Perchesd2182b62011-12-15 14:55:53 -08001496 ath_dbg(common, CONFIG, "Bss Info ASSOC %d, bssid: %pM\n",
1497 bss_conf->aid, common->curbssid);
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301498 ath_beacon_config(sc, vif);
1499 /*
1500 * Request a re-configuration of Beacon related timers
1501 * on the receipt of the first Beacon frame (i.e.,
1502 * after time sync with the AP).
1503 */
1504 sc->ps_flags |= PS_BEACON_SYNC | PS_WAIT_FOR_BEACON;
1505 /* Reset rssi stats */
1506 sc->last_rssi = ATH_RSSI_DUMMY_MARKER;
1507 sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
Rajkumar Manoharan99e4d432011-04-04 22:56:19 +05301508
Rajkumar Manoharan01e18912012-03-15 05:34:27 +05301509 ath_start_rx_poll(sc, 3);
1510
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +05301511 if (!common->disable_ani) {
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301512 set_bit(SC_OP_ANI_RUN, &sc->sc_flags);
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +05301513 ath_start_ani(common);
1514 }
1515
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301516 }
1517}
1518
1519static void ath9k_config_bss(struct ath_softc *sc, struct ieee80211_vif *vif)
1520{
1521 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1522 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1523 struct ath_vif *avp = (void *)vif->drv_priv;
1524
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301525 if (sc->sc_ah->opmode != NL80211_IFTYPE_STATION)
1526 return;
1527
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301528 /* Reconfigure bss info */
1529 if (avp->primary_sta_vif && !bss_conf->assoc) {
Joe Perchesd2182b62011-12-15 14:55:53 -08001530 ath_dbg(common, CONFIG, "Bss Info DISASSOC %d, bssid %pM\n",
Rajkumar Manoharan99e4d432011-04-04 22:56:19 +05301531 common->curaid, common->curbssid);
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301532 clear_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags);
1533 clear_bit(SC_OP_BEACONS, &sc->sc_flags);
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301534 avp->primary_sta_vif = false;
1535 memset(common->curbssid, 0, ETH_ALEN);
1536 common->curaid = 0;
1537 }
1538
1539 ieee80211_iterate_active_interfaces_atomic(
1540 sc->hw, ath9k_bss_iter, sc);
1541
1542 /*
1543 * None of station vifs are associated.
1544 * Clear bssid & aid
1545 */
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301546 if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) {
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301547 ath9k_hw_write_associd(sc->sc_ah);
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301548 clear_bit(SC_OP_ANI_RUN, &sc->sc_flags);
Rajkumar Manoharan99e4d432011-04-04 22:56:19 +05301549 del_timer_sync(&common->ani.timer);
Rajkumar Manoharan01e18912012-03-15 05:34:27 +05301550 del_timer_sync(&sc->rx_poll_timer);
Rajkumar Manoharand2c71c22011-09-15 19:02:54 +05301551 memset(&sc->caldata, 0, sizeof(sc->caldata));
Rajkumar Manoharan99e4d432011-04-04 22:56:19 +05301552 }
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301553}
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001554
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001555static void ath9k_bss_info_changed(struct ieee80211_hw *hw,
1556 struct ieee80211_vif *vif,
1557 struct ieee80211_bss_conf *bss_conf,
1558 u32 changed)
1559{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001560 struct ath_softc *sc = hw->priv;
Johannes Berg2d0ddec2009-04-23 16:13:26 +02001561 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguez15107182009-09-10 09:22:37 -07001562 struct ath_common *common = ath9k_hw_common(ah);
Johannes Berg2d0ddec2009-04-23 16:13:26 +02001563 struct ath_vif *avp = (void *)vif->drv_priv;
Felix Fietkau0005baf2010-01-15 02:33:40 +01001564 int slottime;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001565
Felix Fietkau96f372c2011-04-07 19:07:17 +02001566 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301567 mutex_lock(&sc->mutex);
1568
Rajkumar Manoharan9f619032012-03-10 05:06:49 +05301569 if (changed & BSS_CHANGED_ASSOC) {
Rajkumar Manoharan4f5ef75b2011-04-04 22:56:18 +05301570 ath9k_config_bss(sc, vif);
Sujithc6089cc2009-11-16 11:40:48 +05301571
Joe Perchesd2182b62011-12-15 14:55:53 -08001572 ath_dbg(common, CONFIG, "BSSID: %pM aid: 0x%x\n",
Joe Perches226afe62010-12-02 19:12:37 -08001573 common->curbssid, common->curaid);
Johannes Berg2d0ddec2009-04-23 16:13:26 +02001574 }
1575
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301576 if (changed & BSS_CHANGED_IBSS) {
1577 /* There can be only one vif available */
1578 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1579 common->curaid = bss_conf->aid;
1580 ath9k_hw_write_associd(sc->sc_ah);
1581
1582 if (bss_conf->ibss_joined) {
1583 sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +05301584
1585 if (!common->disable_ani) {
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301586 set_bit(SC_OP_ANI_RUN, &sc->sc_flags);
Mohammed Shafi Shajakhan05c0be22011-05-26 10:56:15 +05301587 ath_start_ani(common);
1588 }
1589
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301590 } else {
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301591 clear_bit(SC_OP_ANI_RUN, &sc->sc_flags);
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301592 del_timer_sync(&common->ani.timer);
Rajkumar Manoharan01e18912012-03-15 05:34:27 +05301593 del_timer_sync(&sc->rx_poll_timer);
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301594 }
1595 }
1596
Rajkumar Manoharaned2578c2012-04-19 19:13:51 +05301597 /*
1598 * In case of AP mode, the HW TSF has to be reset
1599 * when the beacon interval changes.
1600 */
1601 if ((changed & BSS_CHANGED_BEACON_INT) &&
1602 (vif->type == NL80211_IFTYPE_AP))
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301603 set_bit(SC_OP_TSF_RESET, &sc->sc_flags);
Rajkumar Manoharaned2578c2012-04-19 19:13:51 +05301604
1605 /* Configure beaconing (AP, IBSS, MESH) */
1606 if (ath9k_uses_beacons(vif->type) &&
1607 ((changed & BSS_CHANGED_BEACON) ||
1608 (changed & BSS_CHANGED_BEACON_ENABLED) ||
1609 (changed & BSS_CHANGED_BEACON_INT))) {
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +05301610 ath9k_set_beaconing_status(sc, false);
Rajkumar Manoharaned2578c2012-04-19 19:13:51 +05301611 if (bss_conf->enable_beacon)
1612 ath_beacon_alloc(sc, vif);
1613 else
1614 avp->is_bslot_active = false;
1615 ath_beacon_config(sc, vif);
Rajkumar Manoharan014cf3b2011-02-09 17:46:39 +05301616 ath9k_set_beaconing_status(sc, true);
Johannes Berg2d0ddec2009-04-23 16:13:26 +02001617 }
1618
Felix Fietkau0005baf2010-01-15 02:33:40 +01001619 if (changed & BSS_CHANGED_ERP_SLOT) {
1620 if (bss_conf->use_short_slot)
1621 slottime = 9;
1622 else
1623 slottime = 20;
1624 if (vif->type == NL80211_IFTYPE_AP) {
1625 /*
1626 * Defer update, so that connected stations can adjust
1627 * their settings at the same time.
1628 * See beacon.c for more details
1629 */
1630 sc->beacon.slottime = slottime;
1631 sc->beacon.updateslot = UPDATE;
1632 } else {
1633 ah->slottime = slottime;
1634 ath9k_hw_init_global_settings(ah);
1635 }
1636 }
1637
Sujith141b38b2009-02-04 08:10:07 +05301638 mutex_unlock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001639 ath9k_ps_restore(sc);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001640}
1641
Eliad Peller37a41b42011-09-21 14:06:11 +03001642static u64 ath9k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001643{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001644 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001645 u64 tsf;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001646
Sujith141b38b2009-02-04 08:10:07 +05301647 mutex_lock(&sc->mutex);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05301648 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301649 tsf = ath9k_hw_gettsf64(sc->sc_ah);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05301650 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301651 mutex_unlock(&sc->mutex);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001652
1653 return tsf;
1654}
1655
Eliad Peller37a41b42011-09-21 14:06:11 +03001656static void ath9k_set_tsf(struct ieee80211_hw *hw,
1657 struct ieee80211_vif *vif,
1658 u64 tsf)
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01001659{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001660 struct ath_softc *sc = hw->priv;
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01001661
Sujith141b38b2009-02-04 08:10:07 +05301662 mutex_lock(&sc->mutex);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05301663 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301664 ath9k_hw_settsf64(sc->sc_ah, tsf);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05301665 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301666 mutex_unlock(&sc->mutex);
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01001667}
1668
Eliad Peller37a41b42011-09-21 14:06:11 +03001669static void ath9k_reset_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001670{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001671 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001672
Sujith141b38b2009-02-04 08:10:07 +05301673 mutex_lock(&sc->mutex);
Luis R. Rodriguez21526d52009-09-09 20:05:39 -07001674
1675 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301676 ath9k_hw_reset_tsf(sc->sc_ah);
Luis R. Rodriguez21526d52009-09-09 20:05:39 -07001677 ath9k_ps_restore(sc);
1678
Sujith141b38b2009-02-04 08:10:07 +05301679 mutex_unlock(&sc->mutex);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001680}
1681
1682static int ath9k_ampdu_action(struct ieee80211_hw *hw,
Johannes Bergc951ad32009-11-16 12:00:38 +01001683 struct ieee80211_vif *vif,
Sujith141b38b2009-02-04 08:10:07 +05301684 enum ieee80211_ampdu_mlme_action action,
1685 struct ieee80211_sta *sta,
Johannes Berg0b01f032011-01-18 13:51:05 +01001686 u16 tid, u16 *ssn, u8 buf_size)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001687{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001688 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001689 int ret = 0;
1690
Johannes Berg85ad1812010-06-10 10:21:49 +02001691 local_bh_disable();
1692
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001693 switch (action) {
1694 case IEEE80211_AMPDU_RX_START:
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001695 break;
1696 case IEEE80211_AMPDU_RX_STOP:
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001697 break;
1698 case IEEE80211_AMPDU_TX_START:
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001699 ath9k_ps_wakeup(sc);
Felix Fietkau231c3a12010-09-20 19:35:28 +02001700 ret = ath_tx_aggr_start(sc, sta, tid, ssn);
1701 if (!ret)
1702 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001703 ath9k_ps_restore(sc);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001704 break;
1705 case IEEE80211_AMPDU_TX_STOP:
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001706 ath9k_ps_wakeup(sc);
Sujithf83da962009-07-23 15:32:37 +05301707 ath_tx_aggr_stop(sc, sta, tid);
Johannes Bergc951ad32009-11-16 12:00:38 +01001708 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001709 ath9k_ps_restore(sc);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001710 break;
Johannes Bergb1720232009-03-23 17:28:39 +01001711 case IEEE80211_AMPDU_TX_OPERATIONAL:
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001712 ath9k_ps_wakeup(sc);
Sujith8469cde2008-10-29 10:19:28 +05301713 ath_tx_aggr_resume(sc, sta, tid);
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001714 ath9k_ps_restore(sc);
Sujith8469cde2008-10-29 10:19:28 +05301715 break;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001716 default:
Joe Perches38002762010-12-02 19:12:36 -08001717 ath_err(ath9k_hw_common(sc->sc_ah), "Unknown AMPDU action\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001718 }
1719
Johannes Berg85ad1812010-06-10 10:21:49 +02001720 local_bh_enable();
1721
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001722 return ret;
1723}
1724
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001725static int ath9k_get_survey(struct ieee80211_hw *hw, int idx,
1726 struct survey_info *survey)
1727{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001728 struct ath_softc *sc = hw->priv;
Felix Fietkau34300982010-10-10 18:21:52 +02001729 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkau39162db2010-09-29 19:12:06 +02001730 struct ieee80211_supported_band *sband;
Felix Fietkau34300982010-10-10 18:21:52 +02001731 struct ieee80211_channel *chan;
1732 unsigned long flags;
1733 int pos;
1734
1735 spin_lock_irqsave(&common->cc_lock, flags);
1736 if (idx == 0)
1737 ath_update_survey_stats(sc);
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001738
Felix Fietkau39162db2010-09-29 19:12:06 +02001739 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
1740 if (sband && idx >= sband->n_channels) {
1741 idx -= sband->n_channels;
1742 sband = NULL;
1743 }
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001744
Felix Fietkau39162db2010-09-29 19:12:06 +02001745 if (!sband)
1746 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
1747
Felix Fietkau34300982010-10-10 18:21:52 +02001748 if (!sband || idx >= sband->n_channels) {
1749 spin_unlock_irqrestore(&common->cc_lock, flags);
1750 return -ENOENT;
Felix Fietkau4f1a5a42010-09-29 17:15:28 +02001751 }
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001752
Felix Fietkau34300982010-10-10 18:21:52 +02001753 chan = &sband->channels[idx];
1754 pos = chan->hw_value;
1755 memcpy(survey, &sc->survey[pos], sizeof(*survey));
1756 survey->channel = chan;
1757 spin_unlock_irqrestore(&common->cc_lock, flags);
1758
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001759 return 0;
1760}
1761
Felix Fietkaue239d852010-01-15 02:34:58 +01001762static void ath9k_set_coverage_class(struct ieee80211_hw *hw, u8 coverage_class)
1763{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001764 struct ath_softc *sc = hw->priv;
Felix Fietkaue239d852010-01-15 02:34:58 +01001765 struct ath_hw *ah = sc->sc_ah;
1766
1767 mutex_lock(&sc->mutex);
1768 ah->coverage_class = coverage_class;
Mohammed Shafi Shajakhan8b2a38272011-08-24 21:38:07 +05301769
1770 ath9k_ps_wakeup(sc);
Felix Fietkaue239d852010-01-15 02:34:58 +01001771 ath9k_hw_init_global_settings(ah);
Mohammed Shafi Shajakhan8b2a38272011-08-24 21:38:07 +05301772 ath9k_ps_restore(sc);
1773
Felix Fietkaue239d852010-01-15 02:34:58 +01001774 mutex_unlock(&sc->mutex);
1775}
1776
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001777static void ath9k_flush(struct ieee80211_hw *hw, bool drop)
1778{
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001779 struct ath_softc *sc = hw->priv;
Mohammed Shafi Shajakhan99aa55b2011-05-06 20:43:11 +05301780 struct ath_hw *ah = sc->sc_ah;
1781 struct ath_common *common = ath9k_hw_common(ah);
Felix Fietkau86271e42011-03-11 21:38:19 +01001782 int timeout = 200; /* ms */
1783 int i, j;
Rajkumar Manoharan2f6fc352011-04-28 15:31:57 +05301784 bool drain_txq;
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001785
1786 mutex_lock(&sc->mutex);
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001787 cancel_delayed_work_sync(&sc->tx_complete_work);
1788
Mohammed Shafi Shajakhan6a6b3f32011-09-09 10:41:08 +05301789 if (ah->ah_flags & AH_UNPLUGGED) {
Joe Perchesd2182b62011-12-15 14:55:53 -08001790 ath_dbg(common, ANY, "Device has been unplugged!\n");
Mohammed Shafi Shajakhan6a6b3f32011-09-09 10:41:08 +05301791 mutex_unlock(&sc->mutex);
1792 return;
1793 }
1794
Sujith Manoharan781b14a2012-06-04 20:23:55 +05301795 if (test_bit(SC_OP_INVALID, &sc->sc_flags)) {
Joe Perchesd2182b62011-12-15 14:55:53 -08001796 ath_dbg(common, ANY, "Device not present\n");
Mohammed Shafi Shajakhan99aa55b2011-05-06 20:43:11 +05301797 mutex_unlock(&sc->mutex);
1798 return;
1799 }
1800
Felix Fietkau86271e42011-03-11 21:38:19 +01001801 for (j = 0; j < timeout; j++) {
Mohammed Shafi Shajakhan108697c2011-05-13 20:59:42 +05301802 bool npend = false;
Felix Fietkau86271e42011-03-11 21:38:19 +01001803
1804 if (j)
1805 usleep_range(1000, 2000);
1806
1807 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
1808 if (!ATH_TXQ_SETUP(sc, i))
1809 continue;
1810
Mohammed Shafi Shajakhan108697c2011-05-13 20:59:42 +05301811 npend = ath9k_has_pending_frames(sc, &sc->tx.txq[i]);
1812
1813 if (npend)
1814 break;
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001815 }
1816
Felix Fietkau86271e42011-03-11 21:38:19 +01001817 if (!npend)
Felix Fietkau9df0d6a2011-11-16 13:08:42 +01001818 break;
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001819 }
1820
Felix Fietkau9df0d6a2011-11-16 13:08:42 +01001821 if (drop) {
1822 ath9k_ps_wakeup(sc);
1823 spin_lock_bh(&sc->sc_pcu_lock);
1824 drain_txq = ath_drain_all_txq(sc, false);
1825 spin_unlock_bh(&sc->sc_pcu_lock);
Felix Fietkau9adcf442011-09-03 01:40:26 +02001826
Felix Fietkau9df0d6a2011-11-16 13:08:42 +01001827 if (!drain_txq)
1828 ath_reset(sc, false);
Felix Fietkau9adcf442011-09-03 01:40:26 +02001829
Felix Fietkau9df0d6a2011-11-16 13:08:42 +01001830 ath9k_ps_restore(sc);
1831 ieee80211_wake_queues(hw);
1832 }
Senthil Balasubramaniand78f4b32011-03-23 23:07:22 +05301833
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08001834 ieee80211_queue_delayed_work(hw, &sc->tx_complete_work, 0);
1835 mutex_unlock(&sc->mutex);
1836}
1837
Vivek Natarajan15b91e82011-04-06 11:41:11 +05301838static bool ath9k_tx_frames_pending(struct ieee80211_hw *hw)
1839{
1840 struct ath_softc *sc = hw->priv;
1841 int i;
1842
1843 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
1844 if (!ATH_TXQ_SETUP(sc, i))
1845 continue;
1846
1847 if (ath9k_has_pending_frames(sc, &sc->tx.txq[i]))
1848 return true;
1849 }
1850 return false;
1851}
1852
Mohammed Shafi Shajakhan5595f112011-05-19 18:08:57 +05301853static int ath9k_tx_last_beacon(struct ieee80211_hw *hw)
Felix Fietkauba4903f2011-05-17 21:09:54 +02001854{
1855 struct ath_softc *sc = hw->priv;
1856 struct ath_hw *ah = sc->sc_ah;
1857 struct ieee80211_vif *vif;
1858 struct ath_vif *avp;
1859 struct ath_buf *bf;
1860 struct ath_tx_status ts;
Felix Fietkau4286df62012-02-27 19:58:40 +01001861 bool edma = !!(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA);
Felix Fietkauba4903f2011-05-17 21:09:54 +02001862 int status;
1863
1864 vif = sc->beacon.bslot[0];
1865 if (!vif)
1866 return 0;
1867
1868 avp = (void *)vif->drv_priv;
1869 if (!avp->is_bslot_active)
1870 return 0;
1871
Felix Fietkau4286df62012-02-27 19:58:40 +01001872 if (!sc->beacon.tx_processed && !edma) {
Felix Fietkauba4903f2011-05-17 21:09:54 +02001873 tasklet_disable(&sc->bcon_tasklet);
1874
1875 bf = avp->av_bcbuf;
1876 if (!bf || !bf->bf_mpdu)
1877 goto skip;
1878
1879 status = ath9k_hw_txprocdesc(ah, bf->bf_desc, &ts);
1880 if (status == -EINPROGRESS)
1881 goto skip;
1882
1883 sc->beacon.tx_processed = true;
1884 sc->beacon.tx_last = !(ts.ts_status & ATH9K_TXERR_MASK);
1885
1886skip:
1887 tasklet_enable(&sc->bcon_tasklet);
1888 }
1889
1890 return sc->beacon.tx_last;
1891}
1892
Mohammed Shafi Shajakhan52c94f42011-08-20 17:21:42 +05301893static int ath9k_get_stats(struct ieee80211_hw *hw,
1894 struct ieee80211_low_level_stats *stats)
1895{
1896 struct ath_softc *sc = hw->priv;
1897 struct ath_hw *ah = sc->sc_ah;
1898 struct ath9k_mib_stats *mib_stats = &ah->ah_mibStats;
1899
1900 stats->dot11ACKFailureCount = mib_stats->ackrcv_bad;
1901 stats->dot11RTSFailureCount = mib_stats->rts_bad;
1902 stats->dot11FCSErrorCount = mib_stats->fcs_bad;
1903 stats->dot11RTSSuccessCount = mib_stats->rts_good;
1904 return 0;
1905}
1906
Felix Fietkau43c35282011-09-03 01:40:27 +02001907static u32 fill_chainmask(u32 cap, u32 new)
1908{
1909 u32 filled = 0;
1910 int i;
1911
1912 for (i = 0; cap && new; i++, cap >>= 1) {
1913 if (!(cap & BIT(0)))
1914 continue;
1915
1916 if (new & BIT(0))
1917 filled |= BIT(i);
1918
1919 new >>= 1;
1920 }
1921
1922 return filled;
1923}
1924
1925static int ath9k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
1926{
1927 struct ath_softc *sc = hw->priv;
1928 struct ath_hw *ah = sc->sc_ah;
1929
1930 if (!rx_ant || !tx_ant)
1931 return -EINVAL;
1932
1933 sc->ant_rx = rx_ant;
1934 sc->ant_tx = tx_ant;
1935
1936 if (ah->caps.rx_chainmask == 1)
1937 return 0;
1938
1939 /* AR9100 runs into calibration issues if not all rx chains are enabled */
1940 if (AR_SREV_9100(ah))
1941 ah->rxchainmask = 0x7;
1942 else
1943 ah->rxchainmask = fill_chainmask(ah->caps.rx_chainmask, rx_ant);
1944
1945 ah->txchainmask = fill_chainmask(ah->caps.tx_chainmask, tx_ant);
1946 ath9k_reload_chainmask_settings(sc);
1947
1948 return 0;
1949}
1950
1951static int ath9k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
1952{
1953 struct ath_softc *sc = hw->priv;
1954
1955 *tx_ant = sc->ant_tx;
1956 *rx_ant = sc->ant_rx;
1957 return 0;
1958}
1959
Ben Greearb90bd9d2012-05-15 15:33:25 -07001960#ifdef CONFIG_ATH9K_DEBUGFS
1961
1962/* Ethtool support for get-stats */
1963
1964#define AMKSTR(nm) #nm "_BE", #nm "_BK", #nm "_VI", #nm "_VO"
1965static const char ath9k_gstrings_stats[][ETH_GSTRING_LEN] = {
1966 "tx_pkts_nic",
1967 "tx_bytes_nic",
1968 "rx_pkts_nic",
1969 "rx_bytes_nic",
1970 AMKSTR(d_tx_pkts),
1971 AMKSTR(d_tx_bytes),
1972 AMKSTR(d_tx_mpdus_queued),
1973 AMKSTR(d_tx_mpdus_completed),
1974 AMKSTR(d_tx_mpdu_xretries),
1975 AMKSTR(d_tx_aggregates),
1976 AMKSTR(d_tx_ampdus_queued_hw),
1977 AMKSTR(d_tx_ampdus_queued_sw),
1978 AMKSTR(d_tx_ampdus_completed),
1979 AMKSTR(d_tx_ampdu_retries),
1980 AMKSTR(d_tx_ampdu_xretries),
1981 AMKSTR(d_tx_fifo_underrun),
1982 AMKSTR(d_tx_op_exceeded),
1983 AMKSTR(d_tx_timer_expiry),
1984 AMKSTR(d_tx_desc_cfg_err),
1985 AMKSTR(d_tx_data_underrun),
1986 AMKSTR(d_tx_delim_underrun),
1987
1988 "d_rx_decrypt_crc_err",
1989 "d_rx_phy_err",
1990 "d_rx_mic_err",
1991 "d_rx_pre_delim_crc_err",
1992 "d_rx_post_delim_crc_err",
1993 "d_rx_decrypt_busy_err",
1994
1995 "d_rx_phyerr_radar",
1996 "d_rx_phyerr_ofdm_timing",
1997 "d_rx_phyerr_cck_timing",
1998
1999};
2000#define ATH9K_SSTATS_LEN ARRAY_SIZE(ath9k_gstrings_stats)
2001
2002static void ath9k_get_et_strings(struct ieee80211_hw *hw,
2003 struct ieee80211_vif *vif,
2004 u32 sset, u8 *data)
2005{
2006 if (sset == ETH_SS_STATS)
2007 memcpy(data, *ath9k_gstrings_stats,
2008 sizeof(ath9k_gstrings_stats));
2009}
2010
2011static int ath9k_get_et_sset_count(struct ieee80211_hw *hw,
2012 struct ieee80211_vif *vif, int sset)
2013{
2014 if (sset == ETH_SS_STATS)
2015 return ATH9K_SSTATS_LEN;
2016 return 0;
2017}
2018
2019#define PR_QNUM(_n) (sc->tx.txq_map[_n]->axq_qnum)
2020#define AWDATA(elem) \
2021 do { \
2022 data[i++] = sc->debug.stats.txstats[PR_QNUM(WME_AC_BE)].elem; \
2023 data[i++] = sc->debug.stats.txstats[PR_QNUM(WME_AC_BK)].elem; \
2024 data[i++] = sc->debug.stats.txstats[PR_QNUM(WME_AC_VI)].elem; \
2025 data[i++] = sc->debug.stats.txstats[PR_QNUM(WME_AC_VO)].elem; \
2026 } while (0)
2027
2028#define AWDATA_RX(elem) \
2029 do { \
2030 data[i++] = sc->debug.stats.rxstats.elem; \
2031 } while (0)
2032
2033static void ath9k_get_et_stats(struct ieee80211_hw *hw,
2034 struct ieee80211_vif *vif,
2035 struct ethtool_stats *stats, u64 *data)
2036{
2037 struct ath_softc *sc = hw->priv;
2038 int i = 0;
2039
2040 data[i++] = (sc->debug.stats.txstats[PR_QNUM(WME_AC_BE)].tx_pkts_all +
2041 sc->debug.stats.txstats[PR_QNUM(WME_AC_BK)].tx_pkts_all +
2042 sc->debug.stats.txstats[PR_QNUM(WME_AC_VI)].tx_pkts_all +
2043 sc->debug.stats.txstats[PR_QNUM(WME_AC_VO)].tx_pkts_all);
2044 data[i++] = (sc->debug.stats.txstats[PR_QNUM(WME_AC_BE)].tx_bytes_all +
2045 sc->debug.stats.txstats[PR_QNUM(WME_AC_BK)].tx_bytes_all +
2046 sc->debug.stats.txstats[PR_QNUM(WME_AC_VI)].tx_bytes_all +
2047 sc->debug.stats.txstats[PR_QNUM(WME_AC_VO)].tx_bytes_all);
2048 AWDATA_RX(rx_pkts_all);
2049 AWDATA_RX(rx_bytes_all);
2050
2051 AWDATA(tx_pkts_all);
2052 AWDATA(tx_bytes_all);
2053 AWDATA(queued);
2054 AWDATA(completed);
2055 AWDATA(xretries);
2056 AWDATA(a_aggr);
2057 AWDATA(a_queued_hw);
2058 AWDATA(a_queued_sw);
2059 AWDATA(a_completed);
2060 AWDATA(a_retries);
2061 AWDATA(a_xretries);
2062 AWDATA(fifo_underrun);
2063 AWDATA(xtxop);
2064 AWDATA(timer_exp);
2065 AWDATA(desc_cfg_err);
2066 AWDATA(data_underrun);
2067 AWDATA(delim_underrun);
2068
2069 AWDATA_RX(decrypt_crc_err);
2070 AWDATA_RX(phy_err);
2071 AWDATA_RX(mic_err);
2072 AWDATA_RX(pre_delim_crc_err);
2073 AWDATA_RX(post_delim_crc_err);
2074 AWDATA_RX(decrypt_busy_err);
2075
2076 AWDATA_RX(phy_err_stats[ATH9K_PHYERR_RADAR]);
2077 AWDATA_RX(phy_err_stats[ATH9K_PHYERR_OFDM_TIMING]);
2078 AWDATA_RX(phy_err_stats[ATH9K_PHYERR_CCK_TIMING]);
2079
2080 WARN_ON(i != ATH9K_SSTATS_LEN);
2081}
2082
2083/* End of ethtool get-stats functions */
2084
2085#endif
2086
2087
Gabor Juhos6baff7f2009-01-14 20:17:06 +01002088struct ieee80211_ops ath9k_ops = {
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002089 .tx = ath9k_tx,
2090 .start = ath9k_start,
2091 .stop = ath9k_stop,
2092 .add_interface = ath9k_add_interface,
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05302093 .change_interface = ath9k_change_interface,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002094 .remove_interface = ath9k_remove_interface,
2095 .config = ath9k_config,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002096 .configure_filter = ath9k_configure_filter,
Johannes Berg4ca77862010-02-19 19:06:56 +01002097 .sta_add = ath9k_sta_add,
2098 .sta_remove = ath9k_sta_remove,
Felix Fietkau55195412011-04-17 23:28:09 +02002099 .sta_notify = ath9k_sta_notify,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002100 .conf_tx = ath9k_conf_tx,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002101 .bss_info_changed = ath9k_bss_info_changed,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002102 .set_key = ath9k_set_key,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002103 .get_tsf = ath9k_get_tsf,
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01002104 .set_tsf = ath9k_set_tsf,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002105 .reset_tsf = ath9k_reset_tsf,
Johannes Berg4233df62008-10-13 13:35:05 +02002106 .ampdu_action = ath9k_ampdu_action,
Benoit Papillault62dad5b2010-04-28 00:08:24 +02002107 .get_survey = ath9k_get_survey,
Johannes Berg3b319aa2009-06-13 14:50:26 +05302108 .rfkill_poll = ath9k_rfkill_poll_state,
Felix Fietkaue239d852010-01-15 02:34:58 +01002109 .set_coverage_class = ath9k_set_coverage_class,
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002110 .flush = ath9k_flush,
Vivek Natarajan15b91e82011-04-06 11:41:11 +05302111 .tx_frames_pending = ath9k_tx_frames_pending,
Mohammed Shafi Shajakhan52c94f42011-08-20 17:21:42 +05302112 .tx_last_beacon = ath9k_tx_last_beacon,
2113 .get_stats = ath9k_get_stats,
Felix Fietkau43c35282011-09-03 01:40:27 +02002114 .set_antenna = ath9k_set_antenna,
2115 .get_antenna = ath9k_get_antenna,
Ben Greearb90bd9d2012-05-15 15:33:25 -07002116
2117#ifdef CONFIG_ATH9K_DEBUGFS
2118 .get_et_sset_count = ath9k_get_et_sset_count,
2119 .get_et_stats = ath9k_get_et_stats,
2120 .get_et_strings = ath9k_get_et_strings,
2121#endif
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002122};