2f659949e6e0db2047cd7686a8970b7ebd79aefc
[pandora-kernel.git] / drivers / net / wireless / ath / ath9k / beacon.c
1 /*
2  * Copyright (c) 2008-2011 Atheros Communications Inc.
3  *
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
17 #include "ath9k.h"
18
19 #define FUDGE 2
20
21 /*
22  *  This function will modify certain transmit queue properties depending on
23  *  the operating mode of the station (AP or AdHoc).  Parameters are AIFS
24  *  settings and channel width min/max
25 */
26 int ath_beaconq_config(struct ath_softc *sc)
27 {
28         struct ath_hw *ah = sc->sc_ah;
29         struct ath_common *common = ath9k_hw_common(ah);
30         struct ath9k_tx_queue_info qi, qi_be;
31         struct ath_txq *txq;
32
33         ath9k_hw_get_txq_props(ah, sc->beacon.beaconq, &qi);
34         if (sc->sc_ah->opmode == NL80211_IFTYPE_AP) {
35                 /* Always burst out beacon and CAB traffic. */
36                 qi.tqi_aifs = 1;
37                 qi.tqi_cwmin = 0;
38                 qi.tqi_cwmax = 0;
39         } else {
40                 /* Adhoc mode; important thing is to use 2x cwmin. */
41                 txq = sc->tx.txq_map[WME_AC_BE];
42                 ath9k_hw_get_txq_props(ah, txq->axq_qnum, &qi_be);
43                 qi.tqi_aifs = qi_be.tqi_aifs;
44                 qi.tqi_cwmin = 4*qi_be.tqi_cwmin;
45                 qi.tqi_cwmax = qi_be.tqi_cwmax;
46         }
47
48         if (!ath9k_hw_set_txq_props(ah, sc->beacon.beaconq, &qi)) {
49                 ath_err(common,
50                         "Unable to update h/w beacon queue parameters\n");
51                 return 0;
52         } else {
53                 ath9k_hw_resettxqueue(ah, sc->beacon.beaconq);
54                 return 1;
55         }
56 }
57
58 /*
59  *  Associates the beacon frame buffer with a transmit descriptor.  Will set
60  *  up rate codes, and channel flags. Beacons are always sent out at the
61  *  lowest rate, and are not retried.
62 */
63 static void ath_beacon_setup(struct ath_softc *sc, struct ath_vif *avp,
64                              struct ath_buf *bf, int rateidx)
65 {
66         struct sk_buff *skb = bf->bf_mpdu;
67         struct ath_hw *ah = sc->sc_ah;
68         struct ath_common *common = ath9k_hw_common(ah);
69         struct ath_desc *ds;
70         struct ath9k_11n_rate_series series[4];
71         int flags, ctsrate = 0, ctsduration = 0;
72         struct ieee80211_supported_band *sband;
73         u8 rate = 0;
74
75         ds = bf->bf_desc;
76         flags = ATH9K_TXDESC_NOACK;
77
78         ds->ds_link = 0;
79
80         sband = &sc->sbands[common->hw->conf.channel->band];
81         rate = sband->bitrates[rateidx].hw_value;
82         if (sc->sc_flags & SC_OP_PREAMBLE_SHORT)
83                 rate |= sband->bitrates[rateidx].hw_value_short;
84
85         ath9k_hw_set11n_txdesc(ah, ds, skb->len + FCS_LEN,
86                                ATH9K_PKT_TYPE_BEACON,
87                                MAX_RATE_POWER,
88                                ATH9K_TXKEYIX_INVALID,
89                                ATH9K_KEY_TYPE_CLEAR,
90                                flags);
91
92         /* NB: beacon's BufLen must be a multiple of 4 bytes */
93         ath9k_hw_filltxdesc(ah, ds, roundup(skb->len, 4),
94                             true, true, ds, bf->bf_buf_addr,
95                             sc->beacon.beaconq);
96
97         memset(series, 0, sizeof(struct ath9k_11n_rate_series) * 4);
98         series[0].Tries = 1;
99         series[0].Rate = rate;
100         series[0].ChSel = ath_txchainmask_reduction(sc,
101                         common->tx_chainmask, series[0].Rate);
102         series[0].RateFlags = (ctsrate) ? ATH9K_RATESERIES_RTS_CTS : 0;
103         ath9k_hw_set11n_ratescenario(ah, ds, ds, 0, ctsrate, ctsduration,
104                                      series, 4, 0);
105 }
106
107 static void ath_tx_cabq(struct ieee80211_hw *hw, struct sk_buff *skb)
108 {
109         struct ath_softc *sc = hw->priv;
110         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
111         struct ath_tx_control txctl;
112
113         memset(&txctl, 0, sizeof(struct ath_tx_control));
114         txctl.txq = sc->beacon.cabq;
115
116         ath_dbg(common, ATH_DBG_XMIT,
117                 "transmitting CABQ packet, skb: %p\n", skb);
118
119         if (ath_tx_start(hw, skb, &txctl) != 0) {
120                 ath_dbg(common, ATH_DBG_XMIT, "CABQ TX failed\n");
121                 dev_kfree_skb_any(skb);
122         }
123 }
124
125 static struct ath_buf *ath_beacon_generate(struct ieee80211_hw *hw,
126                                            struct ieee80211_vif *vif)
127 {
128         struct ath_softc *sc = hw->priv;
129         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
130         struct ath_buf *bf;
131         struct ath_vif *avp;
132         struct sk_buff *skb;
133         struct ath_txq *cabq;
134         struct ieee80211_tx_info *info;
135         int cabq_depth;
136
137         avp = (void *)vif->drv_priv;
138         cabq = sc->beacon.cabq;
139
140         if ((avp->av_bcbuf == NULL) || !avp->is_bslot_active)
141                 return NULL;
142
143         /* Release the old beacon first */
144
145         bf = avp->av_bcbuf;
146         skb = bf->bf_mpdu;
147         if (skb) {
148                 dma_unmap_single(sc->dev, bf->bf_buf_addr,
149                                  skb->len, DMA_TO_DEVICE);
150                 dev_kfree_skb_any(skb);
151                 bf->bf_buf_addr = 0;
152         }
153
154         /* Get a new beacon from mac80211 */
155
156         skb = ieee80211_beacon_get(hw, vif);
157         bf->bf_mpdu = skb;
158         if (skb == NULL)
159                 return NULL;
160         ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp =
161                 avp->tsf_adjust;
162
163         info = IEEE80211_SKB_CB(skb);
164         if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
165                 /*
166                  * TODO: make sure the seq# gets assigned properly (vs. other
167                  * TX frames)
168                  */
169                 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
170                 sc->tx.seq_no += 0x10;
171                 hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
172                 hdr->seq_ctrl |= cpu_to_le16(sc->tx.seq_no);
173         }
174
175         bf->bf_buf_addr = dma_map_single(sc->dev, skb->data,
176                                          skb->len, DMA_TO_DEVICE);
177         if (unlikely(dma_mapping_error(sc->dev, bf->bf_buf_addr))) {
178                 dev_kfree_skb_any(skb);
179                 bf->bf_mpdu = NULL;
180                 bf->bf_buf_addr = 0;
181                 ath_err(common, "dma_mapping_error on beaconing\n");
182                 return NULL;
183         }
184
185         skb = ieee80211_get_buffered_bc(hw, vif);
186
187         /*
188          * if the CABQ traffic from previous DTIM is pending and the current
189          *  beacon is also a DTIM.
190          *  1) if there is only one vif let the cab traffic continue.
191          *  2) if there are more than one vif and we are using staggered
192          *     beacons, then drain the cabq by dropping all the frames in
193          *     the cabq so that the current vifs cab traffic can be scheduled.
194          */
195         spin_lock_bh(&cabq->axq_lock);
196         cabq_depth = cabq->axq_depth;
197         spin_unlock_bh(&cabq->axq_lock);
198
199         if (skb && cabq_depth) {
200                 if (sc->nvifs > 1) {
201                         ath_dbg(common, ATH_DBG_BEACON,
202                                 "Flushing previous cabq traffic\n");
203                         ath_draintxq(sc, cabq, false);
204                 }
205         }
206
207         ath_beacon_setup(sc, avp, bf, info->control.rates[0].idx);
208
209         while (skb) {
210                 ath_tx_cabq(hw, skb);
211                 skb = ieee80211_get_buffered_bc(hw, vif);
212         }
213
214         return bf;
215 }
216
217 int ath_beacon_alloc(struct ath_softc *sc, struct ieee80211_vif *vif)
218 {
219         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
220         struct ath_vif *avp;
221         struct ath_buf *bf;
222         struct sk_buff *skb;
223         struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf;
224         __le64 tstamp;
225
226         avp = (void *)vif->drv_priv;
227
228         /* Allocate a beacon descriptor if we haven't done so. */
229         if (!avp->av_bcbuf) {
230                 /* Allocate beacon state for hostap/ibss.  We know
231                  * a buffer is available. */
232                 avp->av_bcbuf = list_first_entry(&sc->beacon.bbuf,
233                                                  struct ath_buf, list);
234                 list_del(&avp->av_bcbuf->list);
235
236                 if (ath9k_uses_beacons(vif->type)) {
237                         int slot;
238                         /*
239                          * Assign the vif to a beacon xmit slot. As
240                          * above, this cannot fail to find one.
241                          */
242                         avp->av_bslot = 0;
243                         for (slot = 0; slot < ATH_BCBUF; slot++)
244                                 if (sc->beacon.bslot[slot] == NULL) {
245                                         avp->av_bslot = slot;
246                                         avp->is_bslot_active = false;
247
248                                         /* NB: keep looking for a double slot */
249                                         if (slot == 0 || !sc->beacon.bslot[slot-1])
250                                                 break;
251                                 }
252                         BUG_ON(sc->beacon.bslot[avp->av_bslot] != NULL);
253                         sc->beacon.bslot[avp->av_bslot] = vif;
254                         sc->nbcnvifs++;
255                 }
256         }
257
258         /* release the previous beacon frame, if it already exists. */
259         bf = avp->av_bcbuf;
260         if (bf->bf_mpdu != NULL) {
261                 skb = bf->bf_mpdu;
262                 dma_unmap_single(sc->dev, bf->bf_buf_addr,
263                                  skb->len, DMA_TO_DEVICE);
264                 dev_kfree_skb_any(skb);
265                 bf->bf_mpdu = NULL;
266                 bf->bf_buf_addr = 0;
267         }
268
269         /* NB: the beacon data buffer must be 32-bit aligned. */
270         skb = ieee80211_beacon_get(sc->hw, vif);
271         if (skb == NULL)
272                 return -ENOMEM;
273
274         tstamp = ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp;
275         sc->beacon.bc_tstamp = (u32) le64_to_cpu(tstamp);
276         /* Calculate a TSF adjustment factor required for staggered beacons. */
277         if (avp->av_bslot > 0) {
278                 u64 tsfadjust;
279                 int intval;
280
281                 intval = cur_conf->beacon_interval ? : ATH_DEFAULT_BINTVAL;
282
283                 /*
284                  * Calculate the TSF offset for this beacon slot, i.e., the
285                  * number of usecs that need to be added to the timestamp field
286                  * in Beacon and Probe Response frames. Beacon slot 0 is
287                  * processed at the correct offset, so it does not require TSF
288                  * adjustment. Other slots are adjusted to get the timestamp
289                  * close to the TBTT for the BSS.
290                  */
291                 tsfadjust = TU_TO_USEC(intval * avp->av_bslot) / ATH_BCBUF;
292                 avp->tsf_adjust = cpu_to_le64(tsfadjust);
293
294                 ath_dbg(common, ATH_DBG_BEACON,
295                         "stagger beacons, bslot %d intval %u tsfadjust %llu\n",
296                         avp->av_bslot, intval, (unsigned long long)tsfadjust);
297
298                 ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp =
299                         avp->tsf_adjust;
300         } else
301                 avp->tsf_adjust = cpu_to_le64(0);
302
303         bf->bf_mpdu = skb;
304         bf->bf_buf_addr = dma_map_single(sc->dev, skb->data,
305                                          skb->len, DMA_TO_DEVICE);
306         if (unlikely(dma_mapping_error(sc->dev, bf->bf_buf_addr))) {
307                 dev_kfree_skb_any(skb);
308                 bf->bf_mpdu = NULL;
309                 bf->bf_buf_addr = 0;
310                 ath_err(common, "dma_mapping_error on beacon alloc\n");
311                 return -ENOMEM;
312         }
313         avp->is_bslot_active = true;
314
315         return 0;
316 }
317
318 void ath_beacon_return(struct ath_softc *sc, struct ath_vif *avp)
319 {
320         if (avp->av_bcbuf != NULL) {
321                 struct ath_buf *bf;
322
323                 avp->is_bslot_active = false;
324                 if (avp->av_bslot != -1) {
325                         sc->beacon.bslot[avp->av_bslot] = NULL;
326                         sc->nbcnvifs--;
327                         avp->av_bslot = -1;
328                 }
329
330                 bf = avp->av_bcbuf;
331                 if (bf->bf_mpdu != NULL) {
332                         struct sk_buff *skb = bf->bf_mpdu;
333                         dma_unmap_single(sc->dev, bf->bf_buf_addr,
334                                          skb->len, DMA_TO_DEVICE);
335                         dev_kfree_skb_any(skb);
336                         bf->bf_mpdu = NULL;
337                         bf->bf_buf_addr = 0;
338                 }
339                 list_add_tail(&bf->list, &sc->beacon.bbuf);
340
341                 avp->av_bcbuf = NULL;
342         }
343 }
344
345 void ath_beacon_tasklet(unsigned long data)
346 {
347         struct ath_softc *sc = (struct ath_softc *)data;
348         struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf;
349         struct ath_hw *ah = sc->sc_ah;
350         struct ath_common *common = ath9k_hw_common(ah);
351         struct ath_buf *bf = NULL;
352         struct ieee80211_vif *vif;
353         int slot;
354         u32 bfaddr, bc = 0;
355
356         /*
357          * Check if the previous beacon has gone out.  If
358          * not don't try to post another, skip this period
359          * and wait for the next.  Missed beacons indicate
360          * a problem and should not occur.  If we miss too
361          * many consecutive beacons reset the device.
362          */
363         if (ath9k_hw_numtxpending(ah, sc->beacon.beaconq) != 0) {
364                 sc->beacon.bmisscnt++;
365
366                 if (sc->beacon.bmisscnt < BSTUCK_THRESH * sc->nbcnvifs) {
367                         ath_dbg(common, ATH_DBG_BSTUCK,
368                                 "missed %u consecutive beacons\n",
369                                 sc->beacon.bmisscnt);
370                         ath9k_hw_stop_dma_queue(ah, sc->beacon.beaconq);
371                         if (sc->beacon.bmisscnt > 3)
372                                 ath9k_hw_bstuck_nfcal(ah);
373                 } else if (sc->beacon.bmisscnt >= BSTUCK_THRESH) {
374                         ath_dbg(common, ATH_DBG_BSTUCK,
375                                 "beacon is officially stuck\n");
376                         sc->sc_flags |= SC_OP_TSF_RESET;
377                         ath_reset(sc, true);
378                 }
379
380                 return;
381         }
382
383         /*
384          * Generate beacon frames. we are sending frames
385          * staggered so calculate the slot for this frame based
386          * on the tsf to safeguard against missing an swba.
387          */
388
389
390         if (ah->opmode == NL80211_IFTYPE_AP) {
391                 u16 intval;
392                 u32 tsftu;
393                 u64 tsf;
394
395                 intval = cur_conf->beacon_interval ? : ATH_DEFAULT_BINTVAL;
396                 tsf = ath9k_hw_gettsf64(ah);
397                 tsf += TU_TO_USEC(ah->config.sw_beacon_response_time);
398                 tsftu = TSF_TO_TU((tsf * ATH_BCBUF) >>32, tsf * ATH_BCBUF);
399                 slot = (tsftu % (intval * ATH_BCBUF)) / intval;
400                 vif = sc->beacon.bslot[slot];
401
402                 ath_dbg(common, ATH_DBG_BEACON,
403                         "slot %d [tsf %llu tsftu %u intval %u] vif %p\n",
404                         slot, tsf, tsftu / ATH_BCBUF, intval, vif);
405         } else {
406                 slot = 0;
407                 vif = sc->beacon.bslot[slot];
408         }
409
410
411         bfaddr = 0;
412         if (vif) {
413                 bf = ath_beacon_generate(sc->hw, vif);
414                 if (bf != NULL) {
415                         bfaddr = bf->bf_daddr;
416                         bc = 1;
417                 }
418
419                 if (sc->beacon.bmisscnt != 0) {
420                         ath_dbg(common, ATH_DBG_BSTUCK,
421                                 "resume beacon xmit after %u misses\n",
422                                 sc->beacon.bmisscnt);
423                         sc->beacon.bmisscnt = 0;
424                 }
425         }
426
427         /*
428          * Handle slot time change when a non-ERP station joins/leaves
429          * an 11g network.  The 802.11 layer notifies us via callback,
430          * we mark updateslot, then wait one beacon before effecting
431          * the change.  This gives associated stations at least one
432          * beacon interval to note the state change.
433          *
434          * NB: The slot time change state machine is clocked according
435          *     to whether we are bursting or staggering beacons.  We
436          *     recognize the request to update and record the current
437          *     slot then don't transition until that slot is reached
438          *     again.  If we miss a beacon for that slot then we'll be
439          *     slow to transition but we'll be sure at least one beacon
440          *     interval has passed.  When bursting slot is always left
441          *     set to ATH_BCBUF so this check is a noop.
442          */
443         if (sc->beacon.updateslot == UPDATE) {
444                 sc->beacon.updateslot = COMMIT; /* commit next beacon */
445                 sc->beacon.slotupdate = slot;
446         } else if (sc->beacon.updateslot == COMMIT && sc->beacon.slotupdate == slot) {
447                 ah->slottime = sc->beacon.slottime;
448                 ath9k_hw_init_global_settings(ah);
449                 sc->beacon.updateslot = OK;
450         }
451         if (bfaddr != 0) {
452                 /* NB: cabq traffic should already be queued and primed */
453                 ath9k_hw_puttxbuf(ah, sc->beacon.beaconq, bfaddr);
454                 ath9k_hw_txstart(ah, sc->beacon.beaconq);
455
456                 sc->beacon.ast_be_xmit += bc;     /* XXX per-vif? */
457         }
458 }
459
460 static void ath9k_beacon_init(struct ath_softc *sc,
461                               u32 next_beacon,
462                               u32 beacon_period)
463 {
464         if (sc->sc_flags & SC_OP_TSF_RESET) {
465                 ath9k_ps_wakeup(sc);
466                 ath9k_hw_reset_tsf(sc->sc_ah);
467         }
468
469         ath9k_hw_beaconinit(sc->sc_ah, next_beacon, beacon_period);
470
471         if (sc->sc_flags & SC_OP_TSF_RESET) {
472                 ath9k_ps_restore(sc);
473                 sc->sc_flags &= ~SC_OP_TSF_RESET;
474         }
475 }
476
477 /*
478  * For multi-bss ap support beacons are either staggered evenly over N slots or
479  * burst together.  For the former arrange for the SWBA to be delivered for each
480  * slot. Slots that are not occupied will generate nothing.
481  */
482 static void ath_beacon_config_ap(struct ath_softc *sc,
483                                  struct ath_beacon_config *conf)
484 {
485         struct ath_hw *ah = sc->sc_ah;
486         u32 nexttbtt, intval;
487
488         /* NB: the beacon interval is kept internally in TU's */
489         intval = TU_TO_USEC(conf->beacon_interval & ATH9K_BEACON_PERIOD);
490         intval /= ATH_BCBUF;    /* for staggered beacons */
491         nexttbtt = intval;
492
493         /*
494          * In AP mode we enable the beacon timers and SWBA interrupts to
495          * prepare beacon frames.
496          */
497         ah->imask |= ATH9K_INT_SWBA;
498         ath_beaconq_config(sc);
499
500         /* Set the computed AP beacon timers */
501
502         ath9k_hw_disable_interrupts(ah);
503         ath9k_beacon_init(sc, nexttbtt, intval);
504         sc->beacon.bmisscnt = 0;
505         ath9k_hw_set_interrupts(ah, ah->imask);
506 }
507
508 /*
509  * This sets up the beacon timers according to the timestamp of the last
510  * received beacon and the current TSF, configures PCF and DTIM
511  * handling, programs the sleep registers so the hardware will wakeup in
512  * time to receive beacons, and configures the beacon miss handling so
513  * we'll receive a BMISS interrupt when we stop seeing beacons from the AP
514  * we've associated with.
515  */
516 static void ath_beacon_config_sta(struct ath_softc *sc,
517                                   struct ath_beacon_config *conf)
518 {
519         struct ath_hw *ah = sc->sc_ah;
520         struct ath_common *common = ath9k_hw_common(ah);
521         struct ath9k_beacon_state bs;
522         int dtimperiod, dtimcount, sleepduration;
523         int cfpperiod, cfpcount;
524         u32 nexttbtt = 0, intval, tsftu;
525         u64 tsf;
526         int num_beacons, offset, dtim_dec_count, cfp_dec_count;
527
528         /* No need to configure beacon if we are not associated */
529         if (!common->curaid) {
530                 ath_dbg(common, ATH_DBG_BEACON,
531                         "STA is not yet associated..skipping beacon config\n");
532                 return;
533         }
534
535         memset(&bs, 0, sizeof(bs));
536         intval = conf->beacon_interval & ATH9K_BEACON_PERIOD;
537
538         /*
539          * Setup dtim and cfp parameters according to
540          * last beacon we received (which may be none).
541          */
542         dtimperiod = conf->dtim_period;
543         dtimcount = conf->dtim_count;
544         if (dtimcount >= dtimperiod)    /* NB: sanity check */
545                 dtimcount = 0;
546         cfpperiod = 1;                  /* NB: no PCF support yet */
547         cfpcount = 0;
548
549         sleepduration = conf->listen_interval * intval;
550
551         /*
552          * Pull nexttbtt forward to reflect the current
553          * TSF and calculate dtim+cfp state for the result.
554          */
555         tsf = ath9k_hw_gettsf64(ah);
556         tsftu = TSF_TO_TU(tsf>>32, tsf) + FUDGE;
557
558         num_beacons = tsftu / intval + 1;
559         offset = tsftu % intval;
560         nexttbtt = tsftu - offset;
561         if (offset)
562                 nexttbtt += intval;
563
564         /* DTIM Beacon every dtimperiod Beacon */
565         dtim_dec_count = num_beacons % dtimperiod;
566         /* CFP every cfpperiod DTIM Beacon */
567         cfp_dec_count = (num_beacons / dtimperiod) % cfpperiod;
568         if (dtim_dec_count)
569                 cfp_dec_count++;
570
571         dtimcount -= dtim_dec_count;
572         if (dtimcount < 0)
573                 dtimcount += dtimperiod;
574
575         cfpcount -= cfp_dec_count;
576         if (cfpcount < 0)
577                 cfpcount += cfpperiod;
578
579         bs.bs_intval = intval;
580         bs.bs_nexttbtt = nexttbtt;
581         bs.bs_dtimperiod = dtimperiod*intval;
582         bs.bs_nextdtim = bs.bs_nexttbtt + dtimcount*intval;
583         bs.bs_cfpperiod = cfpperiod*bs.bs_dtimperiod;
584         bs.bs_cfpnext = bs.bs_nextdtim + cfpcount*bs.bs_dtimperiod;
585         bs.bs_cfpmaxduration = 0;
586
587         /*
588          * Calculate the number of consecutive beacons to miss* before taking
589          * a BMISS interrupt. The configuration is specified in TU so we only
590          * need calculate based on the beacon interval.  Note that we clamp the
591          * result to at most 15 beacons.
592          */
593         if (sleepduration > intval) {
594                 bs.bs_bmissthreshold = conf->listen_interval *
595                         ATH_DEFAULT_BMISS_LIMIT / 2;
596         } else {
597                 bs.bs_bmissthreshold = DIV_ROUND_UP(conf->bmiss_timeout, intval);
598                 if (bs.bs_bmissthreshold > 15)
599                         bs.bs_bmissthreshold = 15;
600                 else if (bs.bs_bmissthreshold <= 0)
601                         bs.bs_bmissthreshold = 1;
602         }
603
604         /*
605          * Calculate sleep duration. The configuration is given in ms.
606          * We ensure a multiple of the beacon period is used. Also, if the sleep
607          * duration is greater than the DTIM period then it makes senses
608          * to make it a multiple of that.
609          *
610          * XXX fixed at 100ms
611          */
612
613         bs.bs_sleepduration = roundup(IEEE80211_MS_TO_TU(100), sleepduration);
614         if (bs.bs_sleepduration > bs.bs_dtimperiod)
615                 bs.bs_sleepduration = bs.bs_dtimperiod;
616
617         /* TSF out of range threshold fixed at 1 second */
618         bs.bs_tsfoor_threshold = ATH9K_TSFOOR_THRESHOLD;
619
620         ath_dbg(common, ATH_DBG_BEACON, "tsf: %llu tsftu: %u\n", tsf, tsftu);
621         ath_dbg(common, ATH_DBG_BEACON,
622                 "bmiss: %u sleep: %u cfp-period: %u maxdur: %u next: %u\n",
623                 bs.bs_bmissthreshold, bs.bs_sleepduration,
624                 bs.bs_cfpperiod, bs.bs_cfpmaxduration, bs.bs_cfpnext);
625
626         /* Set the computed STA beacon timers */
627
628         ath9k_hw_disable_interrupts(ah);
629         ath9k_hw_set_sta_beacon_timers(ah, &bs);
630         ah->imask |= ATH9K_INT_BMISS;
631
632         /*
633          * If the beacon config is called beacause of TSFOOR,
634          * Interrupts will be enabled back at the end of ath9k_tasklet
635          */
636         if (!(sc->ps_flags & PS_TSFOOR_SYNC))
637                 ath9k_hw_set_interrupts(ah, ah->imask);
638 }
639
640 static void ath_beacon_config_adhoc(struct ath_softc *sc,
641                                     struct ath_beacon_config *conf)
642 {
643         struct ath_hw *ah = sc->sc_ah;
644         struct ath_common *common = ath9k_hw_common(ah);
645         u32 tsf, delta, intval, nexttbtt;
646
647         tsf = ath9k_hw_gettsf32(ah) + TU_TO_USEC(FUDGE);
648         intval = TU_TO_USEC(conf->beacon_interval & ATH9K_BEACON_PERIOD);
649
650         if (!sc->beacon.bc_tstamp)
651                 nexttbtt = tsf + intval;
652         else {
653                 if (tsf > sc->beacon.bc_tstamp)
654                         delta = (tsf - sc->beacon.bc_tstamp);
655                 else
656                         delta = (tsf + 1 + (~0U - sc->beacon.bc_tstamp));
657                 nexttbtt = tsf + roundup(delta, intval);
658         }
659
660         ath_dbg(common, ATH_DBG_BEACON,
661                 "IBSS nexttbtt %u intval %u (%u)\n",
662                 nexttbtt, intval, conf->beacon_interval);
663
664         /*
665          * In IBSS mode enable the beacon timers but only enable SWBA interrupts
666          * if we need to manually prepare beacon frames.  Otherwise we use a
667          * self-linked tx descriptor and let the hardware deal with things.
668          */
669         ah->imask |= ATH9K_INT_SWBA;
670
671         ath_beaconq_config(sc);
672
673         /* Set the computed ADHOC beacon timers */
674
675         ath9k_hw_disable_interrupts(ah);
676         ath9k_beacon_init(sc, nexttbtt, intval);
677         sc->beacon.bmisscnt = 0;
678         /*
679          * If the beacon config is called beacause of TSFOOR,
680          * Interrupts will be enabled back at the end of ath9k_tasklet
681          */
682         if (!(sc->ps_flags & PS_TSFOOR_SYNC))
683                 ath9k_hw_set_interrupts(ah, ah->imask);
684 }
685
686 static bool ath9k_allow_beacon_config(struct ath_softc *sc,
687                                       struct ieee80211_vif *vif)
688 {
689         struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf;
690         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
691         struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
692         struct ath_vif *avp = (void *)vif->drv_priv;
693
694         /*
695          * Can not have different beacon interval on multiple
696          * AP interface case
697          */
698         if ((sc->sc_ah->opmode == NL80211_IFTYPE_AP) &&
699             (sc->nbcnvifs > 1) &&
700             (vif->type == NL80211_IFTYPE_AP) &&
701             (cur_conf->beacon_interval != bss_conf->beacon_int)) {
702                 ath_dbg(common, ATH_DBG_CONFIG,
703                         "Changing beacon interval of multiple \
704                         AP interfaces !\n");
705                 return false;
706         }
707         /*
708          * Can not configure station vif's beacon config
709          * while on AP opmode
710          */
711         if ((sc->sc_ah->opmode == NL80211_IFTYPE_AP) &&
712             (vif->type != NL80211_IFTYPE_AP)) {
713                 ath_dbg(common, ATH_DBG_CONFIG,
714                         "STA vif's beacon not allowed on AP mode\n");
715                 return false;
716         }
717         /*
718          * Do not allow beacon config if HW was already configured
719          * with another STA vif
720          */
721         if ((sc->sc_ah->opmode == NL80211_IFTYPE_STATION) &&
722             (vif->type == NL80211_IFTYPE_STATION) &&
723             (sc->sc_flags & SC_OP_BEACONS) &&
724             !avp->primary_sta_vif) {
725                 ath_dbg(common, ATH_DBG_CONFIG,
726                         "Beacon already configured for a station interface\n");
727                 return false;
728         }
729         return true;
730 }
731
732 void ath_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif)
733 {
734         struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf;
735         struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
736
737         if (!ath9k_allow_beacon_config(sc, vif))
738                 return;
739
740         /* Setup the beacon configuration parameters */
741         cur_conf->beacon_interval = bss_conf->beacon_int;
742         cur_conf->dtim_period = bss_conf->dtim_period;
743         cur_conf->listen_interval = 1;
744         cur_conf->dtim_count = 1;
745         cur_conf->bmiss_timeout =
746                 ATH_DEFAULT_BMISS_LIMIT * cur_conf->beacon_interval;
747
748         /*
749          * It looks like mac80211 may end up using beacon interval of zero in
750          * some cases (at least for mesh point). Avoid getting into an
751          * infinite loop by using a bit safer value instead. To be safe,
752          * do sanity check on beacon interval for all operating modes.
753          */
754         if (cur_conf->beacon_interval == 0)
755                 cur_conf->beacon_interval = 100;
756
757         /*
758          * We don't parse dtim period from mac80211 during the driver
759          * initialization as it breaks association with hidden-ssid
760          * AP and it causes latency in roaming
761          */
762         if (cur_conf->dtim_period == 0)
763                 cur_conf->dtim_period = 1;
764
765         ath_set_beacon(sc);
766 }
767
768 static bool ath_has_valid_bslot(struct ath_softc *sc)
769 {
770         struct ath_vif *avp;
771         int slot;
772         bool found = false;
773
774         for (slot = 0; slot < ATH_BCBUF; slot++) {
775                 if (sc->beacon.bslot[slot]) {
776                         avp = (void *)sc->beacon.bslot[slot]->drv_priv;
777                         if (avp->is_bslot_active) {
778                                 found = true;
779                                 break;
780                         }
781                 }
782         }
783         return found;
784 }
785
786
787 void ath_set_beacon(struct ath_softc *sc)
788 {
789         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
790         struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf;
791
792         switch (sc->sc_ah->opmode) {
793         case NL80211_IFTYPE_AP:
794                 if (ath_has_valid_bslot(sc))
795                         ath_beacon_config_ap(sc, cur_conf);
796                 break;
797         case NL80211_IFTYPE_ADHOC:
798         case NL80211_IFTYPE_MESH_POINT:
799                 ath_beacon_config_adhoc(sc, cur_conf);
800                 break;
801         case NL80211_IFTYPE_STATION:
802                 ath_beacon_config_sta(sc, cur_conf);
803                 break;
804         default:
805                 ath_dbg(common, ATH_DBG_CONFIG,
806                         "Unsupported beaconing mode\n");
807                 return;
808         }
809
810         sc->sc_flags |= SC_OP_BEACONS;
811 }
812
813 void ath9k_set_beaconing_status(struct ath_softc *sc, bool status)
814 {
815         struct ath_hw *ah = sc->sc_ah;
816
817         if (!ath_has_valid_bslot(sc))
818                 return;
819
820         ath9k_ps_wakeup(sc);
821         if (status) {
822                 /* Re-enable beaconing */
823                 ah->imask |= ATH9K_INT_SWBA;
824                 ath9k_hw_set_interrupts(ah, ah->imask);
825         } else {
826                 /* Disable SWBA interrupt */
827                 ah->imask &= ~ATH9K_INT_SWBA;
828                 ath9k_hw_set_interrupts(ah, ah->imask);
829                 tasklet_kill(&sc->bcon_tasklet);
830                 ath9k_hw_stop_dma_queue(ah, sc->beacon.beaconq);
831         }
832         ath9k_ps_restore(sc);
833 }