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