blob: c27143ba9ffbe8e6d863c0353e3ef3effd29bd5e [file] [log] [blame]
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001/*
Sujith Manoharan5b681382011-05-17 13:36:18 +05302 * Copyright (c) 2008-2011 Atheros Communications Inc.
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07003 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
Luis R. Rodriguezf078f202008-08-04 00:16:41 -070017#include <linux/nl80211.h>
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -080018#include <linux/delay.h>
Sujith394cf0a2009-02-09 13:26:54 +053019#include "ath9k.h"
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -070020#include "btcoex.h"
Luis R. Rodriguezf078f202008-08-04 00:16:41 -070021
Sven Eckelmann313eb872012-06-25 07:15:22 +020022u8 ath9k_parse_mpdudensity(u8 mpdudensity)
Sujithff37e332008-11-24 12:07:55 +053023{
24 /*
25 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
26 * 0 for no restriction
27 * 1 for 1/4 us
28 * 2 for 1/2 us
29 * 3 for 1 us
30 * 4 for 2 us
31 * 5 for 4 us
32 * 6 for 8 us
33 * 7 for 16 us
34 */
35 switch (mpdudensity) {
36 case 0:
37 return 0;
38 case 1:
39 case 2:
40 case 3:
41 /* Our lower layer calculations limit our precision to
42 1 microsecond */
43 return 1;
44 case 4:
45 return 2;
46 case 5:
47 return 4;
48 case 6:
49 return 8;
50 case 7:
51 return 16;
52 default:
53 return 0;
54 }
55}
56
Sujith Manoharane2d389b2014-10-17 07:40:18 +053057static bool ath9k_has_pending_frames(struct ath_softc *sc, struct ath_txq *txq,
58 bool sw_pending)
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -080059{
60 bool pending = false;
61
62 spin_lock_bh(&txq->axq_lock);
63
Sujith Manoharanb7367282014-10-02 06:33:13 +053064 if (txq->axq_depth) {
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -080065 pending = true;
Sujith Manoharanb7367282014-10-02 06:33:13 +053066 goto out;
67 }
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -080068
Sujith Manoharane2d389b2014-10-17 07:40:18 +053069 if (!sw_pending)
70 goto out;
71
Felix Fietkau04535312014-06-11 16:17:51 +053072 if (txq->mac80211_qnum >= 0) {
73 struct list_head *list;
74
75 list = &sc->cur_chan->acq[txq->mac80211_qnum];
76 if (!list_empty(list))
77 pending = true;
78 }
Sujith Manoharanb7367282014-10-02 06:33:13 +053079out:
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -080080 spin_unlock_bh(&txq->axq_lock);
81 return pending;
82}
83
Mohammed Shafi Shajakhan6d79cb42011-05-19 17:40:46 +053084static bool ath9k_setpower(struct ath_softc *sc, enum ath9k_power_mode mode)
Luis R. Rodriguez8c77a562009-09-09 21:02:34 -070085{
86 unsigned long flags;
87 bool ret;
88
Luis R. Rodriguez9ecdef42009-09-09 21:10:09 -070089 spin_lock_irqsave(&sc->sc_pm_lock, flags);
90 ret = ath9k_hw_setpower(sc->sc_ah, mode);
91 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
Luis R. Rodriguez8c77a562009-09-09 21:02:34 -070092
93 return ret;
94}
95
Felix Fietkaubf3dac52013-11-11 22:23:33 +010096void ath_ps_full_sleep(unsigned long data)
97{
98 struct ath_softc *sc = (struct ath_softc *) data;
99 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
100 bool reset;
101
102 spin_lock(&common->cc_lock);
103 ath_hw_cycle_counters_update(common);
104 spin_unlock(&common->cc_lock);
105
106 ath9k_hw_setrxabort(sc->sc_ah, 1);
107 ath9k_hw_stopdmarecv(sc->sc_ah, &reset);
108
109 ath9k_hw_setpower(sc->sc_ah, ATH9K_PM_FULL_SLEEP);
110}
111
Luis R. Rodrigueza91d75ae2009-09-09 20:29:18 -0700112void ath9k_ps_wakeup(struct ath_softc *sc)
113{
Felix Fietkau898c9142010-10-12 14:02:53 +0200114 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Luis R. Rodrigueza91d75ae2009-09-09 20:29:18 -0700115 unsigned long flags;
Felix Fietkaufbb078f2010-11-03 01:36:51 +0100116 enum ath9k_power_mode power_mode;
Luis R. Rodrigueza91d75ae2009-09-09 20:29:18 -0700117
118 spin_lock_irqsave(&sc->sc_pm_lock, flags);
119 if (++sc->ps_usecount != 1)
120 goto unlock;
121
Felix Fietkaubf3dac52013-11-11 22:23:33 +0100122 del_timer_sync(&sc->sleep_timer);
Felix Fietkaufbb078f2010-11-03 01:36:51 +0100123 power_mode = sc->sc_ah->power_mode;
Luis R. Rodriguez9ecdef42009-09-09 21:10:09 -0700124 ath9k_hw_setpower(sc->sc_ah, ATH9K_PM_AWAKE);
Luis R. Rodrigueza91d75ae2009-09-09 20:29:18 -0700125
Felix Fietkau898c9142010-10-12 14:02:53 +0200126 /*
127 * While the hardware is asleep, the cycle counters contain no
128 * useful data. Better clear them now so that they don't mess up
129 * survey data results.
130 */
Felix Fietkaufbb078f2010-11-03 01:36:51 +0100131 if (power_mode != ATH9K_PM_AWAKE) {
132 spin_lock(&common->cc_lock);
133 ath_hw_cycle_counters_update(common);
134 memset(&common->cc_survey, 0, sizeof(common->cc_survey));
Rajkumar Manoharanc9ae6ab2012-06-04 16:28:41 +0530135 memset(&common->cc_ani, 0, sizeof(common->cc_ani));
Felix Fietkaufbb078f2010-11-03 01:36:51 +0100136 spin_unlock(&common->cc_lock);
137 }
Felix Fietkau898c9142010-10-12 14:02:53 +0200138
Luis R. Rodrigueza91d75ae2009-09-09 20:29:18 -0700139 unlock:
140 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
141}
142
143void ath9k_ps_restore(struct ath_softc *sc)
144{
Felix Fietkau898c9142010-10-12 14:02:53 +0200145 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkauc6c539f2011-09-14 21:24:24 +0200146 enum ath9k_power_mode mode;
Luis R. Rodrigueza91d75ae2009-09-09 20:29:18 -0700147 unsigned long flags;
148
149 spin_lock_irqsave(&sc->sc_pm_lock, flags);
150 if (--sc->ps_usecount != 0)
151 goto unlock;
152
Sujith Manoharanad128862012-04-24 10:23:20 +0530153 if (sc->ps_idle) {
Felix Fietkaubf3dac52013-11-11 22:23:33 +0100154 mod_timer(&sc->sleep_timer, jiffies + HZ / 10);
155 goto unlock;
156 }
157
158 if (sc->ps_enabled &&
Sujith Manoharanad128862012-04-24 10:23:20 +0530159 !(sc->ps_flags & (PS_WAIT_FOR_BEACON |
160 PS_WAIT_FOR_CAB |
161 PS_WAIT_FOR_PSPOLL_DATA |
Rajkumar Manoharan424749c2012-10-10 23:03:02 +0530162 PS_WAIT_FOR_TX_ACK |
163 PS_WAIT_FOR_ANI))) {
Felix Fietkauc6c539f2011-09-14 21:24:24 +0200164 mode = ATH9K_PM_NETWORK_SLEEP;
Rajkumar Manoharan08d4df42012-07-01 19:53:54 +0530165 if (ath9k_hw_btcoex_is_enabled(sc->sc_ah))
166 ath9k_btcoex_stop_gen_timer(sc);
Sujith Manoharanad128862012-04-24 10:23:20 +0530167 } else {
Felix Fietkauc6c539f2011-09-14 21:24:24 +0200168 goto unlock;
Sujith Manoharanad128862012-04-24 10:23:20 +0530169 }
Felix Fietkauc6c539f2011-09-14 21:24:24 +0200170
171 spin_lock(&common->cc_lock);
172 ath_hw_cycle_counters_update(common);
173 spin_unlock(&common->cc_lock);
174
Felix Fietkau1a8f0d392011-09-22 08:04:32 -0600175 ath9k_hw_setpower(sc->sc_ah, mode);
Luis R. Rodrigueza91d75ae2009-09-09 20:29:18 -0700176
177 unlock:
178 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
179}
180
Felix Fietkau9adcf442011-09-03 01:40:26 +0200181static void __ath_cancel_work(struct ath_softc *sc)
182{
183 cancel_work_sync(&sc->paprd_work);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200184 cancel_delayed_work_sync(&sc->tx_complete_work);
185 cancel_delayed_work_sync(&sc->hw_pll_work);
Sujith Manoharanfad29cd2012-06-25 13:54:22 +0530186
Sujith Manoharanbf525922012-06-27 14:15:59 +0530187#ifdef CONFIG_ATH9K_BTCOEX_SUPPORT
Sujith Manoharanfad29cd2012-06-25 13:54:22 +0530188 if (ath9k_hw_mci_is_enabled(sc->sc_ah))
189 cancel_work_sync(&sc->mci_work);
Sujith Manoharanbf525922012-06-27 14:15:59 +0530190#endif
Felix Fietkau9adcf442011-09-03 01:40:26 +0200191}
192
Sujith Manoharane60001e2013-10-28 12:22:04 +0530193void ath_cancel_work(struct ath_softc *sc)
Felix Fietkau9adcf442011-09-03 01:40:26 +0200194{
195 __ath_cancel_work(sc);
196 cancel_work_sync(&sc->hw_reset_work);
197}
198
Sujith Manoharane60001e2013-10-28 12:22:04 +0530199void ath_restart_work(struct ath_softc *sc)
Sujith Manoharanaf68aba2012-06-04 20:23:43 +0530200{
Sujith Manoharanaf68aba2012-06-04 20:23:43 +0530201 ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work, 0);
202
Sujith Manoharan19c36162013-08-20 10:05:59 +0530203 if (AR_SREV_9340(sc->sc_ah) || AR_SREV_9330(sc->sc_ah))
Sujith Manoharanaf68aba2012-06-04 20:23:43 +0530204 ieee80211_queue_delayed_work(sc->hw, &sc->hw_pll_work,
205 msecs_to_jiffies(ATH_PLL_WORK_INTERVAL));
206
Sujith Manoharanda0d45f2012-07-17 17:16:29 +0530207 ath_start_ani(sc);
Sujith Manoharanaf68aba2012-06-04 20:23:43 +0530208}
209
John W. Linville9ebea382013-01-28 13:54:03 -0500210static bool ath_prepare_reset(struct ath_softc *sc)
Felix Fietkau9adcf442011-09-03 01:40:26 +0200211{
212 struct ath_hw *ah = sc->sc_ah;
Felix Fietkauceea2a52012-05-24 14:32:19 +0200213 bool ret = true;
Felix Fietkau9adcf442011-09-03 01:40:26 +0200214
215 ieee80211_stop_queues(sc->hw);
Sujith Manoharanda0d45f2012-07-17 17:16:29 +0530216 ath_stop_ani(sc);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200217 ath9k_hw_disable_interrupts(ah);
218
Felix Fietkau300f77c2015-06-02 10:38:32 +0200219 if (AR_SREV_9300_20_OR_LATER(ah)) {
220 ret &= ath_stoprecv(sc);
221 ret &= ath_drain_all_txq(sc);
222 } else {
223 ret &= ath_drain_all_txq(sc);
224 ret &= ath_stoprecv(sc);
225 }
Felix Fietkauceea2a52012-05-24 14:32:19 +0200226
Felix Fietkau9adcf442011-09-03 01:40:26 +0200227 return ret;
228}
229
230static bool ath_complete_reset(struct ath_softc *sc, bool start)
231{
232 struct ath_hw *ah = sc->sc_ah;
233 struct ath_common *common = ath9k_hw_common(ah);
Sujith Manoharan196fb862012-06-04 20:24:13 +0530234 unsigned long flags;
Felix Fietkau9adcf442011-09-03 01:40:26 +0200235
Sujith Manoharan9019f642014-09-05 08:03:15 +0530236 ath9k_calculate_summary_state(sc, sc->cur_chan);
Sujith Manoharan19ec4772014-09-05 08:03:16 +0530237 ath_startrecv(sc);
Felix Fietkaud385c5c2014-11-04 16:56:57 +0100238 ath9k_cmn_update_txpow(ah, sc->cur_chan->cur_txpower,
239 sc->cur_chan->txpower,
240 &sc->cur_chan->cur_txpower);
Oleksij Rempeleefa01d2014-02-27 11:40:46 +0100241 clear_bit(ATH_OP_HW_RESET, &common->op_flags);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200242
Felix Fietkaufbbcd142014-06-11 16:17:49 +0530243 if (!sc->cur_chan->offchannel && start) {
Felix Fietkau8d7e09d2014-06-11 16:18:01 +0530244 /* restore per chanctx TSF timer */
245 if (sc->cur_chan->tsf_val) {
246 u32 offset;
247
248 offset = ath9k_hw_get_tsf_offset(&sc->cur_chan->tsf_ts,
249 NULL);
250 ath9k_hw_settsf64(ah, sc->cur_chan->tsf_val + offset);
251 }
252
253
Oleksij Rempeleefa01d2014-02-27 11:40:46 +0100254 if (!test_bit(ATH_OP_BEACONS, &common->op_flags))
Sujith Manoharan196fb862012-06-04 20:24:13 +0530255 goto work;
Felix Fietkau9adcf442011-09-03 01:40:26 +0200256
Sujith Manoharan196fb862012-06-04 20:24:13 +0530257 if (ah->opmode == NL80211_IFTYPE_STATION &&
Oleksij Rempeleefa01d2014-02-27 11:40:46 +0100258 test_bit(ATH_OP_PRIM_STA_VIF, &common->op_flags)) {
Sujith Manoharan196fb862012-06-04 20:24:13 +0530259 spin_lock_irqsave(&sc->sc_pm_lock, flags);
260 sc->ps_flags |= PS_BEACON_SYNC | PS_WAIT_FOR_BEACON;
261 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
Sujith Manoharana6768282013-05-06 10:09:03 +0530262 } else {
263 ath9k_set_beacon(sc);
Sujith Manoharan196fb862012-06-04 20:24:13 +0530264 }
265 work:
Sujith Manoharanaf68aba2012-06-04 20:23:43 +0530266 ath_restart_work(sc);
Felix Fietkau04535312014-06-11 16:17:51 +0530267 ath_txq_schedule_all(sc);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200268 }
269
Sujith Manoharan071aa9a2014-01-13 13:55:11 +0530270 sc->gtt_cnt = 0;
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +0530271
272 ath9k_hw_set_interrupts(ah);
273 ath9k_hw_enable_interrupts(ah);
Sujith Manoharan5ba8d9d2014-10-02 06:33:19 +0530274 ieee80211_wake_queues(sc->hw);
Felix Fietkaud463af42014-04-06 00:37:03 +0200275 ath9k_p2p_ps_timer(sc);
276
Felix Fietkau9adcf442011-09-03 01:40:26 +0200277 return true;
278}
279
Sujith Manoharan5555c952014-10-17 07:40:11 +0530280static int ath_reset_internal(struct ath_softc *sc, struct ath9k_channel *hchan)
Felix Fietkau9adcf442011-09-03 01:40:26 +0200281{
282 struct ath_hw *ah = sc->sc_ah;
283 struct ath_common *common = ath9k_hw_common(ah);
284 struct ath9k_hw_cal_data *caldata = NULL;
285 bool fastcc = true;
Felix Fietkau9adcf442011-09-03 01:40:26 +0200286 int r;
287
288 __ath_cancel_work(sc);
289
Felix Fietkaue3f31172015-01-14 14:17:36 +0100290 disable_irq(sc->irq);
Felix Fietkau4668cce2013-01-14 16:56:46 +0100291 tasklet_disable(&sc->intr_tq);
Sujith Manoharaneaf04a62014-10-17 07:40:13 +0530292 tasklet_disable(&sc->bcon_tasklet);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200293 spin_lock_bh(&sc->sc_pcu_lock);
294
Felix Fietkaufbbcd142014-06-11 16:17:49 +0530295 if (!sc->cur_chan->offchannel) {
Felix Fietkau9adcf442011-09-03 01:40:26 +0200296 fastcc = false;
Felix Fietkaub01459e2014-06-11 16:17:59 +0530297 caldata = &sc->cur_chan->caldata;
Felix Fietkau9adcf442011-09-03 01:40:26 +0200298 }
299
300 if (!hchan) {
301 fastcc = false;
Felix Fietkau9adcf442011-09-03 01:40:26 +0200302 hchan = ah->curchan;
303 }
304
John W. Linville9ebea382013-01-28 13:54:03 -0500305 if (!ath_prepare_reset(sc))
Felix Fietkau9adcf442011-09-03 01:40:26 +0200306 fastcc = false;
307
Sujith Manoharan9ea35982014-08-27 12:07:23 +0530308 if (ath9k_is_chanctx_enabled())
309 fastcc = false;
310
Rajkumar Manoharand6067f02014-06-20 22:47:49 +0530311 spin_lock_bh(&sc->chan_lock);
312 sc->cur_chandef = sc->cur_chan->chandef;
313 spin_unlock_bh(&sc->chan_lock);
Felix Fietkaubff11762014-06-11 16:17:52 +0530314
Joe Perchesd2182b62011-12-15 14:55:53 -0800315 ath_dbg(common, CONFIG, "Reset to %u MHz, HT40: %d fastcc: %d\n",
Sujith Manoharanfeced202012-01-30 14:21:42 +0530316 hchan->channel, IS_CHAN_HT40(hchan), fastcc);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200317
318 r = ath9k_hw_reset(ah, hchan, caldata, fastcc);
319 if (r) {
320 ath_err(common,
321 "Unable to reset channel, reset status %d\n", r);
Robert Shadef50b1cd2013-04-02 19:52:45 -0400322
323 ath9k_hw_enable_interrupts(ah);
324 ath9k_queue_reset(sc, RESET_TYPE_BB_HANG);
325
Felix Fietkau9adcf442011-09-03 01:40:26 +0200326 goto out;
327 }
328
Rajkumar Manoharane82cb032012-10-12 14:07:25 +0530329 if (ath9k_hw_mci_is_enabled(sc->sc_ah) &&
Felix Fietkaufbbcd142014-06-11 16:17:49 +0530330 sc->cur_chan->offchannel)
Rajkumar Manoharane82cb032012-10-12 14:07:25 +0530331 ath9k_mci_set_txpower(sc, true, false);
332
Felix Fietkau9adcf442011-09-03 01:40:26 +0200333 if (!ath_complete_reset(sc, true))
334 r = -EIO;
335
336out:
Felix Fietkaue3f31172015-01-14 14:17:36 +0100337 enable_irq(sc->irq);
Felix Fietkau9adcf442011-09-03 01:40:26 +0200338 spin_unlock_bh(&sc->sc_pcu_lock);
Sujith Manoharaneaf04a62014-10-17 07:40:13 +0530339 tasklet_enable(&sc->bcon_tasklet);
Felix Fietkau4668cce2013-01-14 16:56:46 +0100340 tasklet_enable(&sc->intr_tq);
341
Felix Fietkau9adcf442011-09-03 01:40:26 +0200342 return r;
343}
344
Ben Greear7e1e3862011-11-03 11:33:13 -0700345static void ath_node_attach(struct ath_softc *sc, struct ieee80211_sta *sta,
346 struct ieee80211_vif *vif)
Sujithff37e332008-11-24 12:07:55 +0530347{
348 struct ath_node *an;
Sujithff37e332008-11-24 12:07:55 +0530349 an = (struct ath_node *)sta->drv_priv;
350
Sujith Manoharana145daf2012-11-28 15:08:54 +0530351 an->sc = sc;
Ben Greear7f010c92011-01-09 23:11:49 -0800352 an->sta = sta;
Ben Greear7e1e3862011-11-03 11:33:13 -0700353 an->vif = vif;
Rajkumar Manoharan4bbf4412014-05-22 12:35:49 +0530354 memset(&an->key_idx, 0, sizeof(an->key_idx));
Sujith Manoharan3d4e20f2012-03-14 14:40:58 +0530355
Sujith Manoharandd5ee592013-02-04 15:38:23 +0530356 ath_tx_node_init(sc, an);
Lorenzo Bianconi44b47a72014-09-16 02:13:16 +0200357
358 ath_dynack_node_init(sc->sc_ah, an);
Sujithff37e332008-11-24 12:07:55 +0530359}
360
361static void ath_node_detach(struct ath_softc *sc, struct ieee80211_sta *sta)
362{
363 struct ath_node *an = (struct ath_node *)sta->drv_priv;
Sujith Manoharandd5ee592013-02-04 15:38:23 +0530364 ath_tx_node_cleanup(sc, an);
Lorenzo Bianconi44b47a72014-09-16 02:13:16 +0200365
366 ath_dynack_node_deinit(sc->sc_ah, an);
Sujithff37e332008-11-24 12:07:55 +0530367}
368
Sujith55624202010-01-08 10:36:02 +0530369void ath9k_tasklet(unsigned long data)
Sujithff37e332008-11-24 12:07:55 +0530370{
371 struct ath_softc *sc = (struct ath_softc *)data;
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -0700372 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -0700373 struct ath_common *common = ath9k_hw_common(ah);
Rajkumar Manoharan124b9792012-07-17 17:16:42 +0530374 enum ath_reset_type type;
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530375 unsigned long flags;
Sujith17d79042009-02-09 13:27:03 +0530376 u32 status = sc->intrstatus;
Felix Fietkaub5c804752010-04-15 17:38:48 -0400377 u32 rxmask;
Sujithff37e332008-11-24 12:07:55 +0530378
Felix Fietkaue3927002011-09-14 21:23:01 +0200379 ath9k_ps_wakeup(sc);
380 spin_lock(&sc->sc_pcu_lock);
381
Sujith Manoharan6549a862013-12-24 10:44:24 +0530382 if (status & ATH9K_INT_FATAL) {
383 type = RESET_TYPE_FATAL_INT;
Rajkumar Manoharan124b9792012-07-17 17:16:42 +0530384 ath9k_queue_reset(sc, type);
Sujith Manoharanc6cc47b2013-09-16 10:37:00 +0530385
386 /*
387 * Increment the ref. counter here so that
388 * interrupts are enabled in the reset routine.
389 */
390 atomic_inc(&ah->intr_ref_cnt);
Felix Fietkauaffad452014-02-22 14:52:49 +0100391 ath_dbg(common, RESET, "FATAL: Skipping interrupts\n");
Felix Fietkaue3927002011-09-14 21:23:01 +0200392 goto out;
Sujithff37e332008-11-24 12:07:55 +0530393 }
394
Sujith Manoharan6549a862013-12-24 10:44:24 +0530395 if ((ah->config.hw_hang_checks & HW_BB_WATCHDOG) &&
396 (status & ATH9K_INT_BB_WATCHDOG)) {
Sujith Manoharan0c759972013-12-24 10:44:26 +0530397 spin_lock(&common->cc_lock);
398 ath_hw_cycle_counters_update(common);
399 ar9003_hw_bb_watchdog_dbg_info(ah);
400 spin_unlock(&common->cc_lock);
401
Sujith Manoharan6549a862013-12-24 10:44:24 +0530402 if (ar9003_hw_bb_watchdog_check(ah)) {
403 type = RESET_TYPE_BB_WATCHDOG;
404 ath9k_queue_reset(sc, type);
405
406 /*
407 * Increment the ref. counter here so that
408 * interrupts are enabled in the reset routine.
409 */
410 atomic_inc(&ah->intr_ref_cnt);
Felix Fietkauaffad452014-02-22 14:52:49 +0100411 ath_dbg(common, RESET,
Sujith Manoharan6549a862013-12-24 10:44:24 +0530412 "BB_WATCHDOG: Skipping interrupts\n");
413 goto out;
414 }
415 }
416
Sujith Manoharan071aa9a2014-01-13 13:55:11 +0530417 if (status & ATH9K_INT_GTT) {
418 sc->gtt_cnt++;
419
420 if ((sc->gtt_cnt >= MAX_GTT_CNT) && !ath9k_hw_check_alive(ah)) {
421 type = RESET_TYPE_TX_GTT;
422 ath9k_queue_reset(sc, type);
423 atomic_inc(&ah->intr_ref_cnt);
Felix Fietkauaffad452014-02-22 14:52:49 +0100424 ath_dbg(common, RESET,
Sujith Manoharan071aa9a2014-01-13 13:55:11 +0530425 "GTT: Skipping interrupts\n");
426 goto out;
427 }
428 }
429
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530430 spin_lock_irqsave(&sc->sc_pm_lock, flags);
Rajkumar Manoharan4105f802011-05-06 18:27:47 +0530431 if ((status & ATH9K_INT_TSFOOR) && sc->ps_enabled) {
432 /*
433 * TSF sync does not look correct; remain awake to sync with
434 * the next Beacon.
435 */
Joe Perchesd2182b62011-12-15 14:55:53 -0800436 ath_dbg(common, PS, "TSFOOR - Sync with next Beacon\n");
Rajkumar Manoharane8fe7332011-08-05 18:59:41 +0530437 sc->ps_flags |= PS_WAIT_FOR_BEACON | PS_BEACON_SYNC;
Rajkumar Manoharan4105f802011-05-06 18:27:47 +0530438 }
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530439 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
Rajkumar Manoharan4105f802011-05-06 18:27:47 +0530440
Felix Fietkaub5c804752010-04-15 17:38:48 -0400441 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
442 rxmask = (ATH9K_INT_RXHP | ATH9K_INT_RXLP | ATH9K_INT_RXEOL |
443 ATH9K_INT_RXORN);
444 else
445 rxmask = (ATH9K_INT_RX | ATH9K_INT_RXEOL | ATH9K_INT_RXORN);
446
447 if (status & rxmask) {
Felix Fietkaub5c804752010-04-15 17:38:48 -0400448 /* Check for high priority Rx first */
449 if ((ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) &&
450 (status & ATH9K_INT_RXHP))
451 ath_rx_tasklet(sc, 0, true);
452
453 ath_rx_tasklet(sc, 0, false);
Sujith063d8be2009-03-30 15:28:49 +0530454 }
455
Vasanthakumar Thiagarajane5003242010-04-15 17:39:36 -0400456 if (status & ATH9K_INT_TX) {
Sujith Manoharan071aa9a2014-01-13 13:55:11 +0530457 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) {
458 /*
459 * For EDMA chips, TX completion is enabled for the
460 * beacon queue, so if a beacon has been transmitted
461 * successfully after a GTT interrupt, the GTT counter
462 * gets reset to zero here.
463 */
Sujith Manoharan3b745c72014-01-20 13:25:28 +0530464 sc->gtt_cnt = 0;
Sujith Manoharan071aa9a2014-01-13 13:55:11 +0530465
Vasanthakumar Thiagarajane5003242010-04-15 17:39:36 -0400466 ath_tx_edma_tasklet(sc);
Sujith Manoharan071aa9a2014-01-13 13:55:11 +0530467 } else {
Vasanthakumar Thiagarajane5003242010-04-15 17:39:36 -0400468 ath_tx_tasklet(sc);
Sujith Manoharan071aa9a2014-01-13 13:55:11 +0530469 }
Felix Fietkau10e23182013-11-11 22:23:35 +0100470
471 wake_up(&sc->tx_wait);
Vasanthakumar Thiagarajane5003242010-04-15 17:39:36 -0400472 }
Sujith063d8be2009-03-30 15:28:49 +0530473
Felix Fietkauc67ce332013-12-14 18:03:38 +0100474 if (status & ATH9K_INT_GENTIMER)
475 ath_gen_timer_isr(sc->sc_ah);
476
Sujith Manoharan56ca0db2012-02-22 12:40:32 +0530477 ath9k_btcoex_handle_interrupt(sc, status);
Mohammed Shafi Shajakhan19686dd2011-11-30 10:41:28 +0530478
Sujithff37e332008-11-24 12:07:55 +0530479 /* re-enable hardware interrupt */
Felix Fietkau4df30712010-11-08 20:54:47 +0100480 ath9k_hw_enable_interrupts(ah);
Sujith Manoharanc6cc47b2013-09-16 10:37:00 +0530481out:
Senthil Balasubramanian52671e42010-12-23 21:06:57 +0530482 spin_unlock(&sc->sc_pcu_lock);
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400483 ath9k_ps_restore(sc);
Sujithff37e332008-11-24 12:07:55 +0530484}
485
Gabor Juhos6baff7f2009-01-14 20:17:06 +0100486irqreturn_t ath_isr(int irq, void *dev)
Sujithff37e332008-11-24 12:07:55 +0530487{
Sujith063d8be2009-03-30 15:28:49 +0530488#define SCHED_INTR ( \
489 ATH9K_INT_FATAL | \
Rajkumar Manoharana4d86d92011-05-20 17:52:10 +0530490 ATH9K_INT_BB_WATCHDOG | \
Sujith063d8be2009-03-30 15:28:49 +0530491 ATH9K_INT_RXORN | \
492 ATH9K_INT_RXEOL | \
493 ATH9K_INT_RX | \
Felix Fietkaub5c804752010-04-15 17:38:48 -0400494 ATH9K_INT_RXLP | \
495 ATH9K_INT_RXHP | \
Sujith063d8be2009-03-30 15:28:49 +0530496 ATH9K_INT_TX | \
497 ATH9K_INT_BMISS | \
498 ATH9K_INT_CST | \
Sujith Manoharan071aa9a2014-01-13 13:55:11 +0530499 ATH9K_INT_GTT | \
Vasanthakumar Thiagarajanebb8e1d2009-09-01 17:46:32 +0530500 ATH9K_INT_TSFOOR | \
Mohammed Shafi Shajakhan40dc5392011-11-30 10:41:18 +0530501 ATH9K_INT_GENTIMER | \
502 ATH9K_INT_MCI)
Sujith063d8be2009-03-30 15:28:49 +0530503
Sujithff37e332008-11-24 12:07:55 +0530504 struct ath_softc *sc = dev;
Sujithcbe61d82009-02-09 13:27:12 +0530505 struct ath_hw *ah = sc->sc_ah;
Oleksij Rempeleefa01d2014-02-27 11:40:46 +0100506 struct ath_common *common = ath9k_hw_common(ah);
Sujithff37e332008-11-24 12:07:55 +0530507 enum ath9k_int status;
Sujith Manoharan78c8a952013-12-28 09:47:15 +0530508 u32 sync_cause = 0;
Sujithff37e332008-11-24 12:07:55 +0530509 bool sched = false;
510
Sujith063d8be2009-03-30 15:28:49 +0530511 /*
512 * The hardware is not ready/present, don't
513 * touch anything. Note this can happen early
514 * on if the IRQ is shared.
515 */
Wojciech Dubowik2ba7d142014-09-18 08:30:41 +0200516 if (!ah || test_bit(ATH_OP_INVALID, &common->op_flags))
Sujith063d8be2009-03-30 15:28:49 +0530517 return IRQ_NONE;
Sujithff37e332008-11-24 12:07:55 +0530518
Felix Fietkau872b5d82014-11-30 21:58:32 +0100519 /* shared irq, not for us */
520 if (!ath9k_hw_intrpend(ah))
521 return IRQ_NONE;
Sujith Manoharanb74713d2012-06-04 20:24:01 +0530522
Sujith063d8be2009-03-30 15:28:49 +0530523 /*
524 * Figure out the reason(s) for the interrupt. Note
525 * that the hal returns a pseudo-ISR that may include
526 * bits we haven't explicitly enabled so we mask the
527 * value to insure we only process bits we requested.
528 */
Felix Fietkau6a4d05d2013-12-19 18:01:48 +0100529 ath9k_hw_getisr(ah, &status, &sync_cause); /* NB: clears ISR too */
530 ath9k_debug_sync_cause(sc, sync_cause);
Pavel Roskin30691682010-03-31 18:05:31 -0400531 status &= ah->imask; /* discard unasked-for bits */
Sujith063d8be2009-03-30 15:28:49 +0530532
Felix Fietkaue3f31172015-01-14 14:17:36 +0100533 if (test_bit(ATH_OP_HW_RESET, &common->op_flags))
Felix Fietkau872b5d82014-11-30 21:58:32 +0100534 return IRQ_HANDLED;
535
Sujith063d8be2009-03-30 15:28:49 +0530536 /*
537 * If there are no status bits set, then this interrupt was not
538 * for me (should have been caught above).
539 */
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400540 if (!status)
Sujith063d8be2009-03-30 15:28:49 +0530541 return IRQ_NONE;
Sujith063d8be2009-03-30 15:28:49 +0530542
543 /* Cache the status */
544 sc->intrstatus = status;
545
546 if (status & SCHED_INTR)
547 sched = true;
548
549 /*
Felix Fietkau3b5801442014-10-25 17:19:28 +0200550 * If a FATAL interrupt is received, we have to reset the chip
551 * immediately.
Sujith063d8be2009-03-30 15:28:49 +0530552 */
Felix Fietkau3b5801442014-10-25 17:19:28 +0200553 if (status & ATH9K_INT_FATAL)
Sujith063d8be2009-03-30 15:28:49 +0530554 goto chip_reset;
555
Sujith Manoharana6bb8602013-12-24 10:44:22 +0530556 if ((ah->config.hw_hang_checks & HW_BB_WATCHDOG) &&
Sujith Manoharan0c759972013-12-24 10:44:26 +0530557 (status & ATH9K_INT_BB_WATCHDOG))
Luis R. Rodriguez08578b82010-05-13 13:33:44 -0400558 goto chip_reset;
Sujith Manoharane60001e2013-10-28 12:22:04 +0530559
Sujith063d8be2009-03-30 15:28:49 +0530560 if (status & ATH9K_INT_SWBA)
561 tasklet_schedule(&sc->bcon_tasklet);
562
563 if (status & ATH9K_INT_TXURN)
564 ath9k_hw_updatetxtriglevel(ah, true);
565
Rajkumar Manoharan0682c9b2011-08-13 10:28:09 +0530566 if (status & ATH9K_INT_RXEOL) {
567 ah->imask &= ~(ATH9K_INT_RXEOL | ATH9K_INT_RXORN);
Felix Fietkau72d874c2011-10-08 20:06:19 +0200568 ath9k_hw_set_interrupts(ah);
Felix Fietkaub5c804752010-04-15 17:38:48 -0400569 }
570
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400571 if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
572 if (status & ATH9K_INT_TIM_TIMER) {
Luis R. Rodriguezff9f0b62010-12-07 15:13:22 -0800573 if (ATH_DBG_WARN_ON_ONCE(sc->ps_idle))
574 goto chip_reset;
Sujith063d8be2009-03-30 15:28:49 +0530575 /* Clear RxAbort bit so that we can
576 * receive frames */
Luis R. Rodriguez9ecdef42009-09-09 21:10:09 -0700577 ath9k_setpower(sc, ATH9K_PM_AWAKE);
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530578 spin_lock(&sc->sc_pm_lock);
Vasanthakumar Thiagarajan153e0802009-05-15 02:47:16 -0400579 ath9k_hw_setrxabort(sc->sc_ah, 0);
Sujith1b04b932010-01-08 10:36:05 +0530580 sc->ps_flags |= PS_WAIT_FOR_BEACON;
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530581 spin_unlock(&sc->sc_pm_lock);
Sujith063d8be2009-03-30 15:28:49 +0530582 }
Sujith063d8be2009-03-30 15:28:49 +0530583
584chip_reset:
585
Sujith817e11d2008-12-07 21:42:44 +0530586 ath_debug_stat_interrupt(sc, status);
587
Sujithff37e332008-11-24 12:07:55 +0530588 if (sched) {
Felix Fietkau4df30712010-11-08 20:54:47 +0100589 /* turn off every interrupt */
590 ath9k_hw_disable_interrupts(ah);
Sujithff37e332008-11-24 12:07:55 +0530591 tasklet_schedule(&sc->intr_tq);
592 }
593
594 return IRQ_HANDLED;
Sujith063d8be2009-03-30 15:28:49 +0530595
596#undef SCHED_INTR
Sujithff37e332008-11-24 12:07:55 +0530597}
598
Sujith Manoharanae2ff232014-10-17 07:40:12 +0530599/*
600 * This function is called when a HW reset cannot be deferred
601 * and has to be immediate.
602 */
Sujith Manoharan5555c952014-10-17 07:40:11 +0530603int ath_reset(struct ath_softc *sc, struct ath9k_channel *hchan)
Sujithff37e332008-11-24 12:07:55 +0530604{
Sujith Manoharanae2ff232014-10-17 07:40:12 +0530605 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkauec303262013-10-05 14:09:30 +0200606 int r;
Sujithff37e332008-11-24 12:07:55 +0530607
Felix Fietkau872b5d82014-11-30 21:58:32 +0100608 ath9k_hw_kill_interrupts(sc->sc_ah);
Sujith Manoharanae2ff232014-10-17 07:40:12 +0530609 set_bit(ATH_OP_HW_RESET, &common->op_flags);
610
Felix Fietkau783cd012011-01-21 18:52:38 +0100611 ath9k_ps_wakeup(sc);
Sujith Manoharan5555c952014-10-17 07:40:11 +0530612 r = ath_reset_internal(sc, hchan);
Felix Fietkau783cd012011-01-21 18:52:38 +0100613 ath9k_ps_restore(sc);
Sujith2ab81d42009-12-14 16:34:56 +0530614
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800615 return r;
Sujithff37e332008-11-24 12:07:55 +0530616}
617
Sujith Manoharanae2ff232014-10-17 07:40:12 +0530618/*
619 * When a HW reset can be deferred, it is added to the
620 * hw_reset_work workqueue, but we set ATH_OP_HW_RESET before
621 * queueing.
622 */
Rajkumar Manoharan124b9792012-07-17 17:16:42 +0530623void ath9k_queue_reset(struct ath_softc *sc, enum ath_reset_type type)
624{
Oleksij Rempeleefa01d2014-02-27 11:40:46 +0100625 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Rajkumar Manoharan124b9792012-07-17 17:16:42 +0530626#ifdef CONFIG_ATH9K_DEBUGFS
627 RESET_STAT_INC(sc, type);
628#endif
Felix Fietkau872b5d82014-11-30 21:58:32 +0100629 ath9k_hw_kill_interrupts(sc->sc_ah);
Oleksij Rempeleefa01d2014-02-27 11:40:46 +0100630 set_bit(ATH_OP_HW_RESET, &common->op_flags);
Rajkumar Manoharan124b9792012-07-17 17:16:42 +0530631 ieee80211_queue_work(sc->hw, &sc->hw_reset_work);
632}
633
Felix Fietkau236de512011-09-03 01:40:25 +0200634void ath_reset_work(struct work_struct *work)
635{
636 struct ath_softc *sc = container_of(work, struct ath_softc, hw_reset_work);
637
Sujith Manoharan5555c952014-10-17 07:40:11 +0530638 ath9k_ps_wakeup(sc);
639 ath_reset_internal(sc, NULL);
640 ath9k_ps_restore(sc);
Felix Fietkau236de512011-09-03 01:40:25 +0200641}
642
Sujithff37e332008-11-24 12:07:55 +0530643/**********************/
644/* mac80211 callbacks */
645/**********************/
646
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700647static int ath9k_start(struct ieee80211_hw *hw)
648{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100649 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -0700650 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -0700651 struct ath_common *common = ath9k_hw_common(ah);
Felix Fietkau39305632014-06-11 16:17:57 +0530652 struct ieee80211_channel *curchan = sc->cur_chan->chandef.chan;
Felix Fietkaufbbcd142014-06-11 16:17:49 +0530653 struct ath_chanctx *ctx = sc->cur_chan;
Sujithff37e332008-11-24 12:07:55 +0530654 struct ath9k_channel *init_channel;
Vasanthakumar Thiagarajan82880a72009-06-13 14:50:24 +0530655 int r;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700656
Joe Perchesd2182b62011-12-15 14:55:53 -0800657 ath_dbg(common, CONFIG,
Joe Perches226afe62010-12-02 19:12:37 -0800658 "Starting driver with initial channel: %d MHz\n",
659 curchan->center_freq);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700660
Felix Fietkauf62d8162011-03-25 17:43:41 +0100661 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +0530662 mutex_lock(&sc->mutex);
663
Felix Fietkaufbbcd142014-06-11 16:17:49 +0530664 init_channel = ath9k_cmn_get_channel(hw, ah, &ctx->chandef);
Felix Fietkaubff11762014-06-11 16:17:52 +0530665 sc->cur_chandef = hw->conf.chandef;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700666
Sujithff37e332008-11-24 12:07:55 +0530667 /* Reset SERDES registers */
Stanislaw Gruszka84c87dc2011-08-05 13:10:32 +0200668 ath9k_hw_configpcipowersave(ah, false);
Sujithff37e332008-11-24 12:07:55 +0530669
670 /*
671 * The basic interface to setting the hardware in a good
672 * state is ``reset''. On return the hardware is known to
673 * be powered up and with interrupts disabled. This must
674 * be followed by initialization of the appropriate bits
675 * and then setup of the interrupt mask.
676 */
Luis R. Rodriguez4bdd1e92010-10-26 15:27:24 -0700677 spin_lock_bh(&sc->sc_pcu_lock);
Felix Fietkauc0c11742011-11-16 13:08:41 +0100678
679 atomic_set(&ah->intr_ref_cnt, -1);
680
Felix Fietkau20bd2a02010-07-31 00:12:00 +0200681 r = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
Luis R. Rodriguezae8d2852008-12-23 15:58:40 -0800682 if (r) {
Joe Perches38002762010-12-02 19:12:36 -0800683 ath_err(common,
684 "Unable to reset hardware; reset status %d (freq %u MHz)\n",
685 r, curchan->center_freq);
Felix Fietkauceb26a62012-10-03 21:07:51 +0200686 ah->reset_power_on = false;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700687 }
Sujithff37e332008-11-24 12:07:55 +0530688
Sujithff37e332008-11-24 12:07:55 +0530689 /* Setup our intr mask. */
Felix Fietkaub5c804752010-04-15 17:38:48 -0400690 ah->imask = ATH9K_INT_TX | ATH9K_INT_RXEOL |
691 ATH9K_INT_RXORN | ATH9K_INT_FATAL |
692 ATH9K_INT_GLOBAL;
693
694 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
Luis R. Rodriguez08578b82010-05-13 13:33:44 -0400695 ah->imask |= ATH9K_INT_RXHP |
Sujith Manoharana6bb8602013-12-24 10:44:22 +0530696 ATH9K_INT_RXLP;
Felix Fietkaub5c804752010-04-15 17:38:48 -0400697 else
698 ah->imask |= ATH9K_INT_RX;
Sujithff37e332008-11-24 12:07:55 +0530699
Sujith Manoharana6bb8602013-12-24 10:44:22 +0530700 if (ah->config.hw_hang_checks & HW_BB_WATCHDOG)
701 ah->imask |= ATH9K_INT_BB_WATCHDOG;
702
Sujith Manoharan071aa9a2014-01-13 13:55:11 +0530703 /*
704 * Enable GTT interrupts only for AR9003/AR9004 chips
705 * for now.
706 */
707 if (AR_SREV_9300_20_OR_LATER(ah))
708 ah->imask |= ATH9K_INT_GTT;
Sujithff37e332008-11-24 12:07:55 +0530709
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -0700710 if (ah->caps.hw_caps & ATH9K_HW_CAP_HT)
Pavel Roskin30691682010-03-31 18:05:31 -0400711 ah->imask |= ATH9K_INT_CST;
Sujithff37e332008-11-24 12:07:55 +0530712
Sujith Manoharane270e772012-06-04 16:27:19 +0530713 ath_mci_enable(sc);
Mohammed Shafi Shajakhan40dc5392011-11-30 10:41:18 +0530714
Oleksij Rempeleefa01d2014-02-27 11:40:46 +0100715 clear_bit(ATH_OP_INVALID, &common->op_flags);
Rajkumar Manoharan5f841b42010-10-27 18:31:15 +0530716 sc->sc_ah->is_monitoring = false;
Sujithff37e332008-11-24 12:07:55 +0530717
Felix Fietkauceb26a62012-10-03 21:07:51 +0200718 if (!ath_complete_reset(sc, false))
719 ah->reset_power_on = false;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700720
Felix Fietkauc0c11742011-11-16 13:08:41 +0100721 if (ah->led_pin >= 0) {
722 ath9k_hw_cfg_output(ah, ah->led_pin,
723 AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
Sujith Manoharanaeeb2062014-11-16 06:11:02 +0530724 ath9k_hw_set_gpio(ah, ah->led_pin,
725 (ah->config.led_active_high) ? 1 : 0);
Felix Fietkauc0c11742011-11-16 13:08:41 +0100726 }
727
728 /*
729 * Reset key cache to sane defaults (all entries cleared) instead of
730 * semi-random values after suspend/resume.
731 */
732 ath9k_cmn_init_crypto(sc->sc_ah);
733
Felix Fietkaua35051c2013-12-14 18:03:45 +0100734 ath9k_hw_reset_tsf(ah);
735
Felix Fietkau9adcf442011-09-03 01:40:26 +0200736 spin_unlock_bh(&sc->sc_pcu_lock);
Senthil Balasubramanian164ace32009-07-14 20:17:09 -0400737
Sujith141b38b2009-02-04 08:10:07 +0530738 mutex_unlock(&sc->mutex);
739
Felix Fietkauf62d8162011-03-25 17:43:41 +0100740 ath9k_ps_restore(sc);
741
Felix Fietkauceb26a62012-10-03 21:07:51 +0200742 return 0;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700743}
744
Thomas Huehn36323f82012-07-23 21:33:42 +0200745static void ath9k_tx(struct ieee80211_hw *hw,
746 struct ieee80211_tx_control *control,
747 struct sk_buff *skb)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700748{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100749 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -0700750 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Sujith528f0c62008-10-29 10:14:26 +0530751 struct ath_tx_control txctl;
Benoit Papillault1bc14882009-11-24 15:49:18 +0100752 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530753 unsigned long flags;
Sujith528f0c62008-10-29 10:14:26 +0530754
Gabor Juhos96148322009-07-24 17:27:21 +0200755 if (sc->ps_enabled) {
Jouni Malinendc8c4582009-05-19 17:01:42 +0300756 /*
757 * mac80211 does not set PM field for normal data frames, so we
758 * need to update that based on the current PS mode.
759 */
760 if (ieee80211_is_data(hdr->frame_control) &&
761 !ieee80211_is_nullfunc(hdr->frame_control) &&
762 !ieee80211_has_pm(hdr->frame_control)) {
Joe Perchesd2182b62011-12-15 14:55:53 -0800763 ath_dbg(common, PS,
Joe Perches226afe62010-12-02 19:12:37 -0800764 "Add PM=1 for a TX frame while in PS mode\n");
Jouni Malinendc8c4582009-05-19 17:01:42 +0300765 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
766 }
767 }
768
Sujith Manoharanad128862012-04-24 10:23:20 +0530769 if (unlikely(sc->sc_ah->power_mode == ATH9K_PM_NETWORK_SLEEP)) {
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300770 /*
771 * We are using PS-Poll and mac80211 can request TX while in
772 * power save mode. Need to wake up hardware for the TX to be
773 * completed and if needed, also for RX of buffered frames.
774 */
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300775 ath9k_ps_wakeup(sc);
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530776 spin_lock_irqsave(&sc->sc_pm_lock, flags);
Vasanthakumar Thiagarajanfdf76622010-05-17 18:57:55 -0700777 if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
778 ath9k_hw_setrxabort(sc->sc_ah, 0);
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300779 if (ieee80211_is_pspoll(hdr->frame_control)) {
Joe Perchesd2182b62011-12-15 14:55:53 -0800780 ath_dbg(common, PS,
Joe Perches226afe62010-12-02 19:12:37 -0800781 "Sending PS-Poll to pick a buffered frame\n");
Sujith1b04b932010-01-08 10:36:05 +0530782 sc->ps_flags |= PS_WAIT_FOR_PSPOLL_DATA;
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300783 } else {
Joe Perchesd2182b62011-12-15 14:55:53 -0800784 ath_dbg(common, PS, "Wake up to complete TX\n");
Sujith1b04b932010-01-08 10:36:05 +0530785 sc->ps_flags |= PS_WAIT_FOR_TX_ACK;
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300786 }
787 /*
788 * The actual restore operation will happen only after
Sujith Manoharanad128862012-04-24 10:23:20 +0530789 * the ps_flags bit is cleared. We are just dropping
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300790 * the ps_usecount here.
791 */
Sujith Manoharan07c15a32012-06-04 20:24:07 +0530792 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
Jouni Malinen9a23f9c2009-05-19 17:01:38 +0300793 ath9k_ps_restore(sc);
794 }
795
Sujith Manoharanad128862012-04-24 10:23:20 +0530796 /*
797 * Cannot tx while the hardware is in full sleep, it first needs a full
798 * chip reset to recover from that
799 */
800 if (unlikely(sc->sc_ah->power_mode == ATH9K_PM_FULL_SLEEP)) {
801 ath_err(common, "TX while HW is in FULL_SLEEP mode\n");
802 goto exit;
803 }
804
Sujith528f0c62008-10-29 10:14:26 +0530805 memset(&txctl, 0, sizeof(struct ath_tx_control));
Felix Fietkau066dae92010-11-07 14:59:39 +0100806 txctl.txq = sc->tx.txq_map[skb_get_queue_mapping(skb)];
Thomas Huehn36323f82012-07-23 21:33:42 +0200807 txctl.sta = control->sta;
Sujith528f0c62008-10-29 10:14:26 +0530808
Joe Perchesd2182b62011-12-15 14:55:53 -0800809 ath_dbg(common, XMIT, "transmitting packet, skb: %p\n", skb);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700810
Jouni Malinenc52f33d2009-03-03 19:23:29 +0200811 if (ath_tx_start(hw, skb, &txctl) != 0) {
Joe Perchesd2182b62011-12-15 14:55:53 -0800812 ath_dbg(common, XMIT, "TX failed\n");
Ben Greeara5a0bca2012-04-03 09:16:55 -0700813 TX_STAT_INC(txctl.txq->axq_qnum, txfailed);
Sujith528f0c62008-10-29 10:14:26 +0530814 goto exit;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700815 }
816
Johannes Berg7bb45682011-02-24 14:42:06 +0100817 return;
Sujith528f0c62008-10-29 10:14:26 +0530818exit:
Felix Fietkau249ee722012-10-03 21:07:52 +0200819 ieee80211_free_txskb(hw, skb);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700820}
821
822static void ath9k_stop(struct ieee80211_hw *hw)
823{
Felix Fietkau9ac586152011-01-24 19:23:18 +0100824 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezaf03abe2009-09-09 02:33:11 -0700825 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -0700826 struct ath_common *common = ath9k_hw_common(ah);
Felix Fietkauc0c11742011-11-16 13:08:41 +0100827 bool prev_idle;
Sujith9c84b792008-10-29 10:17:13 +0530828
Sujith Manoharanea22df22014-08-23 13:29:07 +0530829 ath9k_deinit_channel_context(sc);
830
Sujith4c483812009-08-18 10:51:52 +0530831 mutex_lock(&sc->mutex);
832
Felix Fietkau9adcf442011-09-03 01:40:26 +0200833 ath_cancel_work(sc);
Luis R. Rodriguezc94dbff2009-07-27 11:53:04 -0700834
Oleksij Rempeleefa01d2014-02-27 11:40:46 +0100835 if (test_bit(ATH_OP_INVALID, &common->op_flags)) {
Joe Perchesd2182b62011-12-15 14:55:53 -0800836 ath_dbg(common, ANY, "Device not present\n");
Sujith4c483812009-08-18 10:51:52 +0530837 mutex_unlock(&sc->mutex);
Sujith9c84b792008-10-29 10:17:13 +0530838 return;
839 }
840
Sujith3867cf62009-12-23 20:03:27 -0500841 /* Ensure HW is awake when we try to shut it down. */
842 ath9k_ps_wakeup(sc);
843
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700844 spin_lock_bh(&sc->sc_pcu_lock);
845
Stanislaw Gruszka203043f2011-01-25 14:08:40 +0100846 /* prevent tasklets to enable interrupts once we disable them */
847 ah->imask &= ~ATH9K_INT_GLOBAL;
848
Sujithff37e332008-11-24 12:07:55 +0530849 /* make sure h/w will not generate any interrupt
850 * before setting the invalid flag. */
Felix Fietkau4df30712010-11-08 20:54:47 +0100851 ath9k_hw_disable_interrupts(ah);
Sujithff37e332008-11-24 12:07:55 +0530852
Luis R. Rodriguez6a6733f2010-10-26 15:27:25 -0700853 spin_unlock_bh(&sc->sc_pcu_lock);
854
Stanislaw Gruszka203043f2011-01-25 14:08:40 +0100855 /* we can now sync irq and kill any running tasklets, since we already
856 * disabled interrupts and not holding a spin lock */
857 synchronize_irq(sc->irq);
858 tasklet_kill(&sc->intr_tq);
859 tasklet_kill(&sc->bcon_tasklet);
860
Felix Fietkauc0c11742011-11-16 13:08:41 +0100861 prev_idle = sc->ps_idle;
862 sc->ps_idle = true;
863
864 spin_lock_bh(&sc->sc_pcu_lock);
865
866 if (ah->led_pin >= 0) {
Sujith Manoharanaeeb2062014-11-16 06:11:02 +0530867 ath9k_hw_set_gpio(ah, ah->led_pin,
868 (ah->config.led_active_high) ? 0 : 1);
Felix Fietkauc0c11742011-11-16 13:08:41 +0100869 ath9k_hw_cfg_gpio_input(ah, ah->led_pin);
870 }
871
John W. Linville9ebea382013-01-28 13:54:03 -0500872 ath_prepare_reset(sc);
Felix Fietkauc0c11742011-11-16 13:08:41 +0100873
874 if (sc->rx.frag) {
875 dev_kfree_skb_any(sc->rx.frag);
876 sc->rx.frag = NULL;
877 }
878
879 if (!ah->curchan)
Felix Fietkaufbbcd142014-06-11 16:17:49 +0530880 ah->curchan = ath9k_cmn_get_channel(hw, ah,
881 &sc->cur_chan->chandef);
Felix Fietkauc0c11742011-11-16 13:08:41 +0100882
883 ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
Felix Fietkauef739ab2014-11-30 21:58:31 +0100884
885 set_bit(ATH_OP_INVALID, &common->op_flags);
886
Felix Fietkauc0c11742011-11-16 13:08:41 +0100887 ath9k_hw_phy_disable(ah);
888
889 ath9k_hw_configpcipowersave(ah, true);
890
891 spin_unlock_bh(&sc->sc_pcu_lock);
892
Sujith3867cf62009-12-23 20:03:27 -0500893 ath9k_ps_restore(sc);
894
Felix Fietkauc0c11742011-11-16 13:08:41 +0100895 sc->ps_idle = prev_idle;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700896
Sujith141b38b2009-02-04 08:10:07 +0530897 mutex_unlock(&sc->mutex);
898
Joe Perchesd2182b62011-12-15 14:55:53 -0800899 ath_dbg(common, CONFIG, "Driver halt\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700900}
901
Felix Fietkauc648ecb2013-10-11 23:31:00 +0200902static bool ath9k_uses_beacons(int type)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700903{
Ben Greear48014162011-01-15 19:13:48 +0000904 switch (type) {
Johannes Berg05c914f2008-09-11 00:01:58 +0200905 case NL80211_IFTYPE_AP:
Ben Greear48014162011-01-15 19:13:48 +0000906 case NL80211_IFTYPE_ADHOC:
Pat Erley9cb54122009-03-20 22:59:59 -0400907 case NL80211_IFTYPE_MESH_POINT:
Ben Greear48014162011-01-15 19:13:48 +0000908 return true;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700909 default:
Ben Greear48014162011-01-15 19:13:48 +0000910 return false;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700911 }
Luis R. Rodriguezf078f202008-08-04 00:16:41 -0700912}
913
Sujith Manoharan4b93fd22014-08-23 13:29:22 +0530914static void ath9k_vif_iter(struct ath9k_vif_iter_data *iter_data,
915 u8 *mac, struct ieee80211_vif *vif)
Ben Greear48014162011-01-15 19:13:48 +0000916{
Sujith Manoharancb355822014-09-17 14:45:56 +0530917 struct ath_vif *avp = (struct ath_vif *)vif->drv_priv;
Ben Greear48014162011-01-15 19:13:48 +0000918 int i;
919
Felix Fietkauab11bb22013-04-16 12:51:57 +0200920 if (iter_data->has_hw_macaddr) {
Ben Greear48014162011-01-15 19:13:48 +0000921 for (i = 0; i < ETH_ALEN; i++)
922 iter_data->mask[i] &=
923 ~(iter_data->hw_macaddr[i] ^ mac[i]);
Felix Fietkauab11bb22013-04-16 12:51:57 +0200924 } else {
925 memcpy(iter_data->hw_macaddr, mac, ETH_ALEN);
926 iter_data->has_hw_macaddr = true;
927 }
Ben Greear48014162011-01-15 19:13:48 +0000928
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +0530929 if (!vif->bss_conf.use_short_slot)
930 iter_data->slottime = ATH9K_SLOT_TIME_20;
931
Ben Greear48014162011-01-15 19:13:48 +0000932 switch (vif->type) {
933 case NL80211_IFTYPE_AP:
934 iter_data->naps++;
935 break;
936 case NL80211_IFTYPE_STATION:
937 iter_data->nstations++;
Sujith Manoharancb355822014-09-17 14:45:56 +0530938 if (avp->assoc && !iter_data->primary_sta)
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +0530939 iter_data->primary_sta = vif;
Ben Greear48014162011-01-15 19:13:48 +0000940 break;
941 case NL80211_IFTYPE_ADHOC:
942 iter_data->nadhocs++;
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +0530943 if (vif->bss_conf.enable_beacon)
944 iter_data->beacons = true;
Ben Greear48014162011-01-15 19:13:48 +0000945 break;
946 case NL80211_IFTYPE_MESH_POINT:
947 iter_data->nmeshes++;
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +0530948 if (vif->bss_conf.enable_beacon)
949 iter_data->beacons = true;
Ben Greear48014162011-01-15 19:13:48 +0000950 break;
951 case NL80211_IFTYPE_WDS:
952 iter_data->nwds++;
953 break;
954 default:
Ben Greear48014162011-01-15 19:13:48 +0000955 break;
956 }
957}
958
Sujith Manoharan2ce73c02014-09-19 13:00:42 +0530959static void ath9k_update_bssid_mask(struct ath_softc *sc,
960 struct ath_chanctx *ctx,
961 struct ath9k_vif_iter_data *iter_data)
962{
963 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
964 struct ath_vif *avp;
965 int i;
966
967 if (!ath9k_is_chanctx_enabled())
968 return;
969
970 list_for_each_entry(avp, &ctx->vifs, list) {
971 if (ctx->nvifs_assigned != 1)
972 continue;
973
974 if (!avp->vif->p2p || !iter_data->has_hw_macaddr)
975 continue;
976
977 ether_addr_copy(common->curbssid, avp->bssid);
978
979 /* perm_addr will be used as the p2p device address. */
980 for (i = 0; i < ETH_ALEN; i++)
981 iter_data->mask[i] &=
982 ~(iter_data->hw_macaddr[i] ^
983 sc->hw->wiphy->perm_addr[i]);
984 }
985}
986
Ben Greear48014162011-01-15 19:13:48 +0000987/* Called with sc->mutex held. */
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +0530988void ath9k_calculate_iter_data(struct ath_softc *sc,
989 struct ath_chanctx *ctx,
Ben Greear48014162011-01-15 19:13:48 +0000990 struct ath9k_vif_iter_data *iter_data)
991{
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +0530992 struct ath_vif *avp;
Ben Greear48014162011-01-15 19:13:48 +0000993
994 /*
Ben Greeardaad1662014-11-04 15:22:50 -0800995 * The hardware will use primary station addr together with the
996 * BSSID mask when matching addresses.
Ben Greear48014162011-01-15 19:13:48 +0000997 */
998 memset(iter_data, 0, sizeof(*iter_data));
Joe Perches93803b32015-03-02 19:54:49 -0800999 eth_broadcast_addr(iter_data->mask);
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301000 iter_data->slottime = ATH9K_SLOT_TIME_9;
Ben Greear48014162011-01-15 19:13:48 +00001001
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301002 list_for_each_entry(avp, &ctx->vifs, list)
1003 ath9k_vif_iter(iter_data, avp->vif->addr, avp->vif);
Sujith Manoharan2ce73c02014-09-19 13:00:42 +05301004
1005 ath9k_update_bssid_mask(sc, ctx, iter_data);
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301006}
1007
1008static void ath9k_set_assoc_state(struct ath_softc *sc,
1009 struct ieee80211_vif *vif, bool changed)
1010{
1011 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Sujith Manoharancb355822014-09-17 14:45:56 +05301012 struct ath_vif *avp = (struct ath_vif *)vif->drv_priv;
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301013 unsigned long flags;
1014
1015 set_bit(ATH_OP_PRIM_STA_VIF, &common->op_flags);
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301016
Sujith Manoharancb355822014-09-17 14:45:56 +05301017 ether_addr_copy(common->curbssid, avp->bssid);
1018 common->curaid = avp->aid;
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301019 ath9k_hw_write_associd(sc->sc_ah);
1020
1021 if (changed) {
1022 common->last_rssi = ATH_RSSI_DUMMY_MARKER;
1023 sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
1024
1025 spin_lock_irqsave(&sc->sc_pm_lock, flags);
1026 sc->ps_flags |= PS_BEACON_SYNC | PS_WAIT_FOR_BEACON;
1027 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
1028 }
1029
1030 if (ath9k_hw_mci_is_enabled(sc->sc_ah))
1031 ath9k_mci_update_wlan_channels(sc, false);
1032
1033 ath_dbg(common, CONFIG,
1034 "Primary Station interface: %pM, BSSID: %pM\n",
1035 vif->addr, common->curbssid);
Ben Greear48014162011-01-15 19:13:48 +00001036}
1037
Sujith Manoharan4ee26de2014-09-15 11:25:52 +05301038#ifdef CONFIG_ATH9K_CHANNEL_CONTEXT
1039static void ath9k_set_offchannel_state(struct ath_softc *sc)
1040{
1041 struct ath_hw *ah = sc->sc_ah;
1042 struct ath_common *common = ath9k_hw_common(ah);
1043 struct ieee80211_vif *vif = NULL;
1044
1045 ath9k_ps_wakeup(sc);
1046
1047 if (sc->offchannel.state < ATH_OFFCHANNEL_ROC_START)
1048 vif = sc->offchannel.scan_vif;
1049 else
1050 vif = sc->offchannel.roc_vif;
1051
1052 if (WARN_ON(!vif))
1053 goto exit;
1054
1055 eth_zero_addr(common->curbssid);
1056 eth_broadcast_addr(common->bssidmask);
Sujith Manoharan62ae1ae2014-10-17 07:40:20 +05301057 memcpy(common->macaddr, vif->addr, ETH_ALEN);
Sujith Manoharan4ee26de2014-09-15 11:25:52 +05301058 common->curaid = 0;
1059 ah->opmode = vif->type;
1060 ah->imask &= ~ATH9K_INT_SWBA;
1061 ah->imask &= ~ATH9K_INT_TSFOOR;
1062 ah->slottime = ATH9K_SLOT_TIME_9;
1063
1064 ath_hw_setbssidmask(common);
1065 ath9k_hw_setopmode(ah);
1066 ath9k_hw_write_associd(sc->sc_ah);
1067 ath9k_hw_set_interrupts(ah);
1068 ath9k_hw_init_global_settings(ah);
1069
1070exit:
1071 ath9k_ps_restore(sc);
1072}
1073#endif
1074
Ben Greear48014162011-01-15 19:13:48 +00001075/* Called with sc->mutex held. */
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301076void ath9k_calculate_summary_state(struct ath_softc *sc,
1077 struct ath_chanctx *ctx)
Ben Greear48014162011-01-15 19:13:48 +00001078{
Ben Greear48014162011-01-15 19:13:48 +00001079 struct ath_hw *ah = sc->sc_ah;
1080 struct ath_common *common = ath9k_hw_common(ah);
1081 struct ath9k_vif_iter_data iter_data;
Sujith Manoharan9bf30ff92014-09-05 08:03:11 +05301082 struct ath_beacon_config *cur_conf;
Ben Greear48014162011-01-15 19:13:48 +00001083
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301084 ath_chanctx_check_active(sc, ctx);
1085
1086 if (ctx != sc->cur_chan)
1087 return;
1088
Sujith Manoharan4ee26de2014-09-15 11:25:52 +05301089#ifdef CONFIG_ATH9K_CHANNEL_CONTEXT
1090 if (ctx == &sc->offchannel.chan)
1091 return ath9k_set_offchannel_state(sc);
1092#endif
1093
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301094 ath9k_ps_wakeup(sc);
1095 ath9k_calculate_iter_data(sc, ctx, &iter_data);
1096
1097 if (iter_data.has_hw_macaddr)
Sujith Manoharan62ae1ae2014-10-17 07:40:20 +05301098 memcpy(common->macaddr, iter_data.hw_macaddr, ETH_ALEN);
Ben Greear48014162011-01-15 19:13:48 +00001099
Ben Greear48014162011-01-15 19:13:48 +00001100 memcpy(common->bssidmask, iter_data.mask, ETH_ALEN);
1101 ath_hw_setbssidmask(common);
1102
Ben Greear48014162011-01-15 19:13:48 +00001103 if (iter_data.naps > 0) {
Sujith Manoharan9bf30ff92014-09-05 08:03:11 +05301104 cur_conf = &ctx->beacon;
Sujith Manoharan60ca9f82012-07-17 17:15:37 +05301105 ath9k_hw_set_tsfadjust(ah, true);
Ben Greear48014162011-01-15 19:13:48 +00001106 ah->opmode = NL80211_IFTYPE_AP;
Sujith Manoharan9bf30ff92014-09-05 08:03:11 +05301107 if (cur_conf->enable_beacon)
1108 iter_data.beacons = true;
Ben Greear48014162011-01-15 19:13:48 +00001109 } else {
Sujith Manoharan60ca9f82012-07-17 17:15:37 +05301110 ath9k_hw_set_tsfadjust(ah, false);
Ben Greear48014162011-01-15 19:13:48 +00001111
Javier Cardonafd5999c2011-05-03 16:57:19 -07001112 if (iter_data.nmeshes)
1113 ah->opmode = NL80211_IFTYPE_MESH_POINT;
1114 else if (iter_data.nwds)
Ben Greear48014162011-01-15 19:13:48 +00001115 ah->opmode = NL80211_IFTYPE_AP;
1116 else if (iter_data.nadhocs)
1117 ah->opmode = NL80211_IFTYPE_ADHOC;
1118 else
1119 ah->opmode = NL80211_IFTYPE_STATION;
1120 }
1121
Sujith Manoharandf35d292012-07-17 17:15:43 +05301122 ath9k_hw_setopmode(ah);
1123
Felix Fietkau748299f2014-06-11 16:18:04 +05301124 ctx->switch_after_beacon = false;
Felix Fietkau198823f2012-06-15 15:25:25 +02001125 if ((iter_data.nstations + iter_data.nadhocs + iter_data.nmeshes) > 0)
Ben Greear48014162011-01-15 19:13:48 +00001126 ah->imask |= ATH9K_INT_TSFOOR;
Felix Fietkau748299f2014-06-11 16:18:04 +05301127 else {
Ben Greear48014162011-01-15 19:13:48 +00001128 ah->imask &= ~ATH9K_INT_TSFOOR;
Felix Fietkau748299f2014-06-11 16:18:04 +05301129 if (iter_data.naps == 1 && iter_data.beacons)
1130 ctx->switch_after_beacon = true;
1131 }
Ben Greear48014162011-01-15 19:13:48 +00001132
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301133 ah->imask &= ~ATH9K_INT_SWBA;
1134 if (ah->opmode == NL80211_IFTYPE_STATION) {
1135 bool changed = (iter_data.primary_sta != ctx->primary_sta);
1136
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301137 if (iter_data.primary_sta) {
Sujith Manoharan602607b2014-09-05 08:03:10 +05301138 iter_data.beacons = true;
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301139 ath9k_set_assoc_state(sc, iter_data.primary_sta,
1140 changed);
Sujith Manoharan1030f9f2014-09-15 11:25:54 +05301141 ctx->primary_sta = iter_data.primary_sta;
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301142 } else {
1143 ctx->primary_sta = NULL;
Joe Perches93803b32015-03-02 19:54:49 -08001144 eth_zero_addr(common->curbssid);
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301145 common->curaid = 0;
1146 ath9k_hw_write_associd(sc->sc_ah);
1147 if (ath9k_hw_mci_is_enabled(sc->sc_ah))
1148 ath9k_mci_update_wlan_channels(sc, true);
1149 }
1150 } else if (iter_data.beacons) {
1151 ah->imask |= ATH9K_INT_SWBA;
1152 }
Felix Fietkau72d874c2011-10-08 20:06:19 +02001153 ath9k_hw_set_interrupts(ah);
Sujith Manoharan6dcc3442012-07-17 17:16:36 +05301154
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301155 if (iter_data.beacons)
1156 set_bit(ATH_OP_BEACONS, &common->op_flags);
1157 else
1158 clear_bit(ATH_OP_BEACONS, &common->op_flags);
1159
1160 if (ah->slottime != iter_data.slottime) {
1161 ah->slottime = iter_data.slottime;
1162 ath9k_hw_init_global_settings(ah);
Sujith Manoharan6dcc3442012-07-17 17:16:36 +05301163 }
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301164
1165 if (iter_data.primary_sta)
1166 set_bit(ATH_OP_PRIM_STA_VIF, &common->op_flags);
1167 else
1168 clear_bit(ATH_OP_PRIM_STA_VIF, &common->op_flags);
1169
Sujith Manoharan2ce73c02014-09-19 13:00:42 +05301170 ath_dbg(common, CONFIG,
1171 "macaddr: %pM, bssid: %pM, bssidmask: %pM\n",
1172 common->macaddr, common->curbssid, common->bssidmask);
1173
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301174 ath9k_ps_restore(sc);
Ben Greear48014162011-01-15 19:13:48 +00001175}
1176
Lorenzo Bianconi283dd112015-02-17 10:12:17 +01001177static void ath9k_tpc_vif_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
1178{
1179 int *power = (int *)data;
1180
1181 if (*power < vif->bss_conf.txpower)
1182 *power = vif->bss_conf.txpower;
1183}
1184
1185/* Called with sc->mutex held. */
1186void ath9k_set_txpower(struct ath_softc *sc, struct ieee80211_vif *vif)
1187{
1188 int power;
1189 struct ath_hw *ah = sc->sc_ah;
1190 struct ath_regulatory *reg = ath9k_hw_regulatory(ah);
1191
1192 ath9k_ps_wakeup(sc);
1193 if (ah->tpc_enabled) {
1194 power = (vif) ? vif->bss_conf.txpower : -1;
1195 ieee80211_iterate_active_interfaces_atomic(
1196 sc->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
1197 ath9k_tpc_vif_iter, &power);
1198 if (power == -1)
1199 power = sc->hw->conf.power_level;
1200 } else {
1201 power = sc->hw->conf.power_level;
1202 }
1203 sc->cur_chan->txpower = 2 * power;
1204 ath9k_hw_set_txpowerlimit(ah, sc->cur_chan->txpower, false);
1205 sc->cur_chan->cur_txpower = reg->max_power_level;
1206 ath9k_ps_restore(sc);
1207}
1208
Sujith Manoharana4027642014-09-05 09:50:55 +05301209static void ath9k_assign_hw_queues(struct ieee80211_hw *hw,
1210 struct ieee80211_vif *vif)
1211{
1212 int i;
1213
Sujith Manoharan868caae2014-10-21 19:23:02 +05301214 if (!ath9k_is_chanctx_enabled())
1215 return;
1216
Sujith Manoharana4027642014-09-05 09:50:55 +05301217 for (i = 0; i < IEEE80211_NUM_ACS; i++)
1218 vif->hw_queue[i] = i;
1219
Chun-Yeow Yeoh4b870c22014-11-12 16:40:19 +08001220 if (vif->type == NL80211_IFTYPE_AP ||
1221 vif->type == NL80211_IFTYPE_MESH_POINT)
Sujith Manoharana4027642014-09-05 09:50:55 +05301222 vif->cab_queue = hw->queues - 2;
1223 else
1224 vif->cab_queue = IEEE80211_INVAL_HW_QUEUE;
1225}
1226
Ben Greear48014162011-01-15 19:13:48 +00001227static int ath9k_add_interface(struct ieee80211_hw *hw,
1228 struct ieee80211_vif *vif)
1229{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001230 struct ath_softc *sc = hw->priv;
Ben Greear48014162011-01-15 19:13:48 +00001231 struct ath_hw *ah = sc->sc_ah;
1232 struct ath_common *common = ath9k_hw_common(ah);
Felix Fietkauf89d1bc2013-08-06 14:18:13 +02001233 struct ath_vif *avp = (void *)vif->drv_priv;
1234 struct ath_node *an = &avp->mcast_node;
Ben Greear48014162011-01-15 19:13:48 +00001235
1236 mutex_lock(&sc->mutex);
1237
Luis R. Rodriguez89f927a2013-10-14 17:42:11 -07001238 if (config_enabled(CONFIG_ATH9K_TX99)) {
Sujith Manoharanca529c92014-09-05 08:03:19 +05301239 if (sc->cur_chan->nvifs >= 1) {
Luis R. Rodriguez89f927a2013-10-14 17:42:11 -07001240 mutex_unlock(&sc->mutex);
1241 return -EOPNOTSUPP;
1242 }
1243 sc->tx99_vif = vif;
1244 }
1245
Joe Perchesd2182b62011-12-15 14:55:53 -08001246 ath_dbg(common, CONFIG, "Attach a VIF of type: %d\n", vif->type);
Sujith Manoharanca529c92014-09-05 08:03:19 +05301247 sc->cur_chan->nvifs++;
Ben Greear48014162011-01-15 19:13:48 +00001248
Sujith Manoharan130ef6e2012-07-17 17:15:30 +05301249 if (ath9k_uses_beacons(vif->type))
1250 ath9k_beacon_assign_slot(sc, vif);
1251
Felix Fietkaud463af42014-04-06 00:37:03 +02001252 avp->vif = vif;
Sujith Manoharan499afac2014-08-22 20:39:31 +05301253 if (!ath9k_is_chanctx_enabled()) {
Felix Fietkau39305632014-06-11 16:17:57 +05301254 avp->chanctx = sc->cur_chan;
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301255 list_add_tail(&avp->list, &avp->chanctx->vifs);
1256 }
Sujith Manoharana4027642014-09-05 09:50:55 +05301257
Ben Greeardaad1662014-11-04 15:22:50 -08001258 ath9k_calculate_summary_state(sc, avp->chanctx);
1259
Sujith Manoharana4027642014-09-05 09:50:55 +05301260 ath9k_assign_hw_queues(hw, vif);
Felix Fietkau04535312014-06-11 16:17:51 +05301261
Lorenzo Bianconi283dd112015-02-17 10:12:17 +01001262 ath9k_set_txpower(sc, vif);
1263
Felix Fietkauf89d1bc2013-08-06 14:18:13 +02001264 an->sc = sc;
1265 an->sta = NULL;
1266 an->vif = vif;
1267 an->no_ps_filter = true;
1268 ath_tx_node_init(sc, an);
1269
Ben Greear48014162011-01-15 19:13:48 +00001270 mutex_unlock(&sc->mutex);
Mohammed Shafi Shajakhan327967c2012-09-04 19:33:36 +05301271 return 0;
Ben Greear48014162011-01-15 19:13:48 +00001272}
1273
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301274static int ath9k_change_interface(struct ieee80211_hw *hw,
1275 struct ieee80211_vif *vif,
1276 enum nl80211_iftype new_type,
1277 bool p2p)
1278{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001279 struct ath_softc *sc = hw->priv;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301280 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkauc083ce92014-06-11 16:17:54 +05301281 struct ath_vif *avp = (void *)vif->drv_priv;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301282
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301283 mutex_lock(&sc->mutex);
Ben Greear48014162011-01-15 19:13:48 +00001284
Luis R. Rodriguez89f927a2013-10-14 17:42:11 -07001285 if (config_enabled(CONFIG_ATH9K_TX99)) {
1286 mutex_unlock(&sc->mutex);
1287 return -EOPNOTSUPP;
1288 }
1289
1290 ath_dbg(common, CONFIG, "Change Interface\n");
1291
Ben Greear48014162011-01-15 19:13:48 +00001292 if (ath9k_uses_beacons(vif->type))
Sujith Manoharan130ef6e2012-07-17 17:15:30 +05301293 ath9k_beacon_remove_slot(sc, vif);
Ben Greear48014162011-01-15 19:13:48 +00001294
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301295 vif->type = new_type;
1296 vif->p2p = p2p;
1297
Sujith Manoharan130ef6e2012-07-17 17:15:30 +05301298 if (ath9k_uses_beacons(vif->type))
1299 ath9k_beacon_assign_slot(sc, vif);
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301300
Sujith Manoharana4027642014-09-05 09:50:55 +05301301 ath9k_assign_hw_queues(hw, vif);
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301302 ath9k_calculate_summary_state(sc, avp->chanctx);
Sujith Manoharan130ef6e2012-07-17 17:15:30 +05301303
Lorenzo Bianconi283dd112015-02-17 10:12:17 +01001304 ath9k_set_txpower(sc, vif);
1305
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301306 mutex_unlock(&sc->mutex);
Mohammed Shafi Shajakhan327967c2012-09-04 19:33:36 +05301307 return 0;
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05301308}
1309
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001310static void ath9k_remove_interface(struct ieee80211_hw *hw,
Johannes Berg1ed32e42009-12-23 13:15:45 +01001311 struct ieee80211_vif *vif)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001312{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001313 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -07001314 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkauf89d1bc2013-08-06 14:18:13 +02001315 struct ath_vif *avp = (void *)vif->drv_priv;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001316
Joe Perchesd2182b62011-12-15 14:55:53 -08001317 ath_dbg(common, CONFIG, "Detach Interface\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001318
Sujith141b38b2009-02-04 08:10:07 +05301319 mutex_lock(&sc->mutex);
1320
Sujith Manoharanc7dd40c2014-08-22 20:39:30 +05301321 ath9k_p2p_remove_vif(sc, vif);
Felix Fietkaud463af42014-04-06 00:37:03 +02001322
Sujith Manoharanca529c92014-09-05 08:03:19 +05301323 sc->cur_chan->nvifs--;
Luis R. Rodriguez89f927a2013-10-14 17:42:11 -07001324 sc->tx99_vif = NULL;
Sujith Manoharan499afac2014-08-22 20:39:31 +05301325 if (!ath9k_is_chanctx_enabled())
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301326 list_del(&avp->list);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001327
Ben Greear48014162011-01-15 19:13:48 +00001328 if (ath9k_uses_beacons(vif->type))
Sujith Manoharan130ef6e2012-07-17 17:15:30 +05301329 ath9k_beacon_remove_slot(sc, vif);
Jouni Malinen2c3db3d2009-03-03 19:23:26 +02001330
Felix Fietkauf89d1bc2013-08-06 14:18:13 +02001331 ath_tx_node_cleanup(sc, &avp->mcast_node);
1332
Ben Greeardaad1662014-11-04 15:22:50 -08001333 ath9k_calculate_summary_state(sc, avp->chanctx);
1334
Lorenzo Bianconi283dd112015-02-17 10:12:17 +01001335 ath9k_set_txpower(sc, NULL);
1336
Sujith141b38b2009-02-04 08:10:07 +05301337 mutex_unlock(&sc->mutex);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001338}
1339
Senthil Balasubramanianfbab7392010-10-05 20:36:40 +05301340static void ath9k_enable_ps(struct ath_softc *sc)
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301341{
Pavel Roskin30691682010-03-31 18:05:31 -04001342 struct ath_hw *ah = sc->sc_ah;
Sujith Manoharanad128862012-04-24 10:23:20 +05301343 struct ath_common *common = ath9k_hw_common(ah);
Pavel Roskin30691682010-03-31 18:05:31 -04001344
Luis R. Rodriguez89f927a2013-10-14 17:42:11 -07001345 if (config_enabled(CONFIG_ATH9K_TX99))
1346 return;
1347
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301348 sc->ps_enabled = true;
Pavel Roskin30691682010-03-31 18:05:31 -04001349 if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP)) {
1350 if ((ah->imask & ATH9K_INT_TIM_TIMER) == 0) {
1351 ah->imask |= ATH9K_INT_TIM_TIMER;
Felix Fietkau72d874c2011-10-08 20:06:19 +02001352 ath9k_hw_set_interrupts(ah);
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301353 }
Vasanthakumar Thiagarajanfdf76622010-05-17 18:57:55 -07001354 ath9k_hw_setrxabort(ah, 1);
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301355 }
Sujith Manoharanad128862012-04-24 10:23:20 +05301356 ath_dbg(common, PS, "PowerSave enabled\n");
Senthil Balasubramanian3f7c5c12010-02-03 22:51:13 +05301357}
1358
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301359static void ath9k_disable_ps(struct ath_softc *sc)
1360{
1361 struct ath_hw *ah = sc->sc_ah;
Sujith Manoharanad128862012-04-24 10:23:20 +05301362 struct ath_common *common = ath9k_hw_common(ah);
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301363
Luis R. Rodriguez89f927a2013-10-14 17:42:11 -07001364 if (config_enabled(CONFIG_ATH9K_TX99))
1365 return;
1366
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301367 sc->ps_enabled = false;
1368 ath9k_hw_setpower(ah, ATH9K_PM_AWAKE);
1369 if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP)) {
1370 ath9k_hw_setrxabort(ah, 0);
1371 sc->ps_flags &= ~(PS_WAIT_FOR_BEACON |
1372 PS_WAIT_FOR_CAB |
1373 PS_WAIT_FOR_PSPOLL_DATA |
1374 PS_WAIT_FOR_TX_ACK);
1375 if (ah->imask & ATH9K_INT_TIM_TIMER) {
1376 ah->imask &= ~ATH9K_INT_TIM_TIMER;
Felix Fietkau72d874c2011-10-08 20:06:19 +02001377 ath9k_hw_set_interrupts(ah);
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301378 }
1379 }
Sujith Manoharanad128862012-04-24 10:23:20 +05301380 ath_dbg(common, PS, "PowerSave disabled\n");
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301381}
1382
Johannes Berge8975582008-10-09 12:18:51 +02001383static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001384{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001385 struct ath_softc *sc = hw->priv;
Felix Fietkau34300982010-10-10 18:21:52 +02001386 struct ath_hw *ah = sc->sc_ah;
1387 struct ath_common *common = ath9k_hw_common(ah);
Johannes Berge8975582008-10-09 12:18:51 +02001388 struct ieee80211_conf *conf = &hw->conf;
Felix Fietkaufbbcd142014-06-11 16:17:49 +05301389 struct ath_chanctx *ctx = sc->cur_chan;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001390
Felix Fietkauc0c11742011-11-16 13:08:41 +01001391 ath9k_ps_wakeup(sc);
Sujithaa33de02008-12-18 11:40:16 +05301392 mutex_lock(&sc->mutex);
Sujith141b38b2009-02-04 08:10:07 +05301393
Felix Fietkaudaa1b6e2011-11-16 13:08:43 +01001394 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
Felix Fietkau7545daf2011-01-24 19:23:16 +01001395 sc->ps_idle = !!(conf->flags & IEEE80211_CONF_IDLE);
Rajkumar Manoharanb73f3e72012-07-01 19:53:53 +05301396 if (sc->ps_idle) {
Felix Fietkaudaa1b6e2011-11-16 13:08:43 +01001397 ath_cancel_work(sc);
Rajkumar Manoharanb73f3e72012-07-01 19:53:53 +05301398 ath9k_stop_btcoex(sc);
1399 } else {
1400 ath9k_start_btcoex(sc);
Felix Fietkau75600ab2012-04-12 20:36:31 +02001401 /*
1402 * The chip needs a reset to properly wake up from
1403 * full sleep
1404 */
Felix Fietkau39305632014-06-11 16:17:57 +05301405 ath_chanctx_set_channel(sc, ctx, &ctx->chandef);
Rajkumar Manoharanb73f3e72012-07-01 19:53:53 +05301406 }
Felix Fietkaudaa1b6e2011-11-16 13:08:43 +01001407 }
Luis R. Rodriguez64839172009-07-14 20:22:53 -04001408
Luis R. Rodrigueze7824a52009-11-24 02:53:25 -05001409 /*
1410 * We just prepare to enable PS. We have to wait until our AP has
1411 * ACK'd our null data frame to disable RX otherwise we'll ignore
1412 * those ACKs and end up retransmitting the same null data frames.
1413 * IEEE80211_CONF_CHANGE_PS is only passed by mac80211 for STA mode.
1414 */
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301415 if (changed & IEEE80211_CONF_CHANGE_PS) {
Luis R. Rodriguez8ab2cd02010-09-16 15:12:26 -04001416 unsigned long flags;
1417 spin_lock_irqsave(&sc->sc_pm_lock, flags);
Senthil Balasubramanianfbab7392010-10-05 20:36:40 +05301418 if (conf->flags & IEEE80211_CONF_PS)
1419 ath9k_enable_ps(sc);
Senthil Balasubramanian845d7082010-10-05 20:36:41 +05301420 else
1421 ath9k_disable_ps(sc);
Luis R. Rodriguez8ab2cd02010-09-16 15:12:26 -04001422 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301423 }
1424
Sujith199afd92010-01-08 10:36:13 +05301425 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1426 if (conf->flags & IEEE80211_CONF_MONITOR) {
Joe Perchesd2182b62011-12-15 14:55:53 -08001427 ath_dbg(common, CONFIG, "Monitor mode is enabled\n");
Rajkumar Manoharan5f841b42010-10-27 18:31:15 +05301428 sc->sc_ah->is_monitoring = true;
1429 } else {
Joe Perchesd2182b62011-12-15 14:55:53 -08001430 ath_dbg(common, CONFIG, "Monitor mode is disabled\n");
Rajkumar Manoharan5f841b42010-10-27 18:31:15 +05301431 sc->sc_ah->is_monitoring = false;
Sujith199afd92010-01-08 10:36:13 +05301432 }
1433 }
1434
Sujith Manoharan499afac2014-08-22 20:39:31 +05301435 if (!ath9k_is_chanctx_enabled() && (changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
Felix Fietkaufbbcd142014-06-11 16:17:49 +05301436 ctx->offchannel = !!(conf->flags & IEEE80211_CONF_OFFCHANNEL);
Felix Fietkaubff11762014-06-11 16:17:52 +05301437 ath_chanctx_set_channel(sc, ctx, &hw->conf.chandef);
Sujith094d05d2008-12-12 11:57:43 +05301438 }
Sujith86b89ee2008-08-07 10:54:57 +05301439
Sujithaa33de02008-12-18 11:40:16 +05301440 mutex_unlock(&sc->mutex);
Felix Fietkauc0c11742011-11-16 13:08:41 +01001441 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301442
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001443 return 0;
1444}
1445
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001446#define SUPPORTED_FILTERS \
Johannes Bergdf140462015-04-22 14:40:58 +02001447 (FIF_ALLMULTI | \
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001448 FIF_CONTROL | \
Luis R. Rodriguezaf6a3fc2009-08-08 21:55:16 -04001449 FIF_PSPOLL | \
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001450 FIF_OTHER_BSS | \
1451 FIF_BCN_PRBRESP_PROMISC | \
Jouni Malinen9c1d8e42010-10-13 17:29:31 +03001452 FIF_PROBE_REQ | \
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001453 FIF_FCSFAIL)
1454
Sujith7dcfdcd2008-08-11 14:03:13 +05301455/* FIXME: sc->sc_full_reset ? */
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001456static void ath9k_configure_filter(struct ieee80211_hw *hw,
1457 unsigned int changed_flags,
1458 unsigned int *total_flags,
Johannes Berg3ac64be2009-08-17 16:16:53 +02001459 u64 multicast)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001460{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001461 struct ath_softc *sc = hw->priv;
Janusz.Dziedzic@tieto.comf3771c02015-07-21 11:11:42 +02001462 struct ath_chanctx *ctx;
Sujith7dcfdcd2008-08-11 14:03:13 +05301463 u32 rfilt;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001464
1465 changed_flags &= SUPPORTED_FILTERS;
1466 *total_flags &= SUPPORTED_FILTERS;
1467
Sujith Manoharanfce34432014-09-05 08:03:18 +05301468 spin_lock_bh(&sc->chan_lock);
Janusz.Dziedzic@tieto.comf3771c02015-07-21 11:11:42 +02001469 ath_for_each_chanctx(sc, ctx)
1470 ctx->rxfilter = *total_flags;
Janusz.Dziedzic@tieto.com17382032015-07-21 11:11:43 +02001471#ifdef CONFIG_ATH9K_CHANNEL_CONTEXT
1472 sc->offchannel.chan.rxfilter = *total_flags;
1473#endif
Sujith Manoharanfce34432014-09-05 08:03:18 +05301474 spin_unlock_bh(&sc->chan_lock);
1475
Jouni Malinenaa68aea2009-05-19 17:01:41 +03001476 ath9k_ps_wakeup(sc);
Sujith7dcfdcd2008-08-11 14:03:13 +05301477 rfilt = ath_calcrxfilter(sc);
1478 ath9k_hw_setrxfilter(sc->sc_ah, rfilt);
Jouni Malinenaa68aea2009-05-19 17:01:41 +03001479 ath9k_ps_restore(sc);
Sujith7dcfdcd2008-08-11 14:03:13 +05301480
Joe Perchesd2182b62011-12-15 14:55:53 -08001481 ath_dbg(ath9k_hw_common(sc->sc_ah), CONFIG, "Set HW RX filter: 0x%x\n",
1482 rfilt);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001483}
1484
Johannes Berg4ca77862010-02-19 19:06:56 +01001485static int ath9k_sta_add(struct ieee80211_hw *hw,
1486 struct ieee80211_vif *vif,
1487 struct ieee80211_sta *sta)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001488{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001489 struct ath_softc *sc = hw->priv;
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001490 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1491 struct ath_node *an = (struct ath_node *) sta->drv_priv;
1492 struct ieee80211_key_conf ps_key = { };
Felix Fietkau4ef69d02013-04-27 11:47:01 +02001493 int key;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001494
Ben Greear7e1e3862011-11-03 11:33:13 -07001495 ath_node_attach(sc, sta, vif);
Felix Fietkauf59a59f2011-05-10 20:52:22 +02001496
1497 if (vif->type != NL80211_IFTYPE_AP &&
1498 vif->type != NL80211_IFTYPE_AP_VLAN)
1499 return 0;
1500
Felix Fietkau4ef69d02013-04-27 11:47:01 +02001501 key = ath_key_config(common, vif, sta, &ps_key);
Rajkumar Manoharan4bbf4412014-05-22 12:35:49 +05301502 if (key > 0) {
Felix Fietkau4ef69d02013-04-27 11:47:01 +02001503 an->ps_key = key;
Rajkumar Manoharan4bbf4412014-05-22 12:35:49 +05301504 an->key_idx[0] = key;
1505 }
Johannes Berg4ca77862010-02-19 19:06:56 +01001506
1507 return 0;
1508}
1509
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001510static void ath9k_del_ps_key(struct ath_softc *sc,
1511 struct ieee80211_vif *vif,
1512 struct ieee80211_sta *sta)
1513{
1514 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1515 struct ath_node *an = (struct ath_node *) sta->drv_priv;
1516 struct ieee80211_key_conf ps_key = { .hw_key_idx = an->ps_key };
1517
1518 if (!an->ps_key)
1519 return;
1520
1521 ath_key_delete(common, &ps_key);
Felix Fietkau4ef69d02013-04-27 11:47:01 +02001522 an->ps_key = 0;
Rajkumar Manoharan4bbf4412014-05-22 12:35:49 +05301523 an->key_idx[0] = 0;
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001524}
1525
Johannes Berg4ca77862010-02-19 19:06:56 +01001526static int ath9k_sta_remove(struct ieee80211_hw *hw,
1527 struct ieee80211_vif *vif,
1528 struct ieee80211_sta *sta)
1529{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001530 struct ath_softc *sc = hw->priv;
Johannes Berg4ca77862010-02-19 19:06:56 +01001531
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001532 ath9k_del_ps_key(sc, vif, sta);
Johannes Berg4ca77862010-02-19 19:06:56 +01001533 ath_node_detach(sc, sta);
1534
1535 return 0;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001536}
1537
Sujith Manoharandf3c6eb2014-10-17 07:40:08 +05301538static int ath9k_sta_state(struct ieee80211_hw *hw,
1539 struct ieee80211_vif *vif,
1540 struct ieee80211_sta *sta,
1541 enum ieee80211_sta_state old_state,
1542 enum ieee80211_sta_state new_state)
1543{
1544 struct ath_softc *sc = hw->priv;
1545 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1546 int ret = 0;
1547
1548 if (old_state == IEEE80211_STA_AUTH &&
1549 new_state == IEEE80211_STA_ASSOC) {
1550 ret = ath9k_sta_add(hw, vif, sta);
1551 ath_dbg(common, CONFIG,
1552 "Add station: %pM\n", sta->addr);
1553 } else if (old_state == IEEE80211_STA_ASSOC &&
1554 new_state == IEEE80211_STA_AUTH) {
1555 ret = ath9k_sta_remove(hw, vif, sta);
1556 ath_dbg(common, CONFIG,
1557 "Remove station: %pM\n", sta->addr);
1558 }
1559
Sujith Manoharanb8f92792014-10-17 07:40:09 +05301560 if (ath9k_is_chanctx_enabled()) {
Sujith Manoharan91e6ceb2014-10-17 07:40:19 +05301561 if (vif->type == NL80211_IFTYPE_STATION) {
1562 if (old_state == IEEE80211_STA_ASSOC &&
1563 new_state == IEEE80211_STA_AUTHORIZED)
1564 ath_chanctx_event(sc, vif,
1565 ATH_CHANCTX_EVENT_AUTHORIZED);
1566 }
Sujith Manoharanb8f92792014-10-17 07:40:09 +05301567 }
1568
Sujith Manoharandf3c6eb2014-10-17 07:40:08 +05301569 return ret;
1570}
1571
Rajkumar Manoharan4bbf4412014-05-22 12:35:49 +05301572static void ath9k_sta_set_tx_filter(struct ath_hw *ah,
1573 struct ath_node *an,
1574 bool set)
1575{
1576 int i;
1577
1578 for (i = 0; i < ARRAY_SIZE(an->key_idx); i++) {
1579 if (!an->key_idx[i])
1580 continue;
1581 ath9k_hw_set_tx_filter(ah, an->key_idx[i], set);
1582 }
1583}
1584
Felix Fietkau55195412011-04-17 23:28:09 +02001585static void ath9k_sta_notify(struct ieee80211_hw *hw,
1586 struct ieee80211_vif *vif,
1587 enum sta_notify_cmd cmd,
1588 struct ieee80211_sta *sta)
1589{
1590 struct ath_softc *sc = hw->priv;
1591 struct ath_node *an = (struct ath_node *) sta->drv_priv;
1592
1593 switch (cmd) {
1594 case STA_NOTIFY_SLEEP:
1595 an->sleeping = true;
Johannes Berg042ec452011-09-29 16:04:26 +02001596 ath_tx_aggr_sleep(sta, sc, an);
Rajkumar Manoharan4bbf4412014-05-22 12:35:49 +05301597 ath9k_sta_set_tx_filter(sc->sc_ah, an, true);
Felix Fietkau55195412011-04-17 23:28:09 +02001598 break;
1599 case STA_NOTIFY_AWAKE:
Rajkumar Manoharan4bbf4412014-05-22 12:35:49 +05301600 ath9k_sta_set_tx_filter(sc->sc_ah, an, false);
Felix Fietkau55195412011-04-17 23:28:09 +02001601 an->sleeping = false;
1602 ath_tx_aggr_wakeup(sc, an);
1603 break;
1604 }
1605}
1606
Eliad Peller8a3a3c82011-10-02 10:15:52 +02001607static int ath9k_conf_tx(struct ieee80211_hw *hw,
1608 struct ieee80211_vif *vif, u16 queue,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001609 const struct ieee80211_tx_queue_params *params)
1610{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001611 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -07001612 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkau066dae92010-11-07 14:59:39 +01001613 struct ath_txq *txq;
Sujithea9880f2008-08-07 10:53:10 +05301614 struct ath9k_tx_queue_info qi;
Felix Fietkau066dae92010-11-07 14:59:39 +01001615 int ret = 0;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001616
Sujith Manoharanbea843c2012-11-21 18:13:10 +05301617 if (queue >= IEEE80211_NUM_ACS)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001618 return 0;
1619
Felix Fietkau066dae92010-11-07 14:59:39 +01001620 txq = sc->tx.txq_map[queue];
1621
Felix Fietkau96f372c2011-04-07 19:07:17 +02001622 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301623 mutex_lock(&sc->mutex);
1624
Sujith1ffb0612009-03-30 15:28:46 +05301625 memset(&qi, 0, sizeof(struct ath9k_tx_queue_info));
1626
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001627 qi.tqi_aifs = params->aifs;
1628 qi.tqi_cwmin = params->cw_min;
1629 qi.tqi_cwmax = params->cw_max;
Felix Fietkau531bd072012-07-15 19:53:34 +02001630 qi.tqi_burstTime = params->txop * 32;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001631
Joe Perchesd2182b62011-12-15 14:55:53 -08001632 ath_dbg(common, CONFIG,
Joe Perches226afe62010-12-02 19:12:37 -08001633 "Configure tx [queue/halq] [%d/%d], aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
1634 queue, txq->axq_qnum, params->aifs, params->cw_min,
1635 params->cw_max, params->txop);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001636
Felix Fietkauaa5955c2012-07-15 19:53:36 +02001637 ath_update_max_aggr_framelen(sc, queue, qi.tqi_burstTime);
Felix Fietkau066dae92010-11-07 14:59:39 +01001638 ret = ath_txq_update(sc, txq->axq_qnum, &qi);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001639 if (ret)
Joe Perches38002762010-12-02 19:12:36 -08001640 ath_err(common, "TXQ Update failed\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001641
Sujith141b38b2009-02-04 08:10:07 +05301642 mutex_unlock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001643 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301644
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001645 return ret;
1646}
1647
1648static int ath9k_set_key(struct ieee80211_hw *hw,
1649 enum set_key_cmd cmd,
Johannes Bergdc822b52008-12-29 12:55:09 +01001650 struct ieee80211_vif *vif,
1651 struct ieee80211_sta *sta,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001652 struct ieee80211_key_conf *key)
1653{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001654 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezc46917b2009-09-13 02:42:02 -07001655 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Rajkumar Manoharan4bbf4412014-05-22 12:35:49 +05301656 struct ath_node *an = NULL;
1657 int ret = 0, i;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001658
John W. Linville3e6109c2011-01-05 09:39:17 -05001659 if (ath9k_modparam_nohwcrypt)
Jouni Malinenb3bd89c2009-02-24 13:42:01 +02001660 return -ENOSPC;
1661
Chun-Yeow Yeoh5bd5e9a2011-12-07 12:45:46 -08001662 if ((vif->type == NL80211_IFTYPE_ADHOC ||
1663 vif->type == NL80211_IFTYPE_MESH_POINT) &&
Jouni Malinencfdc9a82011-03-23 14:52:19 +02001664 (key->cipher == WLAN_CIPHER_SUITE_TKIP ||
1665 key->cipher == WLAN_CIPHER_SUITE_CCMP) &&
1666 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
1667 /*
1668 * For now, disable hw crypto for the RSN IBSS group keys. This
1669 * could be optimized in the future to use a modified key cache
1670 * design to support per-STA RX GTK, but until that gets
1671 * implemented, use of software crypto for group addressed
1672 * frames is a acceptable to allow RSN IBSS to be used.
1673 */
1674 return -EOPNOTSUPP;
1675 }
1676
Sujith141b38b2009-02-04 08:10:07 +05301677 mutex_lock(&sc->mutex);
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301678 ath9k_ps_wakeup(sc);
Rajkumar Manoharan4bbf4412014-05-22 12:35:49 +05301679 ath_dbg(common, CONFIG, "Set HW Key %d\n", cmd);
1680 if (sta)
1681 an = (struct ath_node *)sta->drv_priv;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001682
1683 switch (cmd) {
1684 case SET_KEY:
Felix Fietkau93ae2dd2011-04-17 23:28:10 +02001685 if (sta)
1686 ath9k_del_ps_key(sc, vif, sta);
1687
Rajkumar Manoharan4bbf4412014-05-22 12:35:49 +05301688 key->hw_key_idx = 0;
Bruno Randolf040e5392010-09-08 16:05:04 +09001689 ret = ath_key_config(common, vif, sta, key);
Jouni Malinen6ace2892008-12-17 13:32:17 +02001690 if (ret >= 0) {
1691 key->hw_key_idx = ret;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001692 /* push IV and Michael MIC generation to stack */
1693 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
Johannes Berg97359d12010-08-10 09:46:38 +02001694 if (key->cipher == WLAN_CIPHER_SUITE_TKIP)
Senthil Balasubramanian1b961752008-09-01 19:45:21 +05301695 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
Chun-Yeow Yeohe6510b12014-11-16 03:05:40 +08001696 if (sc->sc_ah->sw_mgmt_crypto_tx &&
Johannes Berg97359d12010-08-10 09:46:38 +02001697 key->cipher == WLAN_CIPHER_SUITE_CCMP)
Johannes Berge548c492012-09-04 17:08:23 +02001698 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
Jouni Malinen6ace2892008-12-17 13:32:17 +02001699 ret = 0;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001700 }
Rajkumar Manoharan4bbf4412014-05-22 12:35:49 +05301701 if (an && key->hw_key_idx) {
1702 for (i = 0; i < ARRAY_SIZE(an->key_idx); i++) {
1703 if (an->key_idx[i])
1704 continue;
1705 an->key_idx[i] = key->hw_key_idx;
1706 break;
1707 }
1708 WARN_ON(i == ARRAY_SIZE(an->key_idx));
1709 }
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001710 break;
1711 case DISABLE_KEY:
Bruno Randolf040e5392010-09-08 16:05:04 +09001712 ath_key_delete(common, key);
Rajkumar Manoharan4bbf4412014-05-22 12:35:49 +05301713 if (an) {
1714 for (i = 0; i < ARRAY_SIZE(an->key_idx); i++) {
1715 if (an->key_idx[i] != key->hw_key_idx)
1716 continue;
1717 an->key_idx[i] = 0;
1718 break;
1719 }
1720 }
1721 key->hw_key_idx = 0;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001722 break;
1723 default:
1724 ret = -EINVAL;
1725 }
1726
Vivek Natarajan3cbb5dd2009-01-20 11:17:08 +05301727 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301728 mutex_unlock(&sc->mutex);
1729
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001730 return ret;
1731}
Sujith Manoharan6c43c0902012-07-17 17:15:50 +05301732
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001733static void ath9k_bss_info_changed(struct ieee80211_hw *hw,
1734 struct ieee80211_vif *vif,
1735 struct ieee80211_bss_conf *bss_conf,
1736 u32 changed)
1737{
Sujith Manoharanda0d45f2012-07-17 17:16:29 +05301738#define CHECK_ANI \
1739 (BSS_CHANGED_ASSOC | \
1740 BSS_CHANGED_IBSS | \
1741 BSS_CHANGED_BEACON_ENABLED)
1742
Felix Fietkau9ac586152011-01-24 19:23:18 +01001743 struct ath_softc *sc = hw->priv;
Johannes Berg2d0ddec2009-04-23 16:13:26 +02001744 struct ath_hw *ah = sc->sc_ah;
Luis R. Rodriguez15107182009-09-10 09:22:37 -07001745 struct ath_common *common = ath9k_hw_common(ah);
Johannes Berg2d0ddec2009-04-23 16:13:26 +02001746 struct ath_vif *avp = (void *)vif->drv_priv;
Felix Fietkau0005baf2010-01-15 02:33:40 +01001747 int slottime;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001748
Felix Fietkau96f372c2011-04-07 19:07:17 +02001749 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301750 mutex_lock(&sc->mutex);
1751
Rajkumar Manoharan9f619032012-03-10 05:06:49 +05301752 if (changed & BSS_CHANGED_ASSOC) {
Sujith Manoharan6c43c0902012-07-17 17:15:50 +05301753 ath_dbg(common, CONFIG, "BSSID %pM Changed ASSOC %d\n",
1754 bss_conf->bssid, bss_conf->assoc);
Sujithc6089cc2009-11-16 11:40:48 +05301755
Sujith Manoharan62ae1ae2014-10-17 07:40:20 +05301756 memcpy(avp->bssid, bss_conf->bssid, ETH_ALEN);
Sujith Manoharancb355822014-09-17 14:45:56 +05301757 avp->aid = bss_conf->aid;
1758 avp->assoc = bss_conf->assoc;
1759
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301760 ath9k_calculate_summary_state(sc, avp->chanctx);
Johannes Berg2d0ddec2009-04-23 16:13:26 +02001761 }
1762
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301763 if (changed & BSS_CHANGED_IBSS) {
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301764 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1765 common->curaid = bss_conf->aid;
1766 ath9k_hw_write_associd(sc->sc_ah);
Rajkumar Manoharan2e5ef452011-05-20 17:52:12 +05301767 }
1768
Sujith Manoharanef4ad632012-07-17 17:15:56 +05301769 if ((changed & BSS_CHANGED_BEACON_ENABLED) ||
Rajkumar Manoharan9198cf42014-06-26 16:54:40 +05301770 (changed & BSS_CHANGED_BEACON_INT) ||
1771 (changed & BSS_CHANGED_BEACON_INFO)) {
Sujith Manoharan9bf30ff92014-09-05 08:03:11 +05301772 ath9k_beacon_config(sc, vif, changed);
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301773 if (changed & BSS_CHANGED_BEACON_ENABLED)
1774 ath9k_calculate_summary_state(sc, avp->chanctx);
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301775 }
Johannes Berg2d0ddec2009-04-23 16:13:26 +02001776
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05301777 if ((avp->chanctx == sc->cur_chan) &&
1778 (changed & BSS_CHANGED_ERP_SLOT)) {
Felix Fietkau0005baf2010-01-15 02:33:40 +01001779 if (bss_conf->use_short_slot)
1780 slottime = 9;
1781 else
1782 slottime = 20;
1783 if (vif->type == NL80211_IFTYPE_AP) {
1784 /*
1785 * Defer update, so that connected stations can adjust
1786 * their settings at the same time.
1787 * See beacon.c for more details
1788 */
1789 sc->beacon.slottime = slottime;
1790 sc->beacon.updateslot = UPDATE;
1791 } else {
1792 ah->slottime = slottime;
1793 ath9k_hw_init_global_settings(ah);
1794 }
1795 }
1796
Sujith Manoharanc7dd40c2014-08-22 20:39:30 +05301797 if (changed & BSS_CHANGED_P2P_PS)
1798 ath9k_p2p_bss_info_changed(sc, vif);
Felix Fietkaud463af42014-04-06 00:37:03 +02001799
Sujith Manoharanda0d45f2012-07-17 17:16:29 +05301800 if (changed & CHECK_ANI)
1801 ath_check_ani(sc);
1802
Lorenzo Bianconi283dd112015-02-17 10:12:17 +01001803 if (changed & BSS_CHANGED_TXPOWER) {
1804 ath_dbg(common, CONFIG, "vif %pM power %d dbm power_type %d\n",
1805 vif->addr, bss_conf->txpower, bss_conf->txpower_type);
1806 ath9k_set_txpower(sc, vif);
1807 }
1808
Sujith141b38b2009-02-04 08:10:07 +05301809 mutex_unlock(&sc->mutex);
Felix Fietkau96f372c2011-04-07 19:07:17 +02001810 ath9k_ps_restore(sc);
Sujith Manoharanda0d45f2012-07-17 17:16:29 +05301811
1812#undef CHECK_ANI
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001813}
1814
Eliad Peller37a41b42011-09-21 14:06:11 +03001815static u64 ath9k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001816{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001817 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001818 u64 tsf;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001819
Sujith141b38b2009-02-04 08:10:07 +05301820 mutex_lock(&sc->mutex);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05301821 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301822 tsf = ath9k_hw_gettsf64(sc->sc_ah);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05301823 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301824 mutex_unlock(&sc->mutex);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001825
1826 return tsf;
1827}
1828
Eliad Peller37a41b42011-09-21 14:06:11 +03001829static void ath9k_set_tsf(struct ieee80211_hw *hw,
1830 struct ieee80211_vif *vif,
1831 u64 tsf)
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01001832{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001833 struct ath_softc *sc = hw->priv;
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01001834
Sujith141b38b2009-02-04 08:10:07 +05301835 mutex_lock(&sc->mutex);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05301836 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301837 ath9k_hw_settsf64(sc->sc_ah, tsf);
Sujith Manoharan9abbfb22010-12-10 11:27:06 +05301838 ath9k_ps_restore(sc);
Sujith141b38b2009-02-04 08:10:07 +05301839 mutex_unlock(&sc->mutex);
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01001840}
1841
Eliad Peller37a41b42011-09-21 14:06:11 +03001842static void ath9k_reset_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001843{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001844 struct ath_softc *sc = hw->priv;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001845
Sujith141b38b2009-02-04 08:10:07 +05301846 mutex_lock(&sc->mutex);
Luis R. Rodriguez21526d52009-09-09 20:05:39 -07001847
1848 ath9k_ps_wakeup(sc);
Sujith141b38b2009-02-04 08:10:07 +05301849 ath9k_hw_reset_tsf(sc->sc_ah);
Luis R. Rodriguez21526d52009-09-09 20:05:39 -07001850 ath9k_ps_restore(sc);
1851
Sujith141b38b2009-02-04 08:10:07 +05301852 mutex_unlock(&sc->mutex);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001853}
1854
1855static int ath9k_ampdu_action(struct ieee80211_hw *hw,
Johannes Bergc951ad32009-11-16 12:00:38 +01001856 struct ieee80211_vif *vif,
Sujith141b38b2009-02-04 08:10:07 +05301857 enum ieee80211_ampdu_mlme_action action,
1858 struct ieee80211_sta *sta,
Johannes Berg0b01f032011-01-18 13:51:05 +01001859 u16 tid, u16 *ssn, u8 buf_size)
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001860{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001861 struct ath_softc *sc = hw->priv;
Sujith Manoharan1e929d32014-10-17 07:40:30 +05301862 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkau16e23422013-05-17 12:58:24 +02001863 bool flush = false;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001864 int ret = 0;
1865
Sujith Manoharan7ca7c772013-05-08 05:03:32 +05301866 mutex_lock(&sc->mutex);
Johannes Berg85ad1812010-06-10 10:21:49 +02001867
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001868 switch (action) {
1869 case IEEE80211_AMPDU_RX_START:
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001870 break;
1871 case IEEE80211_AMPDU_RX_STOP:
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001872 break;
1873 case IEEE80211_AMPDU_TX_START:
Sujith Manoharan1e929d32014-10-17 07:40:30 +05301874 if (ath9k_is_chanctx_enabled()) {
1875 if (test_bit(ATH_OP_SCANNING, &common->op_flags)) {
1876 ret = -EBUSY;
1877 break;
1878 }
1879 }
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001880 ath9k_ps_wakeup(sc);
Felix Fietkau231c3a12010-09-20 19:35:28 +02001881 ret = ath_tx_aggr_start(sc, sta, tid, ssn);
1882 if (!ret)
1883 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001884 ath9k_ps_restore(sc);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001885 break;
Johannes Berg18b559d2012-07-18 13:51:25 +02001886 case IEEE80211_AMPDU_TX_STOP_FLUSH:
1887 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
Felix Fietkau16e23422013-05-17 12:58:24 +02001888 flush = true;
1889 case IEEE80211_AMPDU_TX_STOP_CONT:
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001890 ath9k_ps_wakeup(sc);
Sujithf83da962009-07-23 15:32:37 +05301891 ath_tx_aggr_stop(sc, sta, tid);
Felix Fietkau08c96ab2013-05-18 21:28:15 +02001892 if (!flush)
Felix Fietkau16e23422013-05-17 12:58:24 +02001893 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001894 ath9k_ps_restore(sc);
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001895 break;
Johannes Bergb1720232009-03-23 17:28:39 +01001896 case IEEE80211_AMPDU_TX_OPERATIONAL:
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001897 ath9k_ps_wakeup(sc);
Sujith8469cde2008-10-29 10:19:28 +05301898 ath_tx_aggr_resume(sc, sta, tid);
Luis R. Rodriguez8b685ba2009-12-23 20:03:29 -05001899 ath9k_ps_restore(sc);
Sujith8469cde2008-10-29 10:19:28 +05301900 break;
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001901 default:
Joe Perches38002762010-12-02 19:12:36 -08001902 ath_err(ath9k_hw_common(sc->sc_ah), "Unknown AMPDU action\n");
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001903 }
1904
Sujith Manoharan7ca7c772013-05-08 05:03:32 +05301905 mutex_unlock(&sc->mutex);
Johannes Berg85ad1812010-06-10 10:21:49 +02001906
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07001907 return ret;
1908}
1909
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001910static int ath9k_get_survey(struct ieee80211_hw *hw, int idx,
1911 struct survey_info *survey)
1912{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001913 struct ath_softc *sc = hw->priv;
Felix Fietkau34300982010-10-10 18:21:52 +02001914 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkau39162db2010-09-29 19:12:06 +02001915 struct ieee80211_supported_band *sband;
Felix Fietkau34300982010-10-10 18:21:52 +02001916 struct ieee80211_channel *chan;
Felix Fietkau34300982010-10-10 18:21:52 +02001917 int pos;
1918
Luis R. Rodriguez89f927a2013-10-14 17:42:11 -07001919 if (config_enabled(CONFIG_ATH9K_TX99))
1920 return -EOPNOTSUPP;
1921
Sujith Manoharanb7cc9b92013-12-26 08:14:40 +05301922 spin_lock_bh(&common->cc_lock);
Felix Fietkau34300982010-10-10 18:21:52 +02001923 if (idx == 0)
1924 ath_update_survey_stats(sc);
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001925
Felix Fietkau39162db2010-09-29 19:12:06 +02001926 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
1927 if (sband && idx >= sband->n_channels) {
1928 idx -= sband->n_channels;
1929 sband = NULL;
1930 }
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001931
Felix Fietkau39162db2010-09-29 19:12:06 +02001932 if (!sband)
1933 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
1934
Felix Fietkau34300982010-10-10 18:21:52 +02001935 if (!sband || idx >= sband->n_channels) {
Sujith Manoharanb7cc9b92013-12-26 08:14:40 +05301936 spin_unlock_bh(&common->cc_lock);
Felix Fietkau34300982010-10-10 18:21:52 +02001937 return -ENOENT;
Felix Fietkau4f1a5a42010-09-29 17:15:28 +02001938 }
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001939
Felix Fietkau34300982010-10-10 18:21:52 +02001940 chan = &sband->channels[idx];
1941 pos = chan->hw_value;
1942 memcpy(survey, &sc->survey[pos], sizeof(*survey));
1943 survey->channel = chan;
Sujith Manoharanb7cc9b92013-12-26 08:14:40 +05301944 spin_unlock_bh(&common->cc_lock);
Felix Fietkau34300982010-10-10 18:21:52 +02001945
Benoit Papillault62dad5b2010-04-28 00:08:24 +02001946 return 0;
1947}
1948
Lorenzo Bianconi24a19362014-09-16 02:13:15 +02001949static void ath9k_enable_dynack(struct ath_softc *sc)
1950{
1951#ifdef CONFIG_ATH9K_DYNACK
1952 u32 rfilt;
1953 struct ath_hw *ah = sc->sc_ah;
1954
1955 ath_dynack_reset(ah);
1956
1957 ah->dynack.enabled = true;
1958 rfilt = ath_calcrxfilter(sc);
1959 ath9k_hw_setrxfilter(ah, rfilt);
1960#endif
1961}
1962
Lorenzo Bianconia4bcaf52014-09-04 23:57:41 +02001963static void ath9k_set_coverage_class(struct ieee80211_hw *hw,
1964 s16 coverage_class)
Felix Fietkaue239d852010-01-15 02:34:58 +01001965{
Felix Fietkau9ac586152011-01-24 19:23:18 +01001966 struct ath_softc *sc = hw->priv;
Felix Fietkaue239d852010-01-15 02:34:58 +01001967 struct ath_hw *ah = sc->sc_ah;
1968
Luis R. Rodriguez89f927a2013-10-14 17:42:11 -07001969 if (config_enabled(CONFIG_ATH9K_TX99))
1970 return;
1971
Felix Fietkaue239d852010-01-15 02:34:58 +01001972 mutex_lock(&sc->mutex);
Mohammed Shafi Shajakhan8b2a38272011-08-24 21:38:07 +05301973
Lorenzo Bianconi24a19362014-09-16 02:13:15 +02001974 if (coverage_class >= 0) {
1975 ah->coverage_class = coverage_class;
1976 if (ah->dynack.enabled) {
1977 u32 rfilt;
1978
1979 ah->dynack.enabled = false;
1980 rfilt = ath_calcrxfilter(sc);
1981 ath9k_hw_setrxfilter(ah, rfilt);
1982 }
1983 ath9k_ps_wakeup(sc);
1984 ath9k_hw_init_global_settings(ah);
1985 ath9k_ps_restore(sc);
1986 } else if (!ah->dynack.enabled) {
1987 ath9k_enable_dynack(sc);
1988 }
Mohammed Shafi Shajakhan8b2a38272011-08-24 21:38:07 +05301989
Felix Fietkaue239d852010-01-15 02:34:58 +01001990 mutex_unlock(&sc->mutex);
1991}
1992
Sujith Manoharane2d389b2014-10-17 07:40:18 +05301993static bool ath9k_has_tx_pending(struct ath_softc *sc,
1994 bool sw_pending)
Felix Fietkau10e23182013-11-11 22:23:35 +01001995{
Geert Uytterhoevenf7838072014-01-26 11:53:21 +01001996 int i, npend = 0;
Felix Fietkau10e23182013-11-11 22:23:35 +01001997
1998 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
1999 if (!ATH_TXQ_SETUP(sc, i))
2000 continue;
2001
Sujith Manoharane2d389b2014-10-17 07:40:18 +05302002 npend = ath9k_has_pending_frames(sc, &sc->tx.txq[i],
2003 sw_pending);
Felix Fietkau10e23182013-11-11 22:23:35 +01002004 if (npend)
2005 break;
2006 }
2007
2008 return !!npend;
2009}
2010
Emmanuel Grumbach77be2c52014-03-27 11:30:29 +02002011static void ath9k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
2012 u32 queues, bool drop)
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002013{
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002014 struct ath_softc *sc = hw->priv;
Sujith Manoharan25f3bc72014-10-17 07:40:29 +05302015 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkaubff11762014-06-11 16:17:52 +05302016
Sujith Manoharan25f3bc72014-10-17 07:40:29 +05302017 if (ath9k_is_chanctx_enabled()) {
2018 if (!test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags))
2019 goto flush;
2020
2021 /*
2022 * If MCC is active, extend the flush timeout
2023 * and wait for the HW/SW queues to become
2024 * empty. This needs to be done outside the
2025 * sc->mutex lock to allow the channel scheduler
2026 * to switch channel contexts.
2027 *
2028 * The vif queues have been stopped in mac80211,
2029 * so there won't be any incoming frames.
2030 */
2031 __ath9k_flush(hw, queues, drop, true, true);
2032 return;
2033 }
2034flush:
Felix Fietkaubff11762014-06-11 16:17:52 +05302035 mutex_lock(&sc->mutex);
Sujith Manoharan25f3bc72014-10-17 07:40:29 +05302036 __ath9k_flush(hw, queues, drop, true, false);
Felix Fietkaubff11762014-06-11 16:17:52 +05302037 mutex_unlock(&sc->mutex);
2038}
2039
Sujith Manoharane2d389b2014-10-17 07:40:18 +05302040void __ath9k_flush(struct ieee80211_hw *hw, u32 queues, bool drop,
Sujith Manoharan25f3bc72014-10-17 07:40:29 +05302041 bool sw_pending, bool timeout_override)
Felix Fietkaubff11762014-06-11 16:17:52 +05302042{
2043 struct ath_softc *sc = hw->priv;
Mohammed Shafi Shajakhan99aa55b2011-05-06 20:43:11 +05302044 struct ath_hw *ah = sc->sc_ah;
2045 struct ath_common *common = ath9k_hw_common(ah);
Sujith Manoharan2fae0d92014-10-17 07:40:15 +05302046 int timeout;
Rajkumar Manoharan2f6fc352011-04-28 15:31:57 +05302047 bool drain_txq;
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002048
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002049 cancel_delayed_work_sync(&sc->tx_complete_work);
2050
Mohammed Shafi Shajakhan6a6b3f32011-09-09 10:41:08 +05302051 if (ah->ah_flags & AH_UNPLUGGED) {
Joe Perchesd2182b62011-12-15 14:55:53 -08002052 ath_dbg(common, ANY, "Device has been unplugged!\n");
Mohammed Shafi Shajakhan6a6b3f32011-09-09 10:41:08 +05302053 return;
2054 }
2055
Oleksij Rempeleefa01d2014-02-27 11:40:46 +01002056 if (test_bit(ATH_OP_INVALID, &common->op_flags)) {
Joe Perchesd2182b62011-12-15 14:55:53 -08002057 ath_dbg(common, ANY, "Device not present\n");
Mohammed Shafi Shajakhan99aa55b2011-05-06 20:43:11 +05302058 return;
2059 }
2060
Sujith Manoharan2fae0d92014-10-17 07:40:15 +05302061 spin_lock_bh(&sc->chan_lock);
Sujith Manoharan25f3bc72014-10-17 07:40:29 +05302062 if (timeout_override)
2063 timeout = HZ / 5;
2064 else
2065 timeout = sc->cur_chan->flush_timeout;
Sujith Manoharan2fae0d92014-10-17 07:40:15 +05302066 spin_unlock_bh(&sc->chan_lock);
2067
2068 ath_dbg(common, CHAN_CTX,
2069 "Flush timeout: %d\n", jiffies_to_msecs(timeout));
2070
Sujith Manoharane2d389b2014-10-17 07:40:18 +05302071 if (wait_event_timeout(sc->tx_wait, !ath9k_has_tx_pending(sc, sw_pending),
Felix Fietkau10e23182013-11-11 22:23:35 +01002072 timeout) > 0)
2073 drop = false;
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002074
Felix Fietkau9df0d6a2011-11-16 13:08:42 +01002075 if (drop) {
2076 ath9k_ps_wakeup(sc);
2077 spin_lock_bh(&sc->sc_pcu_lock);
Felix Fietkau13815592013-01-20 18:51:53 +01002078 drain_txq = ath_drain_all_txq(sc);
Felix Fietkau9df0d6a2011-11-16 13:08:42 +01002079 spin_unlock_bh(&sc->sc_pcu_lock);
Felix Fietkau9adcf442011-09-03 01:40:26 +02002080
Felix Fietkau9df0d6a2011-11-16 13:08:42 +01002081 if (!drain_txq)
Sujith Manoharan5555c952014-10-17 07:40:11 +05302082 ath_reset(sc, NULL);
Felix Fietkau9adcf442011-09-03 01:40:26 +02002083
Felix Fietkau9df0d6a2011-11-16 13:08:42 +01002084 ath9k_ps_restore(sc);
Felix Fietkau9df0d6a2011-11-16 13:08:42 +01002085 }
Senthil Balasubramaniand78f4b32011-03-23 23:07:22 +05302086
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002087 ieee80211_queue_delayed_work(hw, &sc->tx_complete_work, 0);
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002088}
2089
Vivek Natarajan15b91e82011-04-06 11:41:11 +05302090static bool ath9k_tx_frames_pending(struct ieee80211_hw *hw)
2091{
2092 struct ath_softc *sc = hw->priv;
Vivek Natarajan15b91e82011-04-06 11:41:11 +05302093
Sujith Manoharane2d389b2014-10-17 07:40:18 +05302094 return ath9k_has_tx_pending(sc, true);
Vivek Natarajan15b91e82011-04-06 11:41:11 +05302095}
2096
Mohammed Shafi Shajakhan5595f112011-05-19 18:08:57 +05302097static int ath9k_tx_last_beacon(struct ieee80211_hw *hw)
Felix Fietkauba4903f2011-05-17 21:09:54 +02002098{
2099 struct ath_softc *sc = hw->priv;
2100 struct ath_hw *ah = sc->sc_ah;
2101 struct ieee80211_vif *vif;
2102 struct ath_vif *avp;
2103 struct ath_buf *bf;
2104 struct ath_tx_status ts;
Felix Fietkau4286df62012-02-27 19:58:40 +01002105 bool edma = !!(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA);
Felix Fietkauba4903f2011-05-17 21:09:54 +02002106 int status;
2107
2108 vif = sc->beacon.bslot[0];
2109 if (!vif)
2110 return 0;
2111
Sujith Manoharanaa45fe92012-07-17 17:16:03 +05302112 if (!vif->bss_conf.enable_beacon)
Felix Fietkauba4903f2011-05-17 21:09:54 +02002113 return 0;
2114
Sujith Manoharanaa45fe92012-07-17 17:16:03 +05302115 avp = (void *)vif->drv_priv;
2116
Felix Fietkau4286df62012-02-27 19:58:40 +01002117 if (!sc->beacon.tx_processed && !edma) {
Felix Fietkauba4903f2011-05-17 21:09:54 +02002118 tasklet_disable(&sc->bcon_tasklet);
2119
2120 bf = avp->av_bcbuf;
2121 if (!bf || !bf->bf_mpdu)
2122 goto skip;
2123
2124 status = ath9k_hw_txprocdesc(ah, bf->bf_desc, &ts);
2125 if (status == -EINPROGRESS)
2126 goto skip;
2127
2128 sc->beacon.tx_processed = true;
2129 sc->beacon.tx_last = !(ts.ts_status & ATH9K_TXERR_MASK);
2130
2131skip:
2132 tasklet_enable(&sc->bcon_tasklet);
2133 }
2134
2135 return sc->beacon.tx_last;
2136}
2137
Mohammed Shafi Shajakhan52c94f42011-08-20 17:21:42 +05302138static int ath9k_get_stats(struct ieee80211_hw *hw,
2139 struct ieee80211_low_level_stats *stats)
2140{
2141 struct ath_softc *sc = hw->priv;
2142 struct ath_hw *ah = sc->sc_ah;
2143 struct ath9k_mib_stats *mib_stats = &ah->ah_mibStats;
2144
2145 stats->dot11ACKFailureCount = mib_stats->ackrcv_bad;
2146 stats->dot11RTSFailureCount = mib_stats->rts_bad;
2147 stats->dot11FCSErrorCount = mib_stats->fcs_bad;
2148 stats->dot11RTSSuccessCount = mib_stats->rts_good;
2149 return 0;
2150}
2151
Felix Fietkau43c35282011-09-03 01:40:27 +02002152static u32 fill_chainmask(u32 cap, u32 new)
2153{
2154 u32 filled = 0;
2155 int i;
2156
2157 for (i = 0; cap && new; i++, cap >>= 1) {
2158 if (!(cap & BIT(0)))
2159 continue;
2160
2161 if (new & BIT(0))
2162 filled |= BIT(i);
2163
2164 new >>= 1;
2165 }
2166
2167 return filled;
2168}
2169
Felix Fietkau5d9c7e32012-07-15 19:53:30 +02002170static bool validate_antenna_mask(struct ath_hw *ah, u32 val)
2171{
Felix Fietkaufea92cb2013-01-20 21:55:22 +01002172 if (AR_SREV_9300_20_OR_LATER(ah))
2173 return true;
2174
Felix Fietkau5d9c7e32012-07-15 19:53:30 +02002175 switch (val & 0x7) {
2176 case 0x1:
2177 case 0x3:
2178 case 0x7:
2179 return true;
2180 case 0x2:
2181 return (ah->caps.rx_chainmask == 1);
2182 default:
2183 return false;
2184 }
2185}
2186
Felix Fietkau43c35282011-09-03 01:40:27 +02002187static int ath9k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
2188{
2189 struct ath_softc *sc = hw->priv;
2190 struct ath_hw *ah = sc->sc_ah;
2191
Felix Fietkau5d9c7e32012-07-15 19:53:30 +02002192 if (ah->caps.rx_chainmask != 1)
2193 rx_ant |= tx_ant;
2194
2195 if (!validate_antenna_mask(ah, rx_ant) || !tx_ant)
Felix Fietkau43c35282011-09-03 01:40:27 +02002196 return -EINVAL;
2197
2198 sc->ant_rx = rx_ant;
2199 sc->ant_tx = tx_ant;
2200
2201 if (ah->caps.rx_chainmask == 1)
2202 return 0;
2203
2204 /* AR9100 runs into calibration issues if not all rx chains are enabled */
2205 if (AR_SREV_9100(ah))
2206 ah->rxchainmask = 0x7;
2207 else
2208 ah->rxchainmask = fill_chainmask(ah->caps.rx_chainmask, rx_ant);
2209
2210 ah->txchainmask = fill_chainmask(ah->caps.tx_chainmask, tx_ant);
Oleksij Rempelb57ba3b2014-02-25 14:48:55 +01002211 ath9k_cmn_reload_chainmask(ah);
Felix Fietkau43c35282011-09-03 01:40:27 +02002212
2213 return 0;
2214}
2215
2216static int ath9k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
2217{
2218 struct ath_softc *sc = hw->priv;
2219
2220 *tx_ant = sc->ant_tx;
2221 *rx_ant = sc->ant_rx;
2222 return 0;
2223}
2224
Johannes Berga344d672014-06-12 22:24:31 +02002225static void ath9k_sw_scan_start(struct ieee80211_hw *hw,
2226 struct ieee80211_vif *vif,
2227 const u8 *mac_addr)
Simon Wunderliche93d0832013-01-08 14:48:58 +01002228{
2229 struct ath_softc *sc = hw->priv;
Oleksij Rempeleefa01d2014-02-27 11:40:46 +01002230 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
2231 set_bit(ATH_OP_SCANNING, &common->op_flags);
Simon Wunderliche93d0832013-01-08 14:48:58 +01002232}
2233
Johannes Berga344d672014-06-12 22:24:31 +02002234static void ath9k_sw_scan_complete(struct ieee80211_hw *hw,
2235 struct ieee80211_vif *vif)
Simon Wunderliche93d0832013-01-08 14:48:58 +01002236{
2237 struct ath_softc *sc = hw->priv;
Oleksij Rempeleefa01d2014-02-27 11:40:46 +01002238 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
2239 clear_bit(ATH_OP_SCANNING, &common->op_flags);
Simon Wunderliche93d0832013-01-08 14:48:58 +01002240}
Mohammed Shafi Shajakhanb11e6402012-07-10 14:56:52 +05302241
Sujith Manoharan499afac2014-08-22 20:39:31 +05302242#ifdef CONFIG_ATH9K_CHANNEL_CONTEXT
2243
Sujith Manoharan61856722014-11-16 06:11:07 +05302244static void ath9k_cancel_pending_offchannel(struct ath_softc *sc)
2245{
2246 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
2247
2248 if (sc->offchannel.roc_vif) {
2249 ath_dbg(common, CHAN_CTX,
2250 "%s: Aborting RoC\n", __func__);
2251
2252 del_timer_sync(&sc->offchannel.timer);
2253 if (sc->offchannel.state >= ATH_OFFCHANNEL_ROC_START)
Janusz.Dziedzic@tieto.comd83520b2015-07-21 11:11:41 +02002254 ath_roc_complete(sc, ATH_ROC_COMPLETE_ABORT);
Sujith Manoharan61856722014-11-16 06:11:07 +05302255 }
2256
2257 if (test_bit(ATH_OP_SCANNING, &common->op_flags)) {
2258 ath_dbg(common, CHAN_CTX,
2259 "%s: Aborting HW scan\n", __func__);
2260
2261 del_timer_sync(&sc->offchannel.timer);
2262 ath_scan_complete(sc, true);
2263 }
2264}
2265
Felix Fietkau78b21942014-06-11 16:17:55 +05302266static int ath9k_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
John W. Linville855df362014-06-25 15:15:14 -04002267 struct ieee80211_scan_request *hw_req)
Felix Fietkau78b21942014-06-11 16:17:55 +05302268{
John W. Linville855df362014-06-25 15:15:14 -04002269 struct cfg80211_scan_request *req = &hw_req->req;
Felix Fietkau78b21942014-06-11 16:17:55 +05302270 struct ath_softc *sc = hw->priv;
2271 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
2272 int ret = 0;
2273
2274 mutex_lock(&sc->mutex);
2275
2276 if (WARN_ON(sc->offchannel.scan_req)) {
2277 ret = -EBUSY;
2278 goto out;
2279 }
2280
2281 ath9k_ps_wakeup(sc);
2282 set_bit(ATH_OP_SCANNING, &common->op_flags);
2283 sc->offchannel.scan_vif = vif;
2284 sc->offchannel.scan_req = req;
2285 sc->offchannel.scan_idx = 0;
Felix Fietkau78b21942014-06-11 16:17:55 +05302286
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302287 ath_dbg(common, CHAN_CTX, "HW scan request received on vif: %pM\n",
2288 vif->addr);
2289
2290 if (sc->offchannel.state == ATH_OFFCHANNEL_IDLE) {
2291 ath_dbg(common, CHAN_CTX, "Starting HW scan\n");
Felix Fietkau405393c2014-06-11 16:17:56 +05302292 ath_offchannel_next(sc);
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302293 }
Felix Fietkau78b21942014-06-11 16:17:55 +05302294
2295out:
2296 mutex_unlock(&sc->mutex);
2297
2298 return ret;
2299}
2300
2301static void ath9k_cancel_hw_scan(struct ieee80211_hw *hw,
2302 struct ieee80211_vif *vif)
2303{
2304 struct ath_softc *sc = hw->priv;
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302305 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
2306
2307 ath_dbg(common, CHAN_CTX, "Cancel HW scan on vif: %pM\n", vif->addr);
Felix Fietkau78b21942014-06-11 16:17:55 +05302308
2309 mutex_lock(&sc->mutex);
2310 del_timer_sync(&sc->offchannel.timer);
2311 ath_scan_complete(sc, true);
2312 mutex_unlock(&sc->mutex);
2313}
2314
Felix Fietkau405393c2014-06-11 16:17:56 +05302315static int ath9k_remain_on_channel(struct ieee80211_hw *hw,
2316 struct ieee80211_vif *vif,
2317 struct ieee80211_channel *chan, int duration,
2318 enum ieee80211_roc_type type)
2319{
2320 struct ath_softc *sc = hw->priv;
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302321 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkau405393c2014-06-11 16:17:56 +05302322 int ret = 0;
2323
2324 mutex_lock(&sc->mutex);
2325
2326 if (WARN_ON(sc->offchannel.roc_vif)) {
2327 ret = -EBUSY;
2328 goto out;
2329 }
2330
2331 ath9k_ps_wakeup(sc);
2332 sc->offchannel.roc_vif = vif;
2333 sc->offchannel.roc_chan = chan;
2334 sc->offchannel.roc_duration = duration;
2335
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302336 ath_dbg(common, CHAN_CTX,
2337 "RoC request on vif: %pM, type: %d duration: %d\n",
2338 vif->addr, type, duration);
2339
2340 if (sc->offchannel.state == ATH_OFFCHANNEL_IDLE) {
2341 ath_dbg(common, CHAN_CTX, "Starting RoC period\n");
Felix Fietkau405393c2014-06-11 16:17:56 +05302342 ath_offchannel_next(sc);
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302343 }
Felix Fietkau405393c2014-06-11 16:17:56 +05302344
2345out:
2346 mutex_unlock(&sc->mutex);
2347
2348 return ret;
2349}
2350
2351static int ath9k_cancel_remain_on_channel(struct ieee80211_hw *hw)
2352{
2353 struct ath_softc *sc = hw->priv;
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302354 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkau405393c2014-06-11 16:17:56 +05302355
2356 mutex_lock(&sc->mutex);
2357
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302358 ath_dbg(common, CHAN_CTX, "Cancel RoC\n");
Felix Fietkau405393c2014-06-11 16:17:56 +05302359 del_timer_sync(&sc->offchannel.timer);
2360
2361 if (sc->offchannel.roc_vif) {
2362 if (sc->offchannel.state >= ATH_OFFCHANNEL_ROC_START)
Janusz.Dziedzic@tieto.comd83520b2015-07-21 11:11:41 +02002363 ath_roc_complete(sc, ATH_ROC_COMPLETE_CANCEL);
Felix Fietkau405393c2014-06-11 16:17:56 +05302364 }
2365
2366 mutex_unlock(&sc->mutex);
2367
2368 return 0;
2369}
2370
Felix Fietkau39305632014-06-11 16:17:57 +05302371static int ath9k_add_chanctx(struct ieee80211_hw *hw,
2372 struct ieee80211_chanctx_conf *conf)
2373{
2374 struct ath_softc *sc = hw->priv;
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302375 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkau39305632014-06-11 16:17:57 +05302376 struct ath_chanctx *ctx, **ptr;
Rajkumar Manoharan3ad9c382014-06-11 16:18:15 +05302377 int pos;
Felix Fietkau39305632014-06-11 16:17:57 +05302378
2379 mutex_lock(&sc->mutex);
Rajkumar Manoharanc4dc0d02014-06-11 16:17:58 +05302380
2381 ath_for_each_chanctx(sc, ctx) {
2382 if (ctx->assigned)
2383 continue;
2384
2385 ptr = (void *) conf->drv_priv;
2386 *ptr = ctx;
2387 ctx->assigned = true;
Rajkumar Manoharan3ad9c382014-06-11 16:18:15 +05302388 pos = ctx - &sc->chanctx[0];
2389 ctx->hw_queue_base = pos * IEEE80211_NUM_ACS;
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302390
2391 ath_dbg(common, CHAN_CTX,
2392 "Add channel context: %d MHz\n",
2393 conf->def.chan->center_freq);
2394
Rajkumar Manoharanc4dc0d02014-06-11 16:17:58 +05302395 ath_chanctx_set_channel(sc, ctx, &conf->def);
Sujith Manoharan4c7e9ae2014-08-24 21:16:13 +05302396
Felix Fietkau39305632014-06-11 16:17:57 +05302397 mutex_unlock(&sc->mutex);
Rajkumar Manoharanc4dc0d02014-06-11 16:17:58 +05302398 return 0;
Felix Fietkau39305632014-06-11 16:17:57 +05302399 }
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302400
Felix Fietkau39305632014-06-11 16:17:57 +05302401 mutex_unlock(&sc->mutex);
Rajkumar Manoharanc4dc0d02014-06-11 16:17:58 +05302402 return -ENOSPC;
Felix Fietkau39305632014-06-11 16:17:57 +05302403}
2404
2405
2406static void ath9k_remove_chanctx(struct ieee80211_hw *hw,
2407 struct ieee80211_chanctx_conf *conf)
2408{
2409 struct ath_softc *sc = hw->priv;
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302410 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkau39305632014-06-11 16:17:57 +05302411 struct ath_chanctx *ctx = ath_chanctx_get(conf);
2412
2413 mutex_lock(&sc->mutex);
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302414
2415 ath_dbg(common, CHAN_CTX,
2416 "Remove channel context: %d MHz\n",
2417 conf->def.chan->center_freq);
2418
Felix Fietkau39305632014-06-11 16:17:57 +05302419 ctx->assigned = false;
Sujith Manoharanb18111d2014-10-07 10:14:37 +05302420 ctx->hw_queue_base = 0;
Felix Fietkau73fa2f22014-06-11 16:18:10 +05302421 ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_UNASSIGN);
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302422
Felix Fietkau39305632014-06-11 16:17:57 +05302423 mutex_unlock(&sc->mutex);
2424}
2425
2426static void ath9k_change_chanctx(struct ieee80211_hw *hw,
2427 struct ieee80211_chanctx_conf *conf,
2428 u32 changed)
2429{
2430 struct ath_softc *sc = hw->priv;
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302431 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkau39305632014-06-11 16:17:57 +05302432 struct ath_chanctx *ctx = ath_chanctx_get(conf);
2433
2434 mutex_lock(&sc->mutex);
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302435 ath_dbg(common, CHAN_CTX,
2436 "Change channel context: %d MHz\n",
2437 conf->def.chan->center_freq);
Felix Fietkau39305632014-06-11 16:17:57 +05302438 ath_chanctx_set_channel(sc, ctx, &conf->def);
2439 mutex_unlock(&sc->mutex);
2440}
2441
2442static int ath9k_assign_vif_chanctx(struct ieee80211_hw *hw,
2443 struct ieee80211_vif *vif,
2444 struct ieee80211_chanctx_conf *conf)
2445{
2446 struct ath_softc *sc = hw->priv;
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302447 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkau39305632014-06-11 16:17:57 +05302448 struct ath_vif *avp = (void *)vif->drv_priv;
2449 struct ath_chanctx *ctx = ath_chanctx_get(conf);
Rajkumar Manoharan3ad9c382014-06-11 16:18:15 +05302450 int i;
Felix Fietkau39305632014-06-11 16:17:57 +05302451
Sujith Manoharan61856722014-11-16 06:11:07 +05302452 ath9k_cancel_pending_offchannel(sc);
2453
Felix Fietkau39305632014-06-11 16:17:57 +05302454 mutex_lock(&sc->mutex);
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302455
2456 ath_dbg(common, CHAN_CTX,
2457 "Assign VIF (addr: %pM, type: %d, p2p: %d) to channel context: %d MHz\n",
2458 vif->addr, vif->type, vif->p2p,
2459 conf->def.chan->center_freq);
2460
Felix Fietkau39305632014-06-11 16:17:57 +05302461 avp->chanctx = ctx;
Sujith Manoharan2ce73c02014-09-19 13:00:42 +05302462 ctx->nvifs_assigned++;
Felix Fietkau39305632014-06-11 16:17:57 +05302463 list_add_tail(&avp->list, &ctx->vifs);
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05302464 ath9k_calculate_summary_state(sc, ctx);
Rajkumar Manoharan3ad9c382014-06-11 16:18:15 +05302465 for (i = 0; i < IEEE80211_NUM_ACS; i++)
2466 vif->hw_queue[i] = ctx->hw_queue_base + i;
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302467
Felix Fietkau39305632014-06-11 16:17:57 +05302468 mutex_unlock(&sc->mutex);
2469
2470 return 0;
2471}
2472
2473static void ath9k_unassign_vif_chanctx(struct ieee80211_hw *hw,
2474 struct ieee80211_vif *vif,
2475 struct ieee80211_chanctx_conf *conf)
2476{
2477 struct ath_softc *sc = hw->priv;
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302478 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
Felix Fietkau39305632014-06-11 16:17:57 +05302479 struct ath_vif *avp = (void *)vif->drv_priv;
2480 struct ath_chanctx *ctx = ath_chanctx_get(conf);
Rajkumar Manoharan3ad9c382014-06-11 16:18:15 +05302481 int ac;
Felix Fietkau39305632014-06-11 16:17:57 +05302482
Sujith Manoharan61856722014-11-16 06:11:07 +05302483 ath9k_cancel_pending_offchannel(sc);
2484
Felix Fietkau39305632014-06-11 16:17:57 +05302485 mutex_lock(&sc->mutex);
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302486
2487 ath_dbg(common, CHAN_CTX,
2488 "Remove VIF (addr: %pM, type: %d, p2p: %d) from channel context: %d MHz\n",
2489 vif->addr, vif->type, vif->p2p,
2490 conf->def.chan->center_freq);
2491
Felix Fietkau39305632014-06-11 16:17:57 +05302492 avp->chanctx = NULL;
Sujith Manoharan2ce73c02014-09-19 13:00:42 +05302493 ctx->nvifs_assigned--;
Felix Fietkau39305632014-06-11 16:17:57 +05302494 list_del(&avp->list);
Rajkumar Manoharan9a9c4fb2014-06-11 16:18:03 +05302495 ath9k_calculate_summary_state(sc, ctx);
Rajkumar Manoharan3ad9c382014-06-11 16:18:15 +05302496 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
2497 vif->hw_queue[ac] = IEEE80211_INVAL_HW_QUEUE;
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302498
Felix Fietkau39305632014-06-11 16:17:57 +05302499 mutex_unlock(&sc->mutex);
2500}
2501
Sujith Manoharane20a8542014-08-23 13:29:09 +05302502static void ath9k_mgd_prepare_tx(struct ieee80211_hw *hw,
2503 struct ieee80211_vif *vif)
2504{
2505 struct ath_softc *sc = hw->priv;
2506 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
2507 struct ath_vif *avp = (struct ath_vif *) vif->drv_priv;
Sujith Manoharanc6500ea2014-10-17 07:40:22 +05302508 struct ath_beacon_config *cur_conf;
2509 struct ath_chanctx *go_ctx;
2510 unsigned long timeout;
Sujith Manoharane20a8542014-08-23 13:29:09 +05302511 bool changed = false;
Sujith Manoharanc6500ea2014-10-17 07:40:22 +05302512 u32 beacon_int;
Sujith Manoharane20a8542014-08-23 13:29:09 +05302513
2514 if (!test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags))
2515 return;
2516
2517 if (!avp->chanctx)
2518 return;
2519
2520 mutex_lock(&sc->mutex);
2521
2522 spin_lock_bh(&sc->chan_lock);
Sujith Manoharanc6500ea2014-10-17 07:40:22 +05302523 if (sc->next_chan || (sc->cur_chan != avp->chanctx))
Sujith Manoharane20a8542014-08-23 13:29:09 +05302524 changed = true;
Sujith Manoharanc6500ea2014-10-17 07:40:22 +05302525 spin_unlock_bh(&sc->chan_lock);
2526
2527 if (!changed)
2528 goto out;
2529
Sujith Manoharan61856722014-11-16 06:11:07 +05302530 ath9k_cancel_pending_offchannel(sc);
Sujith Manoharan23aab0c2014-10-17 07:40:28 +05302531
Sujith Manoharanc6500ea2014-10-17 07:40:22 +05302532 go_ctx = ath_is_go_chanctx_present(sc);
2533
2534 if (go_ctx) {
2535 /*
2536 * Wait till the GO interface gets a chance
2537 * to send out an NoA.
2538 */
2539 spin_lock_bh(&sc->chan_lock);
2540 sc->sched.mgd_prepare_tx = true;
2541 cur_conf = &go_ctx->beacon;
2542 beacon_int = TU_TO_USEC(cur_conf->beacon_interval);
2543 spin_unlock_bh(&sc->chan_lock);
2544
Sujith Manoharan61856722014-11-16 06:11:07 +05302545 timeout = usecs_to_jiffies(beacon_int * 2);
Sujith Manoharanc6500ea2014-10-17 07:40:22 +05302546 init_completion(&sc->go_beacon);
2547
Sujith Manoharan61856722014-11-16 06:11:07 +05302548 mutex_unlock(&sc->mutex);
Sujith Manoharan2c3634a2014-11-16 06:11:08 +05302549
Sujith Manoharanc6500ea2014-10-17 07:40:22 +05302550 if (wait_for_completion_timeout(&sc->go_beacon,
Sujith Manoharan2c3634a2014-11-16 06:11:08 +05302551 timeout) == 0) {
Sujith Manoharanc6500ea2014-10-17 07:40:22 +05302552 ath_dbg(common, CHAN_CTX,
2553 "Failed to send new NoA\n");
Sujith Manoharan2c3634a2014-11-16 06:11:08 +05302554
2555 spin_lock_bh(&sc->chan_lock);
2556 sc->sched.mgd_prepare_tx = false;
2557 spin_unlock_bh(&sc->chan_lock);
2558 }
2559
Sujith Manoharan61856722014-11-16 06:11:07 +05302560 mutex_lock(&sc->mutex);
Sujith Manoharane20a8542014-08-23 13:29:09 +05302561 }
Sujith Manoharanc6500ea2014-10-17 07:40:22 +05302562
Sujith Manoharan878066e2014-08-27 12:07:24 +05302563 ath_dbg(common, CHAN_CTX,
Sujith Manoharanc6500ea2014-10-17 07:40:22 +05302564 "%s: Set chanctx state to FORCE_ACTIVE for vif: %pM\n",
2565 __func__, vif->addr);
2566
2567 spin_lock_bh(&sc->chan_lock);
2568 sc->next_chan = avp->chanctx;
Sujith Manoharane20a8542014-08-23 13:29:09 +05302569 sc->sched.state = ATH_CHANCTX_STATE_FORCE_ACTIVE;
2570 spin_unlock_bh(&sc->chan_lock);
2571
Sujith Manoharanc6500ea2014-10-17 07:40:22 +05302572 ath_chanctx_set_next(sc, true);
2573out:
Sujith Manoharane20a8542014-08-23 13:29:09 +05302574 mutex_unlock(&sc->mutex);
2575}
2576
Felix Fietkau78b21942014-06-11 16:17:55 +05302577void ath9k_fill_chanctx_ops(void)
2578{
Sujith Manoharan499afac2014-08-22 20:39:31 +05302579 if (!ath9k_is_chanctx_enabled())
Felix Fietkau78b21942014-06-11 16:17:55 +05302580 return;
2581
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302582 ath9k_ops.hw_scan = ath9k_hw_scan;
2583 ath9k_ops.cancel_hw_scan = ath9k_cancel_hw_scan;
2584 ath9k_ops.remain_on_channel = ath9k_remain_on_channel;
Felix Fietkau405393c2014-06-11 16:17:56 +05302585 ath9k_ops.cancel_remain_on_channel = ath9k_cancel_remain_on_channel;
Sujith Manoharanbc81d432014-08-22 20:39:27 +05302586 ath9k_ops.add_chanctx = ath9k_add_chanctx;
2587 ath9k_ops.remove_chanctx = ath9k_remove_chanctx;
2588 ath9k_ops.change_chanctx = ath9k_change_chanctx;
2589 ath9k_ops.assign_vif_chanctx = ath9k_assign_vif_chanctx;
2590 ath9k_ops.unassign_vif_chanctx = ath9k_unassign_vif_chanctx;
Sujith Manoharane20a8542014-08-23 13:29:09 +05302591 ath9k_ops.mgd_prepare_tx = ath9k_mgd_prepare_tx;
Felix Fietkau78b21942014-06-11 16:17:55 +05302592}
2593
Sujith Manoharan499afac2014-08-22 20:39:31 +05302594#endif
2595
Felix Fietkaud385c5c2014-11-04 16:56:57 +01002596static int ath9k_get_txpower(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
2597 int *dbm)
2598{
2599 struct ath_softc *sc = hw->priv;
2600 struct ath_vif *avp = (void *)vif->drv_priv;
2601
2602 mutex_lock(&sc->mutex);
2603 if (avp->chanctx)
2604 *dbm = avp->chanctx->cur_txpower;
2605 else
2606 *dbm = sc->cur_chan->cur_txpower;
2607 mutex_unlock(&sc->mutex);
2608
2609 *dbm /= 2;
2610
2611 return 0;
2612}
2613
Gabor Juhos6baff7f2009-01-14 20:17:06 +01002614struct ieee80211_ops ath9k_ops = {
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002615 .tx = ath9k_tx,
2616 .start = ath9k_start,
2617 .stop = ath9k_stop,
2618 .add_interface = ath9k_add_interface,
Rajkumar Manoharan6b3b9912010-12-08 19:38:55 +05302619 .change_interface = ath9k_change_interface,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002620 .remove_interface = ath9k_remove_interface,
2621 .config = ath9k_config,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002622 .configure_filter = ath9k_configure_filter,
Sujith Manoharandf3c6eb2014-10-17 07:40:08 +05302623 .sta_state = ath9k_sta_state,
Felix Fietkau55195412011-04-17 23:28:09 +02002624 .sta_notify = ath9k_sta_notify,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002625 .conf_tx = ath9k_conf_tx,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002626 .bss_info_changed = ath9k_bss_info_changed,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002627 .set_key = ath9k_set_key,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002628 .get_tsf = ath9k_get_tsf,
Alina Friedrichsen3b5d6652009-01-24 07:09:59 +01002629 .set_tsf = ath9k_set_tsf,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002630 .reset_tsf = ath9k_reset_tsf,
Johannes Berg4233df62008-10-13 13:35:05 +02002631 .ampdu_action = ath9k_ampdu_action,
Benoit Papillault62dad5b2010-04-28 00:08:24 +02002632 .get_survey = ath9k_get_survey,
Johannes Berg3b319aa2009-06-13 14:50:26 +05302633 .rfkill_poll = ath9k_rfkill_poll_state,
Felix Fietkaue239d852010-01-15 02:34:58 +01002634 .set_coverage_class = ath9k_set_coverage_class,
Vasanthakumar Thiagarajan69081622011-02-19 01:13:42 -08002635 .flush = ath9k_flush,
Vivek Natarajan15b91e82011-04-06 11:41:11 +05302636 .tx_frames_pending = ath9k_tx_frames_pending,
Mohammed Shafi Shajakhan52c94f42011-08-20 17:21:42 +05302637 .tx_last_beacon = ath9k_tx_last_beacon,
Felix Fietkau86a22ac2013-06-07 18:12:01 +02002638 .release_buffered_frames = ath9k_release_buffered_frames,
Mohammed Shafi Shajakhan52c94f42011-08-20 17:21:42 +05302639 .get_stats = ath9k_get_stats,
Felix Fietkau43c35282011-09-03 01:40:27 +02002640 .set_antenna = ath9k_set_antenna,
2641 .get_antenna = ath9k_get_antenna,
Ben Greearb90bd9d2012-05-15 15:33:25 -07002642
Sujith Manoharane60001e2013-10-28 12:22:04 +05302643#ifdef CONFIG_ATH9K_WOW
Mohammed Shafi Shajakhanb11e6402012-07-10 14:56:52 +05302644 .suspend = ath9k_suspend,
2645 .resume = ath9k_resume,
2646 .set_wakeup = ath9k_set_wakeup,
2647#endif
2648
Ben Greearb90bd9d2012-05-15 15:33:25 -07002649#ifdef CONFIG_ATH9K_DEBUGFS
2650 .get_et_sset_count = ath9k_get_et_sset_count,
Sujith Manoharana145daf2012-11-28 15:08:54 +05302651 .get_et_stats = ath9k_get_et_stats,
2652 .get_et_strings = ath9k_get_et_strings,
2653#endif
2654
Sujith Manoharan1cdbaf02014-01-13 07:29:27 +05302655#if defined(CONFIG_MAC80211_DEBUGFS) && defined(CONFIG_ATH9K_STATION_STATISTICS)
Sujith Manoharana145daf2012-11-28 15:08:54 +05302656 .sta_add_debugfs = ath9k_sta_add_debugfs,
Ben Greearb90bd9d2012-05-15 15:33:25 -07002657#endif
Simon Wunderliche93d0832013-01-08 14:48:58 +01002658 .sw_scan_start = ath9k_sw_scan_start,
2659 .sw_scan_complete = ath9k_sw_scan_complete,
Felix Fietkaud385c5c2014-11-04 16:56:57 +01002660 .get_txpower = ath9k_get_txpower,
Luis R. Rodriguezf078f202008-08-04 00:16:41 -07002661};