| 1 | /* |
| 2 | * Copyright (c) 2008-2011 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 | |
| 17 | #include <linux/dma-mapping.h> |
| 18 | #include "ath9k.h" |
| 19 | |
| 20 | #define FUDGE 2 |
| 21 | |
| 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 | |
| 28 | /* |
| 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 | */ |
| 33 | static void ath9k_beaconq_config(struct ath_softc *sc) |
| 34 | { |
| 35 | struct ath_hw *ah = sc->sc_ah; |
| 36 | struct ath_common *common = ath9k_hw_common(ah); |
| 37 | struct ath9k_tx_queue_info qi, qi_be; |
| 38 | struct ath_txq *txq; |
| 39 | |
| 40 | ath9k_hw_get_txq_props(ah, sc->beacon.beaconq, &qi); |
| 41 | |
| 42 | if (sc->sc_ah->opmode == NL80211_IFTYPE_AP || |
| 43 | sc->sc_ah->opmode == NL80211_IFTYPE_MESH_POINT) { |
| 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. */ |
| 50 | txq = sc->tx.txq_map[IEEE80211_AC_BE]; |
| 51 | ath9k_hw_get_txq_props(ah, txq->axq_qnum, &qi_be); |
| 52 | qi.tqi_aifs = qi_be.tqi_aifs; |
| 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; |
| 57 | qi.tqi_cwmax = qi_be.tqi_cwmax; |
| 58 | } |
| 59 | |
| 60 | if (!ath9k_hw_set_txq_props(ah, sc->beacon.beaconq, &qi)) { |
| 61 | ath_err(common, "Unable to update h/w beacon queue parameters\n"); |
| 62 | } else { |
| 63 | ath9k_hw_resettxqueue(ah, sc->beacon.beaconq); |
| 64 | } |
| 65 | } |
| 66 | |
| 67 | /* |
| 68 | * Associates the beacon frame buffer with a transmit descriptor. Will set |
| 69 | * up rate codes, and channel flags. Beacons are always sent out at the |
| 70 | * lowest rate, and are not retried. |
| 71 | */ |
| 72 | static void ath9k_beacon_setup(struct ath_softc *sc, struct ieee80211_vif *vif, |
| 73 | struct ath_buf *bf, int rateidx) |
| 74 | { |
| 75 | struct sk_buff *skb = bf->bf_mpdu; |
| 76 | struct ath_hw *ah = sc->sc_ah; |
| 77 | struct ath_common *common = ath9k_hw_common(ah); |
| 78 | struct ath_tx_info info; |
| 79 | struct ieee80211_supported_band *sband; |
| 80 | u8 chainmask = ah->txchainmask; |
| 81 | u8 rate = 0; |
| 82 | |
| 83 | sband = &common->sbands[sc->cur_chandef.chan->band]; |
| 84 | rate = sband->bitrates[rateidx].hw_value; |
| 85 | if (vif->bss_conf.use_short_preamble) |
| 86 | rate |= sband->bitrates[rateidx].hw_value_short; |
| 87 | |
| 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; |
| 94 | info.flags = ATH9K_TXDESC_NOACK | ATH9K_TXDESC_CLRDMASK; |
| 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); |
| 109 | } |
| 110 | |
| 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; |
| 125 | int noa_len, noa_desc, i = 0; |
| 126 | u8 *hdr; |
| 127 | |
| 128 | if (!avp->offchannel_duration && !avp->periodic_noa_duration) |
| 129 | return; |
| 130 | |
| 131 | noa_desc = !!avp->offchannel_duration + !!avp->periodic_noa_duration; |
| 132 | noa_len = 2 + sizeof(struct ieee80211_p2p_noa_desc) * noa_desc; |
| 133 | |
| 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; |
| 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 | } |
| 158 | } |
| 159 | |
| 160 | static struct ath_buf *ath9k_beacon_generate(struct ieee80211_hw *hw, |
| 161 | struct ieee80211_vif *vif) |
| 162 | { |
| 163 | struct ath_softc *sc = hw->priv; |
| 164 | struct ath_common *common = ath9k_hw_common(sc->sc_ah); |
| 165 | struct ath_buf *bf; |
| 166 | struct ath_vif *avp = (void *)vif->drv_priv; |
| 167 | struct sk_buff *skb; |
| 168 | struct ath_txq *cabq = sc->beacon.cabq; |
| 169 | struct ieee80211_tx_info *info; |
| 170 | struct ieee80211_mgmt *mgmt_hdr; |
| 171 | int cabq_depth; |
| 172 | |
| 173 | if (avp->av_bcbuf == NULL) |
| 174 | return NULL; |
| 175 | |
| 176 | bf = avp->av_bcbuf; |
| 177 | skb = bf->bf_mpdu; |
| 178 | if (skb) { |
| 179 | dma_unmap_single(sc->dev, bf->bf_buf_addr, |
| 180 | skb->len, DMA_TO_DEVICE); |
| 181 | dev_kfree_skb_any(skb); |
| 182 | bf->bf_buf_addr = 0; |
| 183 | bf->bf_mpdu = NULL; |
| 184 | } |
| 185 | |
| 186 | skb = ieee80211_beacon_get(hw, vif); |
| 187 | if (skb == NULL) |
| 188 | return NULL; |
| 189 | |
| 190 | bf->bf_mpdu = skb; |
| 191 | |
| 192 | mgmt_hdr = (struct ieee80211_mgmt *)skb->data; |
| 193 | mgmt_hdr->u.beacon.timestamp = avp->tsf_adjust; |
| 194 | |
| 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 | */ |
| 201 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; |
| 202 | sc->tx.seq_no += 0x10; |
| 203 | hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG); |
| 204 | hdr->seq_ctrl |= cpu_to_le16(sc->tx.seq_no); |
| 205 | } |
| 206 | |
| 207 | if (vif->p2p) |
| 208 | ath9k_beacon_add_noa(sc, avp, skb); |
| 209 | |
| 210 | bf->bf_buf_addr = dma_map_single(sc->dev, skb->data, |
| 211 | skb->len, DMA_TO_DEVICE); |
| 212 | if (unlikely(dma_mapping_error(sc->dev, bf->bf_buf_addr))) { |
| 213 | dev_kfree_skb_any(skb); |
| 214 | bf->bf_mpdu = NULL; |
| 215 | bf->bf_buf_addr = 0; |
| 216 | ath_err(common, "dma_mapping_error on beaconing\n"); |
| 217 | return NULL; |
| 218 | } |
| 219 | |
| 220 | skb = ieee80211_get_buffered_bc(hw, vif); |
| 221 | |
| 222 | /* |
| 223 | * if the CABQ traffic from previous DTIM is pending and the current |
| 224 | * beacon is also a DTIM. |
| 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 |
| 227 | * beacons, then drain the cabq by dropping all the frames in |
| 228 | * the cabq so that the current vifs cab traffic can be scheduled. |
| 229 | */ |
| 230 | spin_lock_bh(&cabq->axq_lock); |
| 231 | cabq_depth = cabq->axq_depth; |
| 232 | spin_unlock_bh(&cabq->axq_lock); |
| 233 | |
| 234 | if (skb && cabq_depth) { |
| 235 | if (sc->nvifs > 1) { |
| 236 | ath_dbg(common, BEACON, |
| 237 | "Flushing previous cabq traffic\n"); |
| 238 | ath_draintxq(sc, cabq); |
| 239 | } |
| 240 | } |
| 241 | |
| 242 | ath9k_beacon_setup(sc, vif, bf, info->control.rates[0].idx); |
| 243 | |
| 244 | if (skb) |
| 245 | ath_tx_cabq(hw, vif, skb); |
| 246 | |
| 247 | return bf; |
| 248 | } |
| 249 | |
| 250 | void ath9k_beacon_assign_slot(struct ath_softc *sc, struct ieee80211_vif *vif) |
| 251 | { |
| 252 | struct ath_common *common = ath9k_hw_common(sc->sc_ah); |
| 253 | struct ath_vif *avp = (void *)vif->drv_priv; |
| 254 | int slot; |
| 255 | |
| 256 | avp->av_bcbuf = list_first_entry(&sc->beacon.bbuf, struct ath_buf, list); |
| 257 | list_del(&avp->av_bcbuf->list); |
| 258 | |
| 259 | for (slot = 0; slot < ATH_BCBUF; slot++) { |
| 260 | if (sc->beacon.bslot[slot] == NULL) { |
| 261 | avp->av_bslot = slot; |
| 262 | break; |
| 263 | } |
| 264 | } |
| 265 | |
| 266 | sc->beacon.bslot[avp->av_bslot] = vif; |
| 267 | sc->nbcnvifs++; |
| 268 | |
| 269 | ath_dbg(common, CONFIG, "Added interface at beacon slot: %d\n", |
| 270 | avp->av_bslot); |
| 271 | } |
| 272 | |
| 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; |
| 278 | |
| 279 | ath_dbg(common, CONFIG, "Removing interface at beacon slot: %d\n", |
| 280 | avp->av_bslot); |
| 281 | |
| 282 | tasklet_disable(&sc->bcon_tasklet); |
| 283 | |
| 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); |
| 288 | dev_kfree_skb_any(skb); |
| 289 | bf->bf_mpdu = NULL; |
| 290 | bf->bf_buf_addr = 0; |
| 291 | } |
| 292 | |
| 293 | avp->av_bcbuf = NULL; |
| 294 | sc->beacon.bslot[avp->av_bslot] = NULL; |
| 295 | sc->nbcnvifs--; |
| 296 | list_add_tail(&bf->list, &sc->beacon.bbuf); |
| 297 | |
| 298 | tasklet_enable(&sc->bcon_tasklet); |
| 299 | } |
| 300 | |
| 301 | static int ath9k_beacon_choose_slot(struct ath_softc *sc) |
| 302 | { |
| 303 | struct ath_common *common = ath9k_hw_common(sc->sc_ah); |
| 304 | struct ath_beacon_config *cur_conf = &sc->cur_chan->beacon; |
| 305 | u16 intval; |
| 306 | u32 tsftu; |
| 307 | u64 tsf; |
| 308 | int slot; |
| 309 | |
| 310 | if (sc->sc_ah->opmode != NL80211_IFTYPE_AP && |
| 311 | sc->sc_ah->opmode != NL80211_IFTYPE_MESH_POINT) { |
| 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 | |
| 329 | static void ath9k_set_tsfadjust(struct ath_softc *sc, struct ieee80211_vif *vif) |
| 330 | { |
| 331 | struct ath_common *common = ath9k_hw_common(sc->sc_ah); |
| 332 | struct ath_vif *avp = (void *)vif->drv_priv; |
| 333 | struct ath_beacon_config *cur_conf = &avp->chanctx->beacon; |
| 334 | u32 tsfadjust; |
| 335 | |
| 336 | if (avp->av_bslot == 0) |
| 337 | return; |
| 338 | |
| 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); |
| 342 | |
| 343 | ath_dbg(common, CONFIG, "tsfadjust is: %llu for bslot: %d\n", |
| 344 | (unsigned long long)tsfadjust, avp->av_bslot); |
| 345 | } |
| 346 | |
| 347 | bool ath9k_csa_is_finished(struct ath_softc *sc, struct ieee80211_vif *vif) |
| 348 | { |
| 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); |
| 356 | return true; |
| 357 | } |
| 358 | |
| 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 | { |
| 367 | ieee80211_iterate_active_interfaces_atomic(sc->hw, |
| 368 | IEEE80211_IFACE_ITER_NORMAL, |
| 369 | ath9k_csa_update_vif, sc); |
| 370 | } |
| 371 | |
| 372 | void ath9k_beacon_tasklet(unsigned long data) |
| 373 | { |
| 374 | struct ath_softc *sc = (struct ath_softc *)data; |
| 375 | struct ath_hw *ah = sc->sc_ah; |
| 376 | struct ath_common *common = ath9k_hw_common(ah); |
| 377 | struct ath_buf *bf = NULL; |
| 378 | struct ieee80211_vif *vif; |
| 379 | bool edma = !!(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA); |
| 380 | int slot; |
| 381 | |
| 382 | if (test_bit(ATH_OP_HW_RESET, &common->op_flags)) { |
| 383 | ath_dbg(common, RESET, |
| 384 | "reset work is pending, skip beaconing now\n"); |
| 385 | return; |
| 386 | } |
| 387 | |
| 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 | */ |
| 395 | if (ath9k_hw_numtxpending(ah, sc->beacon.beaconq) != 0) { |
| 396 | sc->beacon.bmisscnt++; |
| 397 | |
| 398 | ath9k_hw_check_nav(ah); |
| 399 | |
| 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; |
| 408 | |
| 409 | if (sc->beacon.bmisscnt < BSTUCK_THRESH * sc->nbcnvifs) { |
| 410 | ath_dbg(common, BSTUCK, |
| 411 | "missed %u consecutive beacons\n", |
| 412 | sc->beacon.bmisscnt); |
| 413 | ath9k_hw_stop_dma_queue(ah, sc->beacon.beaconq); |
| 414 | if (sc->beacon.bmisscnt > 3) |
| 415 | ath9k_hw_bstuck_nfcal(ah); |
| 416 | } else if (sc->beacon.bmisscnt >= BSTUCK_THRESH) { |
| 417 | ath_dbg(common, BSTUCK, "beacon is officially stuck\n"); |
| 418 | sc->beacon.bmisscnt = 0; |
| 419 | ath9k_queue_reset(sc, RESET_TYPE_BEACON_STUCK); |
| 420 | } |
| 421 | |
| 422 | return; |
| 423 | } |
| 424 | |
| 425 | slot = ath9k_beacon_choose_slot(sc); |
| 426 | vif = sc->beacon.bslot[slot]; |
| 427 | |
| 428 | /* EDMA devices check that in the tx completion function. */ |
| 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 | } |
| 437 | |
| 438 | if (!vif || !vif->bss_conf.enable_beacon) |
| 439 | return; |
| 440 | |
| 441 | ath_chanctx_event(sc, vif, ATH_CHANCTX_EVENT_BEACON_PREPARE); |
| 442 | bf = ath9k_beacon_generate(sc->hw, vif); |
| 443 | |
| 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; |
| 448 | } |
| 449 | |
| 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 | */ |
| 466 | if (sc->beacon.updateslot == UPDATE) { |
| 467 | sc->beacon.updateslot = COMMIT; |
| 468 | sc->beacon.slotupdate = slot; |
| 469 | } else if (sc->beacon.updateslot == COMMIT && |
| 470 | sc->beacon.slotupdate == slot) { |
| 471 | ah->slottime = sc->beacon.slottime; |
| 472 | ath9k_hw_init_global_settings(ah); |
| 473 | sc->beacon.updateslot = OK; |
| 474 | } |
| 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 | |
| 482 | /* NB: cabq traffic should already be queued and primed */ |
| 483 | ath9k_hw_puttxbuf(ah, sc->beacon.beaconq, bf->bf_daddr); |
| 484 | |
| 485 | if (!edma) |
| 486 | ath9k_hw_txstart(ah, sc->beacon.beaconq); |
| 487 | } |
| 488 | } |
| 489 | |
| 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) |
| 495 | { |
| 496 | struct ath_hw *ah = sc->sc_ah; |
| 497 | |
| 498 | ath9k_hw_disable_interrupts(ah); |
| 499 | if (reset_tsf) |
| 500 | ath9k_hw_reset_tsf(ah); |
| 501 | ath9k_beaconq_config(sc); |
| 502 | ath9k_hw_beaconinit(ah, nexttbtt, intval); |
| 503 | sc->beacon.bmisscnt = 0; |
| 504 | ath9k_hw_set_interrupts(ah); |
| 505 | ath9k_hw_enable_interrupts(ah); |
| 506 | } |
| 507 | |
| 508 | /* |
| 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. |
| 512 | */ |
| 513 | static void ath9k_beacon_config_ap(struct ath_softc *sc, |
| 514 | struct ath_beacon_config *conf) |
| 515 | { |
| 516 | struct ath_hw *ah = sc->sc_ah; |
| 517 | |
| 518 | ath9k_cmn_beacon_config_ap(ah, conf, ATH_BCBUF); |
| 519 | ath9k_beacon_init(sc, conf->nexttbtt, conf->intval, false); |
| 520 | } |
| 521 | |
| 522 | static void ath9k_beacon_config_sta(struct ath_hw *ah, |
| 523 | struct ath_beacon_config *conf) |
| 524 | { |
| 525 | struct ath9k_beacon_state bs; |
| 526 | |
| 527 | if (ath9k_cmn_beacon_config_sta(ah, conf, &bs) == -EPERM) |
| 528 | return; |
| 529 | |
| 530 | ath9k_hw_disable_interrupts(ah); |
| 531 | ath9k_hw_set_sta_beacon_timers(ah, &bs); |
| 532 | ah->imask |= ATH9K_INT_BMISS; |
| 533 | |
| 534 | ath9k_hw_set_interrupts(ah); |
| 535 | ath9k_hw_enable_interrupts(ah); |
| 536 | } |
| 537 | |
| 538 | static void ath9k_beacon_config_adhoc(struct ath_softc *sc, |
| 539 | struct ath_beacon_config *conf) |
| 540 | { |
| 541 | struct ath_hw *ah = sc->sc_ah; |
| 542 | struct ath_common *common = ath9k_hw_common(ah); |
| 543 | |
| 544 | ath9k_reset_beacon_status(sc); |
| 545 | |
| 546 | ath9k_cmn_beacon_config_adhoc(ah, conf); |
| 547 | |
| 548 | ath9k_beacon_init(sc, conf->nexttbtt, conf->intval, conf->ibss_creator); |
| 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) |
| 555 | set_bit(ATH_OP_BEACONS, &common->op_flags); |
| 556 | } |
| 557 | |
| 558 | static bool ath9k_allow_beacon_config(struct ath_softc *sc, |
| 559 | struct ieee80211_vif *vif) |
| 560 | { |
| 561 | struct ath_common *common = ath9k_hw_common(sc->sc_ah); |
| 562 | |
| 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 | } |
| 570 | } |
| 571 | |
| 572 | if (sc->sc_ah->opmode == NL80211_IFTYPE_STATION) { |
| 573 | if ((vif->type == NL80211_IFTYPE_STATION) && |
| 574 | test_bit(ATH_OP_BEACONS, &common->op_flags) && |
| 575 | vif != sc->cur_chan->primary_sta) { |
| 576 | ath_dbg(common, CONFIG, |
| 577 | "Beacon already configured for a station interface\n"); |
| 578 | return false; |
| 579 | } |
| 580 | } |
| 581 | |
| 582 | return true; |
| 583 | } |
| 584 | |
| 585 | static void ath9k_cache_beacon_config(struct ath_softc *sc, |
| 586 | struct ath_chanctx *ctx, |
| 587 | struct ieee80211_bss_conf *bss_conf) |
| 588 | { |
| 589 | struct ath_common *common = ath9k_hw_common(sc->sc_ah); |
| 590 | struct ath_beacon_config *cur_conf = &ctx->beacon; |
| 591 | |
| 592 | ath_dbg(common, BEACON, |
| 593 | "Caching beacon data for BSS: %pM\n", bss_conf->bssid); |
| 594 | |
| 595 | cur_conf->beacon_interval = bss_conf->beacon_int; |
| 596 | cur_conf->dtim_period = bss_conf->dtim_period; |
| 597 | cur_conf->dtim_count = 1; |
| 598 | cur_conf->ibss_creator = bss_conf->ibss_creator; |
| 599 | |
| 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; |
| 608 | |
| 609 | cur_conf->bmiss_timeout = |
| 610 | ATH_DEFAULT_BMISS_LIMIT * cur_conf->beacon_interval; |
| 611 | |
| 612 | /* |
| 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 |
| 616 | */ |
| 617 | if (cur_conf->dtim_period == 0) |
| 618 | cur_conf->dtim_period = 1; |
| 619 | |
| 620 | } |
| 621 | |
| 622 | void ath9k_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif, |
| 623 | u32 changed) |
| 624 | { |
| 625 | struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; |
| 626 | struct ath_hw *ah = sc->sc_ah; |
| 627 | struct ath_common *common = ath9k_hw_common(ah); |
| 628 | struct ath_vif *avp = (void *)vif->drv_priv; |
| 629 | struct ath_chanctx *ctx = avp->chanctx; |
| 630 | struct ath_beacon_config *cur_conf; |
| 631 | unsigned long flags; |
| 632 | bool skip_beacon = false; |
| 633 | |
| 634 | if (!ctx) |
| 635 | return; |
| 636 | |
| 637 | cur_conf = &avp->chanctx->beacon; |
| 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 | |
| 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 | |
| 649 | ath9k_set_beacon(sc); |
| 650 | set_bit(ATH_OP_BEACONS, &common->op_flags); |
| 651 | return; |
| 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; |
| 664 | ath9k_cache_beacon_config(sc, ctx, bss_conf); |
| 665 | } |
| 666 | } |
| 667 | |
| 668 | if (ctx != sc->cur_chan) |
| 669 | return; |
| 670 | |
| 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 { |
| 688 | ath9k_set_beacon(sc); |
| 689 | } |
| 690 | |
| 691 | /* |
| 692 | * Do not set the ATH_OP_BEACONS flag for IBSS joiner mode |
| 693 | * here, it is done in ath9k_beacon_config_adhoc(). |
| 694 | */ |
| 695 | if (cur_conf->enable_beacon && !skip_beacon) |
| 696 | set_bit(ATH_OP_BEACONS, &common->op_flags); |
| 697 | else |
| 698 | clear_bit(ATH_OP_BEACONS, &common->op_flags); |
| 699 | } |
| 700 | } |
| 701 | |
| 702 | void ath9k_set_beacon(struct ath_softc *sc) |
| 703 | { |
| 704 | struct ath_common *common = ath9k_hw_common(sc->sc_ah); |
| 705 | struct ath_beacon_config *cur_conf = &sc->cur_chan->beacon; |
| 706 | |
| 707 | switch (sc->sc_ah->opmode) { |
| 708 | case NL80211_IFTYPE_AP: |
| 709 | case NL80211_IFTYPE_MESH_POINT: |
| 710 | ath9k_beacon_config_ap(sc, cur_conf); |
| 711 | break; |
| 712 | case NL80211_IFTYPE_ADHOC: |
| 713 | ath9k_beacon_config_adhoc(sc, cur_conf); |
| 714 | break; |
| 715 | case NL80211_IFTYPE_STATION: |
| 716 | ath9k_beacon_config_sta(sc->sc_ah, cur_conf); |
| 717 | break; |
| 718 | default: |
| 719 | ath_dbg(common, CONFIG, "Unsupported beaconing mode\n"); |
| 720 | return; |
| 721 | } |
| 722 | } |