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 (ath9k_is_chanctx_enabled()) { 431 if (sc->sched.beacon_pending) 432 ath_chanctx_event(sc, NULL, 433 ATH_CHANCTX_EVENT_BEACON_SENT); 434 } 435 436 if (ath9k_csa_is_finished(sc, vif)) 437 return; 438 } 439 440 if (!vif || !vif->bss_conf.enable_beacon) 441 return; 442 443 if (ath9k_is_chanctx_enabled()) { 444 ath_chanctx_event(sc, vif, ATH_CHANCTX_EVENT_BEACON_PREPARE); 445 } 446 447 bf = ath9k_beacon_generate(sc->hw, vif); 448 449 if (sc->beacon.bmisscnt != 0) { 450 ath_dbg(common, BSTUCK, "resume beacon xmit after %u misses\n", 451 sc->beacon.bmisscnt); 452 sc->beacon.bmisscnt = 0; 453 } 454 455 /* 456 * Handle slot time change when a non-ERP station joins/leaves 457 * an 11g network. The 802.11 layer notifies us via callback, 458 * we mark updateslot, then wait one beacon before effecting 459 * the change. This gives associated stations at least one 460 * beacon interval to note the state change. 461 * 462 * NB: The slot time change state machine is clocked according 463 * to whether we are bursting or staggering beacons. We 464 * recognize the request to update and record the current 465 * slot then don't transition until that slot is reached 466 * again. If we miss a beacon for that slot then we'll be 467 * slow to transition but we'll be sure at least one beacon 468 * interval has passed. When bursting slot is always left 469 * set to ATH_BCBUF so this check is a noop. 470 */ 471 if (sc->beacon.updateslot == UPDATE) { 472 sc->beacon.updateslot = COMMIT; 473 sc->beacon.slotupdate = slot; 474 } else if (sc->beacon.updateslot == COMMIT && 475 sc->beacon.slotupdate == slot) { 476 ah->slottime = sc->beacon.slottime; 477 ath9k_hw_init_global_settings(ah); 478 sc->beacon.updateslot = OK; 479 } 480 481 if (bf) { 482 ath9k_reset_beacon_status(sc); 483 484 ath_dbg(common, BEACON, 485 "Transmitting beacon for slot: %d\n", slot); 486 487 /* NB: cabq traffic should already be queued and primed */ 488 ath9k_hw_puttxbuf(ah, sc->beacon.beaconq, bf->bf_daddr); 489 490 if (!edma) 491 ath9k_hw_txstart(ah, sc->beacon.beaconq); 492 } 493 } 494 495 /* 496 * Both nexttbtt and intval have to be in usecs. 497 */ 498 static void ath9k_beacon_init(struct ath_softc *sc, u32 nexttbtt, 499 u32 intval, bool reset_tsf) 500 { 501 struct ath_hw *ah = sc->sc_ah; 502 503 ath9k_hw_disable_interrupts(ah); 504 if (reset_tsf) 505 ath9k_hw_reset_tsf(ah); 506 ath9k_beaconq_config(sc); 507 ath9k_hw_beaconinit(ah, nexttbtt, intval); 508 sc->beacon.bmisscnt = 0; 509 ath9k_hw_set_interrupts(ah); 510 ath9k_hw_enable_interrupts(ah); 511 } 512 513 /* 514 * For multi-bss ap support beacons are either staggered evenly over N slots or 515 * burst together. For the former arrange for the SWBA to be delivered for each 516 * slot. Slots that are not occupied will generate nothing. 517 */ 518 static void ath9k_beacon_config_ap(struct ath_softc *sc, 519 struct ath_beacon_config *conf) 520 { 521 struct ath_hw *ah = sc->sc_ah; 522 523 ath9k_cmn_beacon_config_ap(ah, conf, ATH_BCBUF); 524 ath9k_beacon_init(sc, conf->nexttbtt, conf->intval, false); 525 } 526 527 static void ath9k_beacon_config_sta(struct ath_hw *ah, 528 struct ath_beacon_config *conf) 529 { 530 struct ath9k_beacon_state bs; 531 532 if (ath9k_cmn_beacon_config_sta(ah, conf, &bs) == -EPERM) 533 return; 534 535 ath9k_hw_disable_interrupts(ah); 536 ath9k_hw_set_sta_beacon_timers(ah, &bs); 537 ah->imask |= ATH9K_INT_BMISS; 538 539 ath9k_hw_set_interrupts(ah); 540 ath9k_hw_enable_interrupts(ah); 541 } 542 543 static void ath9k_beacon_config_adhoc(struct ath_softc *sc, 544 struct ath_beacon_config *conf) 545 { 546 struct ath_hw *ah = sc->sc_ah; 547 struct ath_common *common = ath9k_hw_common(ah); 548 549 ath9k_reset_beacon_status(sc); 550 551 ath9k_cmn_beacon_config_adhoc(ah, conf); 552 553 ath9k_beacon_init(sc, conf->nexttbtt, conf->intval, conf->ibss_creator); 554 555 /* 556 * Set the global 'beacon has been configured' flag for the 557 * joiner case in IBSS mode. 558 */ 559 if (!conf->ibss_creator && conf->enable_beacon) 560 set_bit(ATH_OP_BEACONS, &common->op_flags); 561 } 562 563 static bool ath9k_allow_beacon_config(struct ath_softc *sc, 564 struct ieee80211_vif *vif) 565 { 566 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 567 568 if (sc->sc_ah->opmode == NL80211_IFTYPE_AP) { 569 if ((vif->type != NL80211_IFTYPE_AP) || 570 (sc->nbcnvifs > 1)) { 571 ath_dbg(common, CONFIG, 572 "An AP interface is already present !\n"); 573 return false; 574 } 575 } 576 577 if (sc->sc_ah->opmode == NL80211_IFTYPE_STATION) { 578 if ((vif->type == NL80211_IFTYPE_STATION) && 579 test_bit(ATH_OP_BEACONS, &common->op_flags) && 580 vif != sc->cur_chan->primary_sta) { 581 ath_dbg(common, CONFIG, 582 "Beacon already configured for a station interface\n"); 583 return false; 584 } 585 } 586 587 return true; 588 } 589 590 static void ath9k_cache_beacon_config(struct ath_softc *sc, 591 struct ath_chanctx *ctx, 592 struct ieee80211_bss_conf *bss_conf) 593 { 594 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 595 struct ath_beacon_config *cur_conf = &ctx->beacon; 596 597 ath_dbg(common, BEACON, 598 "Caching beacon data for BSS: %pM\n", bss_conf->bssid); 599 600 cur_conf->beacon_interval = bss_conf->beacon_int; 601 cur_conf->dtim_period = bss_conf->dtim_period; 602 cur_conf->dtim_count = 1; 603 cur_conf->ibss_creator = bss_conf->ibss_creator; 604 605 /* 606 * It looks like mac80211 may end up using beacon interval of zero in 607 * some cases (at least for mesh point). Avoid getting into an 608 * infinite loop by using a bit safer value instead. To be safe, 609 * do sanity check on beacon interval for all operating modes. 610 */ 611 if (cur_conf->beacon_interval == 0) 612 cur_conf->beacon_interval = 100; 613 614 cur_conf->bmiss_timeout = 615 ATH_DEFAULT_BMISS_LIMIT * cur_conf->beacon_interval; 616 617 /* 618 * We don't parse dtim period from mac80211 during the driver 619 * initialization as it breaks association with hidden-ssid 620 * AP and it causes latency in roaming 621 */ 622 if (cur_conf->dtim_period == 0) 623 cur_conf->dtim_period = 1; 624 625 } 626 627 void ath9k_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif, 628 u32 changed) 629 { 630 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; 631 struct ath_hw *ah = sc->sc_ah; 632 struct ath_common *common = ath9k_hw_common(ah); 633 struct ath_vif *avp = (void *)vif->drv_priv; 634 struct ath_chanctx *ctx = avp->chanctx; 635 struct ath_beacon_config *cur_conf; 636 unsigned long flags; 637 bool skip_beacon = false; 638 639 if (!ctx) 640 return; 641 642 cur_conf = &avp->chanctx->beacon; 643 if (vif->type == NL80211_IFTYPE_AP) 644 ath9k_set_tsfadjust(sc, vif); 645 646 if (!ath9k_allow_beacon_config(sc, vif)) 647 return; 648 649 if (vif->type == NL80211_IFTYPE_STATION) { 650 ath9k_cache_beacon_config(sc, ctx, bss_conf); 651 if (ctx != sc->cur_chan) 652 return; 653 654 ath9k_set_beacon(sc); 655 set_bit(ATH_OP_BEACONS, &common->op_flags); 656 return; 657 } 658 659 /* 660 * Take care of multiple interfaces when 661 * enabling/disabling SWBA. 662 */ 663 if (changed & BSS_CHANGED_BEACON_ENABLED) { 664 if (!bss_conf->enable_beacon && 665 (sc->nbcnvifs <= 1)) { 666 cur_conf->enable_beacon = false; 667 } else if (bss_conf->enable_beacon) { 668 cur_conf->enable_beacon = true; 669 ath9k_cache_beacon_config(sc, ctx, bss_conf); 670 } 671 } 672 673 if (ctx != sc->cur_chan) 674 return; 675 676 /* 677 * Configure the HW beacon registers only when we have a valid 678 * beacon interval. 679 */ 680 if (cur_conf->beacon_interval) { 681 /* 682 * If we are joining an existing IBSS network, start beaconing 683 * only after a TSF-sync has taken place. Ensure that this 684 * happens by setting the appropriate flags. 685 */ 686 if ((changed & BSS_CHANGED_IBSS) && !bss_conf->ibss_creator && 687 bss_conf->enable_beacon) { 688 spin_lock_irqsave(&sc->sc_pm_lock, flags); 689 sc->ps_flags |= PS_BEACON_SYNC | PS_WAIT_FOR_BEACON; 690 spin_unlock_irqrestore(&sc->sc_pm_lock, flags); 691 skip_beacon = true; 692 } else { 693 ath9k_set_beacon(sc); 694 } 695 696 /* 697 * Do not set the ATH_OP_BEACONS flag for IBSS joiner mode 698 * here, it is done in ath9k_beacon_config_adhoc(). 699 */ 700 if (cur_conf->enable_beacon && !skip_beacon) 701 set_bit(ATH_OP_BEACONS, &common->op_flags); 702 else 703 clear_bit(ATH_OP_BEACONS, &common->op_flags); 704 } 705 } 706 707 void ath9k_set_beacon(struct ath_softc *sc) 708 { 709 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 710 struct ath_beacon_config *cur_conf = &sc->cur_chan->beacon; 711 712 switch (sc->sc_ah->opmode) { 713 case NL80211_IFTYPE_AP: 714 case NL80211_IFTYPE_MESH_POINT: 715 ath9k_beacon_config_ap(sc, cur_conf); 716 break; 717 case NL80211_IFTYPE_ADHOC: 718 ath9k_beacon_config_adhoc(sc, cur_conf); 719 break; 720 case NL80211_IFTYPE_STATION: 721 ath9k_beacon_config_sta(sc->sc_ah, cur_conf); 722 break; 723 default: 724 ath_dbg(common, CONFIG, "Unsupported beaconing mode\n"); 725 return; 726 } 727 } 728