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