Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6] / drivers / net / wireless / ath9k / beacon.c
1 /*
2  * Copyright (c) 2008 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 static int ath_beaconq_config(struct ath_softc *sc)
27 {
28         struct ath_hw *ah = sc->sc_ah;
29         struct ath9k_tx_queue_info qi;
30
31         ath9k_hw_get_txq_props(ah, sc->beacon.beaconq, &qi);
32         if (sc->sc_ah->opmode == NL80211_IFTYPE_AP) {
33                 /* Always burst out beacon and CAB traffic. */
34                 qi.tqi_aifs = 1;
35                 qi.tqi_cwmin = 0;
36                 qi.tqi_cwmax = 0;
37         } else {
38                 /* Adhoc mode; important thing is to use 2x cwmin. */
39                 qi.tqi_aifs = sc->beacon.beacon_qi.tqi_aifs;
40                 qi.tqi_cwmin = 2*sc->beacon.beacon_qi.tqi_cwmin;
41                 qi.tqi_cwmax = sc->beacon.beacon_qi.tqi_cwmax;
42         }
43
44         if (!ath9k_hw_set_txq_props(ah, sc->beacon.beaconq, &qi)) {
45                 DPRINTF(sc, ATH_DBG_FATAL,
46                         "unable to update h/w beacon queue parameters\n");
47                 return 0;
48         } else {
49                 ath9k_hw_resettxqueue(ah, sc->beacon.beaconq);
50                 return 1;
51         }
52 }
53
54 /*
55  *  Associates the beacon frame buffer with a transmit descriptor.  Will set
56  *  up all required antenna switch parameters, rate codes, and channel flags.
57  *  Beacons are always sent out at the lowest rate, and are not retried.
58 */
59 static void ath_beacon_setup(struct ath_softc *sc, struct ath_vif *avp,
60                              struct ath_buf *bf)
61 {
62         struct sk_buff *skb = (struct sk_buff *)bf->bf_mpdu;
63         struct ath_hw *ah = sc->sc_ah;
64         struct ath_desc *ds;
65         struct ath9k_11n_rate_series series[4];
66         struct ath_rate_table *rt;
67         int flags, antenna, ctsrate = 0, ctsduration = 0;
68         u8 rate;
69
70         ds = bf->bf_desc;
71         flags = ATH9K_TXDESC_NOACK;
72
73         if (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC &&
74             (ah->caps.hw_caps & ATH9K_HW_CAP_VEOL)) {
75                 ds->ds_link = bf->bf_daddr; /* self-linked */
76                 flags |= ATH9K_TXDESC_VEOL;
77                 /* Let hardware handle antenna switching. */
78                 antenna = 0;
79         } else {
80                 ds->ds_link = 0;
81                 /*
82                  * Switch antenna every beacon.
83                  * Should only switch every beacon period, not for every SWBA
84                  * XXX assumes two antennae
85                  */
86                 antenna = ((sc->beacon.ast_be_xmit / sc->nbcnvifs) & 1 ? 2 : 1);
87         }
88
89         ds->ds_data = bf->bf_buf_addr;
90
91         rt = sc->cur_rate_table;
92         rate = rt->info[0].ratecode;
93         if (sc->sc_flags & SC_OP_PREAMBLE_SHORT)
94                 rate |= rt->info[0].short_preamble;
95
96         ath9k_hw_set11n_txdesc(ah, ds, skb->len + FCS_LEN,
97                                ATH9K_PKT_TYPE_BEACON,
98                                MAX_RATE_POWER,
99                                ATH9K_TXKEYIX_INVALID,
100                                ATH9K_KEY_TYPE_CLEAR,
101                                flags);
102
103         /* NB: beacon's BufLen must be a multiple of 4 bytes */
104         ath9k_hw_filltxdesc(ah, ds, roundup(skb->len, 4),
105                             true, true, ds);
106
107         memset(series, 0, sizeof(struct ath9k_11n_rate_series) * 4);
108         series[0].Tries = 1;
109         series[0].Rate = rate;
110         series[0].ChSel = sc->tx_chainmask;
111         series[0].RateFlags = (ctsrate) ? ATH9K_RATESERIES_RTS_CTS : 0;
112         ath9k_hw_set11n_ratescenario(ah, ds, ds, 0, ctsrate, ctsduration,
113                                      series, 4, 0);
114 }
115
116 static struct ath_buf *ath_beacon_generate(struct ieee80211_hw *hw,
117                                            struct ieee80211_vif *vif)
118 {
119         struct ath_wiphy *aphy = hw->priv;
120         struct ath_softc *sc = aphy->sc;
121         struct ath_buf *bf;
122         struct ath_vif *avp;
123         struct sk_buff *skb;
124         struct ath_txq *cabq;
125         struct ieee80211_tx_info *info;
126         int cabq_depth;
127
128         if (aphy->state != ATH_WIPHY_ACTIVE)
129                 return NULL;
130
131         avp = (void *)vif->drv_priv;
132         cabq = sc->beacon.cabq;
133
134         if (avp->av_bcbuf == NULL) {
135                 DPRINTF(sc, ATH_DBG_BEACON, "avp=%p av_bcbuf=%p\n",
136                         avp, avp->av_bcbuf);
137                 return NULL;
138         }
139
140         /* Release the old beacon first */
141
142         bf = avp->av_bcbuf;
143         skb = (struct sk_buff *)bf->bf_mpdu;
144         if (skb) {
145                 dma_unmap_single(sc->dev, bf->bf_dmacontext,
146                                  skb->len, DMA_TO_DEVICE);
147                 dev_kfree_skb_any(skb);
148         }
149
150         /* Get a new beacon from mac80211 */
151
152         skb = ieee80211_beacon_get(hw, vif);
153         bf->bf_mpdu = skb;
154         if (skb == NULL)
155                 return NULL;
156
157         info = IEEE80211_SKB_CB(skb);
158         if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
159                 /*
160                  * TODO: make sure the seq# gets assigned properly (vs. other
161                  * TX frames)
162                  */
163                 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
164                 sc->tx.seq_no += 0x10;
165                 hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
166                 hdr->seq_ctrl |= cpu_to_le16(sc->tx.seq_no);
167         }
168
169         bf->bf_buf_addr = bf->bf_dmacontext =
170                 dma_map_single(sc->dev, skb->data,
171                                skb->len, DMA_TO_DEVICE);
172         if (unlikely(dma_mapping_error(sc->dev, bf->bf_buf_addr))) {
173                 dev_kfree_skb_any(skb);
174                 bf->bf_mpdu = NULL;
175                 DPRINTF(sc, ATH_DBG_FATAL, "dma_mapping_error on beaconing\n");
176                 return NULL;
177         }
178
179         skb = ieee80211_get_buffered_bc(hw, vif);
180
181         /*
182          * if the CABQ traffic from previous DTIM is pending and the current
183          *  beacon is also a DTIM.
184          *  1) if there is only one vif let the cab traffic continue.
185          *  2) if there are more than one vif and we are using staggered
186          *     beacons, then drain the cabq by dropping all the frames in
187          *     the cabq so that the current vifs cab traffic can be scheduled.
188          */
189         spin_lock_bh(&cabq->axq_lock);
190         cabq_depth = cabq->axq_depth;
191         spin_unlock_bh(&cabq->axq_lock);
192
193         if (skb && cabq_depth) {
194                 if (sc->nvifs > 1) {
195                         DPRINTF(sc, ATH_DBG_BEACON,
196                                 "Flushing previous cabq traffic\n");
197                         ath_draintxq(sc, cabq, false);
198                 }
199         }
200
201         ath_beacon_setup(sc, avp, bf);
202
203         while (skb) {
204                 ath_tx_cabq(hw, skb);
205                 skb = ieee80211_get_buffered_bc(hw, vif);
206         }
207
208         return bf;
209 }
210
211 /*
212  * Startup beacon transmission for adhoc mode when they are sent entirely
213  * by the hardware using the self-linked descriptor + veol trick.
214 */
215 static void ath_beacon_start_adhoc(struct ath_softc *sc,
216                                    struct ieee80211_vif *vif)
217 {
218         struct ath_hw *ah = sc->sc_ah;
219         struct ath_buf *bf;
220         struct ath_vif *avp;
221         struct sk_buff *skb;
222
223         avp = (void *)vif->drv_priv;
224
225         if (avp->av_bcbuf == NULL)
226                 return;
227
228         bf = avp->av_bcbuf;
229         skb = (struct sk_buff *) bf->bf_mpdu;
230
231         ath_beacon_setup(sc, avp, bf);
232
233         /* NB: caller is known to have already stopped tx dma */
234         ath9k_hw_puttxbuf(ah, sc->beacon.beaconq, bf->bf_daddr);
235         ath9k_hw_txstart(ah, sc->beacon.beaconq);
236         DPRINTF(sc, ATH_DBG_BEACON, "TXDP%u = %llx (%p)\n",
237                 sc->beacon.beaconq, ito64(bf->bf_daddr), bf->bf_desc);
238 }
239
240 int ath_beaconq_setup(struct ath_hw *ah)
241 {
242         struct ath9k_tx_queue_info qi;
243
244         memset(&qi, 0, sizeof(qi));
245         qi.tqi_aifs = 1;
246         qi.tqi_cwmin = 0;
247         qi.tqi_cwmax = 0;
248         /* NB: don't enable any interrupts */
249         return ath9k_hw_setuptxqueue(ah, ATH9K_TX_QUEUE_BEACON, &qi);
250 }
251
252 int ath_beacon_alloc(struct ath_wiphy *aphy, struct ieee80211_vif *vif)
253 {
254         struct ath_softc *sc = aphy->sc;
255         struct ath_vif *avp;
256         struct ieee80211_hdr *hdr;
257         struct ath_buf *bf;
258         struct sk_buff *skb;
259         __le64 tstamp;
260
261         avp = (void *)vif->drv_priv;
262
263         /* Allocate a beacon descriptor if we haven't done so. */
264         if (!avp->av_bcbuf) {
265                 /* Allocate beacon state for hostap/ibss.  We know
266                  * a buffer is available. */
267                 avp->av_bcbuf = list_first_entry(&sc->beacon.bbuf,
268                                                  struct ath_buf, list);
269                 list_del(&avp->av_bcbuf->list);
270
271                 if (sc->sc_ah->opmode == NL80211_IFTYPE_AP ||
272                     !(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_VEOL)) {
273                         int slot;
274                         /*
275                          * Assign the vif to a beacon xmit slot. As
276                          * above, this cannot fail to find one.
277                          */
278                         avp->av_bslot = 0;
279                         for (slot = 0; slot < ATH_BCBUF; slot++)
280                                 if (sc->beacon.bslot[slot] == NULL) {
281                                         /*
282                                          * XXX hack, space out slots to better
283                                          * deal with misses
284                                          */
285                                         if (slot+1 < ATH_BCBUF &&
286                                             sc->beacon.bslot[slot+1] == NULL) {
287                                                 avp->av_bslot = slot+1;
288                                                 break;
289                                         }
290                                         avp->av_bslot = slot;
291                                         /* NB: keep looking for a double slot */
292                                 }
293                         BUG_ON(sc->beacon.bslot[avp->av_bslot] != NULL);
294                         sc->beacon.bslot[avp->av_bslot] = vif;
295                         sc->beacon.bslot_aphy[avp->av_bslot] = aphy;
296                         sc->nbcnvifs++;
297                 }
298         }
299
300         /* release the previous beacon frame, if it already exists. */
301         bf = avp->av_bcbuf;
302         if (bf->bf_mpdu != NULL) {
303                 skb = (struct sk_buff *)bf->bf_mpdu;
304                 dma_unmap_single(sc->dev, bf->bf_dmacontext,
305                                  skb->len, DMA_TO_DEVICE);
306                 dev_kfree_skb_any(skb);
307                 bf->bf_mpdu = NULL;
308         }
309
310         /* NB: the beacon data buffer must be 32-bit aligned. */
311         skb = ieee80211_beacon_get(sc->hw, vif);
312         if (skb == NULL) {
313                 DPRINTF(sc, ATH_DBG_BEACON, "cannot get skb\n");
314                 return -ENOMEM;
315         }
316
317         tstamp = ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp;
318         sc->beacon.bc_tstamp = le64_to_cpu(tstamp);
319
320         /*
321          * Calculate a TSF adjustment factor required for
322          * staggered beacons.  Note that we assume the format
323          * of the beacon frame leaves the tstamp field immediately
324          * following the header.
325          */
326         if (avp->av_bslot > 0) {
327                 u64 tsfadjust;
328                 __le64 val;
329                 int intval;
330
331                 intval = sc->hw->conf.beacon_int ?
332                         sc->hw->conf.beacon_int : ATH_DEFAULT_BINTVAL;
333
334                 /*
335                  * The beacon interval is in TU's; the TSF in usecs.
336                  * We figure out how many TU's to add to align the
337                  * timestamp then convert to TSF units and handle
338                  * byte swapping before writing it in the frame.
339                  * The hardware will then add this each time a beacon
340                  * frame is sent.  Note that we align vif's 1..N
341                  * and leave vif 0 untouched.  This means vap 0
342                  * has a timestamp in one beacon interval while the
343                  * others get a timestamp aligned to the next interval.
344                  */
345                 tsfadjust = (intval * (ATH_BCBUF - avp->av_bslot)) / ATH_BCBUF;
346                 val = cpu_to_le64(tsfadjust << 10);     /* TU->TSF */
347
348                 DPRINTF(sc, ATH_DBG_BEACON,
349                         "stagger beacons, bslot %d intval %u tsfadjust %llu\n",
350                         avp->av_bslot, intval, (unsigned long long)tsfadjust);
351
352                 hdr = (struct ieee80211_hdr *)skb->data;
353                 memcpy(&hdr[1], &val, sizeof(val));
354         }
355
356         bf->bf_mpdu = skb;
357         bf->bf_buf_addr = bf->bf_dmacontext =
358                 dma_map_single(sc->dev, skb->data,
359                                skb->len, DMA_TO_DEVICE);
360         if (unlikely(dma_mapping_error(sc->dev, bf->bf_buf_addr))) {
361                 dev_kfree_skb_any(skb);
362                 bf->bf_mpdu = NULL;
363                 DPRINTF(sc, ATH_DBG_FATAL,
364                         "dma_mapping_error on beacon alloc\n");
365                 return -ENOMEM;
366         }
367
368         return 0;
369 }
370
371 void ath_beacon_return(struct ath_softc *sc, struct ath_vif *avp)
372 {
373         if (avp->av_bcbuf != NULL) {
374                 struct ath_buf *bf;
375
376                 if (avp->av_bslot != -1) {
377                         sc->beacon.bslot[avp->av_bslot] = NULL;
378                         sc->beacon.bslot_aphy[avp->av_bslot] = NULL;
379                         sc->nbcnvifs--;
380                 }
381
382                 bf = avp->av_bcbuf;
383                 if (bf->bf_mpdu != NULL) {
384                         struct sk_buff *skb = (struct sk_buff *)bf->bf_mpdu;
385                         dma_unmap_single(sc->dev, bf->bf_dmacontext,
386                                          skb->len, DMA_TO_DEVICE);
387                         dev_kfree_skb_any(skb);
388                         bf->bf_mpdu = NULL;
389                 }
390                 list_add_tail(&bf->list, &sc->beacon.bbuf);
391
392                 avp->av_bcbuf = NULL;
393         }
394 }
395
396 void ath_beacon_tasklet(unsigned long data)
397 {
398         struct ath_softc *sc = (struct ath_softc *)data;
399         struct ath_hw *ah = sc->sc_ah;
400         struct ath_buf *bf = NULL;
401         struct ieee80211_vif *vif;
402         struct ath_wiphy *aphy;
403         int slot;
404         u32 bfaddr, bc = 0, tsftu;
405         u64 tsf;
406         u16 intval;
407
408         /*
409          * Check if the previous beacon has gone out.  If
410          * not don't try to post another, skip this period
411          * and wait for the next.  Missed beacons indicate
412          * a problem and should not occur.  If we miss too
413          * many consecutive beacons reset the device.
414          */
415         if (ath9k_hw_numtxpending(ah, sc->beacon.beaconq) != 0) {
416                 sc->beacon.bmisscnt++;
417
418                 if (sc->beacon.bmisscnt < BSTUCK_THRESH) {
419                         DPRINTF(sc, ATH_DBG_BEACON,
420                                 "missed %u consecutive beacons\n",
421                                 sc->beacon.bmisscnt);
422                 } else if (sc->beacon.bmisscnt >= BSTUCK_THRESH) {
423                         DPRINTF(sc, ATH_DBG_BEACON,
424                                 "beacon is officially stuck\n");
425                         ath_reset(sc, false);
426                 }
427
428                 return;
429         }
430
431         if (sc->beacon.bmisscnt != 0) {
432                 DPRINTF(sc, ATH_DBG_BEACON,
433                         "resume beacon xmit after %u misses\n",
434                         sc->beacon.bmisscnt);
435                 sc->beacon.bmisscnt = 0;
436         }
437
438         /*
439          * Generate beacon frames. we are sending frames
440          * staggered so calculate the slot for this frame based
441          * on the tsf to safeguard against missing an swba.
442          */
443
444         intval = sc->hw->conf.beacon_int ?
445                 sc->hw->conf.beacon_int : ATH_DEFAULT_BINTVAL;
446
447         tsf = ath9k_hw_gettsf64(ah);
448         tsftu = TSF_TO_TU(tsf>>32, tsf);
449         slot = ((tsftu % intval) * ATH_BCBUF) / intval;
450         vif = sc->beacon.bslot[(slot + 1) % ATH_BCBUF];
451         aphy = sc->beacon.bslot_aphy[(slot + 1) % ATH_BCBUF];
452
453         DPRINTF(sc, ATH_DBG_BEACON,
454                 "slot %d [tsf %llu tsftu %u intval %u] vif %p\n",
455                 slot, tsf, tsftu, intval, vif);
456
457         bfaddr = 0;
458         if (vif) {
459                 bf = ath_beacon_generate(aphy->hw, vif);
460                 if (bf != NULL) {
461                         bfaddr = bf->bf_daddr;
462                         bc = 1;
463                 }
464         }
465
466         /*
467          * Handle slot time change when a non-ERP station joins/leaves
468          * an 11g network.  The 802.11 layer notifies us via callback,
469          * we mark updateslot, then wait one beacon before effecting
470          * the change.  This gives associated stations at least one
471          * beacon interval to note the state change.
472          *
473          * NB: The slot time change state machine is clocked according
474          *     to whether we are bursting or staggering beacons.  We
475          *     recognize the request to update and record the current
476          *     slot then don't transition until that slot is reached
477          *     again.  If we miss a beacon for that slot then we'll be
478          *     slow to transition but we'll be sure at least one beacon
479          *     interval has passed.  When bursting slot is always left
480          *     set to ATH_BCBUF so this check is a noop.
481          */
482         if (sc->beacon.updateslot == UPDATE) {
483                 sc->beacon.updateslot = COMMIT; /* commit next beacon */
484                 sc->beacon.slotupdate = slot;
485         } else if (sc->beacon.updateslot == COMMIT && sc->beacon.slotupdate == slot) {
486                 ath9k_hw_setslottime(sc->sc_ah, sc->beacon.slottime);
487                 sc->beacon.updateslot = OK;
488         }
489         if (bfaddr != 0) {
490                 /*
491                  * Stop any current dma and put the new frame(s) on the queue.
492                  * This should never fail since we check above that no frames
493                  * are still pending on the queue.
494                  */
495                 if (!ath9k_hw_stoptxdma(ah, sc->beacon.beaconq)) {
496                         DPRINTF(sc, ATH_DBG_FATAL,
497                                 "beacon queue %u did not stop?\n", sc->beacon.beaconq);
498                 }
499
500                 /* NB: cabq traffic should already be queued and primed */
501                 ath9k_hw_puttxbuf(ah, sc->beacon.beaconq, bfaddr);
502                 ath9k_hw_txstart(ah, sc->beacon.beaconq);
503
504                 sc->beacon.ast_be_xmit += bc;     /* XXX per-vif? */
505         }
506 }
507
508 /*
509  * For multi-bss ap support beacons are either staggered evenly over N slots or
510  * burst together.  For the former arrange for the SWBA to be delivered for each
511  * slot. Slots that are not occupied will generate nothing.
512  */
513 static void ath_beacon_config_ap(struct ath_softc *sc,
514                                  struct ath_beacon_config *conf,
515                                  struct ath_vif *avp)
516 {
517         u32 nexttbtt, intval;
518
519         /* Configure the timers only when the TSF has to be reset */
520
521         if (!(sc->sc_flags & SC_OP_TSF_RESET))
522                 return;
523
524         /* NB: the beacon interval is kept internally in TU's */
525         intval = conf->beacon_interval & ATH9K_BEACON_PERIOD;
526         intval /= ATH_BCBUF;    /* for staggered beacons */
527         nexttbtt = intval;
528         intval |= ATH9K_BEACON_RESET_TSF;
529
530         /*
531          * In AP mode we enable the beacon timers and SWBA interrupts to
532          * prepare beacon frames.
533          */
534         intval |= ATH9K_BEACON_ENA;
535         sc->imask |= ATH9K_INT_SWBA;
536         ath_beaconq_config(sc);
537
538         /* Set the computed AP beacon timers */
539
540         ath9k_hw_set_interrupts(sc->sc_ah, 0);
541         ath9k_hw_beaconinit(sc->sc_ah, nexttbtt, intval);
542         sc->beacon.bmisscnt = 0;
543         ath9k_hw_set_interrupts(sc->sc_ah, sc->imask);
544
545         /* Clear the reset TSF flag, so that subsequent beacon updation
546            will not reset the HW TSF. */
547
548         sc->sc_flags &= ~SC_OP_TSF_RESET;
549 }
550
551 /*
552  * This sets up the beacon timers according to the timestamp of the last
553  * received beacon and the current TSF, configures PCF and DTIM
554  * handling, programs the sleep registers so the hardware will wakeup in
555  * time to receive beacons, and configures the beacon miss handling so
556  * we'll receive a BMISS interrupt when we stop seeing beacons from the AP
557  * we've associated with.
558  */
559 static void ath_beacon_config_sta(struct ath_softc *sc,
560                                   struct ath_beacon_config *conf,
561                                   struct ath_vif *avp)
562 {
563         struct ath9k_beacon_state bs;
564         int dtimperiod, dtimcount, sleepduration;
565         int cfpperiod, cfpcount;
566         u32 nexttbtt = 0, intval, tsftu;
567         u64 tsf;
568
569         memset(&bs, 0, sizeof(bs));
570         intval = conf->beacon_interval & ATH9K_BEACON_PERIOD;
571
572         /*
573          * Setup dtim and cfp parameters according to
574          * last beacon we received (which may be none).
575          */
576         dtimperiod = conf->dtim_period;
577         if (dtimperiod <= 0)            /* NB: 0 if not known */
578                 dtimperiod = 1;
579         dtimcount = conf->dtim_count;
580         if (dtimcount >= dtimperiod)    /* NB: sanity check */
581                 dtimcount = 0;
582         cfpperiod = 1;                  /* NB: no PCF support yet */
583         cfpcount = 0;
584
585         sleepduration = conf->listen_interval * intval;
586         if (sleepduration <= 0)
587                 sleepduration = intval;
588
589         /*
590          * Pull nexttbtt forward to reflect the current
591          * TSF and calculate dtim+cfp state for the result.
592          */
593         tsf = ath9k_hw_gettsf64(sc->sc_ah);
594         tsftu = TSF_TO_TU(tsf>>32, tsf) + FUDGE;
595         do {
596                 nexttbtt += intval;
597                 if (--dtimcount < 0) {
598                         dtimcount = dtimperiod - 1;
599                         if (--cfpcount < 0)
600                                 cfpcount = cfpperiod - 1;
601                 }
602         } while (nexttbtt < tsftu);
603
604         bs.bs_intval = intval;
605         bs.bs_nexttbtt = nexttbtt;
606         bs.bs_dtimperiod = dtimperiod*intval;
607         bs.bs_nextdtim = bs.bs_nexttbtt + dtimcount*intval;
608         bs.bs_cfpperiod = cfpperiod*bs.bs_dtimperiod;
609         bs.bs_cfpnext = bs.bs_nextdtim + cfpcount*bs.bs_dtimperiod;
610         bs.bs_cfpmaxduration = 0;
611
612         /*
613          * Calculate the number of consecutive beacons to miss* before taking
614          * a BMISS interrupt. The configuration is specified in TU so we only
615          * need calculate based on the beacon interval.  Note that we clamp the
616          * result to at most 15 beacons.
617          */
618         if (sleepduration > intval) {
619                 bs.bs_bmissthreshold = conf->listen_interval *
620                         ATH_DEFAULT_BMISS_LIMIT / 2;
621         } else {
622                 bs.bs_bmissthreshold = DIV_ROUND_UP(conf->bmiss_timeout, intval);
623                 if (bs.bs_bmissthreshold > 15)
624                         bs.bs_bmissthreshold = 15;
625                 else if (bs.bs_bmissthreshold <= 0)
626                         bs.bs_bmissthreshold = 1;
627         }
628
629         /*
630          * Calculate sleep duration. The configuration is given in ms.
631          * We ensure a multiple of the beacon period is used. Also, if the sleep
632          * duration is greater than the DTIM period then it makes senses
633          * to make it a multiple of that.
634          *
635          * XXX fixed at 100ms
636          */
637
638         bs.bs_sleepduration = roundup(IEEE80211_MS_TO_TU(100), sleepduration);
639         if (bs.bs_sleepduration > bs.bs_dtimperiod)
640                 bs.bs_sleepduration = bs.bs_dtimperiod;
641
642         /* TSF out of range threshold fixed at 1 second */
643         bs.bs_tsfoor_threshold = ATH9K_TSFOOR_THRESHOLD;
644
645         DPRINTF(sc, ATH_DBG_BEACON, "tsf: %llu tsftu: %u\n", tsf, tsftu);
646         DPRINTF(sc, ATH_DBG_BEACON,
647                 "bmiss: %u sleep: %u cfp-period: %u maxdur: %u next: %u\n",
648                 bs.bs_bmissthreshold, bs.bs_sleepduration,
649                 bs.bs_cfpperiod, bs.bs_cfpmaxduration, bs.bs_cfpnext);
650
651         /* Set the computed STA beacon timers */
652
653         ath9k_hw_set_interrupts(sc->sc_ah, 0);
654         ath9k_hw_set_sta_beacon_timers(sc->sc_ah, &bs);
655         sc->imask |= ATH9K_INT_BMISS;
656         ath9k_hw_set_interrupts(sc->sc_ah, sc->imask);
657 }
658
659 static void ath_beacon_config_adhoc(struct ath_softc *sc,
660                                     struct ath_beacon_config *conf,
661                                     struct ath_vif *avp,
662                                     struct ieee80211_vif *vif)
663 {
664         u64 tsf;
665         u32 tsftu, intval, nexttbtt;
666
667         intval = conf->beacon_interval & ATH9K_BEACON_PERIOD;
668
669         /* Pull nexttbtt forward to reflect the current TSF */
670
671         nexttbtt = TSF_TO_TU(sc->beacon.bc_tstamp >> 32, sc->beacon.bc_tstamp);
672         if (nexttbtt == 0)
673                 nexttbtt = intval;
674         else if (intval)
675                 nexttbtt = roundup(nexttbtt, intval);
676
677         tsf = ath9k_hw_gettsf64(sc->sc_ah);
678         tsftu = TSF_TO_TU((u32)(tsf>>32), (u32)tsf) + FUDGE;
679         do {
680                 nexttbtt += intval;
681         } while (nexttbtt < tsftu);
682
683         DPRINTF(sc, ATH_DBG_BEACON,
684                 "IBSS nexttbtt %u intval %u (%u)\n",
685                 nexttbtt, intval, conf->beacon_interval);
686
687         /*
688          * In IBSS mode enable the beacon timers but only enable SWBA interrupts
689          * if we need to manually prepare beacon frames.  Otherwise we use a
690          * self-linked tx descriptor and let the hardware deal with things.
691          */
692         intval |= ATH9K_BEACON_ENA;
693         if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_VEOL))
694                 sc->imask |= ATH9K_INT_SWBA;
695
696         ath_beaconq_config(sc);
697
698         /* Set the computed ADHOC beacon timers */
699
700         ath9k_hw_set_interrupts(sc->sc_ah, 0);
701         ath9k_hw_beaconinit(sc->sc_ah, nexttbtt, intval);
702         sc->beacon.bmisscnt = 0;
703         ath9k_hw_set_interrupts(sc->sc_ah, sc->imask);
704
705         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_VEOL)
706                 ath_beacon_start_adhoc(sc, vif);
707 }
708
709 void ath_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif)
710 {
711         struct ath_beacon_config conf;
712
713         /* Setup the beacon configuration parameters */
714
715         memset(&conf, 0, sizeof(struct ath_beacon_config));
716         conf.beacon_interval = sc->hw->conf.beacon_int ?
717                 sc->hw->conf.beacon_int : ATH_DEFAULT_BINTVAL;
718         conf.listen_interval = 1;
719         conf.dtim_period = conf.beacon_interval;
720         conf.dtim_count = 1;
721         conf.bmiss_timeout = ATH_DEFAULT_BMISS_LIMIT * conf.beacon_interval;
722
723         if (vif) {
724                 struct ath_vif *avp = (struct ath_vif *)vif->drv_priv;
725
726                 switch(avp->av_opmode) {
727                 case NL80211_IFTYPE_AP:
728                         ath_beacon_config_ap(sc, &conf, avp);
729                         break;
730                 case NL80211_IFTYPE_ADHOC:
731                         ath_beacon_config_adhoc(sc, &conf, avp, vif);
732                         break;
733                 case NL80211_IFTYPE_STATION:
734                         ath_beacon_config_sta(sc, &conf, avp);
735                         break;
736                 default:
737                         DPRINTF(sc, ATH_DBG_CONFIG,
738                                 "Unsupported beaconing mode\n");
739                         return;
740                 }
741
742                 sc->sc_flags |= SC_OP_BEACONS;
743         }
744 }