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 } 723