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