Commit | Line | Data |
---|---|---|
f078f209 | 1 | /* |
5b68138e | 2 | * Copyright (c) 2008-2011 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 | ||
b7f080cf | 17 | #include <linux/dma-mapping.h> |
394cf0a1 | 18 | #include "ath9k.h" |
f078f209 | 19 | |
5379c8a2 S |
20 | #define FUDGE 2 |
21 | ||
ba4903f9 FF |
22 | static void ath9k_reset_beacon_status(struct ath_softc *sc) |
23 | { | |
24 | sc->beacon.tx_processed = false; | |
25 | sc->beacon.tx_last = false; | |
26 | } | |
27 | ||
f078f209 | 28 | /* |
f078f209 LR |
29 | * This function will modify certain transmit queue properties depending on |
30 | * the operating mode of the station (AP or AdHoc). Parameters are AIFS | |
31 | * settings and channel width min/max | |
32 | */ | |
7e52c8aa | 33 | static void ath9k_beaconq_config(struct ath_softc *sc) |
f078f209 | 34 | { |
cbe61d8a | 35 | struct ath_hw *ah = sc->sc_ah; |
c46917bb | 36 | struct ath_common *common = ath9k_hw_common(ah); |
94db2936 | 37 | struct ath9k_tx_queue_info qi, qi_be; |
066dae93 | 38 | struct ath_txq *txq; |
f078f209 | 39 | |
b77f483f | 40 | ath9k_hw_get_txq_props(ah, sc->beacon.beaconq, &qi); |
7e52c8aa | 41 | |
2660b81a | 42 | if (sc->sc_ah->opmode == NL80211_IFTYPE_AP) { |
f078f209 LR |
43 | /* Always burst out beacon and CAB traffic. */ |
44 | qi.tqi_aifs = 1; | |
45 | qi.tqi_cwmin = 0; | |
46 | qi.tqi_cwmax = 0; | |
47 | } else { | |
48 | /* Adhoc mode; important thing is to use 2x cwmin. */ | |
066dae93 FF |
49 | txq = sc->tx.txq_map[WME_AC_BE]; |
50 | ath9k_hw_get_txq_props(ah, txq->axq_qnum, &qi_be); | |
94db2936 | 51 | qi.tqi_aifs = qi_be.tqi_aifs; |
d202caff VN |
52 | if (ah->slottime == ATH9K_SLOT_TIME_20) |
53 | qi.tqi_cwmin = 2*qi_be.tqi_cwmin; | |
54 | else | |
55 | qi.tqi_cwmin = 4*qi_be.tqi_cwmin; | |
94db2936 | 56 | qi.tqi_cwmax = qi_be.tqi_cwmax; |
f078f209 LR |
57 | } |
58 | ||
b77f483f | 59 | if (!ath9k_hw_set_txq_props(ah, sc->beacon.beaconq, &qi)) { |
7e52c8aa | 60 | ath_err(common, "Unable to update h/w beacon queue parameters\n"); |
f078f209 | 61 | } else { |
9fc9ab0a | 62 | ath9k_hw_resettxqueue(ah, sc->beacon.beaconq); |
f078f209 LR |
63 | } |
64 | } | |
65 | ||
66 | /* | |
f078f209 | 67 | * Associates the beacon frame buffer with a transmit descriptor. Will set |
dd347f2f FF |
68 | * up rate codes, and channel flags. Beacons are always sent out at the |
69 | * lowest rate, and are not retried. | |
f078f209 | 70 | */ |
fb6e252f | 71 | static void ath9k_beacon_setup(struct ath_softc *sc, struct ieee80211_vif *vif, |
64b84010 | 72 | struct ath_buf *bf, int rateidx) |
f078f209 | 73 | { |
a22be22a | 74 | struct sk_buff *skb = bf->bf_mpdu; |
cbe61d8a | 75 | struct ath_hw *ah = sc->sc_ah; |
43c27613 | 76 | struct ath_common *common = ath9k_hw_common(ah); |
493cf04f | 77 | struct ath_tx_info info; |
545750d3 | 78 | struct ieee80211_supported_band *sband; |
493cf04f | 79 | u8 chainmask = ah->txchainmask; |
545750d3 | 80 | u8 rate = 0; |
f078f209 | 81 | |
545750d3 | 82 | sband = &sc->sbands[common->hw->conf.channel->band]; |
64b84010 | 83 | rate = sband->bitrates[rateidx].hw_value; |
d47a61aa | 84 | if (vif->bss_conf.use_short_preamble) |
64b84010 | 85 | rate |= sband->bitrates[rateidx].hw_value_short; |
9fc9ab0a | 86 | |
493cf04f FF |
87 | memset(&info, 0, sizeof(info)); |
88 | info.pkt_len = skb->len + FCS_LEN; | |
89 | info.type = ATH9K_PKT_TYPE_BEACON; | |
90 | info.txpower = MAX_RATE_POWER; | |
91 | info.keyix = ATH9K_TXKEYIX_INVALID; | |
92 | info.keytype = ATH9K_KEY_TYPE_CLEAR; | |
cd484aeb | 93 | info.flags = ATH9K_TXDESC_NOACK | ATH9K_TXDESC_CLRDMASK; |
493cf04f FF |
94 | |
95 | info.buf_addr[0] = bf->bf_buf_addr; | |
96 | info.buf_len[0] = roundup(skb->len, 4); | |
97 | ||
98 | info.is_first = true; | |
99 | info.is_last = true; | |
100 | ||
101 | info.qcu = sc->beacon.beaconq; | |
102 | ||
103 | info.rates[0].Tries = 1; | |
104 | info.rates[0].Rate = rate; | |
105 | info.rates[0].ChSel = ath_txchainmask_reduction(sc, chainmask, rate); | |
106 | ||
107 | ath9k_hw_set_txdesc(ah, bf->bf_desc, &info); | |
f078f209 LR |
108 | } |
109 | ||
fb6e252f | 110 | static void ath9k_tx_cabq(struct ieee80211_hw *hw, struct sk_buff *skb) |
28d16708 | 111 | { |
9ac58615 | 112 | struct ath_softc *sc = hw->priv; |
28d16708 FF |
113 | struct ath_common *common = ath9k_hw_common(sc->sc_ah); |
114 | struct ath_tx_control txctl; | |
115 | ||
116 | memset(&txctl, 0, sizeof(struct ath_tx_control)); | |
117 | txctl.txq = sc->beacon.cabq; | |
118 | ||
d2182b69 | 119 | ath_dbg(common, XMIT, "transmitting CABQ packet, skb: %p\n", skb); |
28d16708 FF |
120 | |
121 | if (ath_tx_start(hw, skb, &txctl) != 0) { | |
d2182b69 | 122 | ath_dbg(common, XMIT, "CABQ TX failed\n"); |
249ee722 | 123 | ieee80211_free_txskb(hw, skb); |
28d16708 FF |
124 | } |
125 | } | |
126 | ||
fb6e252f SM |
127 | static struct ath_buf *ath9k_beacon_generate(struct ieee80211_hw *hw, |
128 | struct ieee80211_vif *vif) | |
f078f209 | 129 | { |
9ac58615 | 130 | struct ath_softc *sc = hw->priv; |
c46917bb | 131 | struct ath_common *common = ath9k_hw_common(sc->sc_ah); |
f078f209 | 132 | struct ath_buf *bf; |
aa45fe96 | 133 | struct ath_vif *avp = (void *)vif->drv_priv; |
f078f209 | 134 | struct sk_buff *skb; |
aa45fe96 | 135 | struct ath_txq *cabq = sc->beacon.cabq; |
147583c0 | 136 | struct ieee80211_tx_info *info; |
fb6e252f | 137 | struct ieee80211_mgmt *mgmt_hdr; |
980b24da S |
138 | int cabq_depth; |
139 | ||
aa45fe96 | 140 | if (avp->av_bcbuf == NULL) |
f078f209 | 141 | return NULL; |
980b24da | 142 | |
f078f209 | 143 | bf = avp->av_bcbuf; |
a22be22a | 144 | skb = bf->bf_mpdu; |
a8fff50e | 145 | if (skb) { |
c1739eb3 | 146 | dma_unmap_single(sc->dev, bf->bf_buf_addr, |
9fc9ab0a | 147 | skb->len, DMA_TO_DEVICE); |
3fbb9d95 | 148 | dev_kfree_skb_any(skb); |
6cf9e995 | 149 | bf->bf_buf_addr = 0; |
a8fff50e | 150 | } |
f078f209 | 151 | |
c52f33d0 | 152 | skb = ieee80211_beacon_get(hw, vif); |
a8fff50e JM |
153 | if (skb == NULL) |
154 | return NULL; | |
fb6e252f SM |
155 | |
156 | bf->bf_mpdu = skb; | |
157 | ||
158 | mgmt_hdr = (struct ieee80211_mgmt *)skb->data; | |
159 | mgmt_hdr->u.beacon.timestamp = avp->tsf_adjust; | |
980b24da | 160 | |
147583c0 JM |
161 | info = IEEE80211_SKB_CB(skb); |
162 | if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) { | |
163 | /* | |
164 | * TODO: make sure the seq# gets assigned properly (vs. other | |
165 | * TX frames) | |
166 | */ | |
980b24da | 167 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; |
b77f483f | 168 | sc->tx.seq_no += 0x10; |
147583c0 | 169 | hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG); |
b77f483f | 170 | hdr->seq_ctrl |= cpu_to_le16(sc->tx.seq_no); |
147583c0 | 171 | } |
980b24da | 172 | |
c1739eb3 BG |
173 | bf->bf_buf_addr = dma_map_single(sc->dev, skb->data, |
174 | skb->len, DMA_TO_DEVICE); | |
7da3c55c | 175 | if (unlikely(dma_mapping_error(sc->dev, bf->bf_buf_addr))) { |
f8316df1 LR |
176 | dev_kfree_skb_any(skb); |
177 | bf->bf_mpdu = NULL; | |
6cf9e995 | 178 | bf->bf_buf_addr = 0; |
3800276a | 179 | ath_err(common, "dma_mapping_error on beaconing\n"); |
f8316df1 LR |
180 | return NULL; |
181 | } | |
f078f209 | 182 | |
c52f33d0 | 183 | skb = ieee80211_get_buffered_bc(hw, vif); |
f078f209 | 184 | |
f078f209 LR |
185 | /* |
186 | * if the CABQ traffic from previous DTIM is pending and the current | |
187 | * beacon is also a DTIM. | |
17d7904d S |
188 | * 1) if there is only one vif let the cab traffic continue. |
189 | * 2) if there are more than one vif and we are using staggered | |
f078f209 | 190 | * beacons, then drain the cabq by dropping all the frames in |
17d7904d | 191 | * the cabq so that the current vifs cab traffic can be scheduled. |
f078f209 LR |
192 | */ |
193 | spin_lock_bh(&cabq->axq_lock); | |
194 | cabq_depth = cabq->axq_depth; | |
195 | spin_unlock_bh(&cabq->axq_lock); | |
196 | ||
e022edbd | 197 | if (skb && cabq_depth) { |
17d7904d | 198 | if (sc->nvifs > 1) { |
d2182b69 | 199 | ath_dbg(common, BEACON, |
226afe68 | 200 | "Flushing previous cabq traffic\n"); |
9fc9ab0a | 201 | ath_draintxq(sc, cabq, false); |
f078f209 LR |
202 | } |
203 | } | |
204 | ||
fb6e252f | 205 | ath9k_beacon_setup(sc, vif, bf, info->control.rates[0].idx); |
f078f209 | 206 | |
e022edbd | 207 | while (skb) { |
fb6e252f | 208 | ath9k_tx_cabq(hw, skb); |
c52f33d0 | 209 | skb = ieee80211_get_buffered_bc(hw, vif); |
e022edbd | 210 | } |
f078f209 | 211 | |
f078f209 LR |
212 | return bf; |
213 | } | |
214 | ||
130ef6e9 | 215 | void ath9k_beacon_assign_slot(struct ath_softc *sc, struct ieee80211_vif *vif) |
f078f209 | 216 | { |
c46917bb | 217 | struct ath_common *common = ath9k_hw_common(sc->sc_ah); |
130ef6e9 SM |
218 | struct ath_vif *avp = (void *)vif->drv_priv; |
219 | int slot; | |
f078f209 | 220 | |
130ef6e9 SM |
221 | avp->av_bcbuf = list_first_entry(&sc->beacon.bbuf, struct ath_buf, list); |
222 | list_del(&avp->av_bcbuf->list); | |
f078f209 | 223 | |
130ef6e9 SM |
224 | for (slot = 0; slot < ATH_BCBUF; slot++) { |
225 | if (sc->beacon.bslot[slot] == NULL) { | |
226 | avp->av_bslot = slot; | |
130ef6e9 | 227 | break; |
f078f209 LR |
228 | } |
229 | } | |
230 | ||
130ef6e9 SM |
231 | sc->beacon.bslot[avp->av_bslot] = vif; |
232 | sc->nbcnvifs++; | |
f078f209 | 233 | |
130ef6e9 SM |
234 | ath_dbg(common, CONFIG, "Added interface at beacon slot: %d\n", |
235 | avp->av_bslot); | |
236 | } | |
f078f209 | 237 | |
130ef6e9 SM |
238 | void ath9k_beacon_remove_slot(struct ath_softc *sc, struct ieee80211_vif *vif) |
239 | { | |
240 | struct ath_common *common = ath9k_hw_common(sc->sc_ah); | |
241 | struct ath_vif *avp = (void *)vif->drv_priv; | |
242 | struct ath_buf *bf = avp->av_bcbuf; | |
f078f209 | 243 | |
130ef6e9 SM |
244 | ath_dbg(common, CONFIG, "Removing interface at beacon slot: %d\n", |
245 | avp->av_bslot); | |
f078f209 | 246 | |
130ef6e9 | 247 | tasklet_disable(&sc->bcon_tasklet); |
f078f209 | 248 | |
130ef6e9 SM |
249 | if (bf && bf->bf_mpdu) { |
250 | struct sk_buff *skb = bf->bf_mpdu; | |
251 | dma_unmap_single(sc->dev, bf->bf_buf_addr, | |
252 | skb->len, DMA_TO_DEVICE); | |
f8316df1 LR |
253 | dev_kfree_skb_any(skb); |
254 | bf->bf_mpdu = NULL; | |
6cf9e995 | 255 | bf->bf_buf_addr = 0; |
f8316df1 | 256 | } |
f078f209 | 257 | |
130ef6e9 | 258 | avp->av_bcbuf = NULL; |
130ef6e9 SM |
259 | sc->beacon.bslot[avp->av_bslot] = NULL; |
260 | sc->nbcnvifs--; | |
261 | list_add_tail(&bf->list, &sc->beacon.bbuf); | |
f078f209 | 262 | |
130ef6e9 | 263 | tasklet_enable(&sc->bcon_tasklet); |
f078f209 LR |
264 | } |
265 | ||
fb6e252f SM |
266 | static int ath9k_beacon_choose_slot(struct ath_softc *sc) |
267 | { | |
268 | struct ath_common *common = ath9k_hw_common(sc->sc_ah); | |
269 | struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; | |
270 | u16 intval; | |
271 | u32 tsftu; | |
272 | u64 tsf; | |
273 | int slot; | |
274 | ||
275 | if (sc->sc_ah->opmode != NL80211_IFTYPE_AP) { | |
276 | ath_dbg(common, BEACON, "slot 0, tsf: %llu\n", | |
277 | ath9k_hw_gettsf64(sc->sc_ah)); | |
278 | return 0; | |
279 | } | |
280 | ||
281 | intval = cur_conf->beacon_interval ? : ATH_DEFAULT_BINTVAL; | |
282 | tsf = ath9k_hw_gettsf64(sc->sc_ah); | |
283 | tsf += TU_TO_USEC(sc->sc_ah->config.sw_beacon_response_time); | |
284 | tsftu = TSF_TO_TU((tsf * ATH_BCBUF) >>32, tsf * ATH_BCBUF); | |
285 | slot = (tsftu % (intval * ATH_BCBUF)) / intval; | |
286 | ||
287 | ath_dbg(common, BEACON, "slot: %d tsf: %llu tsftu: %u\n", | |
288 | slot, tsf, tsftu / ATH_BCBUF); | |
289 | ||
290 | return slot; | |
291 | } | |
292 | ||
2f8e82e8 SM |
293 | void ath9k_set_tsfadjust(struct ath_softc *sc, struct ieee80211_vif *vif) |
294 | { | |
295 | struct ath_common *common = ath9k_hw_common(sc->sc_ah); | |
296 | struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; | |
297 | struct ath_vif *avp = (void *)vif->drv_priv; | |
298 | u64 tsfadjust; | |
299 | ||
300 | if (avp->av_bslot == 0) | |
301 | return; | |
302 | ||
303 | tsfadjust = cur_conf->beacon_interval * avp->av_bslot / ATH_BCBUF; | |
304 | avp->tsf_adjust = cpu_to_le64(TU_TO_USEC(tsfadjust)); | |
305 | ||
306 | ath_dbg(common, CONFIG, "tsfadjust is: %llu for bslot: %d\n", | |
307 | (unsigned long long)tsfadjust, avp->av_bslot); | |
308 | } | |
309 | ||
fb6e252f | 310 | void ath9k_beacon_tasklet(unsigned long data) |
f078f209 | 311 | { |
f078f209 | 312 | struct ath_softc *sc = (struct ath_softc *)data; |
cbe61d8a | 313 | struct ath_hw *ah = sc->sc_ah; |
c46917bb | 314 | struct ath_common *common = ath9k_hw_common(ah); |
f078f209 | 315 | struct ath_buf *bf = NULL; |
2c3db3d5 | 316 | struct ieee80211_vif *vif; |
98f0a5eb | 317 | bool edma = !!(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA); |
2c3db3d5 | 318 | int slot; |
f078f209 | 319 | |
124b979b | 320 | if (test_bit(SC_OP_HW_RESET, &sc->sc_flags)) { |
4e7fb718 RM |
321 | ath_dbg(common, RESET, |
322 | "reset work is pending, skip beaconing now\n"); | |
323 | return; | |
324 | } | |
124b979b | 325 | |
f078f209 LR |
326 | /* |
327 | * Check if the previous beacon has gone out. If | |
328 | * not don't try to post another, skip this period | |
329 | * and wait for the next. Missed beacons indicate | |
330 | * a problem and should not occur. If we miss too | |
331 | * many consecutive beacons reset the device. | |
332 | */ | |
b77f483f S |
333 | if (ath9k_hw_numtxpending(ah, sc->beacon.beaconq) != 0) { |
334 | sc->beacon.bmisscnt++; | |
9546aae0 | 335 | |
b381fa32 FF |
336 | if (!ath9k_hw_check_alive(ah)) |
337 | ieee80211_queue_work(sc->hw, &sc->hw_check_work); | |
338 | ||
c944daf4 | 339 | if (sc->beacon.bmisscnt < BSTUCK_THRESH * sc->nbcnvifs) { |
d2182b69 | 340 | ath_dbg(common, BSTUCK, |
226afe68 JP |
341 | "missed %u consecutive beacons\n", |
342 | sc->beacon.bmisscnt); | |
efff395e | 343 | ath9k_hw_stop_dma_queue(ah, sc->beacon.beaconq); |
87c510fe FF |
344 | if (sc->beacon.bmisscnt > 3) |
345 | ath9k_hw_bstuck_nfcal(ah); | |
b77f483f | 346 | } else if (sc->beacon.bmisscnt >= BSTUCK_THRESH) { |
d2182b69 | 347 | ath_dbg(common, BSTUCK, "beacon is officially stuck\n"); |
4e7fb718 | 348 | sc->beacon.bmisscnt = 0; |
124b979b | 349 | ath9k_queue_reset(sc, RESET_TYPE_BEACON_STUCK); |
f078f209 | 350 | } |
9546aae0 | 351 | |
f078f209 LR |
352 | return; |
353 | } | |
980b24da | 354 | |
fb6e252f SM |
355 | slot = ath9k_beacon_choose_slot(sc); |
356 | vif = sc->beacon.bslot[slot]; | |
980b24da | 357 | |
fb6e252f SM |
358 | if (!vif || !vif->bss_conf.enable_beacon) |
359 | return; | |
980b24da | 360 | |
fb6e252f SM |
361 | bf = ath9k_beacon_generate(sc->hw, vif); |
362 | WARN_ON(!bf); | |
c944daf4 | 363 | |
fb6e252f SM |
364 | if (sc->beacon.bmisscnt != 0) { |
365 | ath_dbg(common, BSTUCK, "resume beacon xmit after %u misses\n", | |
366 | sc->beacon.bmisscnt); | |
367 | sc->beacon.bmisscnt = 0; | |
f078f209 | 368 | } |
9546aae0 | 369 | |
f078f209 LR |
370 | /* |
371 | * Handle slot time change when a non-ERP station joins/leaves | |
372 | * an 11g network. The 802.11 layer notifies us via callback, | |
373 | * we mark updateslot, then wait one beacon before effecting | |
374 | * the change. This gives associated stations at least one | |
375 | * beacon interval to note the state change. | |
376 | * | |
377 | * NB: The slot time change state machine is clocked according | |
378 | * to whether we are bursting or staggering beacons. We | |
379 | * recognize the request to update and record the current | |
380 | * slot then don't transition until that slot is reached | |
381 | * again. If we miss a beacon for that slot then we'll be | |
382 | * slow to transition but we'll be sure at least one beacon | |
383 | * interval has passed. When bursting slot is always left | |
384 | * set to ATH_BCBUF so this check is a noop. | |
385 | */ | |
b77f483f | 386 | if (sc->beacon.updateslot == UPDATE) { |
fb6e252f | 387 | sc->beacon.updateslot = COMMIT; |
b77f483f | 388 | sc->beacon.slotupdate = slot; |
fb6e252f SM |
389 | } else if (sc->beacon.updateslot == COMMIT && |
390 | sc->beacon.slotupdate == slot) { | |
0005baf4 FF |
391 | ah->slottime = sc->beacon.slottime; |
392 | ath9k_hw_init_global_settings(ah); | |
b77f483f | 393 | sc->beacon.updateslot = OK; |
ff37e337 | 394 | } |
fb6e252f SM |
395 | |
396 | if (bf) { | |
397 | ath9k_reset_beacon_status(sc); | |
398 | ||
399 | ath_dbg(common, BEACON, | |
400 | "Transmitting beacon for slot: %d\n", slot); | |
401 | ||
f078f209 | 402 | /* NB: cabq traffic should already be queued and primed */ |
fb6e252f | 403 | ath9k_hw_puttxbuf(ah, sc->beacon.beaconq, bf->bf_daddr); |
98f0a5eb MSS |
404 | |
405 | if (!edma) | |
406 | ath9k_hw_txstart(ah, sc->beacon.beaconq); | |
f078f209 | 407 | } |
f078f209 LR |
408 | } |
409 | ||
ef4ad633 | 410 | static void ath9k_beacon_init(struct ath_softc *sc, u32 nexttbtt, u32 intval) |
21526d57 | 411 | { |
ef4ad633 | 412 | struct ath_hw *ah = sc->sc_ah; |
21526d57 | 413 | |
ef4ad633 SM |
414 | ath9k_hw_disable_interrupts(ah); |
415 | ath9k_hw_reset_tsf(ah); | |
7e52c8aa | 416 | ath9k_beaconq_config(sc); |
ef4ad633 SM |
417 | ath9k_hw_beaconinit(ah, nexttbtt, intval); |
418 | sc->beacon.bmisscnt = 0; | |
419 | ath9k_hw_set_interrupts(ah); | |
420 | ath9k_hw_enable_interrupts(ah); | |
21526d57 LR |
421 | } |
422 | ||
f078f209 | 423 | /* |
5379c8a2 S |
424 | * For multi-bss ap support beacons are either staggered evenly over N slots or |
425 | * burst together. For the former arrange for the SWBA to be delivered for each | |
426 | * slot. Slots that are not occupied will generate nothing. | |
f078f209 | 427 | */ |
ef4ad633 SM |
428 | static void ath9k_beacon_config_ap(struct ath_softc *sc, |
429 | struct ath_beacon_config *conf) | |
f078f209 | 430 | { |
3069168c | 431 | struct ath_hw *ah = sc->sc_ah; |
ef4ad633 | 432 | struct ath_common *common = ath9k_hw_common(ah); |
980b24da | 433 | u32 nexttbtt, intval; |
f078f209 | 434 | |
5379c8a2 | 435 | /* NB: the beacon interval is kept internally in TU's */ |
f29f5c08 | 436 | intval = TU_TO_USEC(conf->beacon_interval); |
ef4ad633 | 437 | intval /= ATH_BCBUF; |
5379c8a2 | 438 | nexttbtt = intval; |
d8728ee9 | 439 | |
ef4ad633 SM |
440 | if (conf->enable_beacon) |
441 | ah->imask |= ATH9K_INT_SWBA; | |
442 | else | |
443 | ah->imask &= ~ATH9K_INT_SWBA; | |
f078f209 | 444 | |
ef4ad633 SM |
445 | ath_dbg(common, BEACON, "AP nexttbtt: %u intval: %u conf_intval: %u\n", |
446 | nexttbtt, intval, conf->beacon_interval); | |
f078f209 | 447 | |
21526d57 | 448 | ath9k_beacon_init(sc, nexttbtt, intval); |
5379c8a2 | 449 | } |
459f5f90 | 450 | |
5379c8a2 S |
451 | /* |
452 | * This sets up the beacon timers according to the timestamp of the last | |
453 | * received beacon and the current TSF, configures PCF and DTIM | |
454 | * handling, programs the sleep registers so the hardware will wakeup in | |
455 | * time to receive beacons, and configures the beacon miss handling so | |
456 | * we'll receive a BMISS interrupt when we stop seeing beacons from the AP | |
457 | * we've associated with. | |
458 | */ | |
ef4ad633 SM |
459 | static void ath9k_beacon_config_sta(struct ath_softc *sc, |
460 | struct ath_beacon_config *conf) | |
5379c8a2 | 461 | { |
3069168c PR |
462 | struct ath_hw *ah = sc->sc_ah; |
463 | struct ath_common *common = ath9k_hw_common(ah); | |
5379c8a2 S |
464 | struct ath9k_beacon_state bs; |
465 | int dtimperiod, dtimcount, sleepduration; | |
466 | int cfpperiod, cfpcount; | |
467 | u32 nexttbtt = 0, intval, tsftu; | |
468 | u64 tsf; | |
267a9012 | 469 | int num_beacons, offset, dtim_dec_count, cfp_dec_count; |
5379c8a2 | 470 | |
1a20034a | 471 | /* No need to configure beacon if we are not associated */ |
6c43c090 | 472 | if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) { |
d2182b69 | 473 | ath_dbg(common, BEACON, |
226afe68 | 474 | "STA is not yet associated..skipping beacon config\n"); |
1a20034a SB |
475 | return; |
476 | } | |
477 | ||
5379c8a2 | 478 | memset(&bs, 0, sizeof(bs)); |
f29f5c08 | 479 | intval = conf->beacon_interval; |
5379c8a2 S |
480 | |
481 | /* | |
482 | * Setup dtim and cfp parameters according to | |
483 | * last beacon we received (which may be none). | |
484 | */ | |
485 | dtimperiod = conf->dtim_period; | |
5379c8a2 S |
486 | dtimcount = conf->dtim_count; |
487 | if (dtimcount >= dtimperiod) /* NB: sanity check */ | |
488 | dtimcount = 0; | |
489 | cfpperiod = 1; /* NB: no PCF support yet */ | |
490 | cfpcount = 0; | |
491 | ||
492 | sleepduration = conf->listen_interval * intval; | |
5379c8a2 S |
493 | |
494 | /* | |
495 | * Pull nexttbtt forward to reflect the current | |
496 | * TSF and calculate dtim+cfp state for the result. | |
497 | */ | |
3069168c | 498 | tsf = ath9k_hw_gettsf64(ah); |
5379c8a2 | 499 | tsftu = TSF_TO_TU(tsf>>32, tsf) + FUDGE; |
267a9012 JM |
500 | |
501 | num_beacons = tsftu / intval + 1; | |
502 | offset = tsftu % intval; | |
503 | nexttbtt = tsftu - offset; | |
504 | if (offset) | |
5379c8a2 | 505 | nexttbtt += intval; |
267a9012 JM |
506 | |
507 | /* DTIM Beacon every dtimperiod Beacon */ | |
508 | dtim_dec_count = num_beacons % dtimperiod; | |
509 | /* CFP every cfpperiod DTIM Beacon */ | |
510 | cfp_dec_count = (num_beacons / dtimperiod) % cfpperiod; | |
511 | if (dtim_dec_count) | |
512 | cfp_dec_count++; | |
513 | ||
514 | dtimcount -= dtim_dec_count; | |
515 | if (dtimcount < 0) | |
516 | dtimcount += dtimperiod; | |
517 | ||
518 | cfpcount -= cfp_dec_count; | |
519 | if (cfpcount < 0) | |
520 | cfpcount += cfpperiod; | |
5379c8a2 S |
521 | |
522 | bs.bs_intval = intval; | |
523 | bs.bs_nexttbtt = nexttbtt; | |
524 | bs.bs_dtimperiod = dtimperiod*intval; | |
525 | bs.bs_nextdtim = bs.bs_nexttbtt + dtimcount*intval; | |
526 | bs.bs_cfpperiod = cfpperiod*bs.bs_dtimperiod; | |
527 | bs.bs_cfpnext = bs.bs_nextdtim + cfpcount*bs.bs_dtimperiod; | |
528 | bs.bs_cfpmaxduration = 0; | |
529 | ||
530 | /* | |
531 | * Calculate the number of consecutive beacons to miss* before taking | |
532 | * a BMISS interrupt. The configuration is specified in TU so we only | |
533 | * need calculate based on the beacon interval. Note that we clamp the | |
534 | * result to at most 15 beacons. | |
535 | */ | |
536 | if (sleepduration > intval) { | |
537 | bs.bs_bmissthreshold = conf->listen_interval * | |
538 | ATH_DEFAULT_BMISS_LIMIT / 2; | |
f078f209 | 539 | } else { |
5379c8a2 S |
540 | bs.bs_bmissthreshold = DIV_ROUND_UP(conf->bmiss_timeout, intval); |
541 | if (bs.bs_bmissthreshold > 15) | |
542 | bs.bs_bmissthreshold = 15; | |
543 | else if (bs.bs_bmissthreshold <= 0) | |
544 | bs.bs_bmissthreshold = 1; | |
f078f209 LR |
545 | } |
546 | ||
5379c8a2 S |
547 | /* |
548 | * Calculate sleep duration. The configuration is given in ms. | |
549 | * We ensure a multiple of the beacon period is used. Also, if the sleep | |
550 | * duration is greater than the DTIM period then it makes senses | |
551 | * to make it a multiple of that. | |
552 | * | |
553 | * XXX fixed at 100ms | |
554 | */ | |
980b24da | 555 | |
5379c8a2 S |
556 | bs.bs_sleepduration = roundup(IEEE80211_MS_TO_TU(100), sleepduration); |
557 | if (bs.bs_sleepduration > bs.bs_dtimperiod) | |
558 | bs.bs_sleepduration = bs.bs_dtimperiod; | |
980b24da | 559 | |
5379c8a2 S |
560 | /* TSF out of range threshold fixed at 1 second */ |
561 | bs.bs_tsfoor_threshold = ATH9K_TSFOOR_THRESHOLD; | |
f078f209 | 562 | |
d2182b69 JP |
563 | ath_dbg(common, BEACON, "tsf: %llu tsftu: %u\n", tsf, tsftu); |
564 | ath_dbg(common, BEACON, | |
226afe68 JP |
565 | "bmiss: %u sleep: %u cfp-period: %u maxdur: %u next: %u\n", |
566 | bs.bs_bmissthreshold, bs.bs_sleepduration, | |
567 | bs.bs_cfpperiod, bs.bs_cfpmaxduration, bs.bs_cfpnext); | |
f078f209 | 568 | |
5379c8a2 | 569 | /* Set the computed STA beacon timers */ |
980b24da | 570 | |
4df3071e | 571 | ath9k_hw_disable_interrupts(ah); |
3069168c PR |
572 | ath9k_hw_set_sta_beacon_timers(ah, &bs); |
573 | ah->imask |= ATH9K_INT_BMISS; | |
deb75188 | 574 | |
72d874c6 | 575 | ath9k_hw_set_interrupts(ah); |
e8fe7336 | 576 | ath9k_hw_enable_interrupts(ah); |
5379c8a2 | 577 | } |
f078f209 | 578 | |
ef4ad633 SM |
579 | static void ath9k_beacon_config_adhoc(struct ath_softc *sc, |
580 | struct ath_beacon_config *conf) | |
5379c8a2 | 581 | { |
3069168c PR |
582 | struct ath_hw *ah = sc->sc_ah; |
583 | struct ath_common *common = ath9k_hw_common(ah); | |
ef4ad633 | 584 | u32 intval, nexttbtt; |
dd347f2f | 585 | |
ba4903f9 FF |
586 | ath9k_reset_beacon_status(sc); |
587 | ||
f29f5c08 | 588 | intval = TU_TO_USEC(conf->beacon_interval); |
ef4ad633 | 589 | nexttbtt = intval; |
f078f209 | 590 | |
ef4ad633 SM |
591 | if (conf->enable_beacon) |
592 | ah->imask |= ATH9K_INT_SWBA; | |
593 | else | |
594 | ah->imask &= ~ATH9K_INT_SWBA; | |
9fc9ab0a | 595 | |
ef4ad633 SM |
596 | ath_dbg(common, BEACON, "IBSS nexttbtt: %u intval: %u conf_intval: %u\n", |
597 | nexttbtt, intval, conf->beacon_interval); | |
9fc9ab0a | 598 | |
21526d57 | 599 | ath9k_beacon_init(sc, nexttbtt, intval); |
f078f209 LR |
600 | } |
601 | ||
ef4ad633 | 602 | bool ath9k_allow_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif) |
f078f209 | 603 | { |
c46917bb | 604 | struct ath_common *common = ath9k_hw_common(sc->sc_ah); |
99e4d43a | 605 | struct ath_vif *avp = (void *)vif->drv_priv; |
5379c8a2 | 606 | |
ef4ad633 SM |
607 | if (sc->sc_ah->opmode == NL80211_IFTYPE_AP) { |
608 | if ((vif->type != NL80211_IFTYPE_AP) || | |
609 | (sc->nbcnvifs > 1)) { | |
610 | ath_dbg(common, CONFIG, | |
611 | "An AP interface is already present !\n"); | |
612 | return false; | |
613 | } | |
99e4d43a | 614 | } |
ef4ad633 SM |
615 | |
616 | if (sc->sc_ah->opmode == NL80211_IFTYPE_STATION) { | |
617 | if ((vif->type == NL80211_IFTYPE_STATION) && | |
618 | test_bit(SC_OP_BEACONS, &sc->sc_flags) && | |
619 | !avp->primary_sta_vif) { | |
620 | ath_dbg(common, CONFIG, | |
621 | "Beacon already configured for a station interface\n"); | |
622 | return false; | |
623 | } | |
ee832d3e | 624 | } |
ef4ad633 | 625 | |
99e4d43a RM |
626 | return true; |
627 | } | |
628 | ||
ef4ad633 SM |
629 | static void ath9k_cache_beacon_config(struct ath_softc *sc, |
630 | struct ieee80211_bss_conf *bss_conf) | |
99e4d43a | 631 | { |
ef4ad633 | 632 | struct ath_common *common = ath9k_hw_common(sc->sc_ah); |
99e4d43a | 633 | struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; |
ee832d3e | 634 | |
ef4ad633 SM |
635 | ath_dbg(common, BEACON, |
636 | "Caching beacon data for BSS: %pM\n", bss_conf->bssid); | |
99e4d43a | 637 | |
99e4d43a RM |
638 | cur_conf->beacon_interval = bss_conf->beacon_int; |
639 | cur_conf->dtim_period = bss_conf->dtim_period; | |
4801416c BG |
640 | cur_conf->listen_interval = 1; |
641 | cur_conf->dtim_count = 1; | |
642 | cur_conf->bmiss_timeout = | |
643 | ATH_DEFAULT_BMISS_LIMIT * cur_conf->beacon_interval; | |
6b96f93e | 644 | |
c4f9f16b VT |
645 | /* |
646 | * It looks like mac80211 may end up using beacon interval of zero in | |
647 | * some cases (at least for mesh point). Avoid getting into an | |
648 | * infinite loop by using a bit safer value instead. To be safe, | |
649 | * do sanity check on beacon interval for all operating modes. | |
650 | */ | |
651 | if (cur_conf->beacon_interval == 0) | |
652 | cur_conf->beacon_interval = 100; | |
6b96f93e | 653 | |
ee832d3e | 654 | /* |
3a2329f2 MSS |
655 | * We don't parse dtim period from mac80211 during the driver |
656 | * initialization as it breaks association with hidden-ssid | |
657 | * AP and it causes latency in roaming | |
ee832d3e MSS |
658 | */ |
659 | if (cur_conf->dtim_period == 0) | |
660 | cur_conf->dtim_period = 1; | |
661 | ||
99e4d43a RM |
662 | } |
663 | ||
ef4ad633 SM |
664 | void ath9k_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif, |
665 | u32 changed) | |
8e22ad32 | 666 | { |
ef4ad633 SM |
667 | struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; |
668 | struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; | |
8e22ad32 | 669 | |
ef4ad633 SM |
670 | if (sc->sc_ah->opmode == NL80211_IFTYPE_STATION) { |
671 | ath9k_cache_beacon_config(sc, bss_conf); | |
672 | ath9k_set_beacon(sc); | |
673 | set_bit(SC_OP_BEACONS, &sc->sc_flags); | |
674 | } else { | |
675 | /* | |
676 | * Take care of multiple interfaces when | |
677 | * enabling/disabling SWBA. | |
678 | */ | |
679 | if (changed & BSS_CHANGED_BEACON_ENABLED) { | |
680 | if (!bss_conf->enable_beacon && | |
681 | (sc->nbcnvifs <= 1)) { | |
682 | cur_conf->enable_beacon = false; | |
683 | } else if (bss_conf->enable_beacon) { | |
684 | cur_conf->enable_beacon = true; | |
685 | ath9k_cache_beacon_config(sc, bss_conf); | |
8e22ad32 RM |
686 | } |
687 | } | |
ef4ad633 SM |
688 | |
689 | if (cur_conf->beacon_interval) { | |
690 | ath9k_set_beacon(sc); | |
691 | ||
692 | if (cur_conf->enable_beacon) | |
693 | set_bit(SC_OP_BEACONS, &sc->sc_flags); | |
694 | else | |
695 | clear_bit(SC_OP_BEACONS, &sc->sc_flags); | |
696 | } | |
8e22ad32 | 697 | } |
8e22ad32 RM |
698 | } |
699 | ||
ef4ad633 | 700 | void ath9k_set_beacon(struct ath_softc *sc) |
99e4d43a RM |
701 | { |
702 | struct ath_common *common = ath9k_hw_common(sc->sc_ah); | |
703 | struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; | |
704 | ||
26cd322b | 705 | switch (sc->sc_ah->opmode) { |
6b96f93e | 706 | case NL80211_IFTYPE_AP: |
ef4ad633 | 707 | ath9k_beacon_config_ap(sc, cur_conf); |
6b96f93e VT |
708 | break; |
709 | case NL80211_IFTYPE_ADHOC: | |
710 | case NL80211_IFTYPE_MESH_POINT: | |
ef4ad633 | 711 | ath9k_beacon_config_adhoc(sc, cur_conf); |
6b96f93e VT |
712 | break; |
713 | case NL80211_IFTYPE_STATION: | |
ef4ad633 | 714 | ath9k_beacon_config_sta(sc, cur_conf); |
6b96f93e VT |
715 | break; |
716 | default: | |
d2182b69 | 717 | ath_dbg(common, CONFIG, "Unsupported beaconing mode\n"); |
6b96f93e VT |
718 | return; |
719 | } | |
014cf3bb | 720 | } |