063f5ce32a01af76d57eb0f681c6f594252f0354
[dragonfly.git] / sys / dev / netif / ath / ath / if_ath_beacon.c
1 /*-
2  * Copyright (c) 2002-2009 Sam Leffler, Errno Consulting
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer,
10  *    without modification.
11  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
12  *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
13  *    redistribution must be conditioned upon including a substantially
14  *    similar Disclaimer requirement for further binary redistribution.
15  *
16  * NO WARRANTY
17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
20  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
21  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
22  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
27  * THE POSSIBILITY OF SUCH DAMAGES.
28  */
29
30 #include <sys/cdefs.h>
31
32 /*
33  * Driver for the Atheros Wireless LAN controller.
34  *
35  * This software is derived from work of Atsushi Onoe; his contribution
36  * is greatly appreciated.
37  */
38
39 #include "opt_inet.h"
40 #include "opt_ath.h"
41 /*
42  * This is needed for register operations which are performed
43  * by the driver - eg, calls to ath_hal_gettsf32().
44  *
45  * It's also required for any AH_DEBUG checks in here, eg the
46  * module dependencies.
47  */
48 #include "opt_ah.h"
49 #include "opt_wlan.h"
50
51 #include <sys/param.h>
52 #include <sys/systm.h>
53 #include <sys/sysctl.h>
54 #include <sys/mbuf.h>
55 #include <sys/malloc.h>
56 #include <sys/lock.h>
57 #include <sys/mutex.h>
58 #include <sys/kernel.h>
59 #include <sys/socket.h>
60 #include <sys/sockio.h>
61 #include <sys/errno.h>
62 #include <sys/callout.h>
63 #include <sys/bus.h>
64 #include <sys/endian.h>
65 #include <sys/kthread.h>
66 #include <sys/taskqueue.h>
67 #include <sys/priv.h>
68 #include <sys/module.h>
69 #include <sys/ktr.h>
70
71 #include <net/if.h>
72 #include <net/if_var.h>
73 #include <net/if_dl.h>
74 #include <net/if_media.h>
75 #include <net/if_types.h>
76 #include <net/if_arp.h>
77 #include <net/ethernet.h>
78 #include <net/if_llc.h>
79
80 #include <netproto/802_11/ieee80211_var.h>
81 #include <netproto/802_11/ieee80211_regdomain.h>
82 #ifdef IEEE80211_SUPPORT_SUPERG
83 #include <netproto/802_11/ieee80211_superg.h>
84 #endif
85
86 #include <net/bpf.h>
87
88 #ifdef INET
89 #include <netinet/in.h>
90 #include <netinet/if_ether.h>
91 #endif
92
93 #include <dev/netif/ath/ath/if_athvar.h>
94
95 #include <dev/netif/ath/ath/if_ath_debug.h>
96 #include <dev/netif/ath/ath/if_ath_misc.h>
97 #include <dev/netif/ath/ath/if_ath_tx.h>
98 #include <dev/netif/ath/ath/if_ath_beacon.h>
99
100 #ifdef ATH_TX99_DIAG
101 #include <dev/netif/ath/ath_tx99/ath_tx99.h>
102 #endif
103
104 /*
105  * Setup a h/w transmit queue for beacons.
106  */
107 int
108 ath_beaconq_setup(struct ath_softc *sc)
109 {
110         struct ath_hal *ah = sc->sc_ah;
111         HAL_TXQ_INFO qi;
112
113         memset(&qi, 0, sizeof(qi));
114         qi.tqi_aifs = HAL_TXQ_USEDEFAULT;
115         qi.tqi_cwmin = HAL_TXQ_USEDEFAULT;
116         qi.tqi_cwmax = HAL_TXQ_USEDEFAULT;
117         /* NB: for dynamic turbo, don't enable any other interrupts */
118         qi.tqi_qflags = HAL_TXQ_TXDESCINT_ENABLE;
119         if (sc->sc_isedma)
120                 qi.tqi_qflags |= HAL_TXQ_TXOKINT_ENABLE |
121                     HAL_TXQ_TXERRINT_ENABLE;
122
123         return ath_hal_setuptxqueue(ah, HAL_TX_QUEUE_BEACON, &qi);
124 }
125
126 /*
127  * Setup the transmit queue parameters for the beacon queue.
128  */
129 int
130 ath_beaconq_config(struct ath_softc *sc)
131 {
132 #define ATH_EXPONENT_TO_VALUE(v)        ((1<<(v))-1)
133         struct ieee80211com *ic = sc->sc_ifp->if_l2com;
134         struct ath_hal *ah = sc->sc_ah;
135         HAL_TXQ_INFO qi;
136
137         ath_hal_gettxqueueprops(ah, sc->sc_bhalq, &qi);
138         if (ic->ic_opmode == IEEE80211_M_HOSTAP ||
139             ic->ic_opmode == IEEE80211_M_MBSS) {
140                 /*
141                  * Always burst out beacon and CAB traffic.
142                  */
143                 qi.tqi_aifs = ATH_BEACON_AIFS_DEFAULT;
144                 qi.tqi_cwmin = ATH_BEACON_CWMIN_DEFAULT;
145                 qi.tqi_cwmax = ATH_BEACON_CWMAX_DEFAULT;
146         } else {
147                 struct wmeParams *wmep =
148                         &ic->ic_wme.wme_chanParams.cap_wmeParams[WME_AC_BE];
149                 /*
150                  * Adhoc mode; important thing is to use 2x cwmin.
151                  */
152                 qi.tqi_aifs = wmep->wmep_aifsn;
153                 qi.tqi_cwmin = 2*ATH_EXPONENT_TO_VALUE(wmep->wmep_logcwmin);
154                 qi.tqi_cwmax = ATH_EXPONENT_TO_VALUE(wmep->wmep_logcwmax);
155         }
156
157         if (!ath_hal_settxqueueprops(ah, sc->sc_bhalq, &qi)) {
158                 device_printf(sc->sc_dev, "unable to update parameters for "
159                         "beacon hardware queue!\n");
160                 return 0;
161         } else {
162                 ath_hal_resettxqueue(ah, sc->sc_bhalq); /* push to h/w */
163                 return 1;
164         }
165 #undef ATH_EXPONENT_TO_VALUE
166 }
167
168 /*
169  * Allocate and setup an initial beacon frame.
170  */
171 int
172 ath_beacon_alloc(struct ath_softc *sc, struct ieee80211_node *ni)
173 {
174         struct ieee80211vap *vap = ni->ni_vap;
175         struct ath_vap *avp = ATH_VAP(vap);
176         struct ath_buf *bf;
177         struct mbuf *m;
178         int error;
179
180         bf = avp->av_bcbuf;
181         DPRINTF(sc, ATH_DEBUG_NODE, "%s: bf_m=%p, bf_node=%p\n",
182             __func__, bf->bf_m, bf->bf_node);
183         if (bf->bf_m != NULL) {
184                 bus_dmamap_unload(sc->sc_dmat, bf->bf_dmamap);
185                 m_freem(bf->bf_m);
186                 bf->bf_m = NULL;
187         }
188         if (bf->bf_node != NULL) {
189                 ieee80211_free_node(bf->bf_node);
190                 bf->bf_node = NULL;
191         }
192
193         /*
194          * NB: the beacon data buffer must be 32-bit aligned;
195          * we assume the mbuf routines will return us something
196          * with this alignment (perhaps should assert).
197          */
198         m = ieee80211_beacon_alloc(ni, &avp->av_boff);
199         if (m == NULL) {
200                 device_printf(sc->sc_dev, "%s: cannot get mbuf\n", __func__);
201                 sc->sc_stats.ast_be_nombuf++;
202                 return ENOMEM;
203         }
204         error = bus_dmamap_load_mbuf_sg(sc->sc_dmat, bf->bf_dmamap, m,
205                                      bf->bf_segs, &bf->bf_nseg,
206                                      BUS_DMA_NOWAIT);
207         if (error != 0) {
208                 device_printf(sc->sc_dev,
209                     "%s: cannot map mbuf, bus_dmamap_load_mbuf_sg returns %d\n",
210                     __func__, error);
211                 m_freem(m);
212                 return error;
213         }
214
215         /*
216          * Calculate a TSF adjustment factor required for staggered
217          * beacons.  Note that we assume the format of the beacon
218          * frame leaves the tstamp field immediately following the
219          * header.
220          */
221         if (sc->sc_stagbeacons && avp->av_bslot > 0) {
222                 uint64_t tsfadjust;
223                 struct ieee80211_frame *wh;
224
225                 /*
226                  * The beacon interval is in TU's; the TSF is in usecs.
227                  * We figure out how many TU's to add to align the timestamp
228                  * then convert to TSF units and handle byte swapping before
229                  * inserting it in the frame.  The hardware will then add this
230                  * each time a beacon frame is sent.  Note that we align vap's
231                  * 1..N and leave vap 0 untouched.  This means vap 0 has a
232                  * timestamp in one beacon interval while the others get a
233                  * timstamp aligned to the next interval.
234                  */
235                 tsfadjust = ni->ni_intval *
236                     (ATH_BCBUF - avp->av_bslot) / ATH_BCBUF;
237                 tsfadjust = htole64(tsfadjust << 10);   /* TU -> TSF */
238
239                 DPRINTF(sc, ATH_DEBUG_BEACON,
240                     "%s: %s beacons bslot %d intval %u tsfadjust %llu\n",
241                     __func__, sc->sc_stagbeacons ? "stagger" : "burst",
242                     avp->av_bslot, ni->ni_intval,
243                     (long long unsigned) le64toh(tsfadjust));
244
245                 wh = mtod(m, struct ieee80211_frame *);
246                 memcpy(&wh[1], &tsfadjust, sizeof(tsfadjust));
247         }
248         bf->bf_m = m;
249         bf->bf_node = ieee80211_ref_node(ni);
250
251         return 0;
252 }
253
254 /*
255  * Setup the beacon frame for transmit.
256  */
257 static void
258 ath_beacon_setup(struct ath_softc *sc, struct ath_buf *bf)
259 {
260 #define USE_SHPREAMBLE(_ic) \
261         (((_ic)->ic_flags & (IEEE80211_F_SHPREAMBLE | IEEE80211_F_USEBARKER))\
262                 == IEEE80211_F_SHPREAMBLE)
263         struct ieee80211_node *ni = bf->bf_node;
264         struct ieee80211com *ic = ni->ni_ic;
265         struct mbuf *m = bf->bf_m;
266         struct ath_hal *ah = sc->sc_ah;
267         struct ath_desc *ds;
268         int flags, antenna;
269         const HAL_RATE_TABLE *rt;
270         u_int8_t rix, rate;
271         HAL_DMA_ADDR bufAddrList[4];
272         uint32_t segLenList[4];
273         HAL_11N_RATE_SERIES rc[4];
274
275         DPRINTF(sc, ATH_DEBUG_BEACON_PROC, "%s: m %p len %u\n",
276                 __func__, m, m->m_len);
277
278         /* setup descriptors */
279         ds = bf->bf_desc;
280         bf->bf_last = bf;
281         bf->bf_lastds = ds;
282
283         flags = HAL_TXDESC_NOACK;
284         if (ic->ic_opmode == IEEE80211_M_IBSS && sc->sc_hasveol) {
285                 /* self-linked descriptor */
286                 ath_hal_settxdesclink(sc->sc_ah, ds, bf->bf_daddr);
287                 flags |= HAL_TXDESC_VEOL;
288                 /*
289                  * Let hardware handle antenna switching.
290                  */
291                 antenna = sc->sc_txantenna;
292         } else {
293                 ath_hal_settxdesclink(sc->sc_ah, ds, 0);
294                 /*
295                  * Switch antenna every 4 beacons.
296                  * XXX assumes two antenna
297                  */
298                 if (sc->sc_txantenna != 0)
299                         antenna = sc->sc_txantenna;
300                 else if (sc->sc_stagbeacons && sc->sc_nbcnvaps != 0)
301                         antenna = ((sc->sc_stats.ast_be_xmit / sc->sc_nbcnvaps) & 4 ? 2 : 1);
302                 else
303                         antenna = (sc->sc_stats.ast_be_xmit & 4 ? 2 : 1);
304         }
305
306         KASSERT(bf->bf_nseg == 1,
307                 ("multi-segment beacon frame; nseg %u", bf->bf_nseg));
308
309         /*
310          * Calculate rate code.
311          * XXX everything at min xmit rate
312          */
313         rix = 0;
314         rt = sc->sc_currates;
315         rate = rt->info[rix].rateCode;
316         if (USE_SHPREAMBLE(ic))
317                 rate |= rt->info[rix].shortPreamble;
318         ath_hal_setuptxdesc(ah, ds
319                 , m->m_len + IEEE80211_CRC_LEN  /* frame length */
320                 , sizeof(struct ieee80211_frame)/* header length */
321                 , HAL_PKT_TYPE_BEACON           /* Atheros packet type */
322                 , ieee80211_get_node_txpower(ni)        /* txpower XXX */
323                 , rate, 1                       /* series 0 rate/tries */
324                 , HAL_TXKEYIX_INVALID           /* no encryption */
325                 , antenna                       /* antenna mode */
326                 , flags                         /* no ack, veol for beacons */
327                 , 0                             /* rts/cts rate */
328                 , 0                             /* rts/cts duration */
329         );
330
331         /*
332          * The EDMA HAL currently assumes that _all_ rate control
333          * settings are done in ath_hal_set11nratescenario(), rather
334          * than in ath_hal_setuptxdesc().
335          */
336         if (sc->sc_isedma) {
337                 memset(&rc, 0, sizeof(rc));
338
339                 rc[0].ChSel = sc->sc_txchainmask;
340                 rc[0].Tries = 1;
341                 rc[0].Rate = rt->info[rix].rateCode;
342                 rc[0].RateIndex = rix;
343                 rc[0].tx_power_cap = 0x3f;
344                 rc[0].PktDuration =
345                     ath_hal_computetxtime(ah, rt, roundup(m->m_len, 4),
346                         rix, 0);
347                 ath_hal_set11nratescenario(ah, ds, 0, 0, rc, 4, flags);
348         }
349
350         /* NB: beacon's BufLen must be a multiple of 4 bytes */
351         segLenList[0] = roundup(m->m_len, 4);
352         segLenList[1] = segLenList[2] = segLenList[3] = 0;
353         bufAddrList[0] = bf->bf_segs[0].ds_addr;
354         bufAddrList[1] = bufAddrList[2] = bufAddrList[3] = 0;
355         ath_hal_filltxdesc(ah, ds
356                 , bufAddrList
357                 , segLenList
358                 , 0                             /* XXX desc id */
359                 , sc->sc_bhalq                  /* hardware TXQ */
360                 , AH_TRUE                       /* first segment */
361                 , AH_TRUE                       /* last segment */
362                 , ds                            /* first descriptor */
363         );
364 #if 0
365         ath_desc_swap(ds);
366 #endif
367 #undef USE_SHPREAMBLE
368 }
369
370 void
371 ath_beacon_update(struct ieee80211vap *vap, int item)
372 {
373         struct ieee80211_beacon_offsets *bo = &ATH_VAP(vap)->av_boff;
374
375         setbit(bo->bo_flags, item);
376 }
377
378 /*
379  * Handle a beacon miss.
380  */
381 static void
382 ath_beacon_miss(struct ath_softc *sc)
383 {
384         HAL_SURVEY_SAMPLE hs;
385         HAL_BOOL ret;
386         uint32_t hangs;
387
388         bzero(&hs, sizeof(hs));
389
390         ret = ath_hal_get_mib_cycle_counts(sc->sc_ah, &hs);
391
392         if (ath_hal_gethangstate(sc->sc_ah, 0xffff, &hangs) && hangs != 0) {
393                 DPRINTF(sc, ATH_DEBUG_BEACON,
394                     "%s: hang=0x%08x\n",
395                     __func__,
396                     hangs);
397         }
398
399 #ifdef  ATH_DEBUG_ALQ
400         if (if_ath_alq_checkdebug(&sc->sc_alq, ATH_ALQ_MISSED_BEACON))
401                 if_ath_alq_post(&sc->sc_alq, ATH_ALQ_MISSED_BEACON, 0, NULL);
402 #endif
403
404         DPRINTF(sc, ATH_DEBUG_BEACON,
405             "%s: valid=%d, txbusy=%u, rxbusy=%u, chanbusy=%u, "
406             "extchanbusy=%u, cyclecount=%u\n",
407             __func__,
408             ret,
409             hs.tx_busy,
410             hs.rx_busy,
411             hs.chan_busy,
412             hs.ext_chan_busy,
413             hs.cycle_count);
414 }
415
416 /*
417  * Transmit a beacon frame at SWBA.  Dynamic updates to the
418  * frame contents are done as needed and the slot time is
419  * also adjusted based on current state.
420  */
421 void
422 ath_beacon_proc(void *arg, int pending)
423 {
424         struct ath_softc *sc = arg;
425         struct ath_hal *ah = sc->sc_ah;
426         struct ieee80211vap *vap;
427         struct ath_buf *bf;
428         int slot, otherant;
429         uint32_t bfaddr;
430
431         DPRINTF(sc, ATH_DEBUG_BEACON_PROC, "%s: pending %u\n",
432                 __func__, pending);
433         /*
434          * Check if the previous beacon has gone out.  If
435          * not don't try to post another, skip this period
436          * and wait for the next.  Missed beacons indicate
437          * a problem and should not occur.  If we miss too
438          * many consecutive beacons reset the device.
439          */
440         if (ath_hal_numtxpending(ah, sc->sc_bhalq) != 0) {
441                 sc->sc_bmisscount++;
442                 sc->sc_stats.ast_be_missed++;
443                 ath_beacon_miss(sc);
444                 DPRINTF(sc, ATH_DEBUG_BEACON,
445                         "%s: missed %u consecutive beacons\n",
446                         __func__, sc->sc_bmisscount);
447                 if (sc->sc_bmisscount >= ath_bstuck_threshold)
448                         taskqueue_enqueue(sc->sc_tq, &sc->sc_bstucktask);
449                 return;
450         }
451         if (sc->sc_bmisscount != 0) {
452                 DPRINTF(sc, ATH_DEBUG_BEACON,
453                         "%s: resume beacon xmit after %u misses\n",
454                         __func__, sc->sc_bmisscount);
455                 sc->sc_bmisscount = 0;
456 #ifdef  ATH_DEBUG_ALQ
457                 if (if_ath_alq_checkdebug(&sc->sc_alq, ATH_ALQ_RESUME_BEACON))
458                         if_ath_alq_post(&sc->sc_alq, ATH_ALQ_RESUME_BEACON, 0, NULL);
459 #endif
460         }
461
462         if (sc->sc_stagbeacons) {                       /* staggered beacons */
463                 struct ieee80211com *ic = sc->sc_ifp->if_l2com;
464                 uint32_t tsftu;
465
466                 tsftu = ath_hal_gettsf32(ah) >> 10;
467                 /* XXX lintval */
468                 slot = ((tsftu % ic->ic_lintval) * ATH_BCBUF) / ic->ic_lintval;
469                 vap = sc->sc_bslot[(slot+1) % ATH_BCBUF];
470                 bfaddr = 0;
471                 if (vap != NULL && vap->iv_state >= IEEE80211_S_RUN) {
472                         bf = ath_beacon_generate(sc, vap);
473                         if (bf != NULL)
474                                 bfaddr = bf->bf_daddr;
475                 }
476         } else {                                        /* burst'd beacons */
477                 uint32_t *bflink = &bfaddr;
478
479                 for (slot = 0; slot < ATH_BCBUF; slot++) {
480                         vap = sc->sc_bslot[slot];
481                         if (vap != NULL && vap->iv_state >= IEEE80211_S_RUN) {
482                                 bf = ath_beacon_generate(sc, vap);
483                                 /*
484                                  * XXX TODO: this should use settxdesclinkptr()
485                                  * otherwise it won't work for EDMA chipsets!
486                                  */
487                                 if (bf != NULL) {
488                                         /* XXX should do this using the ds */
489                                         *bflink = bf->bf_daddr;
490                                         ath_hal_gettxdesclinkptr(sc->sc_ah,
491                                             bf->bf_desc, &bflink);
492                                 }
493                         }
494                 }
495                 /*
496                  * XXX TODO: this should use settxdesclinkptr()
497                  * otherwise it won't work for EDMA chipsets!
498                  */
499                 *bflink = 0;                            /* terminate list */
500         }
501
502         /*
503          * Handle slot time change when a non-ERP station joins/leaves
504          * an 11g network.  The 802.11 layer notifies us via callback,
505          * we mark updateslot, then wait one beacon before effecting
506          * the change.  This gives associated stations at least one
507          * beacon interval to note the state change.
508          */
509         /* XXX locking */
510         if (sc->sc_updateslot == UPDATE) {
511                 sc->sc_updateslot = COMMIT;     /* commit next beacon */
512                 sc->sc_slotupdate = slot;
513         } else if (sc->sc_updateslot == COMMIT && sc->sc_slotupdate == slot)
514                 ath_setslottime(sc);            /* commit change to h/w */
515
516         /*
517          * Check recent per-antenna transmit statistics and flip
518          * the default antenna if noticeably more frames went out
519          * on the non-default antenna.
520          * XXX assumes 2 anntenae
521          */
522         if (!sc->sc_diversity && (!sc->sc_stagbeacons || slot == 0)) {
523                 otherant = sc->sc_defant & 1 ? 2 : 1;
524                 if (sc->sc_ant_tx[otherant] > sc->sc_ant_tx[sc->sc_defant] + 2)
525                         ath_setdefantenna(sc, otherant);
526                 sc->sc_ant_tx[1] = sc->sc_ant_tx[2] = 0;
527         }
528
529         /* Program the CABQ with the contents of the CABQ txq and start it */
530         ATH_TXQ_LOCK(sc->sc_cabq);
531         ath_beacon_cabq_start(sc);
532         ATH_TXQ_UNLOCK(sc->sc_cabq);
533
534         /* Program the new beacon frame if we have one for this interval */
535         if (bfaddr != 0) {
536                 /*
537                  * Stop any current dma and put the new frame on the queue.
538                  * This should never fail since we check above that no frames
539                  * are still pending on the queue.
540                  */
541                 if (! sc->sc_isedma) {
542                         if (!ath_hal_stoptxdma(ah, sc->sc_bhalq)) {
543                                 DPRINTF(sc, ATH_DEBUG_ANY,
544                                         "%s: beacon queue %u did not stop?\n",
545                                         __func__, sc->sc_bhalq);
546                         }
547                 }
548                 /* NB: cabq traffic should already be queued and primed */
549
550                 ath_hal_puttxbuf(ah, sc->sc_bhalq, bfaddr);
551                 ath_hal_txstart(ah, sc->sc_bhalq);
552
553                 sc->sc_stats.ast_be_xmit++;
554         }
555 }
556
557 static void
558 ath_beacon_cabq_start_edma(struct ath_softc *sc)
559 {
560         struct ath_buf *bf, *bf_last;
561         struct ath_txq *cabq = sc->sc_cabq;
562 #if 0
563         struct ath_buf *bfi;
564         int i = 0;
565 #endif
566
567         ATH_TXQ_LOCK_ASSERT(cabq);
568
569         if (TAILQ_EMPTY(&cabq->axq_q))
570                 return;
571         bf = TAILQ_FIRST(&cabq->axq_q);
572         bf_last = TAILQ_LAST(&cabq->axq_q, axq_q_s);
573
574         /*
575          * This is a dirty, dirty hack to push the contents of
576          * the cabq staging queue into the FIFO.
577          *
578          * This ideally should live in the EDMA code file
579          * and only push things into the CABQ if there's a FIFO
580          * slot.
581          *
582          * We can't treat this like a normal TX queue because
583          * in the case of multi-VAP traffic, we may have to flush
584          * the CABQ each new (staggered) beacon that goes out.
585          * But for non-staggered beacons, we could in theory
586          * handle multicast traffic for all VAPs in one FIFO
587          * push.  Just keep all of this in mind if you're wondering
588          * how to correctly/better handle multi-VAP CABQ traffic
589          * with EDMA.
590          */
591
592         /*
593          * Is the CABQ FIFO free? If not, complain loudly and
594          * don't queue anything.  Maybe we'll flush the CABQ
595          * traffic, maybe we won't.  But that'll happen next
596          * beacon interval.
597          */
598         if (cabq->axq_fifo_depth >= HAL_TXFIFO_DEPTH) {
599                 device_printf(sc->sc_dev,
600                     "%s: Q%d: CAB FIFO queue=%d?\n",
601                     __func__,
602                     cabq->axq_qnum,
603                     cabq->axq_fifo_depth);
604                 return;
605         }
606
607         /*
608          * Ok, so here's the gymnastics reqiured to make this
609          * all sensible.
610          */
611
612         /*
613          * Tag the first/last buffer appropriately.
614          */
615         bf->bf_flags |= ATH_BUF_FIFOPTR;
616         bf_last->bf_flags |= ATH_BUF_FIFOEND;
617
618 #if 0
619         i = 0;
620         TAILQ_FOREACH(bfi, &cabq->axq_q, bf_list) {
621                 ath_printtxbuf(sc, bf, cabq->axq_qnum, i, 0);
622                 i++;
623         }
624 #endif
625
626         /*
627          * We now need to push this set of frames onto the tail
628          * of the FIFO queue.  We don't adjust the aggregate
629          * count, only the queue depth counter(s).
630          * We also need to blank the link pointer now.
631          */
632         TAILQ_CONCAT(&cabq->fifo.axq_q, &cabq->axq_q, bf_list);
633         cabq->axq_link = NULL;
634         cabq->fifo.axq_depth += cabq->axq_depth;
635         cabq->axq_depth = 0;
636
637         /* Bump FIFO queue */
638         cabq->axq_fifo_depth++;
639
640         /* Push the first entry into the hardware */
641         ath_hal_puttxbuf(sc->sc_ah, cabq->axq_qnum, bf->bf_daddr);
642         cabq->axq_flags |= ATH_TXQ_PUTRUNNING;
643
644         /* NB: gated by beacon so safe to start here */
645         ath_hal_txstart(sc->sc_ah, cabq->axq_qnum);
646
647 }
648
649 static void
650 ath_beacon_cabq_start_legacy(struct ath_softc *sc)
651 {
652         struct ath_buf *bf;
653         struct ath_txq *cabq = sc->sc_cabq;
654
655         ATH_TXQ_LOCK_ASSERT(cabq);
656         if (TAILQ_EMPTY(&cabq->axq_q))
657                 return;
658         bf = TAILQ_FIRST(&cabq->axq_q);
659
660         /* Push the first entry into the hardware */
661         ath_hal_puttxbuf(sc->sc_ah, cabq->axq_qnum, bf->bf_daddr);
662         cabq->axq_flags |= ATH_TXQ_PUTRUNNING;
663
664         /* NB: gated by beacon so safe to start here */
665         ath_hal_txstart(sc->sc_ah, cabq->axq_qnum);
666 }
667
668 /*
669  * Start CABQ transmission - this assumes that all frames are prepped
670  * and ready in the CABQ.
671  */
672 void
673 ath_beacon_cabq_start(struct ath_softc *sc)
674 {
675         struct ath_txq *cabq = sc->sc_cabq;
676
677         ATH_TXQ_LOCK_ASSERT(cabq);
678
679         if (TAILQ_EMPTY(&cabq->axq_q))
680                 return;
681
682         if (sc->sc_isedma)
683                 ath_beacon_cabq_start_edma(sc);
684         else
685                 ath_beacon_cabq_start_legacy(sc);
686 }
687
688 struct ath_buf *
689 ath_beacon_generate(struct ath_softc *sc, struct ieee80211vap *vap)
690 {
691         struct ath_vap *avp = ATH_VAP(vap);
692         struct ath_txq *cabq = sc->sc_cabq;
693         struct ath_buf *bf;
694         struct mbuf *m;
695         int nmcastq, error;
696
697         KASSERT(vap->iv_state >= IEEE80211_S_RUN,
698             ("not running, state %d", vap->iv_state));
699         KASSERT(avp->av_bcbuf != NULL, ("no beacon buffer"));
700
701         /*
702          * Update dynamic beacon contents.  If this returns
703          * non-zero then we need to remap the memory because
704          * the beacon frame changed size (probably because
705          * of the TIM bitmap).
706          */
707         bf = avp->av_bcbuf;
708         m = bf->bf_m;
709         /* XXX lock mcastq? */
710         nmcastq = avp->av_mcastq.axq_depth;
711
712         if (ieee80211_beacon_update(bf->bf_node, &avp->av_boff, m, nmcastq)) {
713                 /* XXX too conservative? */
714                 bus_dmamap_unload(sc->sc_dmat, bf->bf_dmamap);
715                 error = bus_dmamap_load_mbuf_sg(sc->sc_dmat, bf->bf_dmamap, m,
716                                              bf->bf_segs, &bf->bf_nseg,
717                                              BUS_DMA_NOWAIT);
718                 if (error != 0) {
719                         if_printf(vap->iv_ifp,
720                             "%s: bus_dmamap_load_mbuf_sg failed, error %u\n",
721                             __func__, error);
722                         return NULL;
723                 }
724         }
725         if ((avp->av_boff.bo_tim[4] & 1) && cabq->axq_depth) {
726                 DPRINTF(sc, ATH_DEBUG_BEACON,
727                     "%s: cabq did not drain, mcastq %u cabq %u\n",
728                     __func__, nmcastq, cabq->axq_depth);
729                 sc->sc_stats.ast_cabq_busy++;
730                 if (sc->sc_nvaps > 1 && sc->sc_stagbeacons) {
731                         /*
732                          * CABQ traffic from a previous vap is still pending.
733                          * We must drain the q before this beacon frame goes
734                          * out as otherwise this vap's stations will get cab
735                          * frames from a different vap.
736                          * XXX could be slow causing us to miss DBA
737                          */
738                         /*
739                          * XXX TODO: this doesn't stop CABQ DMA - it assumes
740                          * that since we're about to transmit a beacon, we've
741                          * already stopped transmitting on the CABQ.  But this
742                          * doesn't at all mean that the CABQ DMA QCU will
743                          * accept a new TXDP!  So what, should we do a DMA
744                          * stop? What if it fails?
745                          *
746                          * More thought is required here.
747                          */
748                         ath_tx_draintxq(sc, cabq);
749                 }
750         }
751         ath_beacon_setup(sc, bf);
752         bus_dmamap_sync(sc->sc_dmat, bf->bf_dmamap, BUS_DMASYNC_PREWRITE);
753
754         /*
755          * Enable the CAB queue before the beacon queue to
756          * insure cab frames are triggered by this beacon.
757          */
758         if (avp->av_boff.bo_tim[4] & 1) {
759
760                 /* NB: only at DTIM */
761                 ATH_TXQ_LOCK(&avp->av_mcastq);
762                 if (nmcastq) {
763                         struct ath_buf *bfm, *bfc_last;
764
765                         /*
766                          * Move frames from the s/w mcast q to the h/w cab q.
767                          *
768                          * XXX TODO: if we chain together multiple VAPs
769                          * worth of CABQ traffic, should we keep the
770                          * MORE data bit set on the last frame of each
771                          * intermediary VAP (ie, only clear the MORE
772                          * bit of the last frame on the last vap?)
773                          */
774                         bfm = TAILQ_FIRST(&avp->av_mcastq.axq_q);
775                         ATH_TXQ_LOCK(cabq);
776
777                         /*
778                          * If there's already a frame on the CABQ, we
779                          * need to link to the end of the last frame.
780                          * We can't use axq_link here because
781                          * EDMA descriptors require some recalculation
782                          * (checksum) to occur.
783                          */
784                         bfc_last = ATH_TXQ_LAST(cabq, axq_q_s);
785                         if (bfc_last != NULL) {
786                                 ath_hal_settxdesclink(sc->sc_ah,
787                                     bfc_last->bf_lastds,
788                                     bfm->bf_daddr);
789                         }
790                         ath_txqmove(cabq, &avp->av_mcastq);
791                         ATH_TXQ_UNLOCK(cabq);
792                         /*
793                          * XXX not entirely accurate, in case a mcast
794                          * queue frame arrived before we grabbed the TX
795                          * lock.
796                          */
797                         sc->sc_stats.ast_cabq_xmit += nmcastq;
798                 }
799                 ATH_TXQ_UNLOCK(&avp->av_mcastq);
800         }
801         return bf;
802 }
803
804 void
805 ath_beacon_start_adhoc(struct ath_softc *sc, struct ieee80211vap *vap)
806 {
807         struct ath_vap *avp = ATH_VAP(vap);
808         struct ath_hal *ah = sc->sc_ah;
809         struct ath_buf *bf;
810         struct mbuf *m;
811         int error;
812
813         KASSERT(avp->av_bcbuf != NULL, ("no beacon buffer"));
814
815         /*
816          * Update dynamic beacon contents.  If this returns
817          * non-zero then we need to remap the memory because
818          * the beacon frame changed size (probably because
819          * of the TIM bitmap).
820          */
821         bf = avp->av_bcbuf;
822         m = bf->bf_m;
823         if (ieee80211_beacon_update(bf->bf_node, &avp->av_boff, m, 0)) {
824                 /* XXX too conservative? */
825                 bus_dmamap_unload(sc->sc_dmat, bf->bf_dmamap);
826                 error = bus_dmamap_load_mbuf_sg(sc->sc_dmat, bf->bf_dmamap, m,
827                                              bf->bf_segs, &bf->bf_nseg,
828                                              BUS_DMA_NOWAIT);
829                 if (error != 0) {
830                         if_printf(vap->iv_ifp,
831                             "%s: bus_dmamap_load_mbuf_sg failed, error %u\n",
832                             __func__, error);
833                         return;
834                 }
835         }
836         ath_beacon_setup(sc, bf);
837         bus_dmamap_sync(sc->sc_dmat, bf->bf_dmamap, BUS_DMASYNC_PREWRITE);
838
839         /* NB: caller is known to have already stopped tx dma */
840         ath_hal_puttxbuf(ah, sc->sc_bhalq, bf->bf_daddr);
841         ath_hal_txstart(ah, sc->sc_bhalq);
842 }
843
844 /*
845  * Reclaim beacon resources and return buffer to the pool.
846  */
847 void
848 ath_beacon_return(struct ath_softc *sc, struct ath_buf *bf)
849 {
850
851         DPRINTF(sc, ATH_DEBUG_NODE, "%s: free bf=%p, bf_m=%p, bf_node=%p\n",
852             __func__, bf, bf->bf_m, bf->bf_node);
853         if (bf->bf_m != NULL) {
854                 bus_dmamap_unload(sc->sc_dmat, bf->bf_dmamap);
855                 m_freem(bf->bf_m);
856                 bf->bf_m = NULL;
857         }
858         if (bf->bf_node != NULL) {
859                 ieee80211_free_node(bf->bf_node);
860                 bf->bf_node = NULL;
861         }
862         TAILQ_INSERT_TAIL(&sc->sc_bbuf, bf, bf_list);
863 }
864
865 /*
866  * Reclaim beacon resources.
867  */
868 void
869 ath_beacon_free(struct ath_softc *sc)
870 {
871         struct ath_buf *bf;
872
873         TAILQ_FOREACH(bf, &sc->sc_bbuf, bf_list) {
874                 DPRINTF(sc, ATH_DEBUG_NODE,
875                     "%s: free bf=%p, bf_m=%p, bf_node=%p\n",
876                         __func__, bf, bf->bf_m, bf->bf_node);
877                 if (bf->bf_m != NULL) {
878                         bus_dmamap_unload(sc->sc_dmat, bf->bf_dmamap);
879                         m_freem(bf->bf_m);
880                         bf->bf_m = NULL;
881                 }
882                 if (bf->bf_node != NULL) {
883                         ieee80211_free_node(bf->bf_node);
884                         bf->bf_node = NULL;
885                 }
886         }
887 }
888
889 /*
890  * Configure the beacon and sleep timers.
891  *
892  * When operating as an AP this resets the TSF and sets
893  * up the hardware to notify us when we need to issue beacons.
894  *
895  * When operating in station mode this sets up the beacon
896  * timers according to the timestamp of the last received
897  * beacon and the current TSF, configures PCF and DTIM
898  * handling, programs the sleep registers so the hardware
899  * will wakeup in time to receive beacons, and configures
900  * the beacon miss handling so we'll receive a BMISS
901  * interrupt when we stop seeing beacons from the AP
902  * we've associated with.
903  */
904 void
905 ath_beacon_config(struct ath_softc *sc, struct ieee80211vap *vap)
906 {
907 #define TSF_TO_TU(_h,_l) \
908         ((((u_int32_t)(_h)) << 22) | (((u_int32_t)(_l)) >> 10))
909 #define FUDGE   2
910         struct ath_hal *ah = sc->sc_ah;
911         struct ieee80211com *ic = sc->sc_ifp->if_l2com;
912         struct ieee80211_node *ni;
913         u_int32_t nexttbtt, intval, tsftu;
914         u_int32_t nexttbtt_u8, intval_u8;
915         u_int64_t tsf;
916
917         if (vap == NULL)
918                 vap = TAILQ_FIRST(&ic->ic_vaps);        /* XXX */
919         /*
920          * Just ensure that we aren't being called when the last
921          * VAP is destroyed.
922          */
923         if (vap == NULL) {
924                 device_printf(sc->sc_dev, "%s: called with no VAPs\n",
925                     __func__);
926                 return;
927         }
928
929         ni = ieee80211_ref_node(vap->iv_bss);
930
931         /* extract tstamp from last beacon and convert to TU */
932         nexttbtt = TSF_TO_TU(LE_READ_4(ni->ni_tstamp.data + 4),
933                              LE_READ_4(ni->ni_tstamp.data));
934         if (ic->ic_opmode == IEEE80211_M_HOSTAP ||
935             ic->ic_opmode == IEEE80211_M_MBSS) {
936                 /*
937                  * For multi-bss ap/mesh support beacons are either staggered
938                  * evenly over N slots or burst together.  For the former
939                  * arrange for the SWBA to be delivered for each slot.
940                  * Slots that are not occupied will generate nothing.
941                  */
942                 /* NB: the beacon interval is kept internally in TU's */
943                 intval = ni->ni_intval & HAL_BEACON_PERIOD;
944                 if (sc->sc_stagbeacons)
945                         intval /= ATH_BCBUF;
946         } else {
947                 /* NB: the beacon interval is kept internally in TU's */
948                 intval = ni->ni_intval & HAL_BEACON_PERIOD;
949         }
950         if (nexttbtt == 0)              /* e.g. for ap mode */
951                 nexttbtt = intval;
952         else if (intval)                /* NB: can be 0 for monitor mode */
953                 nexttbtt = roundup(nexttbtt, intval);
954         DPRINTF(sc, ATH_DEBUG_BEACON, "%s: nexttbtt %u intval %u (%u)\n",
955                 __func__, nexttbtt, intval, ni->ni_intval);
956         if (ic->ic_opmode == IEEE80211_M_STA && !sc->sc_swbmiss) {
957                 HAL_BEACON_STATE bs;
958                 int dtimperiod, dtimcount;
959                 int cfpperiod, cfpcount;
960
961                 /*
962                  * Setup dtim and cfp parameters according to
963                  * last beacon we received (which may be none).
964                  */
965                 dtimperiod = ni->ni_dtim_period;
966                 if (dtimperiod <= 0)            /* NB: 0 if not known */
967                         dtimperiod = 1;
968                 dtimcount = ni->ni_dtim_count;
969                 if (dtimcount >= dtimperiod)    /* NB: sanity check */
970                         dtimcount = 0;          /* XXX? */
971                 cfpperiod = 1;                  /* NB: no PCF support yet */
972                 cfpcount = 0;
973                 /*
974                  * Pull nexttbtt forward to reflect the current
975                  * TSF and calculate dtim+cfp state for the result.
976                  */
977                 tsf = ath_hal_gettsf64(ah);
978                 tsftu = TSF_TO_TU(tsf>>32, tsf) + FUDGE;
979                 do {
980                         nexttbtt += intval;
981                         if (--dtimcount < 0) {
982                                 dtimcount = dtimperiod - 1;
983                                 if (--cfpcount < 0)
984                                         cfpcount = cfpperiod - 1;
985                         }
986                 } while (nexttbtt < tsftu);
987                 memset(&bs, 0, sizeof(bs));
988                 bs.bs_intval = intval;
989                 bs.bs_nexttbtt = nexttbtt;
990                 bs.bs_dtimperiod = dtimperiod*intval;
991                 bs.bs_nextdtim = bs.bs_nexttbtt + dtimcount*intval;
992                 bs.bs_cfpperiod = cfpperiod*bs.bs_dtimperiod;
993                 bs.bs_cfpnext = bs.bs_nextdtim + cfpcount*bs.bs_dtimperiod;
994                 bs.bs_cfpmaxduration = 0;
995 #if 0
996                 /*
997                  * The 802.11 layer records the offset to the DTIM
998                  * bitmap while receiving beacons; use it here to
999                  * enable h/w detection of our AID being marked in
1000                  * the bitmap vector (to indicate frames for us are
1001                  * pending at the AP).
1002                  * XXX do DTIM handling in s/w to WAR old h/w bugs
1003                  * XXX enable based on h/w rev for newer chips
1004                  */
1005                 bs.bs_timoffset = ni->ni_timoff;
1006 #endif
1007                 /*
1008                  * Calculate the number of consecutive beacons to miss
1009                  * before taking a BMISS interrupt.
1010                  * Note that we clamp the result to at most 10 beacons.
1011                  */
1012                 bs.bs_bmissthreshold = vap->iv_bmissthreshold;
1013                 if (bs.bs_bmissthreshold > 10)
1014                         bs.bs_bmissthreshold = 10;
1015                 else if (bs.bs_bmissthreshold <= 0)
1016                         bs.bs_bmissthreshold = 1;
1017
1018                 /*
1019                  * Calculate sleep duration.  The configuration is
1020                  * given in ms.  We insure a multiple of the beacon
1021                  * period is used.  Also, if the sleep duration is
1022                  * greater than the DTIM period then it makes senses
1023                  * to make it a multiple of that.
1024                  *
1025                  * XXX fixed at 100ms
1026                  */
1027                 bs.bs_sleepduration =
1028                         roundup(IEEE80211_MS_TO_TU(100), bs.bs_intval);
1029                 if (bs.bs_sleepduration > bs.bs_dtimperiod)
1030                         bs.bs_sleepduration = roundup(bs.bs_sleepduration, bs.bs_dtimperiod);
1031
1032                 DPRINTF(sc, ATH_DEBUG_BEACON,
1033                         "%s: tsf %ju tsf:tu %u intval %u nexttbtt %u dtim %u nextdtim %u bmiss %u sleep %u cfp:period %u maxdur %u next %u timoffset %u\n"
1034                         , __func__
1035                         , tsf, tsftu
1036                         , bs.bs_intval
1037                         , bs.bs_nexttbtt
1038                         , bs.bs_dtimperiod
1039                         , bs.bs_nextdtim
1040                         , bs.bs_bmissthreshold
1041                         , bs.bs_sleepduration
1042                         , bs.bs_cfpperiod
1043                         , bs.bs_cfpmaxduration
1044                         , bs.bs_cfpnext
1045                         , bs.bs_timoffset
1046                 );
1047                 ath_hal_intrset(ah, 0);
1048                 ath_hal_beacontimers(ah, &bs);
1049                 sc->sc_imask |= HAL_INT_BMISS;
1050                 ath_hal_intrset(ah, sc->sc_imask);
1051         } else {
1052                 ath_hal_intrset(ah, 0);
1053                 if (nexttbtt == intval)
1054                         intval |= HAL_BEACON_RESET_TSF;
1055                 if (ic->ic_opmode == IEEE80211_M_IBSS) {
1056                         /*
1057                          * In IBSS mode enable the beacon timers but only
1058                          * enable SWBA interrupts if we need to manually
1059                          * prepare beacon frames.  Otherwise we use a
1060                          * self-linked tx descriptor and let the hardware
1061                          * deal with things.
1062                          */
1063                         intval |= HAL_BEACON_ENA;
1064                         if (!sc->sc_hasveol)
1065                                 sc->sc_imask |= HAL_INT_SWBA;
1066                         if ((intval & HAL_BEACON_RESET_TSF) == 0) {
1067                                 /*
1068                                  * Pull nexttbtt forward to reflect
1069                                  * the current TSF.
1070                                  */
1071                                 tsf = ath_hal_gettsf64(ah);
1072                                 tsftu = TSF_TO_TU(tsf>>32, tsf) + FUDGE;
1073                                 do {
1074                                         nexttbtt += intval;
1075                                 } while (nexttbtt < tsftu);
1076                         }
1077                         ath_beaconq_config(sc);
1078                 } else if (ic->ic_opmode == IEEE80211_M_HOSTAP ||
1079                     ic->ic_opmode == IEEE80211_M_MBSS) {
1080                         /*
1081                          * In AP/mesh mode we enable the beacon timers
1082                          * and SWBA interrupts to prepare beacon frames.
1083                          */
1084                         intval |= HAL_BEACON_ENA;
1085                         sc->sc_imask |= HAL_INT_SWBA;   /* beacon prepare */
1086                         ath_beaconq_config(sc);
1087                 }
1088
1089                 /*
1090                  * Now dirty things because for now, the EDMA HAL has
1091                  * nexttbtt and intval is TU/8.
1092                  */
1093                 if (sc->sc_isedma) {
1094                         nexttbtt_u8 = (nexttbtt << 3);
1095                         intval_u8 = (intval << 3);
1096                         if (intval & HAL_BEACON_ENA)
1097                                 intval_u8 |= HAL_BEACON_ENA;
1098                         if (intval & HAL_BEACON_RESET_TSF)
1099                                 intval_u8 |= HAL_BEACON_RESET_TSF;
1100                         ath_hal_beaconinit(ah, nexttbtt_u8, intval_u8);
1101                 } else
1102                         ath_hal_beaconinit(ah, nexttbtt, intval);
1103                 sc->sc_bmisscount = 0;
1104                 ath_hal_intrset(ah, sc->sc_imask);
1105                 /*
1106                  * When using a self-linked beacon descriptor in
1107                  * ibss mode load it once here.
1108                  */
1109                 if (ic->ic_opmode == IEEE80211_M_IBSS && sc->sc_hasveol)
1110                         ath_beacon_start_adhoc(sc, vap);
1111         }
1112         sc->sc_syncbeacon = 0;
1113         ieee80211_free_node(ni);
1114 #undef FUDGE
1115 #undef TSF_TO_TU
1116 }