beacon.c revision ac56703e0e790509963ee42cddebe706fbd3b74c
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 "ath9k.h" 18 19#define FUDGE 2 20 21/* 22 * This function will modify certain transmit queue properties depending on 23 * the operating mode of the station (AP or AdHoc). Parameters are AIFS 24 * settings and channel width min/max 25*/ 26int ath_beaconq_config(struct ath_softc *sc) 27{ 28 struct ath_hw *ah = sc->sc_ah; 29 struct ath_common *common = ath9k_hw_common(ah); 30 struct ath9k_tx_queue_info qi, qi_be; 31 struct ath_txq *txq; 32 33 ath9k_hw_get_txq_props(ah, sc->beacon.beaconq, &qi); 34 if (sc->sc_ah->opmode == NL80211_IFTYPE_AP) { 35 /* Always burst out beacon and CAB traffic. */ 36 qi.tqi_aifs = 1; 37 qi.tqi_cwmin = 0; 38 qi.tqi_cwmax = 0; 39 } else { 40 /* Adhoc mode; important thing is to use 2x cwmin. */ 41 txq = sc->tx.txq_map[WME_AC_BE]; 42 ath9k_hw_get_txq_props(ah, txq->axq_qnum, &qi_be); 43 qi.tqi_aifs = qi_be.tqi_aifs; 44 qi.tqi_cwmin = 4*qi_be.tqi_cwmin; 45 qi.tqi_cwmax = qi_be.tqi_cwmax; 46 } 47 48 if (!ath9k_hw_set_txq_props(ah, sc->beacon.beaconq, &qi)) { 49 ath_err(common, 50 "Unable to update h/w beacon queue parameters\n"); 51 return 0; 52 } else { 53 ath9k_hw_resettxqueue(ah, sc->beacon.beaconq); 54 return 1; 55 } 56} 57 58/* 59 * Associates the beacon frame buffer with a transmit descriptor. Will set 60 * up rate codes, and channel flags. Beacons are always sent out at the 61 * lowest rate, and are not retried. 62*/ 63static void ath_beacon_setup(struct ath_softc *sc, struct ath_vif *avp, 64 struct ath_buf *bf, int rateidx) 65{ 66 struct sk_buff *skb = bf->bf_mpdu; 67 struct ath_hw *ah = sc->sc_ah; 68 struct ath_common *common = ath9k_hw_common(ah); 69 struct ath_desc *ds; 70 struct ath9k_11n_rate_series series[4]; 71 int flags, ctsrate = 0, ctsduration = 0; 72 struct ieee80211_supported_band *sband; 73 u8 rate = 0; 74 75 ds = bf->bf_desc; 76 flags = ATH9K_TXDESC_NOACK; 77 78 ds->ds_link = 0; 79 80 sband = &sc->sbands[common->hw->conf.channel->band]; 81 rate = sband->bitrates[rateidx].hw_value; 82 if (sc->sc_flags & SC_OP_PREAMBLE_SHORT) 83 rate |= sband->bitrates[rateidx].hw_value_short; 84 85 ath9k_hw_set11n_txdesc(ah, ds, skb->len + FCS_LEN, 86 ATH9K_PKT_TYPE_BEACON, 87 MAX_RATE_POWER, 88 ATH9K_TXKEYIX_INVALID, 89 ATH9K_KEY_TYPE_CLEAR, 90 flags); 91 92 /* NB: beacon's BufLen must be a multiple of 4 bytes */ 93 ath9k_hw_filltxdesc(ah, ds, roundup(skb->len, 4), 94 true, true, ds, bf->bf_buf_addr, 95 sc->beacon.beaconq); 96 97 memset(series, 0, sizeof(struct ath9k_11n_rate_series) * 4); 98 series[0].Tries = 1; 99 series[0].Rate = rate; 100 series[0].ChSel = ath_txchainmask_reduction(sc, 101 common->tx_chainmask, series[0].Rate); 102 series[0].RateFlags = (ctsrate) ? ATH9K_RATESERIES_RTS_CTS : 0; 103 ath9k_hw_set11n_ratescenario(ah, ds, ds, 0, ctsrate, ctsduration, 104 series, 4, 0); 105} 106 107static void ath_tx_cabq(struct ieee80211_hw *hw, struct sk_buff *skb) 108{ 109 struct ath_softc *sc = hw->priv; 110 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 111 struct ath_tx_control txctl; 112 113 memset(&txctl, 0, sizeof(struct ath_tx_control)); 114 txctl.txq = sc->beacon.cabq; 115 116 ath_dbg(common, ATH_DBG_XMIT, 117 "transmitting CABQ packet, skb: %p\n", skb); 118 119 if (ath_tx_start(hw, skb, &txctl) != 0) { 120 ath_dbg(common, ATH_DBG_XMIT, "CABQ TX failed\n"); 121 dev_kfree_skb_any(skb); 122 } 123} 124 125static struct ath_buf *ath_beacon_generate(struct ieee80211_hw *hw, 126 struct ieee80211_vif *vif) 127{ 128 struct ath_softc *sc = hw->priv; 129 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 130 struct ath_buf *bf; 131 struct ath_vif *avp; 132 struct sk_buff *skb; 133 struct ath_txq *cabq; 134 struct ieee80211_tx_info *info; 135 int cabq_depth; 136 137 avp = (void *)vif->drv_priv; 138 cabq = sc->beacon.cabq; 139 140 if ((avp->av_bcbuf == NULL) || !avp->is_bslot_active) 141 return NULL; 142 143 /* Release the old beacon first */ 144 145 bf = avp->av_bcbuf; 146 skb = bf->bf_mpdu; 147 if (skb) { 148 dma_unmap_single(sc->dev, bf->bf_buf_addr, 149 skb->len, DMA_TO_DEVICE); 150 dev_kfree_skb_any(skb); 151 bf->bf_buf_addr = 0; 152 } 153 154 /* Get a new beacon from mac80211 */ 155 156 skb = ieee80211_beacon_get(hw, vif); 157 bf->bf_mpdu = skb; 158 if (skb == NULL) 159 return NULL; 160 ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp = 161 avp->tsf_adjust; 162 163 info = IEEE80211_SKB_CB(skb); 164 if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) { 165 /* 166 * TODO: make sure the seq# gets assigned properly (vs. other 167 * TX frames) 168 */ 169 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 170 sc->tx.seq_no += 0x10; 171 hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG); 172 hdr->seq_ctrl |= cpu_to_le16(sc->tx.seq_no); 173 } 174 175 bf->bf_buf_addr = dma_map_single(sc->dev, skb->data, 176 skb->len, DMA_TO_DEVICE); 177 if (unlikely(dma_mapping_error(sc->dev, bf->bf_buf_addr))) { 178 dev_kfree_skb_any(skb); 179 bf->bf_mpdu = NULL; 180 bf->bf_buf_addr = 0; 181 ath_err(common, "dma_mapping_error on beaconing\n"); 182 return NULL; 183 } 184 185 skb = ieee80211_get_buffered_bc(hw, vif); 186 187 /* 188 * if the CABQ traffic from previous DTIM is pending and the current 189 * beacon is also a DTIM. 190 * 1) if there is only one vif let the cab traffic continue. 191 * 2) if there are more than one vif and we are using staggered 192 * beacons, then drain the cabq by dropping all the frames in 193 * the cabq so that the current vifs cab traffic can be scheduled. 194 */ 195 spin_lock_bh(&cabq->axq_lock); 196 cabq_depth = cabq->axq_depth; 197 spin_unlock_bh(&cabq->axq_lock); 198 199 if (skb && cabq_depth) { 200 if (sc->nvifs > 1) { 201 ath_dbg(common, ATH_DBG_BEACON, 202 "Flushing previous cabq traffic\n"); 203 ath_draintxq(sc, cabq, false); 204 } 205 } 206 207 ath_beacon_setup(sc, avp, bf, info->control.rates[0].idx); 208 209 while (skb) { 210 ath_tx_cabq(hw, skb); 211 skb = ieee80211_get_buffered_bc(hw, vif); 212 } 213 214 return bf; 215} 216 217int ath_beacon_alloc(struct ath_softc *sc, struct ieee80211_vif *vif) 218{ 219 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 220 struct ath_vif *avp; 221 struct ath_buf *bf; 222 struct sk_buff *skb; 223 struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; 224 __le64 tstamp; 225 226 avp = (void *)vif->drv_priv; 227 228 /* Allocate a beacon descriptor if we haven't done so. */ 229 if (!avp->av_bcbuf) { 230 /* Allocate beacon state for hostap/ibss. We know 231 * a buffer is available. */ 232 avp->av_bcbuf = list_first_entry(&sc->beacon.bbuf, 233 struct ath_buf, list); 234 list_del(&avp->av_bcbuf->list); 235 236 if (ath9k_uses_beacons(vif->type)) { 237 int slot; 238 /* 239 * Assign the vif to a beacon xmit slot. As 240 * above, this cannot fail to find one. 241 */ 242 avp->av_bslot = 0; 243 for (slot = 0; slot < ATH_BCBUF; slot++) 244 if (sc->beacon.bslot[slot] == NULL) { 245 avp->av_bslot = slot; 246 avp->is_bslot_active = false; 247 248 /* NB: keep looking for a double slot */ 249 if (slot == 0 || !sc->beacon.bslot[slot-1]) 250 break; 251 } 252 BUG_ON(sc->beacon.bslot[avp->av_bslot] != NULL); 253 sc->beacon.bslot[avp->av_bslot] = vif; 254 sc->nbcnvifs++; 255 } 256 } 257 258 /* release the previous beacon frame, if it already exists. */ 259 bf = avp->av_bcbuf; 260 if (bf->bf_mpdu != NULL) { 261 skb = bf->bf_mpdu; 262 dma_unmap_single(sc->dev, bf->bf_buf_addr, 263 skb->len, DMA_TO_DEVICE); 264 dev_kfree_skb_any(skb); 265 bf->bf_mpdu = NULL; 266 bf->bf_buf_addr = 0; 267 } 268 269 /* NB: the beacon data buffer must be 32-bit aligned. */ 270 skb = ieee80211_beacon_get(sc->hw, vif); 271 if (skb == NULL) 272 return -ENOMEM; 273 274 tstamp = ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp; 275 sc->beacon.bc_tstamp = (u32) le64_to_cpu(tstamp); 276 /* Calculate a TSF adjustment factor required for staggered beacons. */ 277 if (avp->av_bslot > 0) { 278 u64 tsfadjust; 279 int intval; 280 281 intval = cur_conf->beacon_interval ? : ATH_DEFAULT_BINTVAL; 282 283 /* 284 * Calculate the TSF offset for this beacon slot, i.e., the 285 * number of usecs that need to be added to the timestamp field 286 * in Beacon and Probe Response frames. Beacon slot 0 is 287 * processed at the correct offset, so it does not require TSF 288 * adjustment. Other slots are adjusted to get the timestamp 289 * close to the TBTT for the BSS. 290 */ 291 tsfadjust = TU_TO_USEC(intval * avp->av_bslot) / ATH_BCBUF; 292 avp->tsf_adjust = cpu_to_le64(tsfadjust); 293 294 ath_dbg(common, ATH_DBG_BEACON, 295 "stagger beacons, bslot %d intval %u tsfadjust %llu\n", 296 avp->av_bslot, intval, (unsigned long long)tsfadjust); 297 298 ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp = 299 avp->tsf_adjust; 300 } else 301 avp->tsf_adjust = cpu_to_le64(0); 302 303 bf->bf_mpdu = skb; 304 bf->bf_buf_addr = dma_map_single(sc->dev, skb->data, 305 skb->len, DMA_TO_DEVICE); 306 if (unlikely(dma_mapping_error(sc->dev, bf->bf_buf_addr))) { 307 dev_kfree_skb_any(skb); 308 bf->bf_mpdu = NULL; 309 bf->bf_buf_addr = 0; 310 ath_err(common, "dma_mapping_error on beacon alloc\n"); 311 return -ENOMEM; 312 } 313 avp->is_bslot_active = true; 314 315 return 0; 316} 317 318void ath_beacon_return(struct ath_softc *sc, struct ath_vif *avp) 319{ 320 if (avp->av_bcbuf != NULL) { 321 struct ath_buf *bf; 322 323 avp->is_bslot_active = false; 324 if (avp->av_bslot != -1) { 325 sc->beacon.bslot[avp->av_bslot] = NULL; 326 sc->nbcnvifs--; 327 avp->av_bslot = -1; 328 } 329 330 bf = avp->av_bcbuf; 331 if (bf->bf_mpdu != NULL) { 332 struct sk_buff *skb = bf->bf_mpdu; 333 dma_unmap_single(sc->dev, bf->bf_buf_addr, 334 skb->len, DMA_TO_DEVICE); 335 dev_kfree_skb_any(skb); 336 bf->bf_mpdu = NULL; 337 bf->bf_buf_addr = 0; 338 } 339 list_add_tail(&bf->list, &sc->beacon.bbuf); 340 341 avp->av_bcbuf = NULL; 342 } 343} 344 345void ath_beacon_tasklet(unsigned long data) 346{ 347 struct ath_softc *sc = (struct ath_softc *)data; 348 struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; 349 struct ath_hw *ah = sc->sc_ah; 350 struct ath_common *common = ath9k_hw_common(ah); 351 struct ath_buf *bf = NULL; 352 struct ieee80211_vif *vif; 353 int slot; 354 u32 bfaddr, bc = 0; 355 356 /* 357 * Check if the previous beacon has gone out. If 358 * not don't try to post another, skip this period 359 * and wait for the next. Missed beacons indicate 360 * a problem and should not occur. If we miss too 361 * many consecutive beacons reset the device. 362 */ 363 if (ath9k_hw_numtxpending(ah, sc->beacon.beaconq) != 0) { 364 sc->beacon.bmisscnt++; 365 366 if (sc->beacon.bmisscnt < BSTUCK_THRESH * sc->nbcnvifs) { 367 ath_dbg(common, ATH_DBG_BSTUCK, 368 "missed %u consecutive beacons\n", 369 sc->beacon.bmisscnt); 370 ath9k_hw_stop_dma_queue(ah, sc->beacon.beaconq); 371 if (sc->beacon.bmisscnt > 3) 372 ath9k_hw_bstuck_nfcal(ah); 373 } else if (sc->beacon.bmisscnt >= BSTUCK_THRESH) { 374 ath_dbg(common, ATH_DBG_BSTUCK, 375 "beacon is officially stuck\n"); 376 sc->sc_flags |= SC_OP_TSF_RESET; 377 ath_reset(sc, true); 378 } 379 380 return; 381 } 382 383 /* 384 * Generate beacon frames. we are sending frames 385 * staggered so calculate the slot for this frame based 386 * on the tsf to safeguard against missing an swba. 387 */ 388 389 390 if (ah->opmode == NL80211_IFTYPE_AP) { 391 u16 intval; 392 u32 tsftu; 393 u64 tsf; 394 395 intval = cur_conf->beacon_interval ? : ATH_DEFAULT_BINTVAL; 396 tsf = ath9k_hw_gettsf64(ah); 397 tsf += TU_TO_USEC(ah->config.sw_beacon_response_time); 398 tsftu = TSF_TO_TU((tsf * ATH_BCBUF) >>32, tsf * ATH_BCBUF); 399 slot = (tsftu % (intval * ATH_BCBUF)) / intval; 400 vif = sc->beacon.bslot[slot]; 401 402 ath_dbg(common, ATH_DBG_BEACON, 403 "slot %d [tsf %llu tsftu %u intval %u] vif %p\n", 404 slot, tsf, tsftu / ATH_BCBUF, intval, vif); 405 } else { 406 slot = 0; 407 vif = sc->beacon.bslot[slot]; 408 } 409 410 411 bfaddr = 0; 412 if (vif) { 413 bf = ath_beacon_generate(sc->hw, vif); 414 if (bf != NULL) { 415 bfaddr = bf->bf_daddr; 416 bc = 1; 417 } 418 419 if (sc->beacon.bmisscnt != 0) { 420 ath_dbg(common, ATH_DBG_BSTUCK, 421 "resume beacon xmit after %u misses\n", 422 sc->beacon.bmisscnt); 423 sc->beacon.bmisscnt = 0; 424 } 425 } 426 427 /* 428 * Handle slot time change when a non-ERP station joins/leaves 429 * an 11g network. The 802.11 layer notifies us via callback, 430 * we mark updateslot, then wait one beacon before effecting 431 * the change. This gives associated stations at least one 432 * beacon interval to note the state change. 433 * 434 * NB: The slot time change state machine is clocked according 435 * to whether we are bursting or staggering beacons. We 436 * recognize the request to update and record the current 437 * slot then don't transition until that slot is reached 438 * again. If we miss a beacon for that slot then we'll be 439 * slow to transition but we'll be sure at least one beacon 440 * interval has passed. When bursting slot is always left 441 * set to ATH_BCBUF so this check is a noop. 442 */ 443 if (sc->beacon.updateslot == UPDATE) { 444 sc->beacon.updateslot = COMMIT; /* commit next beacon */ 445 sc->beacon.slotupdate = slot; 446 } else if (sc->beacon.updateslot == COMMIT && sc->beacon.slotupdate == slot) { 447 ah->slottime = sc->beacon.slottime; 448 ath9k_hw_init_global_settings(ah); 449 sc->beacon.updateslot = OK; 450 } 451 if (bfaddr != 0) { 452 /* NB: cabq traffic should already be queued and primed */ 453 ath9k_hw_puttxbuf(ah, sc->beacon.beaconq, bfaddr); 454 ath9k_hw_txstart(ah, sc->beacon.beaconq); 455 456 sc->beacon.ast_be_xmit += bc; /* XXX per-vif? */ 457 } 458} 459 460static void ath9k_beacon_init(struct ath_softc *sc, 461 u32 next_beacon, 462 u32 beacon_period) 463{ 464 if (sc->sc_flags & SC_OP_TSF_RESET) { 465 ath9k_ps_wakeup(sc); 466 ath9k_hw_reset_tsf(sc->sc_ah); 467 } 468 469 ath9k_hw_beaconinit(sc->sc_ah, next_beacon, beacon_period); 470 471 if (sc->sc_flags & SC_OP_TSF_RESET) { 472 ath9k_ps_restore(sc); 473 sc->sc_flags &= ~SC_OP_TSF_RESET; 474 } 475} 476 477/* 478 * For multi-bss ap support beacons are either staggered evenly over N slots or 479 * burst together. For the former arrange for the SWBA to be delivered for each 480 * slot. Slots that are not occupied will generate nothing. 481 */ 482static void ath_beacon_config_ap(struct ath_softc *sc, 483 struct ath_beacon_config *conf) 484{ 485 struct ath_hw *ah = sc->sc_ah; 486 u32 nexttbtt, intval; 487 488 /* NB: the beacon interval is kept internally in TU's */ 489 intval = TU_TO_USEC(conf->beacon_interval & ATH9K_BEACON_PERIOD); 490 intval /= ATH_BCBUF; /* for staggered beacons */ 491 nexttbtt = intval; 492 493 /* 494 * In AP mode we enable the beacon timers and SWBA interrupts to 495 * prepare beacon frames. 496 */ 497 ah->imask |= ATH9K_INT_SWBA; 498 ath_beaconq_config(sc); 499 500 /* Set the computed AP beacon timers */ 501 502 ath9k_hw_disable_interrupts(ah); 503 ath9k_beacon_init(sc, nexttbtt, intval); 504 sc->beacon.bmisscnt = 0; 505 ath9k_hw_set_interrupts(ah, ah->imask); 506} 507 508/* 509 * This sets up the beacon timers according to the timestamp of the last 510 * received beacon and the current TSF, configures PCF and DTIM 511 * handling, programs the sleep registers so the hardware will wakeup in 512 * time to receive beacons, and configures the beacon miss handling so 513 * we'll receive a BMISS interrupt when we stop seeing beacons from the AP 514 * we've associated with. 515 */ 516static void ath_beacon_config_sta(struct ath_softc *sc, 517 struct ath_beacon_config *conf) 518{ 519 struct ath_hw *ah = sc->sc_ah; 520 struct ath_common *common = ath9k_hw_common(ah); 521 struct ath9k_beacon_state bs; 522 int dtimperiod, dtimcount, sleepduration; 523 int cfpperiod, cfpcount; 524 u32 nexttbtt = 0, intval, tsftu; 525 u64 tsf; 526 int num_beacons, offset, dtim_dec_count, cfp_dec_count; 527 528 /* No need to configure beacon if we are not associated */ 529 if (!common->curaid) { 530 ath_dbg(common, ATH_DBG_BEACON, 531 "STA is not yet associated..skipping beacon config\n"); 532 return; 533 } 534 535 memset(&bs, 0, sizeof(bs)); 536 intval = conf->beacon_interval & ATH9K_BEACON_PERIOD; 537 538 /* 539 * Setup dtim and cfp parameters according to 540 * last beacon we received (which may be none). 541 */ 542 dtimperiod = conf->dtim_period; 543 dtimcount = conf->dtim_count; 544 if (dtimcount >= dtimperiod) /* NB: sanity check */ 545 dtimcount = 0; 546 cfpperiod = 1; /* NB: no PCF support yet */ 547 cfpcount = 0; 548 549 sleepduration = conf->listen_interval * intval; 550 551 /* 552 * Pull nexttbtt forward to reflect the current 553 * TSF and calculate dtim+cfp state for the result. 554 */ 555 tsf = ath9k_hw_gettsf64(ah); 556 tsftu = TSF_TO_TU(tsf>>32, tsf) + FUDGE; 557 558 num_beacons = tsftu / intval + 1; 559 offset = tsftu % intval; 560 nexttbtt = tsftu - offset; 561 if (offset) 562 nexttbtt += intval; 563 564 /* DTIM Beacon every dtimperiod Beacon */ 565 dtim_dec_count = num_beacons % dtimperiod; 566 /* CFP every cfpperiod DTIM Beacon */ 567 cfp_dec_count = (num_beacons / dtimperiod) % cfpperiod; 568 if (dtim_dec_count) 569 cfp_dec_count++; 570 571 dtimcount -= dtim_dec_count; 572 if (dtimcount < 0) 573 dtimcount += dtimperiod; 574 575 cfpcount -= cfp_dec_count; 576 if (cfpcount < 0) 577 cfpcount += cfpperiod; 578 579 bs.bs_intval = intval; 580 bs.bs_nexttbtt = nexttbtt; 581 bs.bs_dtimperiod = dtimperiod*intval; 582 bs.bs_nextdtim = bs.bs_nexttbtt + dtimcount*intval; 583 bs.bs_cfpperiod = cfpperiod*bs.bs_dtimperiod; 584 bs.bs_cfpnext = bs.bs_nextdtim + cfpcount*bs.bs_dtimperiod; 585 bs.bs_cfpmaxduration = 0; 586 587 /* 588 * Calculate the number of consecutive beacons to miss* before taking 589 * a BMISS interrupt. The configuration is specified in TU so we only 590 * need calculate based on the beacon interval. Note that we clamp the 591 * result to at most 15 beacons. 592 */ 593 if (sleepduration > intval) { 594 bs.bs_bmissthreshold = conf->listen_interval * 595 ATH_DEFAULT_BMISS_LIMIT / 2; 596 } else { 597 bs.bs_bmissthreshold = DIV_ROUND_UP(conf->bmiss_timeout, intval); 598 if (bs.bs_bmissthreshold > 15) 599 bs.bs_bmissthreshold = 15; 600 else if (bs.bs_bmissthreshold <= 0) 601 bs.bs_bmissthreshold = 1; 602 } 603 604 /* 605 * Calculate sleep duration. The configuration is given in ms. 606 * We ensure a multiple of the beacon period is used. Also, if the sleep 607 * duration is greater than the DTIM period then it makes senses 608 * to make it a multiple of that. 609 * 610 * XXX fixed at 100ms 611 */ 612 613 bs.bs_sleepduration = roundup(IEEE80211_MS_TO_TU(100), sleepduration); 614 if (bs.bs_sleepduration > bs.bs_dtimperiod) 615 bs.bs_sleepduration = bs.bs_dtimperiod; 616 617 /* TSF out of range threshold fixed at 1 second */ 618 bs.bs_tsfoor_threshold = ATH9K_TSFOOR_THRESHOLD; 619 620 ath_dbg(common, ATH_DBG_BEACON, "tsf: %llu tsftu: %u\n", tsf, tsftu); 621 ath_dbg(common, ATH_DBG_BEACON, 622 "bmiss: %u sleep: %u cfp-period: %u maxdur: %u next: %u\n", 623 bs.bs_bmissthreshold, bs.bs_sleepduration, 624 bs.bs_cfpperiod, bs.bs_cfpmaxduration, bs.bs_cfpnext); 625 626 /* Set the computed STA beacon timers */ 627 628 ath9k_hw_disable_interrupts(ah); 629 ath9k_hw_set_sta_beacon_timers(ah, &bs); 630 ah->imask |= ATH9K_INT_BMISS; 631 632 /* 633 * If the beacon config is called beacause of TSFOOR, 634 * Interrupts will be enabled back at the end of ath9k_tasklet 635 */ 636 if (!(sc->ps_flags & PS_TSFOOR_SYNC)) 637 ath9k_hw_set_interrupts(ah, ah->imask); 638} 639 640static void ath_beacon_config_adhoc(struct ath_softc *sc, 641 struct ath_beacon_config *conf) 642{ 643 struct ath_hw *ah = sc->sc_ah; 644 struct ath_common *common = ath9k_hw_common(ah); 645 u32 tsf, delta, intval, nexttbtt; 646 647 tsf = ath9k_hw_gettsf32(ah) + TU_TO_USEC(FUDGE); 648 intval = TU_TO_USEC(conf->beacon_interval & ATH9K_BEACON_PERIOD); 649 650 if (!sc->beacon.bc_tstamp) 651 nexttbtt = tsf + intval; 652 else { 653 if (tsf > sc->beacon.bc_tstamp) 654 delta = (tsf - sc->beacon.bc_tstamp); 655 else 656 delta = (tsf + 1 + (~0U - sc->beacon.bc_tstamp)); 657 nexttbtt = tsf + intval - (delta % intval); 658 } 659 660 ath_dbg(common, ATH_DBG_BEACON, 661 "IBSS nexttbtt %u intval %u (%u)\n", 662 nexttbtt, intval, conf->beacon_interval); 663 664 /* 665 * In IBSS mode enable the beacon timers but only enable SWBA interrupts 666 * if we need to manually prepare beacon frames. Otherwise we use a 667 * self-linked tx descriptor and let the hardware deal with things. 668 */ 669 ah->imask |= ATH9K_INT_SWBA; 670 671 ath_beaconq_config(sc); 672 673 /* Set the computed ADHOC beacon timers */ 674 675 ath9k_hw_disable_interrupts(ah); 676 ath9k_beacon_init(sc, nexttbtt, intval); 677 sc->beacon.bmisscnt = 0; 678 /* 679 * If the beacon config is called beacause of TSFOOR, 680 * Interrupts will be enabled back at the end of ath9k_tasklet 681 */ 682 if (!(sc->ps_flags & PS_TSFOOR_SYNC)) 683 ath9k_hw_set_interrupts(ah, ah->imask); 684} 685 686static bool ath9k_allow_beacon_config(struct ath_softc *sc, 687 struct ieee80211_vif *vif) 688{ 689 struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; 690 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 691 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; 692 struct ath_vif *avp = (void *)vif->drv_priv; 693 694 /* 695 * Can not have different beacon interval on multiple 696 * AP interface case 697 */ 698 if ((sc->sc_ah->opmode == NL80211_IFTYPE_AP) && 699 (sc->nbcnvifs > 1) && 700 (vif->type == NL80211_IFTYPE_AP) && 701 (cur_conf->beacon_interval != bss_conf->beacon_int)) { 702 ath_dbg(common, ATH_DBG_CONFIG, 703 "Changing beacon interval of multiple \ 704 AP interfaces !\n"); 705 return false; 706 } 707 /* 708 * Can not configure station vif's beacon config 709 * while on AP opmode 710 */ 711 if ((sc->sc_ah->opmode == NL80211_IFTYPE_AP) && 712 (vif->type != NL80211_IFTYPE_AP)) { 713 ath_dbg(common, ATH_DBG_CONFIG, 714 "STA vif's beacon not allowed on AP mode\n"); 715 return false; 716 } 717 /* 718 * Do not allow beacon config if HW was already configured 719 * with another STA vif 720 */ 721 if ((sc->sc_ah->opmode == NL80211_IFTYPE_STATION) && 722 (vif->type == NL80211_IFTYPE_STATION) && 723 (sc->sc_flags & SC_OP_BEACONS) && 724 !avp->primary_sta_vif) { 725 ath_dbg(common, ATH_DBG_CONFIG, 726 "Beacon already configured for a station interface\n"); 727 return false; 728 } 729 return true; 730} 731 732void ath_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif) 733{ 734 struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; 735 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; 736 737 if (!ath9k_allow_beacon_config(sc, vif)) 738 return; 739 740 /* Setup the beacon configuration parameters */ 741 cur_conf->beacon_interval = bss_conf->beacon_int; 742 cur_conf->dtim_period = bss_conf->dtim_period; 743 cur_conf->listen_interval = 1; 744 cur_conf->dtim_count = 1; 745 cur_conf->bmiss_timeout = 746 ATH_DEFAULT_BMISS_LIMIT * cur_conf->beacon_interval; 747 748 /* 749 * It looks like mac80211 may end up using beacon interval of zero in 750 * some cases (at least for mesh point). Avoid getting into an 751 * infinite loop by using a bit safer value instead. To be safe, 752 * do sanity check on beacon interval for all operating modes. 753 */ 754 if (cur_conf->beacon_interval == 0) 755 cur_conf->beacon_interval = 100; 756 757 /* 758 * We don't parse dtim period from mac80211 during the driver 759 * initialization as it breaks association with hidden-ssid 760 * AP and it causes latency in roaming 761 */ 762 if (cur_conf->dtim_period == 0) 763 cur_conf->dtim_period = 1; 764 765 ath_set_beacon(sc); 766} 767 768static bool ath_has_valid_bslot(struct ath_softc *sc) 769{ 770 struct ath_vif *avp; 771 int slot; 772 bool found = false; 773 774 for (slot = 0; slot < ATH_BCBUF; slot++) { 775 if (sc->beacon.bslot[slot]) { 776 avp = (void *)sc->beacon.bslot[slot]->drv_priv; 777 if (avp->is_bslot_active) { 778 found = true; 779 break; 780 } 781 } 782 } 783 return found; 784} 785 786 787void ath_set_beacon(struct ath_softc *sc) 788{ 789 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 790 struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; 791 792 switch (sc->sc_ah->opmode) { 793 case NL80211_IFTYPE_AP: 794 if (ath_has_valid_bslot(sc)) 795 ath_beacon_config_ap(sc, cur_conf); 796 break; 797 case NL80211_IFTYPE_ADHOC: 798 case NL80211_IFTYPE_MESH_POINT: 799 ath_beacon_config_adhoc(sc, cur_conf); 800 break; 801 case NL80211_IFTYPE_STATION: 802 ath_beacon_config_sta(sc, cur_conf); 803 break; 804 default: 805 ath_dbg(common, ATH_DBG_CONFIG, 806 "Unsupported beaconing mode\n"); 807 return; 808 } 809 810 sc->sc_flags |= SC_OP_BEACONS; 811} 812 813void ath9k_set_beaconing_status(struct ath_softc *sc, bool status) 814{ 815 struct ath_hw *ah = sc->sc_ah; 816 817 if (!ath_has_valid_bslot(sc)) 818 return; 819 820 ath9k_ps_wakeup(sc); 821 if (status) { 822 /* Re-enable beaconing */ 823 ah->imask |= ATH9K_INT_SWBA; 824 ath9k_hw_set_interrupts(ah, ah->imask); 825 } else { 826 /* Disable SWBA interrupt */ 827 ah->imask &= ~ATH9K_INT_SWBA; 828 ath9k_hw_set_interrupts(ah, ah->imask); 829 tasklet_kill(&sc->bcon_tasklet); 830 ath9k_hw_stop_dma_queue(ah, sc->beacon.beaconq); 831 } 832 ath9k_ps_restore(sc); 833} 834