c8dce038e3c9ddde45c6b31d5a6937a54d9eb23c
[openwrt/svn-archive/archive.git] / package / mac80211 / patches / 300-pending_work.patch
1 --- a/drivers/net/wireless/ath/ath9k/ath9k.h
2 +++ b/drivers/net/wireless/ath/ath9k/ath9k.h
3 @@ -360,7 +360,7 @@ void ath_tx_aggr_sleep(struct ieee80211_
4
5 struct ath_vif {
6 int av_bslot;
7 - bool is_bslot_active, primary_sta_vif;
8 + bool primary_sta_vif;
9 __le64 tsf_adjust; /* TSF adjustment for staggered beacons */
10 struct ath_buf *av_bcbuf;
11 };
12 @@ -386,6 +386,7 @@ struct ath_beacon_config {
13 u16 dtim_period;
14 u16 bmiss_timeout;
15 u8 dtim_count;
16 + bool enable_beacon;
17 };
18
19 struct ath_beacon {
20 @@ -397,7 +398,6 @@ struct ath_beacon {
21
22 u32 beaconq;
23 u32 bmisscnt;
24 - u32 ast_be_xmit;
25 u32 bc_tstamp;
26 struct ieee80211_vif *bslot[ATH_BCBUF];
27 int slottime;
28 @@ -411,12 +411,14 @@ struct ath_beacon {
29 bool tx_last;
30 };
31
32 -void ath_beacon_tasklet(unsigned long data);
33 -void ath_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif);
34 -int ath_beacon_alloc(struct ath_softc *sc, struct ieee80211_vif *vif);
35 -void ath_beacon_return(struct ath_softc *sc, struct ath_vif *avp);
36 -int ath_beaconq_config(struct ath_softc *sc);
37 -void ath_set_beacon(struct ath_softc *sc);
38 +void ath9k_beacon_tasklet(unsigned long data);
39 +bool ath9k_allow_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif);
40 +void ath9k_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif,
41 + u32 changed);
42 +void ath9k_beacon_assign_slot(struct ath_softc *sc, struct ieee80211_vif *vif);
43 +void ath9k_beacon_remove_slot(struct ath_softc *sc, struct ieee80211_vif *vif);
44 +void ath9k_set_tsfadjust(struct ath_softc *sc, struct ieee80211_vif *vif);
45 +void ath9k_set_beacon(struct ath_softc *sc);
46 void ath9k_set_beaconing_status(struct ath_softc *sc, bool status);
47
48 /*******************/
49 @@ -442,9 +444,12 @@ void ath_rx_poll(unsigned long data);
50 void ath_start_rx_poll(struct ath_softc *sc, u8 nbeacon);
51 void ath_paprd_calibrate(struct work_struct *work);
52 void ath_ani_calibrate(unsigned long data);
53 -void ath_start_ani(struct ath_common *common);
54 +void ath_start_ani(struct ath_softc *sc);
55 +void ath_stop_ani(struct ath_softc *sc);
56 +void ath_check_ani(struct ath_softc *sc);
57 int ath_update_survey_stats(struct ath_softc *sc);
58 void ath_update_survey_nf(struct ath_softc *sc, int channel);
59 +void ath9k_queue_reset(struct ath_softc *sc, enum ath_reset_type type);
60
61 /**********/
62 /* BTCOEX */
63 @@ -613,7 +618,6 @@ enum sc_op_flags {
64 SC_OP_INVALID,
65 SC_OP_BEACONS,
66 SC_OP_RXFLUSH,
67 - SC_OP_TSF_RESET,
68 SC_OP_ANI_RUN,
69 SC_OP_PRIM_STA_VIF,
70 SC_OP_HW_RESET,
71 --- a/drivers/net/wireless/ath/ath9k/beacon.c
72 +++ b/drivers/net/wireless/ath/ath9k/beacon.c
73 @@ -30,7 +30,7 @@ static void ath9k_reset_beacon_status(st
74 * the operating mode of the station (AP or AdHoc). Parameters are AIFS
75 * settings and channel width min/max
76 */
77 -int ath_beaconq_config(struct ath_softc *sc)
78 +static void ath9k_beaconq_config(struct ath_softc *sc)
79 {
80 struct ath_hw *ah = sc->sc_ah;
81 struct ath_common *common = ath9k_hw_common(ah);
82 @@ -38,6 +38,7 @@ int ath_beaconq_config(struct ath_softc
83 struct ath_txq *txq;
84
85 ath9k_hw_get_txq_props(ah, sc->beacon.beaconq, &qi);
86 +
87 if (sc->sc_ah->opmode == NL80211_IFTYPE_AP) {
88 /* Always burst out beacon and CAB traffic. */
89 qi.tqi_aifs = 1;
90 @@ -56,12 +57,9 @@ int ath_beaconq_config(struct ath_softc
91 }
92
93 if (!ath9k_hw_set_txq_props(ah, sc->beacon.beaconq, &qi)) {
94 - ath_err(common,
95 - "Unable to update h/w beacon queue parameters\n");
96 - return 0;
97 + ath_err(common, "Unable to update h/w beacon queue parameters\n");
98 } else {
99 ath9k_hw_resettxqueue(ah, sc->beacon.beaconq);
100 - return 1;
101 }
102 }
103
104 @@ -70,7 +68,7 @@ int ath_beaconq_config(struct ath_softc
105 * up rate codes, and channel flags. Beacons are always sent out at the
106 * lowest rate, and are not retried.
107 */
108 -static void ath_beacon_setup(struct ath_softc *sc, struct ieee80211_vif *vif,
109 +static void ath9k_beacon_setup(struct ath_softc *sc, struct ieee80211_vif *vif,
110 struct ath_buf *bf, int rateidx)
111 {
112 struct sk_buff *skb = bf->bf_mpdu;
113 @@ -81,8 +79,6 @@ static void ath_beacon_setup(struct ath_
114 u8 chainmask = ah->txchainmask;
115 u8 rate = 0;
116
117 - ath9k_reset_beacon_status(sc);
118 -
119 sband = &sc->sbands[common->hw->conf.channel->band];
120 rate = sband->bitrates[rateidx].hw_value;
121 if (vif->bss_conf.use_short_preamble)
122 @@ -111,7 +107,7 @@ static void ath_beacon_setup(struct ath_
123 ath9k_hw_set_txdesc(ah, bf->bf_desc, &info);
124 }
125
126 -static void ath_tx_cabq(struct ieee80211_hw *hw, struct sk_buff *skb)
127 +static void ath9k_tx_cabq(struct ieee80211_hw *hw, struct sk_buff *skb)
128 {
129 struct ath_softc *sc = hw->priv;
130 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
131 @@ -128,28 +124,22 @@ static void ath_tx_cabq(struct ieee80211
132 }
133 }
134
135 -static struct ath_buf *ath_beacon_generate(struct ieee80211_hw *hw,
136 - struct ieee80211_vif *vif)
137 +static struct ath_buf *ath9k_beacon_generate(struct ieee80211_hw *hw,
138 + struct ieee80211_vif *vif)
139 {
140 struct ath_softc *sc = hw->priv;
141 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
142 struct ath_buf *bf;
143 - struct ath_vif *avp;
144 + struct ath_vif *avp = (void *)vif->drv_priv;
145 struct sk_buff *skb;
146 - struct ath_txq *cabq;
147 + struct ath_txq *cabq = sc->beacon.cabq;
148 struct ieee80211_tx_info *info;
149 + struct ieee80211_mgmt *mgmt_hdr;
150 int cabq_depth;
151
152 - ath9k_reset_beacon_status(sc);
153 -
154 - avp = (void *)vif->drv_priv;
155 - cabq = sc->beacon.cabq;
156 -
157 - if ((avp->av_bcbuf == NULL) || !avp->is_bslot_active)
158 + if (avp->av_bcbuf == NULL)
159 return NULL;
160
161 - /* Release the old beacon first */
162 -
163 bf = avp->av_bcbuf;
164 skb = bf->bf_mpdu;
165 if (skb) {
166 @@ -159,14 +149,14 @@ static struct ath_buf *ath_beacon_genera
167 bf->bf_buf_addr = 0;
168 }
169
170 - /* Get a new beacon from mac80211 */
171 -
172 skb = ieee80211_beacon_get(hw, vif);
173 - bf->bf_mpdu = skb;
174 if (skb == NULL)
175 return NULL;
176 - ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp =
177 - avp->tsf_adjust;
178 +
179 + bf->bf_mpdu = skb;
180 +
181 + mgmt_hdr = (struct ieee80211_mgmt *)skb->data;
182 + mgmt_hdr->u.beacon.timestamp = avp->tsf_adjust;
183
184 info = IEEE80211_SKB_CB(skb);
185 if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
186 @@ -212,61 +202,52 @@ static struct ath_buf *ath_beacon_genera
187 }
188 }
189
190 - ath_beacon_setup(sc, vif, bf, info->control.rates[0].idx);
191 + ath9k_beacon_setup(sc, vif, bf, info->control.rates[0].idx);
192
193 while (skb) {
194 - ath_tx_cabq(hw, skb);
195 + ath9k_tx_cabq(hw, skb);
196 skb = ieee80211_get_buffered_bc(hw, vif);
197 }
198
199 return bf;
200 }
201
202 -int ath_beacon_alloc(struct ath_softc *sc, struct ieee80211_vif *vif)
203 +void ath9k_beacon_assign_slot(struct ath_softc *sc, struct ieee80211_vif *vif)
204 {
205 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
206 - struct ath_vif *avp;
207 - struct ath_buf *bf;
208 - struct sk_buff *skb;
209 - struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf;
210 - __le64 tstamp;
211 + struct ath_vif *avp = (void *)vif->drv_priv;
212 + int slot;
213
214 - avp = (void *)vif->drv_priv;
215 + avp->av_bcbuf = list_first_entry(&sc->beacon.bbuf, struct ath_buf, list);
216 + list_del(&avp->av_bcbuf->list);
217
218 - /* Allocate a beacon descriptor if we haven't done so. */
219 - if (!avp->av_bcbuf) {
220 - /* Allocate beacon state for hostap/ibss. We know
221 - * a buffer is available. */
222 - avp->av_bcbuf = list_first_entry(&sc->beacon.bbuf,
223 - struct ath_buf, list);
224 - list_del(&avp->av_bcbuf->list);
225 -
226 - if (ath9k_uses_beacons(vif->type)) {
227 - int slot;
228 - /*
229 - * Assign the vif to a beacon xmit slot. As
230 - * above, this cannot fail to find one.
231 - */
232 - avp->av_bslot = 0;
233 - for (slot = 0; slot < ATH_BCBUF; slot++)
234 - if (sc->beacon.bslot[slot] == NULL) {
235 - avp->av_bslot = slot;
236 - avp->is_bslot_active = false;
237 -
238 - /* NB: keep looking for a double slot */
239 - if (slot == 0 || !sc->beacon.bslot[slot-1])
240 - break;
241 - }
242 - BUG_ON(sc->beacon.bslot[avp->av_bslot] != NULL);
243 - sc->beacon.bslot[avp->av_bslot] = vif;
244 - sc->nbcnvifs++;
245 + for (slot = 0; slot < ATH_BCBUF; slot++) {
246 + if (sc->beacon.bslot[slot] == NULL) {
247 + avp->av_bslot = slot;
248 + break;
249 }
250 }
251
252 - /* release the previous beacon frame, if it already exists. */
253 - bf = avp->av_bcbuf;
254 - if (bf->bf_mpdu != NULL) {
255 - skb = bf->bf_mpdu;
256 + sc->beacon.bslot[avp->av_bslot] = vif;
257 + sc->nbcnvifs++;
258 +
259 + ath_dbg(common, CONFIG, "Added interface at beacon slot: %d\n",
260 + avp->av_bslot);
261 +}
262 +
263 +void ath9k_beacon_remove_slot(struct ath_softc *sc, struct ieee80211_vif *vif)
264 +{
265 + struct ath_common *common = ath9k_hw_common(sc->sc_ah);
266 + struct ath_vif *avp = (void *)vif->drv_priv;
267 + struct ath_buf *bf = avp->av_bcbuf;
268 +
269 + ath_dbg(common, CONFIG, "Removing interface at beacon slot: %d\n",
270 + avp->av_bslot);
271 +
272 + tasklet_disable(&sc->bcon_tasklet);
273 +
274 + if (bf && bf->bf_mpdu) {
275 + struct sk_buff *skb = bf->bf_mpdu;
276 dma_unmap_single(sc->dev, bf->bf_buf_addr,
277 skb->len, DMA_TO_DEVICE);
278 dev_kfree_skb_any(skb);
279 @@ -274,99 +255,74 @@ int ath_beacon_alloc(struct ath_softc *s
280 bf->bf_buf_addr = 0;
281 }
282
283 - /* NB: the beacon data buffer must be 32-bit aligned. */
284 - skb = ieee80211_beacon_get(sc->hw, vif);
285 - if (skb == NULL)
286 - return -ENOMEM;
287 -
288 - tstamp = ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp;
289 - sc->beacon.bc_tstamp = (u32) le64_to_cpu(tstamp);
290 - /* Calculate a TSF adjustment factor required for staggered beacons. */
291 - if (avp->av_bslot > 0) {
292 - u64 tsfadjust;
293 - int intval;
294 + avp->av_bcbuf = NULL;
295 + sc->beacon.bslot[avp->av_bslot] = NULL;
296 + sc->nbcnvifs--;
297 + list_add_tail(&bf->list, &sc->beacon.bbuf);
298
299 - intval = cur_conf->beacon_interval ? : ATH_DEFAULT_BINTVAL;
300 + tasklet_enable(&sc->bcon_tasklet);
301 +}
302
303 - /*
304 - * Calculate the TSF offset for this beacon slot, i.e., the
305 - * number of usecs that need to be added to the timestamp field
306 - * in Beacon and Probe Response frames. Beacon slot 0 is
307 - * processed at the correct offset, so it does not require TSF
308 - * adjustment. Other slots are adjusted to get the timestamp
309 - * close to the TBTT for the BSS.
310 - */
311 - tsfadjust = TU_TO_USEC(intval * avp->av_bslot) / ATH_BCBUF;
312 - avp->tsf_adjust = cpu_to_le64(tsfadjust);
313 +static int ath9k_beacon_choose_slot(struct ath_softc *sc)
314 +{
315 + struct ath_common *common = ath9k_hw_common(sc->sc_ah);
316 + struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf;
317 + u16 intval;
318 + u32 tsftu;
319 + u64 tsf;
320 + int slot;
321
322 - ath_dbg(common, BEACON,
323 - "stagger beacons, bslot %d intval %u tsfadjust %llu\n",
324 - avp->av_bslot, intval, (unsigned long long)tsfadjust);
325 + if (sc->sc_ah->opmode != NL80211_IFTYPE_AP) {
326 + ath_dbg(common, BEACON, "slot 0, tsf: %llu\n",
327 + ath9k_hw_gettsf64(sc->sc_ah));
328 + return 0;
329 + }
330
331 - ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp =
332 - avp->tsf_adjust;
333 - } else
334 - avp->tsf_adjust = cpu_to_le64(0);
335 + intval = cur_conf->beacon_interval ? : ATH_DEFAULT_BINTVAL;
336 + tsf = ath9k_hw_gettsf64(sc->sc_ah);
337 + tsf += TU_TO_USEC(sc->sc_ah->config.sw_beacon_response_time);
338 + tsftu = TSF_TO_TU((tsf * ATH_BCBUF) >>32, tsf * ATH_BCBUF);
339 + slot = (tsftu % (intval * ATH_BCBUF)) / intval;
340
341 - bf->bf_mpdu = skb;
342 - bf->bf_buf_addr = dma_map_single(sc->dev, skb->data,
343 - skb->len, DMA_TO_DEVICE);
344 - if (unlikely(dma_mapping_error(sc->dev, bf->bf_buf_addr))) {
345 - dev_kfree_skb_any(skb);
346 - bf->bf_mpdu = NULL;
347 - bf->bf_buf_addr = 0;
348 - ath_err(common, "dma_mapping_error on beacon alloc\n");
349 - return -ENOMEM;
350 - }
351 - avp->is_bslot_active = true;
352 + ath_dbg(common, BEACON, "slot: %d tsf: %llu tsftu: %u\n",
353 + slot, tsf, tsftu / ATH_BCBUF);
354
355 - return 0;
356 + return slot;
357 }
358
359 -void ath_beacon_return(struct ath_softc *sc, struct ath_vif *avp)
360 +void ath9k_set_tsfadjust(struct ath_softc *sc, struct ieee80211_vif *vif)
361 {
362 - if (avp->av_bcbuf != NULL) {
363 - struct ath_buf *bf;
364 + struct ath_common *common = ath9k_hw_common(sc->sc_ah);
365 + struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf;
366 + struct ath_vif *avp = (void *)vif->drv_priv;
367 + u64 tsfadjust;
368
369 - avp->is_bslot_active = false;
370 - if (avp->av_bslot != -1) {
371 - sc->beacon.bslot[avp->av_bslot] = NULL;
372 - sc->nbcnvifs--;
373 - avp->av_bslot = -1;
374 - }
375 + if (avp->av_bslot == 0)
376 + return;
377
378 - bf = avp->av_bcbuf;
379 - if (bf->bf_mpdu != NULL) {
380 - struct sk_buff *skb = bf->bf_mpdu;
381 - dma_unmap_single(sc->dev, bf->bf_buf_addr,
382 - skb->len, DMA_TO_DEVICE);
383 - dev_kfree_skb_any(skb);
384 - bf->bf_mpdu = NULL;
385 - bf->bf_buf_addr = 0;
386 - }
387 - list_add_tail(&bf->list, &sc->beacon.bbuf);
388 + tsfadjust = cur_conf->beacon_interval * avp->av_bslot / ATH_BCBUF;
389 + avp->tsf_adjust = cpu_to_le64(TU_TO_USEC(tsfadjust));
390
391 - avp->av_bcbuf = NULL;
392 - }
393 + ath_dbg(common, CONFIG, "tsfadjust is: %llu for bslot: %d\n",
394 + (unsigned long long)tsfadjust, avp->av_bslot);
395 }
396
397 -void ath_beacon_tasklet(unsigned long data)
398 +void ath9k_beacon_tasklet(unsigned long data)
399 {
400 struct ath_softc *sc = (struct ath_softc *)data;
401 - struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf;
402 struct ath_hw *ah = sc->sc_ah;
403 struct ath_common *common = ath9k_hw_common(ah);
404 struct ath_buf *bf = NULL;
405 struct ieee80211_vif *vif;
406 bool edma = !!(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA);
407 int slot;
408 - u32 bfaddr, bc = 0;
409
410 - if (work_pending(&sc->hw_reset_work)) {
411 + if (test_bit(SC_OP_HW_RESET, &sc->sc_flags)) {
412 ath_dbg(common, RESET,
413 "reset work is pending, skip beaconing now\n");
414 return;
415 }
416 +
417 /*
418 * Check if the previous beacon has gone out. If
419 * not don't try to post another, skip this period
420 @@ -390,55 +346,25 @@ void ath_beacon_tasklet(unsigned long da
421 } else if (sc->beacon.bmisscnt >= BSTUCK_THRESH) {
422 ath_dbg(common, BSTUCK, "beacon is officially stuck\n");
423 sc->beacon.bmisscnt = 0;
424 - set_bit(SC_OP_TSF_RESET, &sc->sc_flags);
425 - ieee80211_queue_work(sc->hw, &sc->hw_reset_work);
426 + ath9k_queue_reset(sc, RESET_TYPE_BEACON_STUCK);
427 }
428
429 return;
430 }
431
432 - /*
433 - * Generate beacon frames. we are sending frames
434 - * staggered so calculate the slot for this frame based
435 - * on the tsf to safeguard against missing an swba.
436 - */
437 -
438 -
439 - if (ah->opmode == NL80211_IFTYPE_AP) {
440 - u16 intval;
441 - u32 tsftu;
442 - u64 tsf;
443 -
444 - intval = cur_conf->beacon_interval ? : ATH_DEFAULT_BINTVAL;
445 - tsf = ath9k_hw_gettsf64(ah);
446 - tsf += TU_TO_USEC(ah->config.sw_beacon_response_time);
447 - tsftu = TSF_TO_TU((tsf * ATH_BCBUF) >>32, tsf * ATH_BCBUF);
448 - slot = (tsftu % (intval * ATH_BCBUF)) / intval;
449 - vif = sc->beacon.bslot[slot];
450 -
451 - ath_dbg(common, BEACON,
452 - "slot %d [tsf %llu tsftu %u intval %u] vif %p\n",
453 - slot, tsf, tsftu / ATH_BCBUF, intval, vif);
454 - } else {
455 - slot = 0;
456 - vif = sc->beacon.bslot[slot];
457 - }
458 + slot = ath9k_beacon_choose_slot(sc);
459 + vif = sc->beacon.bslot[slot];
460
461 + if (!vif || !vif->bss_conf.enable_beacon)
462 + return;
463
464 - bfaddr = 0;
465 - if (vif) {
466 - bf = ath_beacon_generate(sc->hw, vif);
467 - if (bf != NULL) {
468 - bfaddr = bf->bf_daddr;
469 - bc = 1;
470 - }
471 + bf = ath9k_beacon_generate(sc->hw, vif);
472 + WARN_ON(!bf);
473
474 - if (sc->beacon.bmisscnt != 0) {
475 - ath_dbg(common, BSTUCK,
476 - "resume beacon xmit after %u misses\n",
477 - sc->beacon.bmisscnt);
478 - sc->beacon.bmisscnt = 0;
479 - }
480 + if (sc->beacon.bmisscnt != 0) {
481 + ath_dbg(common, BSTUCK, "resume beacon xmit after %u misses\n",
482 + sc->beacon.bmisscnt);
483 + sc->beacon.bmisscnt = 0;
484 }
485
486 /*
487 @@ -458,39 +384,37 @@ void ath_beacon_tasklet(unsigned long da
488 * set to ATH_BCBUF so this check is a noop.
489 */
490 if (sc->beacon.updateslot == UPDATE) {
491 - sc->beacon.updateslot = COMMIT; /* commit next beacon */
492 + sc->beacon.updateslot = COMMIT;
493 sc->beacon.slotupdate = slot;
494 - } else if (sc->beacon.updateslot == COMMIT && sc->beacon.slotupdate == slot) {
495 + } else if (sc->beacon.updateslot == COMMIT &&
496 + sc->beacon.slotupdate == slot) {
497 ah->slottime = sc->beacon.slottime;
498 ath9k_hw_init_global_settings(ah);
499 sc->beacon.updateslot = OK;
500 }
501 - if (bfaddr != 0) {
502 +
503 + if (bf) {
504 + ath9k_reset_beacon_status(sc);
505 +
506 /* NB: cabq traffic should already be queued and primed */
507 - ath9k_hw_puttxbuf(ah, sc->beacon.beaconq, bfaddr);
508 + ath9k_hw_puttxbuf(ah, sc->beacon.beaconq, bf->bf_daddr);
509
510 if (!edma)
511 ath9k_hw_txstart(ah, sc->beacon.beaconq);
512 -
513 - sc->beacon.ast_be_xmit += bc; /* XXX per-vif? */
514 }
515 }
516
517 -static void ath9k_beacon_init(struct ath_softc *sc,
518 - u32 next_beacon,
519 - u32 beacon_period)
520 +static void ath9k_beacon_init(struct ath_softc *sc, u32 nexttbtt, u32 intval)
521 {
522 - if (test_bit(SC_OP_TSF_RESET, &sc->sc_flags)) {
523 - ath9k_ps_wakeup(sc);
524 - ath9k_hw_reset_tsf(sc->sc_ah);
525 - }
526 -
527 - ath9k_hw_beaconinit(sc->sc_ah, next_beacon, beacon_period);
528 + struct ath_hw *ah = sc->sc_ah;
529
530 - if (test_bit(SC_OP_TSF_RESET, &sc->sc_flags)) {
531 - ath9k_ps_restore(sc);
532 - clear_bit(SC_OP_TSF_RESET, &sc->sc_flags);
533 - }
534 + ath9k_hw_disable_interrupts(ah);
535 + ath9k_hw_reset_tsf(ah);
536 + ath9k_beaconq_config(sc);
537 + ath9k_hw_beaconinit(ah, nexttbtt, intval);
538 + sc->beacon.bmisscnt = 0;
539 + ath9k_hw_set_interrupts(ah);
540 + ath9k_hw_enable_interrupts(ah);
541 }
542
543 /*
544 @@ -498,32 +422,27 @@ static void ath9k_beacon_init(struct ath
545 * burst together. For the former arrange for the SWBA to be delivered for each
546 * slot. Slots that are not occupied will generate nothing.
547 */
548 -static void ath_beacon_config_ap(struct ath_softc *sc,
549 - struct ath_beacon_config *conf)
550 +static void ath9k_beacon_config_ap(struct ath_softc *sc,
551 + struct ath_beacon_config *conf)
552 {
553 struct ath_hw *ah = sc->sc_ah;
554 + struct ath_common *common = ath9k_hw_common(ah);
555 u32 nexttbtt, intval;
556
557 /* NB: the beacon interval is kept internally in TU's */
558 intval = TU_TO_USEC(conf->beacon_interval);
559 - intval /= ATH_BCBUF; /* for staggered beacons */
560 + intval /= ATH_BCBUF;
561 nexttbtt = intval;
562
563 - /*
564 - * In AP mode we enable the beacon timers and SWBA interrupts to
565 - * prepare beacon frames.
566 - */
567 - ah->imask |= ATH9K_INT_SWBA;
568 - ath_beaconq_config(sc);
569 + if (conf->enable_beacon)
570 + ah->imask |= ATH9K_INT_SWBA;
571 + else
572 + ah->imask &= ~ATH9K_INT_SWBA;
573
574 - /* Set the computed AP beacon timers */
575 + ath_dbg(common, BEACON, "AP nexttbtt: %u intval: %u conf_intval: %u\n",
576 + nexttbtt, intval, conf->beacon_interval);
577
578 - ath9k_hw_disable_interrupts(ah);
579 - set_bit(SC_OP_TSF_RESET, &sc->sc_flags);
580 ath9k_beacon_init(sc, nexttbtt, intval);
581 - sc->beacon.bmisscnt = 0;
582 - ath9k_hw_set_interrupts(ah);
583 - ath9k_hw_enable_interrupts(ah);
584 }
585
586 /*
587 @@ -534,8 +453,8 @@ static void ath_beacon_config_ap(struct
588 * we'll receive a BMISS interrupt when we stop seeing beacons from the AP
589 * we've associated with.
590 */
591 -static void ath_beacon_config_sta(struct ath_softc *sc,
592 - struct ath_beacon_config *conf)
593 +static void ath9k_beacon_config_sta(struct ath_softc *sc,
594 + struct ath_beacon_config *conf)
595 {
596 struct ath_hw *ah = sc->sc_ah;
597 struct ath_common *common = ath9k_hw_common(ah);
598 @@ -654,8 +573,8 @@ static void ath_beacon_config_sta(struct
599 ath9k_hw_enable_interrupts(ah);
600 }
601
602 -static void ath_beacon_config_adhoc(struct ath_softc *sc,
603 - struct ath_beacon_config *conf)
604 +static void ath9k_beacon_config_adhoc(struct ath_softc *sc,
605 + struct ath_beacon_config *conf)
606 {
607 struct ath_hw *ah = sc->sc_ah;
608 struct ath_common *common = ath9k_hw_common(ah);
609 @@ -669,82 +588,53 @@ static void ath_beacon_config_adhoc(stru
610 tsf = roundup(ath9k_hw_gettsf32(ah) + TU_TO_USEC(FUDGE), intval);
611 nexttbtt = tsf + intval;
612
613 - ath_dbg(common, BEACON, "IBSS nexttbtt %u intval %u (%u)\n",
614 - nexttbtt, intval, conf->beacon_interval);
615 -
616 - /*
617 - * In IBSS mode enable the beacon timers but only enable SWBA interrupts
618 - * if we need to manually prepare beacon frames. Otherwise we use a
619 - * self-linked tx descriptor and let the hardware deal with things.
620 - */
621 - ah->imask |= ATH9K_INT_SWBA;
622 -
623 - ath_beaconq_config(sc);
624 + if (conf->enable_beacon)
625 + ah->imask |= ATH9K_INT_SWBA;
626 + else
627 + ah->imask &= ~ATH9K_INT_SWBA;
628
629 - /* Set the computed ADHOC beacon timers */
630 + ath_dbg(common, BEACON, "IBSS nexttbtt: %u intval: %u conf_intval: %u\n",
631 + nexttbtt, intval, conf->beacon_interval);
632
633 - ath9k_hw_disable_interrupts(ah);
634 ath9k_beacon_init(sc, nexttbtt, intval);
635 - sc->beacon.bmisscnt = 0;
636 -
637 - ath9k_hw_set_interrupts(ah);
638 - ath9k_hw_enable_interrupts(ah);
639 }
640
641 -static bool ath9k_allow_beacon_config(struct ath_softc *sc,
642 - struct ieee80211_vif *vif)
643 +bool ath9k_allow_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif)
644 {
645 - struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf;
646 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
647 - struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
648 struct ath_vif *avp = (void *)vif->drv_priv;
649
650 - /*
651 - * Can not have different beacon interval on multiple
652 - * AP interface case
653 - */
654 - if ((sc->sc_ah->opmode == NL80211_IFTYPE_AP) &&
655 - (sc->nbcnvifs > 1) &&
656 - (vif->type == NL80211_IFTYPE_AP) &&
657 - (cur_conf->beacon_interval != bss_conf->beacon_int)) {
658 - ath_dbg(common, CONFIG,
659 - "Changing beacon interval of multiple AP interfaces !\n");
660 - return false;
661 - }
662 - /*
663 - * Can not configure station vif's beacon config
664 - * while on AP opmode
665 - */
666 - if ((sc->sc_ah->opmode == NL80211_IFTYPE_AP) &&
667 - (vif->type != NL80211_IFTYPE_AP)) {
668 - ath_dbg(common, CONFIG,
669 - "STA vif's beacon not allowed on AP mode\n");
670 - return false;
671 + if (sc->sc_ah->opmode == NL80211_IFTYPE_AP) {
672 + if ((vif->type != NL80211_IFTYPE_AP) ||
673 + (sc->nbcnvifs > 1)) {
674 + ath_dbg(common, CONFIG,
675 + "An AP interface is already present !\n");
676 + return false;
677 + }
678 }
679 - /*
680 - * Do not allow beacon config if HW was already configured
681 - * with another STA vif
682 - */
683 - if ((sc->sc_ah->opmode == NL80211_IFTYPE_STATION) &&
684 - (vif->type == NL80211_IFTYPE_STATION) &&
685 - test_bit(SC_OP_BEACONS, &sc->sc_flags) &&
686 - !avp->primary_sta_vif) {
687 - ath_dbg(common, CONFIG,
688 - "Beacon already configured for a station interface\n");
689 - return false;
690 +
691 + if (sc->sc_ah->opmode == NL80211_IFTYPE_STATION) {
692 + if ((vif->type == NL80211_IFTYPE_STATION) &&
693 + test_bit(SC_OP_BEACONS, &sc->sc_flags) &&
694 + !avp->primary_sta_vif) {
695 + ath_dbg(common, CONFIG,
696 + "Beacon already configured for a station interface\n");
697 + return false;
698 + }
699 }
700 +
701 return true;
702 }
703
704 -void ath_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif)
705 +static void ath9k_cache_beacon_config(struct ath_softc *sc,
706 + struct ieee80211_bss_conf *bss_conf)
707 {
708 + struct ath_common *common = ath9k_hw_common(sc->sc_ah);
709 struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf;
710 - struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
711
712 - if (!ath9k_allow_beacon_config(sc, vif))
713 - return;
714 + ath_dbg(common, BEACON,
715 + "Caching beacon data for BSS: %pM\n", bss_conf->bssid);
716
717 - /* Setup the beacon configuration parameters */
718 cur_conf->beacon_interval = bss_conf->beacon_int;
719 cur_conf->dtim_period = bss_conf->dtim_period;
720 cur_conf->listen_interval = 1;
721 @@ -769,73 +659,59 @@ void ath_beacon_config(struct ath_softc
722 if (cur_conf->dtim_period == 0)
723 cur_conf->dtim_period = 1;
724
725 - ath_set_beacon(sc);
726 }
727
728 -static bool ath_has_valid_bslot(struct ath_softc *sc)
729 +void ath9k_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif,
730 + u32 changed)
731 {
732 - struct ath_vif *avp;
733 - int slot;
734 - bool found = false;
735 + struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
736 + struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf;
737
738 - for (slot = 0; slot < ATH_BCBUF; slot++) {
739 - if (sc->beacon.bslot[slot]) {
740 - avp = (void *)sc->beacon.bslot[slot]->drv_priv;
741 - if (avp->is_bslot_active) {
742 - found = true;
743 - break;
744 - }
745 + ath9k_cache_beacon_config(sc, bss_conf);
746 +
747 + if (sc->sc_ah->opmode == NL80211_IFTYPE_STATION) {
748 + ath9k_set_beacon(sc);
749 + set_bit(SC_OP_BEACONS, &sc->sc_flags);
750 + } else {
751 + /*
752 + * Take care of multiple interfaces when
753 + * enabling/disabling SWBA.
754 + */
755 + if (changed & BSS_CHANGED_BEACON_ENABLED) {
756 + if (!bss_conf->enable_beacon &&
757 + (sc->nbcnvifs <= 1))
758 + cur_conf->enable_beacon = false;
759 + else if (bss_conf->enable_beacon)
760 + cur_conf->enable_beacon = true;
761 }
762 +
763 + ath9k_set_beacon(sc);
764 +
765 + if (cur_conf->enable_beacon)
766 + set_bit(SC_OP_BEACONS, &sc->sc_flags);
767 + else
768 + clear_bit(SC_OP_BEACONS, &sc->sc_flags);
769 }
770 - return found;
771 }
772
773 -
774 -void ath_set_beacon(struct ath_softc *sc)
775 +void ath9k_set_beacon(struct ath_softc *sc)
776 {
777 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
778 struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf;
779
780 switch (sc->sc_ah->opmode) {
781 case NL80211_IFTYPE_AP:
782 - if (ath_has_valid_bslot(sc))
783 - ath_beacon_config_ap(sc, cur_conf);
784 + ath9k_beacon_config_ap(sc, cur_conf);
785 break;
786 case NL80211_IFTYPE_ADHOC:
787 case NL80211_IFTYPE_MESH_POINT:
788 - ath_beacon_config_adhoc(sc, cur_conf);
789 + ath9k_beacon_config_adhoc(sc, cur_conf);
790 break;
791 case NL80211_IFTYPE_STATION:
792 - ath_beacon_config_sta(sc, cur_conf);
793 + ath9k_beacon_config_sta(sc, cur_conf);
794 break;
795 default:
796 ath_dbg(common, CONFIG, "Unsupported beaconing mode\n");
797 return;
798 }
799 -
800 - set_bit(SC_OP_BEACONS, &sc->sc_flags);
801 -}
802 -
803 -void ath9k_set_beaconing_status(struct ath_softc *sc, bool status)
804 -{
805 - struct ath_hw *ah = sc->sc_ah;
806 -
807 - if (!ath_has_valid_bslot(sc)) {
808 - clear_bit(SC_OP_BEACONS, &sc->sc_flags);
809 - return;
810 - }
811 -
812 - ath9k_ps_wakeup(sc);
813 - if (status) {
814 - /* Re-enable beaconing */
815 - ah->imask |= ATH9K_INT_SWBA;
816 - ath9k_hw_set_interrupts(ah);
817 - } else {
818 - /* Disable SWBA interrupt */
819 - ah->imask &= ~ATH9K_INT_SWBA;
820 - ath9k_hw_set_interrupts(ah);
821 - tasklet_kill(&sc->bcon_tasklet);
822 - ath9k_hw_stop_dma_queue(ah, sc->beacon.beaconq);
823 - }
824 - ath9k_ps_restore(sc);
825 }
826 --- a/drivers/net/wireless/ath/ath9k/debug.c
827 +++ b/drivers/net/wireless/ath/ath9k/debug.c
828 @@ -206,10 +206,9 @@ static ssize_t write_file_disable_ani(st
829
830 if (disable_ani) {
831 clear_bit(SC_OP_ANI_RUN, &sc->sc_flags);
832 - del_timer_sync(&common->ani.timer);
833 + ath_stop_ani(sc);
834 } else {
835 - set_bit(SC_OP_ANI_RUN, &sc->sc_flags);
836 - ath_start_ani(common);
837 + ath_check_ani(sc);
838 }
839
840 return count;
841 --- a/drivers/net/wireless/ath/ath9k/debug.h
842 +++ b/drivers/net/wireless/ath/ath9k/debug.h
843 @@ -32,6 +32,19 @@ struct ath_buf;
844 #define RESET_STAT_INC(sc, type) do { } while (0)
845 #endif
846
847 +enum ath_reset_type {
848 + RESET_TYPE_BB_HANG,
849 + RESET_TYPE_BB_WATCHDOG,
850 + RESET_TYPE_FATAL_INT,
851 + RESET_TYPE_TX_ERROR,
852 + RESET_TYPE_TX_HANG,
853 + RESET_TYPE_PLL_HANG,
854 + RESET_TYPE_MAC_HANG,
855 + RESET_TYPE_BEACON_STUCK,
856 + RESET_TYPE_MCI,
857 + __RESET_TYPE_MAX
858 +};
859 +
860 #ifdef CONFIG_ATH9K_DEBUGFS
861
862 /**
863 @@ -209,17 +222,6 @@ struct ath_rx_stats {
864 u32 rx_frags;
865 };
866
867 -enum ath_reset_type {
868 - RESET_TYPE_BB_HANG,
869 - RESET_TYPE_BB_WATCHDOG,
870 - RESET_TYPE_FATAL_INT,
871 - RESET_TYPE_TX_ERROR,
872 - RESET_TYPE_TX_HANG,
873 - RESET_TYPE_PLL_HANG,
874 - RESET_TYPE_MAC_HANG,
875 - __RESET_TYPE_MAX
876 -};
877 -
878 struct ath_stats {
879 struct ath_interrupt_stats istats;
880 struct ath_tx_stats txstats[ATH9K_NUM_TX_QUEUES];
881 --- a/drivers/net/wireless/ath/ath9k/htc_drv_main.c
882 +++ b/drivers/net/wireless/ath/ath9k/htc_drv_main.c
883 @@ -1111,7 +1111,7 @@ static int ath9k_htc_add_interface(struc
884
885 if ((priv->ah->opmode == NL80211_IFTYPE_AP) &&
886 !test_bit(OP_ANI_RUNNING, &priv->op_flags)) {
887 - ath9k_hw_set_tsfadjust(priv->ah, 1);
888 + ath9k_hw_set_tsfadjust(priv->ah, true);
889 ath9k_htc_start_ani(priv);
890 }
891
892 --- a/drivers/net/wireless/ath/ath9k/hw.c
893 +++ b/drivers/net/wireless/ath/ath9k/hw.c
894 @@ -2908,9 +2908,9 @@ void ath9k_hw_reset_tsf(struct ath_hw *a
895 }
896 EXPORT_SYMBOL(ath9k_hw_reset_tsf);
897
898 -void ath9k_hw_set_tsfadjust(struct ath_hw *ah, u32 setting)
899 +void ath9k_hw_set_tsfadjust(struct ath_hw *ah, bool set)
900 {
901 - if (setting)
902 + if (set)
903 ah->misc_mode |= AR_PCU_TX_ADD_TSF;
904 else
905 ah->misc_mode &= ~AR_PCU_TX_ADD_TSF;
906 --- a/drivers/net/wireless/ath/ath9k/hw.h
907 +++ b/drivers/net/wireless/ath/ath9k/hw.h
908 @@ -943,7 +943,7 @@ u32 ath9k_hw_gettsf32(struct ath_hw *ah)
909 u64 ath9k_hw_gettsf64(struct ath_hw *ah);
910 void ath9k_hw_settsf64(struct ath_hw *ah, u64 tsf64);
911 void ath9k_hw_reset_tsf(struct ath_hw *ah);
912 -void ath9k_hw_set_tsfadjust(struct ath_hw *ah, u32 setting);
913 +void ath9k_hw_set_tsfadjust(struct ath_hw *ah, bool set);
914 void ath9k_hw_init_global_settings(struct ath_hw *ah);
915 u32 ar9003_get_pll_sqsum_dvc(struct ath_hw *ah);
916 void ath9k_hw_set11nmac2040(struct ath_hw *ah);
917 --- a/drivers/net/wireless/ath/ath9k/init.c
918 +++ b/drivers/net/wireless/ath/ath9k/init.c
919 @@ -560,7 +560,7 @@ static int ath9k_init_softc(u16 devid, s
920 spin_lock_init(&sc->debug.samp_lock);
921 #endif
922 tasklet_init(&sc->intr_tq, ath9k_tasklet, (unsigned long)sc);
923 - tasklet_init(&sc->bcon_tasklet, ath_beacon_tasklet,
924 + tasklet_init(&sc->bcon_tasklet, ath9k_beacon_tasklet,
925 (unsigned long)sc);
926
927 INIT_WORK(&sc->hw_reset_work, ath_reset_work);
928 --- a/drivers/net/wireless/ath/ath9k/link.c
929 +++ b/drivers/net/wireless/ath/ath9k/link.c
930 @@ -50,8 +50,7 @@ void ath_tx_complete_poll_work(struct wo
931 if (needreset) {
932 ath_dbg(ath9k_hw_common(sc->sc_ah), RESET,
933 "tx hung, resetting the chip\n");
934 - RESET_STAT_INC(sc, RESET_TYPE_TX_HANG);
935 - ieee80211_queue_work(sc->hw, &sc->hw_reset_work);
936 + ath9k_queue_reset(sc, RESET_TYPE_TX_HANG);
937 return;
938 }
939
940 @@ -69,6 +68,7 @@ void ath_hw_check(struct work_struct *wo
941 unsigned long flags;
942 int busy;
943 u8 is_alive, nbeacon = 1;
944 + enum ath_reset_type type;
945
946 ath9k_ps_wakeup(sc);
947 is_alive = ath9k_hw_check_alive(sc->sc_ah);
948 @@ -78,7 +78,7 @@ void ath_hw_check(struct work_struct *wo
949 else if (!is_alive && AR_SREV_9300(sc->sc_ah)) {
950 ath_dbg(common, RESET,
951 "DCU stuck is detected. Schedule chip reset\n");
952 - RESET_STAT_INC(sc, RESET_TYPE_MAC_HANG);
953 + type = RESET_TYPE_MAC_HANG;
954 goto sched_reset;
955 }
956
957 @@ -90,7 +90,7 @@ void ath_hw_check(struct work_struct *wo
958 busy, sc->hw_busy_count + 1);
959 if (busy >= 99) {
960 if (++sc->hw_busy_count >= 3) {
961 - RESET_STAT_INC(sc, RESET_TYPE_BB_HANG);
962 + type = RESET_TYPE_BB_HANG;
963 goto sched_reset;
964 }
965 } else if (busy >= 0) {
966 @@ -102,7 +102,7 @@ void ath_hw_check(struct work_struct *wo
967 goto out;
968
969 sched_reset:
970 - ieee80211_queue_work(sc->hw, &sc->hw_reset_work);
971 + ath9k_queue_reset(sc, type);
972 out:
973 ath9k_ps_restore(sc);
974 }
975 @@ -119,8 +119,7 @@ static bool ath_hw_pll_rx_hang_check(str
976 count++;
977 if (count == 3) {
978 ath_dbg(common, RESET, "PLL WAR, resetting the chip\n");
979 - RESET_STAT_INC(sc, RESET_TYPE_PLL_HANG);
980 - ieee80211_queue_work(sc->hw, &sc->hw_reset_work);
981 + ath9k_queue_reset(sc, RESET_TYPE_PLL_HANG);
982 count = 0;
983 return true;
984 }
985 @@ -432,26 +431,69 @@ set_timer:
986 }
987 }
988
989 -void ath_start_ani(struct ath_common *common)
990 +void ath_start_ani(struct ath_softc *sc)
991 {
992 - struct ath_hw *ah = common->ah;
993 + struct ath_hw *ah = sc->sc_ah;
994 + struct ath_common *common = ath9k_hw_common(ah);
995 unsigned long timestamp = jiffies_to_msecs(jiffies);
996 - struct ath_softc *sc = (struct ath_softc *) common->priv;
997
998 - if (!test_bit(SC_OP_ANI_RUN, &sc->sc_flags))
999 - return;
1000 -
1001 - if (sc->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)
1002 + if (common->disable_ani ||
1003 + !test_bit(SC_OP_ANI_RUN, &sc->sc_flags) ||
1004 + (sc->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL))
1005 return;
1006
1007 common->ani.longcal_timer = timestamp;
1008 common->ani.shortcal_timer = timestamp;
1009 common->ani.checkani_timer = timestamp;
1010
1011 + ath_dbg(common, ANI, "Starting ANI\n");
1012 mod_timer(&common->ani.timer,
1013 jiffies + msecs_to_jiffies((u32)ah->config.ani_poll_interval));
1014 }
1015
1016 +void ath_stop_ani(struct ath_softc *sc)
1017 +{
1018 + struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1019 +
1020 + ath_dbg(common, ANI, "Stopping ANI\n");
1021 + del_timer_sync(&common->ani.timer);
1022 +}
1023 +
1024 +void ath_check_ani(struct ath_softc *sc)
1025 +{
1026 + struct ath_hw *ah = sc->sc_ah;
1027 + struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf;
1028 +
1029 + /*
1030 + * Check for the various conditions in which ANI has to
1031 + * be stopped.
1032 + */
1033 + if (ah->opmode == NL80211_IFTYPE_ADHOC) {
1034 + if (!cur_conf->enable_beacon)
1035 + goto stop_ani;
1036 + } else if (ah->opmode == NL80211_IFTYPE_AP) {
1037 + if (!cur_conf->enable_beacon) {
1038 + /*
1039 + * Disable ANI only when there are no
1040 + * associated stations.
1041 + */
1042 + if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags))
1043 + goto stop_ani;
1044 + }
1045 + } else if (ah->opmode == NL80211_IFTYPE_STATION) {
1046 + if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags))
1047 + goto stop_ani;
1048 + }
1049 +
1050 + set_bit(SC_OP_ANI_RUN, &sc->sc_flags);
1051 + ath_start_ani(sc);
1052 + return;
1053 +
1054 +stop_ani:
1055 + clear_bit(SC_OP_ANI_RUN, &sc->sc_flags);
1056 + ath_stop_ani(sc);
1057 +}
1058 +
1059 void ath_update_survey_nf(struct ath_softc *sc, int channel)
1060 {
1061 struct ath_hw *ah = sc->sc_ah;
1062 --- a/drivers/net/wireless/ath/ath9k/main.c
1063 +++ b/drivers/net/wireless/ath/ath9k/main.c
1064 @@ -167,8 +167,6 @@ static void ath_cancel_work(struct ath_s
1065
1066 static void ath_restart_work(struct ath_softc *sc)
1067 {
1068 - struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1069 -
1070 ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work, 0);
1071
1072 if (AR_SREV_9340(sc->sc_ah) || AR_SREV_9485(sc->sc_ah) ||
1073 @@ -177,21 +175,18 @@ static void ath_restart_work(struct ath_
1074 msecs_to_jiffies(ATH_PLL_WORK_INTERVAL));
1075
1076 ath_start_rx_poll(sc, 3);
1077 -
1078 - if (!common->disable_ani)
1079 - ath_start_ani(common);
1080 + ath_start_ani(sc);
1081 }
1082
1083 static bool ath_prepare_reset(struct ath_softc *sc, bool retry_tx, bool flush)
1084 {
1085 struct ath_hw *ah = sc->sc_ah;
1086 - struct ath_common *common = ath9k_hw_common(ah);
1087 bool ret = true;
1088
1089 ieee80211_stop_queues(sc->hw);
1090
1091 sc->hw_busy_count = 0;
1092 - del_timer_sync(&common->ani.timer);
1093 + ath_stop_ani(sc);
1094 del_timer_sync(&sc->rx_poll_timer);
1095
1096 ath9k_debug_samp_bb_mac(sc);
1097 @@ -236,7 +231,7 @@ static bool ath_complete_reset(struct at
1098 if (!test_bit(SC_OP_BEACONS, &sc->sc_flags))
1099 goto work;
1100
1101 - ath_set_beacon(sc);
1102 + ath9k_set_beacon(sc);
1103
1104 if (ah->opmode == NL80211_IFTYPE_STATION &&
1105 test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) {
1106 @@ -365,6 +360,7 @@ void ath9k_tasklet(unsigned long data)
1107 struct ath_softc *sc = (struct ath_softc *)data;
1108 struct ath_hw *ah = sc->sc_ah;
1109 struct ath_common *common = ath9k_hw_common(ah);
1110 + enum ath_reset_type type;
1111 unsigned long flags;
1112 u32 status = sc->intrstatus;
1113 u32 rxmask;
1114 @@ -374,18 +370,13 @@ void ath9k_tasklet(unsigned long data)
1115
1116 if ((status & ATH9K_INT_FATAL) ||
1117 (status & ATH9K_INT_BB_WATCHDOG)) {
1118 -#ifdef CONFIG_ATH9K_DEBUGFS
1119 - enum ath_reset_type type;
1120
1121 if (status & ATH9K_INT_FATAL)
1122 type = RESET_TYPE_FATAL_INT;
1123 else
1124 type = RESET_TYPE_BB_WATCHDOG;
1125
1126 - RESET_STAT_INC(sc, type);
1127 -#endif
1128 - set_bit(SC_OP_HW_RESET, &sc->sc_flags);
1129 - ieee80211_queue_work(sc->hw, &sc->hw_reset_work);
1130 + ath9k_queue_reset(sc, type);
1131 goto out;
1132 }
1133
1134 @@ -575,6 +566,15 @@ static int ath_reset(struct ath_softc *s
1135 return r;
1136 }
1137
1138 +void ath9k_queue_reset(struct ath_softc *sc, enum ath_reset_type type)
1139 +{
1140 +#ifdef CONFIG_ATH9K_DEBUGFS
1141 + RESET_STAT_INC(sc, type);
1142 +#endif
1143 + set_bit(SC_OP_HW_RESET, &sc->sc_flags);
1144 + ieee80211_queue_work(sc->hw, &sc->hw_reset_work);
1145 +}
1146 +
1147 void ath_reset_work(struct work_struct *work)
1148 {
1149 struct ath_softc *sc = container_of(work, struct ath_softc, hw_reset_work);
1150 @@ -841,16 +841,6 @@ bool ath9k_uses_beacons(int type)
1151 }
1152 }
1153
1154 -static void ath9k_reclaim_beacon(struct ath_softc *sc,
1155 - struct ieee80211_vif *vif)
1156 -{
1157 - struct ath_vif *avp = (void *)vif->drv_priv;
1158 -
1159 - ath9k_set_beaconing_status(sc, false);
1160 - ath_beacon_return(sc, avp);
1161 - ath9k_set_beaconing_status(sc, true);
1162 -}
1163 -
1164 static void ath9k_vif_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
1165 {
1166 struct ath9k_vif_iter_data *iter_data = data;
1167 @@ -918,18 +908,14 @@ static void ath9k_calculate_summary_stat
1168
1169 ath9k_calculate_iter_data(hw, vif, &iter_data);
1170
1171 - /* Set BSSID mask. */
1172 memcpy(common->bssidmask, iter_data.mask, ETH_ALEN);
1173 ath_hw_setbssidmask(common);
1174
1175 - /* Set op-mode & TSF */
1176 if (iter_data.naps > 0) {
1177 - ath9k_hw_set_tsfadjust(ah, 1);
1178 - set_bit(SC_OP_TSF_RESET, &sc->sc_flags);
1179 + ath9k_hw_set_tsfadjust(ah, true);
1180 ah->opmode = NL80211_IFTYPE_AP;
1181 } else {
1182 - ath9k_hw_set_tsfadjust(ah, 0);
1183 - clear_bit(SC_OP_TSF_RESET, &sc->sc_flags);
1184 + ath9k_hw_set_tsfadjust(ah, false);
1185
1186 if (iter_data.nmeshes)
1187 ah->opmode = NL80211_IFTYPE_MESH_POINT;
1188 @@ -941,45 +927,14 @@ static void ath9k_calculate_summary_stat
1189 ah->opmode = NL80211_IFTYPE_STATION;
1190 }
1191
1192 - /*
1193 - * Enable MIB interrupts when there are hardware phy counters.
1194 - */
1195 + ath9k_hw_setopmode(ah);
1196 +
1197 if ((iter_data.nstations + iter_data.nadhocs + iter_data.nmeshes) > 0)
1198 ah->imask |= ATH9K_INT_TSFOOR;
1199 else
1200 ah->imask &= ~ATH9K_INT_TSFOOR;
1201
1202 ath9k_hw_set_interrupts(ah);
1203 -
1204 - /* Set up ANI */
1205 - if (iter_data.naps > 0) {
1206 - sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
1207 -
1208 - if (!common->disable_ani) {
1209 - set_bit(SC_OP_ANI_RUN, &sc->sc_flags);
1210 - ath_start_ani(common);
1211 - }
1212 -
1213 - } else {
1214 - clear_bit(SC_OP_ANI_RUN, &sc->sc_flags);
1215 - del_timer_sync(&common->ani.timer);
1216 - }
1217 -}
1218 -
1219 -/* Called with sc->mutex held, vif counts set up properly. */
1220 -static void ath9k_do_vif_add_setup(struct ieee80211_hw *hw,
1221 - struct ieee80211_vif *vif)
1222 -{
1223 - struct ath_softc *sc = hw->priv;
1224 -
1225 - ath9k_calculate_summary_state(hw, vif);
1226 -
1227 - if (ath9k_uses_beacons(vif->type)) {
1228 - /* Reserve a beacon slot for the vif */
1229 - ath9k_set_beaconing_status(sc, false);
1230 - ath_beacon_alloc(sc, vif);
1231 - ath9k_set_beaconing_status(sc, true);
1232 - }
1233 }
1234
1235 static int ath9k_add_interface(struct ieee80211_hw *hw,
1236 @@ -1021,7 +976,10 @@ static int ath9k_add_interface(struct ie
1237
1238 sc->nvifs++;
1239
1240 - ath9k_do_vif_add_setup(hw, vif);
1241 + ath9k_calculate_summary_state(hw, vif);
1242 + if (ath9k_uses_beacons(vif->type))
1243 + ath9k_beacon_assign_slot(sc, vif);
1244 +
1245 out:
1246 mutex_unlock(&sc->mutex);
1247 ath9k_ps_restore(sc);
1248 @@ -1038,6 +996,7 @@ static int ath9k_change_interface(struct
1249 int ret = 0;
1250
1251 ath_dbg(common, CONFIG, "Change Interface\n");
1252 +
1253 mutex_lock(&sc->mutex);
1254 ath9k_ps_wakeup(sc);
1255
1256 @@ -1050,15 +1009,16 @@ static int ath9k_change_interface(struct
1257 }
1258 }
1259
1260 - /* Clean up old vif stuff */
1261 if (ath9k_uses_beacons(vif->type))
1262 - ath9k_reclaim_beacon(sc, vif);
1263 + ath9k_beacon_remove_slot(sc, vif);
1264
1265 - /* Add new settings */
1266 vif->type = new_type;
1267 vif->p2p = p2p;
1268
1269 - ath9k_do_vif_add_setup(hw, vif);
1270 + ath9k_calculate_summary_state(hw, vif);
1271 + if (ath9k_uses_beacons(vif->type))
1272 + ath9k_beacon_assign_slot(sc, vif);
1273 +
1274 out:
1275 ath9k_ps_restore(sc);
1276 mutex_unlock(&sc->mutex);
1277 @@ -1078,9 +1038,8 @@ static void ath9k_remove_interface(struc
1278
1279 sc->nvifs--;
1280
1281 - /* Reclaim beacon resources */
1282 if (ath9k_uses_beacons(vif->type))
1283 - ath9k_reclaim_beacon(sc, vif);
1284 + ath9k_beacon_remove_slot(sc, vif);
1285
1286 ath9k_calculate_summary_state(hw, NULL);
1287
1288 @@ -1388,10 +1347,6 @@ static int ath9k_conf_tx(struct ieee8021
1289 if (ret)
1290 ath_err(common, "TXQ Update failed\n");
1291
1292 - if (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC)
1293 - if (queue == WME_AC_BE && !ret)
1294 - ath_beaconq_config(sc);
1295 -
1296 mutex_unlock(&sc->mutex);
1297 ath9k_ps_restore(sc);
1298
1299 @@ -1460,85 +1415,36 @@ static int ath9k_set_key(struct ieee8021
1300
1301 return ret;
1302 }
1303 -static void ath9k_bss_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
1304 +
1305 +static void ath9k_bss_assoc_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
1306 {
1307 struct ath_softc *sc = data;
1308 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1309 - struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1310 struct ath_vif *avp = (void *)vif->drv_priv;
1311 + struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1312 unsigned long flags;
1313 - /*
1314 - * Skip iteration if primary station vif's bss info
1315 - * was not changed
1316 - */
1317 +
1318 if (test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags))
1319 return;
1320
1321 if (bss_conf->assoc) {
1322 set_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags);
1323 avp->primary_sta_vif = true;
1324 +
1325 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1326 common->curaid = bss_conf->aid;
1327 ath9k_hw_write_associd(sc->sc_ah);
1328 - ath_dbg(common, CONFIG, "Bss Info ASSOC %d, bssid: %pM\n",
1329 - bss_conf->aid, common->curbssid);
1330 - ath_beacon_config(sc, vif);
1331 - /*
1332 - * Request a re-configuration of Beacon related timers
1333 - * on the receipt of the first Beacon frame (i.e.,
1334 - * after time sync with the AP).
1335 - */
1336 - spin_lock_irqsave(&sc->sc_pm_lock, flags);
1337 - sc->ps_flags |= PS_BEACON_SYNC | PS_WAIT_FOR_BEACON;
1338 - spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
1339
1340 - /* Reset rssi stats */
1341 sc->last_rssi = ATH_RSSI_DUMMY_MARKER;
1342 sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
1343
1344 - ath_start_rx_poll(sc, 3);
1345 -
1346 - if (!common->disable_ani) {
1347 - set_bit(SC_OP_ANI_RUN, &sc->sc_flags);
1348 - ath_start_ani(common);
1349 - }
1350 -
1351 - }
1352 -}
1353 -
1354 -static void ath9k_config_bss(struct ath_softc *sc, struct ieee80211_vif *vif)
1355 -{
1356 - struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1357 - struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1358 - struct ath_vif *avp = (void *)vif->drv_priv;
1359 -
1360 - if (sc->sc_ah->opmode != NL80211_IFTYPE_STATION)
1361 - return;
1362 -
1363 - /* Reconfigure bss info */
1364 - if (avp->primary_sta_vif && !bss_conf->assoc) {
1365 - ath_dbg(common, CONFIG, "Bss Info DISASSOC %d, bssid %pM\n",
1366 - common->curaid, common->curbssid);
1367 - clear_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags);
1368 - clear_bit(SC_OP_BEACONS, &sc->sc_flags);
1369 - avp->primary_sta_vif = false;
1370 - memset(common->curbssid, 0, ETH_ALEN);
1371 - common->curaid = 0;
1372 - }
1373 -
1374 - ieee80211_iterate_active_interfaces_atomic(
1375 - sc->hw, ath9k_bss_iter, sc);
1376 + spin_lock_irqsave(&sc->sc_pm_lock, flags);
1377 + sc->ps_flags |= PS_BEACON_SYNC | PS_WAIT_FOR_BEACON;
1378 + spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
1379
1380 - /*
1381 - * None of station vifs are associated.
1382 - * Clear bssid & aid
1383 - */
1384 - if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) {
1385 - ath9k_hw_write_associd(sc->sc_ah);
1386 - clear_bit(SC_OP_ANI_RUN, &sc->sc_flags);
1387 - del_timer_sync(&common->ani.timer);
1388 - del_timer_sync(&sc->rx_poll_timer);
1389 - memset(&sc->caldata, 0, sizeof(sc->caldata));
1390 + ath_dbg(common, CONFIG,
1391 + "Primary Station interface: %pM, BSSID: %pM\n",
1392 + vif->addr, common->curbssid);
1393 }
1394 }
1395
1396 @@ -1547,6 +1453,11 @@ static void ath9k_bss_info_changed(struc
1397 struct ieee80211_bss_conf *bss_conf,
1398 u32 changed)
1399 {
1400 +#define CHECK_ANI \
1401 + (BSS_CHANGED_ASSOC | \
1402 + BSS_CHANGED_IBSS | \
1403 + BSS_CHANGED_BEACON_ENABLED)
1404 +
1405 struct ath_softc *sc = hw->priv;
1406 struct ath_hw *ah = sc->sc_ah;
1407 struct ath_common *common = ath9k_hw_common(ah);
1408 @@ -1557,53 +1468,43 @@ static void ath9k_bss_info_changed(struc
1409 mutex_lock(&sc->mutex);
1410
1411 if (changed & BSS_CHANGED_ASSOC) {
1412 - ath9k_config_bss(sc, vif);
1413 + ath_dbg(common, CONFIG, "BSSID %pM Changed ASSOC %d\n",
1414 + bss_conf->bssid, bss_conf->assoc);
1415
1416 - ath_dbg(common, CONFIG, "BSSID: %pM aid: 0x%x\n",
1417 - common->curbssid, common->curaid);
1418 + /*
1419 + * Do not do anything when the opmode is not STATION.
1420 + */
1421 + if (ah->opmode == NL80211_IFTYPE_STATION) {
1422 + if (avp->primary_sta_vif && !bss_conf->assoc) {
1423 + clear_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags);
1424 + clear_bit(SC_OP_BEACONS, &sc->sc_flags);
1425 + avp->primary_sta_vif = false;
1426 + }
1427 +
1428 + ieee80211_iterate_active_interfaces_atomic(sc->hw,
1429 + ath9k_bss_assoc_iter, sc);
1430 +
1431 + if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) {
1432 + memset(common->curbssid, 0, ETH_ALEN);
1433 + common->curaid = 0;
1434 + ath9k_hw_write_associd(sc->sc_ah);
1435 + }
1436 + }
1437 }
1438
1439 if (changed & BSS_CHANGED_IBSS) {
1440 - /* There can be only one vif available */
1441 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1442 common->curaid = bss_conf->aid;
1443 ath9k_hw_write_associd(sc->sc_ah);
1444 -
1445 - if (bss_conf->ibss_joined) {
1446 - sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
1447 -
1448 - if (!common->disable_ani) {
1449 - set_bit(SC_OP_ANI_RUN, &sc->sc_flags);
1450 - ath_start_ani(common);
1451 - }
1452 -
1453 - } else {
1454 - clear_bit(SC_OP_ANI_RUN, &sc->sc_flags);
1455 - del_timer_sync(&common->ani.timer);
1456 - del_timer_sync(&sc->rx_poll_timer);
1457 - }
1458 }
1459
1460 - /*
1461 - * In case of AP mode, the HW TSF has to be reset
1462 - * when the beacon interval changes.
1463 - */
1464 - if ((changed & BSS_CHANGED_BEACON_INT) &&
1465 - (vif->type == NL80211_IFTYPE_AP))
1466 - set_bit(SC_OP_TSF_RESET, &sc->sc_flags);
1467 -
1468 - /* Configure beaconing (AP, IBSS, MESH) */
1469 - if (ath9k_uses_beacons(vif->type) &&
1470 - ((changed & BSS_CHANGED_BEACON) ||
1471 - (changed & BSS_CHANGED_BEACON_ENABLED) ||
1472 - (changed & BSS_CHANGED_BEACON_INT))) {
1473 - ath9k_set_beaconing_status(sc, false);
1474 - if (bss_conf->enable_beacon)
1475 - ath_beacon_alloc(sc, vif);
1476 - else
1477 - avp->is_bslot_active = false;
1478 - ath_beacon_config(sc, vif);
1479 - ath9k_set_beaconing_status(sc, true);
1480 + if ((changed & BSS_CHANGED_BEACON) ||
1481 + (changed & BSS_CHANGED_BEACON_ENABLED) ||
1482 + (changed & BSS_CHANGED_BEACON_INT)) {
1483 + if (ah->opmode == NL80211_IFTYPE_AP)
1484 + ath9k_set_tsfadjust(sc, vif);
1485 + if (ath9k_allow_beacon_config(sc, vif))
1486 + ath9k_beacon_config(sc, vif, changed);
1487 }
1488
1489 if (changed & BSS_CHANGED_ERP_SLOT) {
1490 @@ -1625,8 +1526,13 @@ static void ath9k_bss_info_changed(struc
1491 }
1492 }
1493
1494 + if (changed & CHECK_ANI)
1495 + ath_check_ani(sc);
1496 +
1497 mutex_unlock(&sc->mutex);
1498 ath9k_ps_restore(sc);
1499 +
1500 +#undef CHECK_ANI
1501 }
1502
1503 static u64 ath9k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1504 @@ -1855,10 +1761,11 @@ static int ath9k_tx_last_beacon(struct i
1505 if (!vif)
1506 return 0;
1507
1508 - avp = (void *)vif->drv_priv;
1509 - if (!avp->is_bslot_active)
1510 + if (!vif->bss_conf.enable_beacon)
1511 return 0;
1512
1513 + avp = (void *)vif->drv_priv;
1514 +
1515 if (!sc->beacon.tx_processed && !edma) {
1516 tasklet_disable(&sc->bcon_tasklet);
1517
1518 --- a/drivers/net/wireless/ath/ath9k/mci.c
1519 +++ b/drivers/net/wireless/ath/ath9k/mci.c
1520 @@ -202,7 +202,7 @@ static void ath_mci_cal_msg(struct ath_s
1521 case MCI_GPM_BT_CAL_REQ:
1522 if (mci_hw->bt_state == MCI_BT_AWAKE) {
1523 ar9003_mci_state(ah, MCI_STATE_SET_BT_CAL_START);
1524 - ieee80211_queue_work(sc->hw, &sc->hw_reset_work);
1525 + ath9k_queue_reset(sc, RESET_TYPE_MCI);
1526 }
1527 ath_dbg(common, MCI, "MCI State : %d\n", mci_hw->bt_state);
1528 break;
1529 --- a/drivers/net/wireless/ath/ath9k/recv.c
1530 +++ b/drivers/net/wireless/ath/ath9k/recv.c
1531 @@ -553,7 +553,7 @@ static void ath_rx_ps_beacon(struct ath_
1532 sc->ps_flags &= ~PS_BEACON_SYNC;
1533 ath_dbg(common, PS,
1534 "Reconfigure Beacon timers based on timestamp from the AP\n");
1535 - ath_set_beacon(sc);
1536 + ath9k_set_beacon(sc);
1537 }
1538
1539 if (ath_beacon_dtim_pending_cab(skb)) {
1540 --- a/drivers/net/wireless/ath/ath9k/xmit.c
1541 +++ b/drivers/net/wireless/ath/ath9k/xmit.c
1542 @@ -614,10 +614,8 @@ static void ath_tx_complete_aggr(struct
1543
1544 rcu_read_unlock();
1545
1546 - if (needreset) {
1547 - RESET_STAT_INC(sc, RESET_TYPE_TX_ERROR);
1548 - ieee80211_queue_work(sc->hw, &sc->hw_reset_work);
1549 - }
1550 + if (needreset)
1551 + ath9k_queue_reset(sc, RESET_TYPE_TX_ERROR);
1552 }
1553
1554 static bool ath_lookup_legacy(struct ath_buf *bf)
1555 @@ -1586,7 +1584,8 @@ void ath_txq_schedule(struct ath_softc *
1556 struct ath_atx_ac *ac, *ac_tmp, *last_ac;
1557 struct ath_atx_tid *tid, *last_tid;
1558
1559 - if (work_pending(&sc->hw_reset_work) || list_empty(&txq->axq_acq) ||
1560 + if (test_bit(SC_OP_HW_RESET, &sc->sc_flags) ||
1561 + list_empty(&txq->axq_acq) ||
1562 txq->axq_ampdu_depth >= ATH_AGGR_MIN_QDEPTH)
1563 return;
1564
1565 @@ -2191,7 +2190,7 @@ static void ath_tx_processq(struct ath_s
1566
1567 ath_txq_lock(sc, txq);
1568 for (;;) {
1569 - if (work_pending(&sc->hw_reset_work))
1570 + if (test_bit(SC_OP_HW_RESET, &sc->sc_flags))
1571 break;
1572
1573 if (list_empty(&txq->axq_q)) {
1574 @@ -2274,7 +2273,7 @@ void ath_tx_edma_tasklet(struct ath_soft
1575 int status;
1576
1577 for (;;) {
1578 - if (work_pending(&sc->hw_reset_work))
1579 + if (test_bit(SC_OP_HW_RESET, &sc->sc_flags))
1580 break;
1581
1582 status = ath9k_hw_txprocdesc(ah, NULL, (void *)&ts);
1583 --- a/include/net/mac80211.h
1584 +++ b/include/net/mac80211.h
1585 @@ -3596,22 +3596,6 @@ void ieee80211_request_smps(struct ieee8
1586 enum ieee80211_smps_mode smps_mode);
1587
1588 /**
1589 - * ieee80211_key_removed - disable hw acceleration for key
1590 - * @key_conf: The key hw acceleration should be disabled for
1591 - *
1592 - * This allows drivers to indicate that the given key has been
1593 - * removed from hardware acceleration, due to a new key that
1594 - * was added. Don't use this if the key can continue to be used
1595 - * for TX, if the key restriction is on RX only it is permitted
1596 - * to keep the key for TX only and not call this function.
1597 - *
1598 - * Due to locking constraints, it may only be called during
1599 - * @set_key. This function must be allowed to sleep, and the
1600 - * key it tries to disable may still be used until it returns.
1601 - */
1602 -void ieee80211_key_removed(struct ieee80211_key_conf *key_conf);
1603 -
1604 -/**
1605 * ieee80211_ready_on_channel - notification of remain-on-channel start
1606 * @hw: pointer as obtained from ieee80211_alloc_hw()
1607 */
1608 --- a/net/mac80211/agg-rx.c
1609 +++ b/net/mac80211/agg-rx.c
1610 @@ -203,6 +203,8 @@ static void ieee80211_send_addba_resp(st
1611 memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
1612 else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
1613 memcpy(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN);
1614 + else if (sdata->vif.type == NL80211_IFTYPE_WDS)
1615 + memcpy(mgmt->bssid, da, ETH_ALEN);
1616
1617 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
1618 IEEE80211_STYPE_ACTION);
1619 --- a/net/mac80211/agg-tx.c
1620 +++ b/net/mac80211/agg-tx.c
1621 @@ -81,7 +81,8 @@ static void ieee80211_send_addba_request
1622 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
1623 if (sdata->vif.type == NL80211_IFTYPE_AP ||
1624 sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
1625 - sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
1626 + sdata->vif.type == NL80211_IFTYPE_MESH_POINT ||
1627 + sdata->vif.type == NL80211_IFTYPE_WDS)
1628 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
1629 else if (sdata->vif.type == NL80211_IFTYPE_STATION)
1630 memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
1631 @@ -459,6 +460,7 @@ int ieee80211_start_tx_ba_session(struct
1632 sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
1633 sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
1634 sdata->vif.type != NL80211_IFTYPE_AP &&
1635 + sdata->vif.type != NL80211_IFTYPE_WDS &&
1636 sdata->vif.type != NL80211_IFTYPE_ADHOC)
1637 return -EINVAL;
1638
1639 --- a/net/mac80211/cfg.c
1640 +++ b/net/mac80211/cfg.c
1641 @@ -1741,6 +1741,8 @@ static int ieee80211_set_txq_params(stru
1642 return -EINVAL;
1643 }
1644
1645 + ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_QOS);
1646 +
1647 return 0;
1648 }
1649
1650 --- a/net/mac80211/debugfs_sta.c
1651 +++ b/net/mac80211/debugfs_sta.c
1652 @@ -63,11 +63,11 @@ static ssize_t sta_flags_read(struct fil
1653 test_sta_flag(sta, WLAN_STA_##flg) ? #flg "\n" : ""
1654
1655 int res = scnprintf(buf, sizeof(buf),
1656 - "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
1657 + "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
1658 TEST(AUTH), TEST(ASSOC), TEST(PS_STA),
1659 TEST(PS_DRIVER), TEST(AUTHORIZED),
1660 TEST(SHORT_PREAMBLE),
1661 - TEST(WME), TEST(WDS), TEST(CLEAR_PS_FILT),
1662 + TEST(WME), TEST(CLEAR_PS_FILT),
1663 TEST(MFP), TEST(BLOCK_BA), TEST(PSPOLL),
1664 TEST(UAPSD), TEST(SP), TEST(TDLS_PEER),
1665 TEST(TDLS_PEER_AUTH), TEST(4ADDR_EVENT),
1666 --- a/net/mac80211/iface.c
1667 +++ b/net/mac80211/iface.c
1668 @@ -400,7 +400,6 @@ static int ieee80211_do_open(struct net_
1669 {
1670 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1671 struct ieee80211_local *local = sdata->local;
1672 - struct sta_info *sta;
1673 u32 changed = 0;
1674 int res;
1675 u32 hw_reconf_flags = 0;
1676 @@ -538,28 +537,6 @@ static int ieee80211_do_open(struct net_
1677
1678 set_bit(SDATA_STATE_RUNNING, &sdata->state);
1679
1680 - if (sdata->vif.type == NL80211_IFTYPE_WDS) {
1681 - /* Create STA entry for the WDS peer */
1682 - sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
1683 - GFP_KERNEL);
1684 - if (!sta) {
1685 - res = -ENOMEM;
1686 - goto err_del_interface;
1687 - }
1688 -
1689 - sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
1690 - sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
1691 - sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
1692 -
1693 - res = sta_info_insert(sta);
1694 - if (res) {
1695 - /* STA has been freed */
1696 - goto err_del_interface;
1697 - }
1698 -
1699 - rate_control_rate_init(sta);
1700 - }
1701 -
1702 /*
1703 * set_multicast_list will be invoked by the networking core
1704 * which will check whether any increments here were done in
1705 @@ -949,6 +926,72 @@ static void ieee80211_if_setup(struct ne
1706 dev->destructor = free_netdev;
1707 }
1708
1709 +static void ieee80211_wds_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
1710 + struct sk_buff *skb)
1711 +{
1712 + struct ieee80211_local *local = sdata->local;
1713 + struct ieee80211_rx_status *rx_status;
1714 + struct ieee802_11_elems elems;
1715 + struct ieee80211_mgmt *mgmt;
1716 + struct sta_info *sta;
1717 + size_t baselen;
1718 + u32 rates = 0;
1719 + u16 stype;
1720 + bool new = false;
1721 + enum ieee80211_band band = local->hw.conf.channel->band;
1722 + struct ieee80211_supported_band *sband = local->hw.wiphy->bands[band];
1723 +
1724 + rx_status = IEEE80211_SKB_RXCB(skb);
1725 + mgmt = (struct ieee80211_mgmt *) skb->data;
1726 + stype = le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE;
1727 +
1728 + if (stype != IEEE80211_STYPE_BEACON)
1729 + return;
1730 +
1731 + baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
1732 + if (baselen > skb->len)
1733 + return;
1734 +
1735 + ieee802_11_parse_elems(mgmt->u.probe_resp.variable,
1736 + skb->len - baselen, &elems);
1737 +
1738 + rates = ieee80211_sta_get_rates(local, &elems, band, NULL);
1739 +
1740 + rcu_read_lock();
1741 +
1742 + sta = sta_info_get(sdata, sdata->u.wds.remote_addr);
1743 +
1744 + if (!sta) {
1745 + rcu_read_unlock();
1746 + sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
1747 + GFP_KERNEL);
1748 + if (!sta)
1749 + return;
1750 +
1751 + new = true;
1752 + }
1753 +
1754 + sta->last_rx = jiffies;
1755 + sta->sta.supp_rates[local->hw.conf.channel->band] = rates;
1756 +
1757 + if (elems.ht_cap_elem)
1758 + ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
1759 + elems.ht_cap_elem, &sta->sta.ht_cap);
1760 +
1761 + if (elems.wmm_param)
1762 + set_sta_flag(sta, WLAN_STA_WME);
1763 +
1764 + if (new) {
1765 + sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
1766 + sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
1767 + sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
1768 + rate_control_rate_init(sta);
1769 + sta_info_insert_rcu(sta);
1770 + }
1771 +
1772 + rcu_read_unlock();
1773 +}
1774 +
1775 static void ieee80211_iface_work(struct work_struct *work)
1776 {
1777 struct ieee80211_sub_if_data *sdata =
1778 @@ -1053,6 +1096,9 @@ static void ieee80211_iface_work(struct
1779 break;
1780 ieee80211_mesh_rx_queued_mgmt(sdata, skb);
1781 break;
1782 + case NL80211_IFTYPE_WDS:
1783 + ieee80211_wds_rx_queued_mgmt(sdata, skb);
1784 + break;
1785 default:
1786 WARN(1, "frame for unexpected interface type");
1787 break;
1788 --- a/net/mac80211/key.c
1789 +++ b/net/mac80211/key.c
1790 @@ -197,26 +197,6 @@ static void ieee80211_key_disable_hw_acc
1791 key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
1792 }
1793
1794 -void ieee80211_key_removed(struct ieee80211_key_conf *key_conf)
1795 -{
1796 - struct ieee80211_key *key;
1797 -
1798 - key = container_of(key_conf, struct ieee80211_key, conf);
1799 -
1800 - might_sleep();
1801 - assert_key_lock(key->local);
1802 -
1803 - key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
1804 -
1805 - /*
1806 - * Flush TX path to avoid attempts to use this key
1807 - * after this function returns. Until then, drivers
1808 - * must be prepared to handle the key.
1809 - */
1810 - synchronize_rcu();
1811 -}
1812 -EXPORT_SYMBOL_GPL(ieee80211_key_removed);
1813 -
1814 static void __ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata,
1815 int idx, bool uni, bool multi)
1816 {
1817 --- a/net/mac80211/mlme.c
1818 +++ b/net/mac80211/mlme.c
1819 @@ -1108,7 +1108,7 @@ void ieee80211_dynamic_ps_timer(unsigned
1820 }
1821
1822 /* MLME */
1823 -static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
1824 +static bool ieee80211_sta_wmm_params(struct ieee80211_local *local,
1825 struct ieee80211_sub_if_data *sdata,
1826 u8 *wmm_param, size_t wmm_param_len)
1827 {
1828 @@ -1119,23 +1119,23 @@ static void ieee80211_sta_wmm_params(str
1829 u8 *pos, uapsd_queues = 0;
1830
1831 if (!local->ops->conf_tx)
1832 - return;
1833 + return false;
1834
1835 if (local->hw.queues < IEEE80211_NUM_ACS)
1836 - return;
1837 + return false;
1838
1839 if (!wmm_param)
1840 - return;
1841 + return false;
1842
1843 if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1)
1844 - return;
1845 + return false;
1846
1847 if (ifmgd->flags & IEEE80211_STA_UAPSD_ENABLED)
1848 uapsd_queues = ifmgd->uapsd_queues;
1849
1850 count = wmm_param[6] & 0x0f;
1851 if (count == ifmgd->wmm_last_param_set)
1852 - return;
1853 + return false;
1854 ifmgd->wmm_last_param_set = count;
1855
1856 pos = wmm_param + 8;
1857 @@ -1202,6 +1202,7 @@ static void ieee80211_sta_wmm_params(str
1858
1859 /* enable WMM or activate new settings */
1860 sdata->vif.bss_conf.qos = true;
1861 + return true;
1862 }
1863
1864 static void __ieee80211_stop_poll(struct ieee80211_sub_if_data *sdata)
1865 @@ -2435,14 +2436,6 @@ static void ieee80211_rx_mgmt_beacon(str
1866 directed_tim = ieee80211_check_tim(elems.tim, elems.tim_len,
1867 ifmgd->aid);
1868
1869 - if (ncrc != ifmgd->beacon_crc || !ifmgd->beacon_crc_valid) {
1870 - ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems,
1871 - true);
1872 -
1873 - ieee80211_sta_wmm_params(local, sdata, elems.wmm_param,
1874 - elems.wmm_param_len);
1875 - }
1876 -
1877 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) {
1878 if (directed_tim) {
1879 if (local->hw.conf.dynamic_ps_timeout > 0) {
1880 @@ -2473,6 +2466,13 @@ static void ieee80211_rx_mgmt_beacon(str
1881 ifmgd->beacon_crc = ncrc;
1882 ifmgd->beacon_crc_valid = true;
1883
1884 + ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems,
1885 + true);
1886 +
1887 + if (ieee80211_sta_wmm_params(local, sdata, elems.wmm_param,
1888 + elems.wmm_param_len))
1889 + changed |= BSS_CHANGED_QOS;
1890 +
1891 if (elems.erp_info && elems.erp_info_len >= 1) {
1892 erp_valid = true;
1893 erp_value = elems.erp_info[0];
1894 --- a/net/mac80211/rc80211_minstrel_ht.c
1895 +++ b/net/mac80211/rc80211_minstrel_ht.c
1896 @@ -626,8 +626,12 @@ minstrel_ht_get_rate(void *priv, struct
1897
1898 #ifdef CONFIG_MAC80211_DEBUGFS
1899 /* use fixed index if set */
1900 - if (mp->fixed_rate_idx != -1)
1901 - sample_idx = mp->fixed_rate_idx;
1902 + if (mp->fixed_rate_idx != -1) {
1903 + mi->max_tp_rate = mp->fixed_rate_idx;
1904 + mi->max_tp_rate2 = mp->fixed_rate_idx;
1905 + mi->max_prob_rate = mp->fixed_rate_idx;
1906 + sample_idx = -1;
1907 + }
1908 #endif
1909
1910 if (sample_idx >= 0) {
1911 --- a/net/mac80211/rx.c
1912 +++ b/net/mac80211/rx.c
1913 @@ -2262,6 +2262,7 @@ ieee80211_rx_h_action(struct ieee80211_r
1914 sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
1915 sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
1916 sdata->vif.type != NL80211_IFTYPE_AP &&
1917 + sdata->vif.type != NL80211_IFTYPE_WDS &&
1918 sdata->vif.type != NL80211_IFTYPE_ADHOC)
1919 break;
1920
1921 @@ -2479,14 +2480,15 @@ ieee80211_rx_h_mgmt(struct ieee80211_rx_
1922
1923 if (!ieee80211_vif_is_mesh(&sdata->vif) &&
1924 sdata->vif.type != NL80211_IFTYPE_ADHOC &&
1925 - sdata->vif.type != NL80211_IFTYPE_STATION)
1926 + sdata->vif.type != NL80211_IFTYPE_STATION &&
1927 + sdata->vif.type != NL80211_IFTYPE_WDS)
1928 return RX_DROP_MONITOR;
1929
1930 switch (stype) {
1931 case cpu_to_le16(IEEE80211_STYPE_AUTH):
1932 case cpu_to_le16(IEEE80211_STYPE_BEACON):
1933 case cpu_to_le16(IEEE80211_STYPE_PROBE_RESP):
1934 - /* process for all: mesh, mlme, ibss */
1935 + /* process for all: mesh, mlme, ibss, wds */
1936 break;
1937 case cpu_to_le16(IEEE80211_STYPE_ASSOC_RESP):
1938 case cpu_to_le16(IEEE80211_STYPE_REASSOC_RESP):
1939 @@ -2817,10 +2819,16 @@ static int prepare_for_handlers(struct i
1940 }
1941 break;
1942 case NL80211_IFTYPE_WDS:
1943 - if (bssid || !ieee80211_is_data(hdr->frame_control))
1944 - return 0;
1945 if (!ether_addr_equal(sdata->u.wds.remote_addr, hdr->addr2))
1946 return 0;
1947 +
1948 + if (ieee80211_is_data(hdr->frame_control) ||
1949 + ieee80211_is_action(hdr->frame_control)) {
1950 + if (compare_ether_addr(sdata->vif.addr, hdr->addr1))
1951 + return 0;
1952 + } else if (!ieee80211_is_beacon(hdr->frame_control))
1953 + return 0;
1954 +
1955 break;
1956 default:
1957 /* should never get here */
1958 --- a/net/mac80211/sta_info.h
1959 +++ b/net/mac80211/sta_info.h
1960 @@ -32,7 +32,6 @@
1961 * @WLAN_STA_SHORT_PREAMBLE: Station is capable of receiving short-preamble
1962 * frames.
1963 * @WLAN_STA_WME: Station is a QoS-STA.
1964 - * @WLAN_STA_WDS: Station is one of our WDS peers.
1965 * @WLAN_STA_CLEAR_PS_FILT: Clear PS filter in hardware (using the
1966 * IEEE80211_TX_CTL_CLEAR_PS_FILT control flag) when the next
1967 * frame to this station is transmitted.
1968 @@ -64,7 +63,6 @@ enum ieee80211_sta_info_flags {
1969 WLAN_STA_AUTHORIZED,
1970 WLAN_STA_SHORT_PREAMBLE,
1971 WLAN_STA_WME,
1972 - WLAN_STA_WDS,
1973 WLAN_STA_CLEAR_PS_FILT,
1974 WLAN_STA_MFP,
1975 WLAN_STA_BLOCK_BA,
1976 --- a/net/mac80211/tx.c
1977 +++ b/net/mac80211/tx.c
1978 @@ -2716,7 +2716,7 @@ EXPORT_SYMBOL(ieee80211_get_buffered_bc)
1979 void ieee80211_tx_skb_tid(struct ieee80211_sub_if_data *sdata,
1980 struct sk_buff *skb, int tid)
1981 {
1982 - int ac = ieee802_1d_to_ac[tid];
1983 + int ac = ieee802_1d_to_ac[tid & 7];
1984
1985 skb_set_mac_header(skb, 0);
1986 skb_set_network_header(skb, 0);