beacon.c revision 066dae93bdfcc7af5e38a33617773fd5c6457607
1/* 2 * Copyright (c) 2008-2009 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_print(common, ATH_DBG_FATAL, 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 all required antenna switch parameters, rate codes, and channel flags. 61 * Beacons are always sent out at the 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, antenna, 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 * Switch antenna every beacon. 81 * Should only switch every beacon period, not for every SWBA 82 * XXX assumes two antennae 83 */ 84 antenna = ((sc->beacon.ast_be_xmit / sc->nbcnvifs) & 1 ? 2 : 1); 85 86 sband = &sc->sbands[common->hw->conf.channel->band]; 87 rate = sband->bitrates[rateidx].hw_value; 88 if (sc->sc_flags & SC_OP_PREAMBLE_SHORT) 89 rate |= sband->bitrates[rateidx].hw_value_short; 90 91 ath9k_hw_set11n_txdesc(ah, ds, skb->len + FCS_LEN, 92 ATH9K_PKT_TYPE_BEACON, 93 MAX_RATE_POWER, 94 ATH9K_TXKEYIX_INVALID, 95 ATH9K_KEY_TYPE_CLEAR, 96 flags); 97 98 /* NB: beacon's BufLen must be a multiple of 4 bytes */ 99 ath9k_hw_filltxdesc(ah, ds, roundup(skb->len, 4), 100 true, true, ds, bf->bf_buf_addr, 101 sc->beacon.beaconq); 102 103 memset(series, 0, sizeof(struct ath9k_11n_rate_series) * 4); 104 series[0].Tries = 1; 105 series[0].Rate = rate; 106 series[0].ChSel = common->tx_chainmask; 107 series[0].RateFlags = (ctsrate) ? ATH9K_RATESERIES_RTS_CTS : 0; 108 ath9k_hw_set11n_ratescenario(ah, ds, ds, 0, ctsrate, ctsduration, 109 series, 4, 0); 110} 111 112static struct ath_buf *ath_beacon_generate(struct ieee80211_hw *hw, 113 struct ieee80211_vif *vif) 114{ 115 struct ath_wiphy *aphy = hw->priv; 116 struct ath_softc *sc = aphy->sc; 117 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 118 struct ath_buf *bf; 119 struct ath_vif *avp; 120 struct sk_buff *skb; 121 struct ath_txq *cabq; 122 struct ieee80211_tx_info *info; 123 int cabq_depth; 124 125 if (aphy->state != ATH_WIPHY_ACTIVE) 126 return NULL; 127 128 avp = (void *)vif->drv_priv; 129 cabq = sc->beacon.cabq; 130 131 if (avp->av_bcbuf == NULL) 132 return NULL; 133 134 /* Release the old beacon first */ 135 136 bf = avp->av_bcbuf; 137 skb = bf->bf_mpdu; 138 if (skb) { 139 dma_unmap_single(sc->dev, bf->bf_buf_addr, 140 skb->len, DMA_TO_DEVICE); 141 dev_kfree_skb_any(skb); 142 bf->bf_buf_addr = 0; 143 } 144 145 /* Get a new beacon from mac80211 */ 146 147 skb = ieee80211_beacon_get(hw, vif); 148 bf->bf_mpdu = skb; 149 if (skb == NULL) 150 return NULL; 151 ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp = 152 avp->tsf_adjust; 153 154 info = IEEE80211_SKB_CB(skb); 155 if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) { 156 /* 157 * TODO: make sure the seq# gets assigned properly (vs. other 158 * TX frames) 159 */ 160 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 161 sc->tx.seq_no += 0x10; 162 hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG); 163 hdr->seq_ctrl |= cpu_to_le16(sc->tx.seq_no); 164 } 165 166 bf->bf_buf_addr = dma_map_single(sc->dev, skb->data, 167 skb->len, DMA_TO_DEVICE); 168 if (unlikely(dma_mapping_error(sc->dev, bf->bf_buf_addr))) { 169 dev_kfree_skb_any(skb); 170 bf->bf_mpdu = NULL; 171 bf->bf_buf_addr = 0; 172 ath_print(common, ATH_DBG_FATAL, 173 "dma_mapping_error on beaconing\n"); 174 return NULL; 175 } 176 177 skb = ieee80211_get_buffered_bc(hw, vif); 178 179 /* 180 * if the CABQ traffic from previous DTIM is pending and the current 181 * beacon is also a DTIM. 182 * 1) if there is only one vif let the cab traffic continue. 183 * 2) if there are more than one vif and we are using staggered 184 * beacons, then drain the cabq by dropping all the frames in 185 * the cabq so that the current vifs cab traffic can be scheduled. 186 */ 187 spin_lock_bh(&cabq->axq_lock); 188 cabq_depth = cabq->axq_depth; 189 spin_unlock_bh(&cabq->axq_lock); 190 191 if (skb && cabq_depth) { 192 if (sc->nvifs > 1) { 193 ath_print(common, ATH_DBG_BEACON, 194 "Flushing previous cabq traffic\n"); 195 ath_draintxq(sc, cabq, false); 196 } 197 } 198 199 ath_beacon_setup(sc, avp, bf, info->control.rates[0].idx); 200 201 while (skb) { 202 ath_tx_cabq(hw, skb); 203 skb = ieee80211_get_buffered_bc(hw, vif); 204 } 205 206 return bf; 207} 208 209int ath_beacon_alloc(struct ath_wiphy *aphy, struct ieee80211_vif *vif) 210{ 211 struct ath_softc *sc = aphy->sc; 212 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 213 struct ath_vif *avp; 214 struct ath_buf *bf; 215 struct sk_buff *skb; 216 __le64 tstamp; 217 218 avp = (void *)vif->drv_priv; 219 220 /* Allocate a beacon descriptor if we haven't done so. */ 221 if (!avp->av_bcbuf) { 222 /* Allocate beacon state for hostap/ibss. We know 223 * a buffer is available. */ 224 avp->av_bcbuf = list_first_entry(&sc->beacon.bbuf, 225 struct ath_buf, list); 226 list_del(&avp->av_bcbuf->list); 227 228 if (sc->sc_ah->opmode == NL80211_IFTYPE_AP || 229 sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC || 230 sc->sc_ah->opmode == NL80211_IFTYPE_MESH_POINT) { 231 int slot; 232 /* 233 * Assign the vif to a beacon xmit slot. As 234 * above, this cannot fail to find one. 235 */ 236 avp->av_bslot = 0; 237 for (slot = 0; slot < ATH_BCBUF; slot++) 238 if (sc->beacon.bslot[slot] == NULL) { 239 avp->av_bslot = slot; 240 241 /* NB: keep looking for a double slot */ 242 if (slot == 0 || !sc->beacon.bslot[slot-1]) 243 break; 244 } 245 BUG_ON(sc->beacon.bslot[avp->av_bslot] != NULL); 246 sc->beacon.bslot[avp->av_bslot] = vif; 247 sc->beacon.bslot_aphy[avp->av_bslot] = aphy; 248 sc->nbcnvifs++; 249 } 250 } 251 252 /* release the previous beacon frame, if it already exists. */ 253 bf = avp->av_bcbuf; 254 if (bf->bf_mpdu != NULL) { 255 skb = bf->bf_mpdu; 256 dma_unmap_single(sc->dev, bf->bf_buf_addr, 257 skb->len, DMA_TO_DEVICE); 258 dev_kfree_skb_any(skb); 259 bf->bf_mpdu = NULL; 260 bf->bf_buf_addr = 0; 261 } 262 263 /* NB: the beacon data buffer must be 32-bit aligned. */ 264 skb = ieee80211_beacon_get(sc->hw, vif); 265 if (skb == NULL) { 266 ath_print(common, ATH_DBG_BEACON, "cannot get skb\n"); 267 return -ENOMEM; 268 } 269 270 tstamp = ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp; 271 sc->beacon.bc_tstamp = le64_to_cpu(tstamp); 272 /* Calculate a TSF adjustment factor required for staggered beacons. */ 273 if (avp->av_bslot > 0) { 274 u64 tsfadjust; 275 int intval; 276 277 intval = sc->beacon_interval ? : ATH_DEFAULT_BINTVAL; 278 279 /* 280 * Calculate the TSF offset for this beacon slot, i.e., the 281 * number of usecs that need to be added to the timestamp field 282 * in Beacon and Probe Response frames. Beacon slot 0 is 283 * processed at the correct offset, so it does not require TSF 284 * adjustment. Other slots are adjusted to get the timestamp 285 * close to the TBTT for the BSS. 286 */ 287 tsfadjust = intval * avp->av_bslot / ATH_BCBUF; 288 avp->tsf_adjust = cpu_to_le64(TU_TO_USEC(tsfadjust)); 289 290 ath_print(common, ATH_DBG_BEACON, 291 "stagger beacons, bslot %d intval " 292 "%u tsfadjust %llu\n", 293 avp->av_bslot, intval, (unsigned long long)tsfadjust); 294 295 ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp = 296 avp->tsf_adjust; 297 } else 298 avp->tsf_adjust = cpu_to_le64(0); 299 300 bf->bf_mpdu = skb; 301 bf->bf_buf_addr = dma_map_single(sc->dev, skb->data, 302 skb->len, DMA_TO_DEVICE); 303 if (unlikely(dma_mapping_error(sc->dev, bf->bf_buf_addr))) { 304 dev_kfree_skb_any(skb); 305 bf->bf_mpdu = NULL; 306 bf->bf_buf_addr = 0; 307 ath_print(common, ATH_DBG_FATAL, 308 "dma_mapping_error on beacon alloc\n"); 309 return -ENOMEM; 310 } 311 312 return 0; 313} 314 315void ath_beacon_return(struct ath_softc *sc, struct ath_vif *avp) 316{ 317 if (avp->av_bcbuf != NULL) { 318 struct ath_buf *bf; 319 320 if (avp->av_bslot != -1) { 321 sc->beacon.bslot[avp->av_bslot] = NULL; 322 sc->beacon.bslot_aphy[avp->av_bslot] = NULL; 323 sc->nbcnvifs--; 324 } 325 326 bf = avp->av_bcbuf; 327 if (bf->bf_mpdu != NULL) { 328 struct sk_buff *skb = bf->bf_mpdu; 329 dma_unmap_single(sc->dev, bf->bf_buf_addr, 330 skb->len, DMA_TO_DEVICE); 331 dev_kfree_skb_any(skb); 332 bf->bf_mpdu = NULL; 333 bf->bf_buf_addr = 0; 334 } 335 list_add_tail(&bf->list, &sc->beacon.bbuf); 336 337 avp->av_bcbuf = NULL; 338 } 339} 340 341void ath_beacon_tasklet(unsigned long data) 342{ 343 struct ath_softc *sc = (struct ath_softc *)data; 344 struct ath_hw *ah = sc->sc_ah; 345 struct ath_common *common = ath9k_hw_common(ah); 346 struct ath_buf *bf = NULL; 347 struct ieee80211_vif *vif; 348 struct ath_wiphy *aphy; 349 int slot; 350 u32 bfaddr, bc = 0, tsftu; 351 u64 tsf; 352 u16 intval; 353 354 /* 355 * Check if the previous beacon has gone out. If 356 * not don't try to post another, skip this period 357 * and wait for the next. Missed beacons indicate 358 * a problem and should not occur. If we miss too 359 * many consecutive beacons reset the device. 360 */ 361 if (ath9k_hw_numtxpending(ah, sc->beacon.beaconq) != 0) { 362 sc->beacon.bmisscnt++; 363 364 if (sc->beacon.bmisscnt < BSTUCK_THRESH) { 365 ath_print(common, ATH_DBG_BSTUCK, 366 "missed %u consecutive beacons\n", 367 sc->beacon.bmisscnt); 368 ath9k_hw_bstuck_nfcal(ah); 369 } else if (sc->beacon.bmisscnt >= BSTUCK_THRESH) { 370 ath_print(common, ATH_DBG_BSTUCK, 371 "beacon is officially stuck\n"); 372 sc->sc_flags |= SC_OP_TSF_RESET; 373 ath_reset(sc, true); 374 } 375 376 return; 377 } 378 379 if (sc->beacon.bmisscnt != 0) { 380 ath_print(common, ATH_DBG_BSTUCK, 381 "resume beacon xmit after %u misses\n", 382 sc->beacon.bmisscnt); 383 sc->beacon.bmisscnt = 0; 384 } 385 386 /* 387 * Generate beacon frames. we are sending frames 388 * staggered so calculate the slot for this frame based 389 * on the tsf to safeguard against missing an swba. 390 */ 391 392 intval = sc->beacon_interval ? : ATH_DEFAULT_BINTVAL; 393 394 tsf = ath9k_hw_gettsf64(ah); 395 tsftu = TSF_TO_TU(tsf>>32, tsf); 396 slot = ((tsftu % intval) * ATH_BCBUF) / intval; 397 /* 398 * Reverse the slot order to get slot 0 on the TBTT offset that does 399 * not require TSF adjustment and other slots adding 400 * slot/ATH_BCBUF * beacon_int to timestamp. For example, with 401 * ATH_BCBUF = 4, we process beacon slots as follows: 3 2 1 0 3 2 1 .. 402 * and slot 0 is at correct offset to TBTT. 403 */ 404 slot = ATH_BCBUF - slot - 1; 405 vif = sc->beacon.bslot[slot]; 406 aphy = sc->beacon.bslot_aphy[slot]; 407 408 ath_print(common, ATH_DBG_BEACON, 409 "slot %d [tsf %llu tsftu %u intval %u] vif %p\n", 410 slot, tsf, tsftu, intval, vif); 411 412 bfaddr = 0; 413 if (vif) { 414 bf = ath_beacon_generate(aphy->hw, vif); 415 if (bf != NULL) { 416 bfaddr = bf->bf_daddr; 417 bc = 1; 418 } 419 } 420 421 /* 422 * Handle slot time change when a non-ERP station joins/leaves 423 * an 11g network. The 802.11 layer notifies us via callback, 424 * we mark updateslot, then wait one beacon before effecting 425 * the change. This gives associated stations at least one 426 * beacon interval to note the state change. 427 * 428 * NB: The slot time change state machine is clocked according 429 * to whether we are bursting or staggering beacons. We 430 * recognize the request to update and record the current 431 * slot then don't transition until that slot is reached 432 * again. If we miss a beacon for that slot then we'll be 433 * slow to transition but we'll be sure at least one beacon 434 * interval has passed. When bursting slot is always left 435 * set to ATH_BCBUF so this check is a noop. 436 */ 437 if (sc->beacon.updateslot == UPDATE) { 438 sc->beacon.updateslot = COMMIT; /* commit next beacon */ 439 sc->beacon.slotupdate = slot; 440 } else if (sc->beacon.updateslot == COMMIT && sc->beacon.slotupdate == slot) { 441 ah->slottime = sc->beacon.slottime; 442 ath9k_hw_init_global_settings(ah); 443 sc->beacon.updateslot = OK; 444 } 445 if (bfaddr != 0) { 446 /* 447 * Stop any current dma and put the new frame(s) on the queue. 448 * This should never fail since we check above that no frames 449 * are still pending on the queue. 450 */ 451 if (!ath9k_hw_stoptxdma(ah, sc->beacon.beaconq)) { 452 ath_print(common, ATH_DBG_FATAL, 453 "beacon queue %u did not stop?\n", sc->beacon.beaconq); 454 } 455 456 /* NB: cabq traffic should already be queued and primed */ 457 ath9k_hw_puttxbuf(ah, sc->beacon.beaconq, bfaddr); 458 ath9k_hw_txstart(ah, sc->beacon.beaconq); 459 460 sc->beacon.ast_be_xmit += bc; /* XXX per-vif? */ 461 } 462} 463 464static void ath9k_beacon_init(struct ath_softc *sc, 465 u32 next_beacon, 466 u32 beacon_period) 467{ 468 if (beacon_period & ATH9K_BEACON_RESET_TSF) 469 ath9k_ps_wakeup(sc); 470 471 ath9k_hw_beaconinit(sc->sc_ah, next_beacon, beacon_period); 472 473 if (beacon_period & ATH9K_BEACON_RESET_TSF) 474 ath9k_ps_restore(sc); 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 = conf->beacon_interval & ATH9K_BEACON_PERIOD; 490 intval /= ATH_BCBUF; /* for staggered beacons */ 491 nexttbtt = intval; 492 493 if (sc->sc_flags & SC_OP_TSF_RESET) 494 intval |= ATH9K_BEACON_RESET_TSF; 495 496 /* 497 * In AP mode we enable the beacon timers and SWBA interrupts to 498 * prepare beacon frames. 499 */ 500 intval |= ATH9K_BEACON_ENA; 501 ah->imask |= ATH9K_INT_SWBA; 502 ath_beaconq_config(sc); 503 504 /* Set the computed AP beacon timers */ 505 506 ath9k_hw_disable_interrupts(ah); 507 ath9k_beacon_init(sc, nexttbtt, intval); 508 sc->beacon.bmisscnt = 0; 509 ath9k_hw_set_interrupts(ah, ah->imask); 510 511 /* Clear the reset TSF flag, so that subsequent beacon updation 512 will not reset the HW TSF. */ 513 514 sc->sc_flags &= ~SC_OP_TSF_RESET; 515} 516 517/* 518 * This sets up the beacon timers according to the timestamp of the last 519 * received beacon and the current TSF, configures PCF and DTIM 520 * handling, programs the sleep registers so the hardware will wakeup in 521 * time to receive beacons, and configures the beacon miss handling so 522 * we'll receive a BMISS interrupt when we stop seeing beacons from the AP 523 * we've associated with. 524 */ 525static void ath_beacon_config_sta(struct ath_softc *sc, 526 struct ath_beacon_config *conf) 527{ 528 struct ath_hw *ah = sc->sc_ah; 529 struct ath_common *common = ath9k_hw_common(ah); 530 struct ath9k_beacon_state bs; 531 int dtimperiod, dtimcount, sleepduration; 532 int cfpperiod, cfpcount; 533 u32 nexttbtt = 0, intval, tsftu; 534 u64 tsf; 535 int num_beacons, offset, dtim_dec_count, cfp_dec_count; 536 537 /* No need to configure beacon if we are not associated */ 538 if (!common->curaid) { 539 ath_print(common, ATH_DBG_BEACON, 540 "STA is not yet associated..skipping beacon config\n"); 541 return; 542 } 543 544 memset(&bs, 0, sizeof(bs)); 545 intval = conf->beacon_interval & ATH9K_BEACON_PERIOD; 546 547 /* 548 * Setup dtim and cfp parameters according to 549 * last beacon we received (which may be none). 550 */ 551 dtimperiod = conf->dtim_period; 552 if (dtimperiod <= 0) /* NB: 0 if not known */ 553 dtimperiod = 1; 554 dtimcount = conf->dtim_count; 555 if (dtimcount >= dtimperiod) /* NB: sanity check */ 556 dtimcount = 0; 557 cfpperiod = 1; /* NB: no PCF support yet */ 558 cfpcount = 0; 559 560 sleepduration = conf->listen_interval * intval; 561 if (sleepduration <= 0) 562 sleepduration = intval; 563 564 /* 565 * Pull nexttbtt forward to reflect the current 566 * TSF and calculate dtim+cfp state for the result. 567 */ 568 tsf = ath9k_hw_gettsf64(ah); 569 tsftu = TSF_TO_TU(tsf>>32, tsf) + FUDGE; 570 571 num_beacons = tsftu / intval + 1; 572 offset = tsftu % intval; 573 nexttbtt = tsftu - offset; 574 if (offset) 575 nexttbtt += intval; 576 577 /* DTIM Beacon every dtimperiod Beacon */ 578 dtim_dec_count = num_beacons % dtimperiod; 579 /* CFP every cfpperiod DTIM Beacon */ 580 cfp_dec_count = (num_beacons / dtimperiod) % cfpperiod; 581 if (dtim_dec_count) 582 cfp_dec_count++; 583 584 dtimcount -= dtim_dec_count; 585 if (dtimcount < 0) 586 dtimcount += dtimperiod; 587 588 cfpcount -= cfp_dec_count; 589 if (cfpcount < 0) 590 cfpcount += cfpperiod; 591 592 bs.bs_intval = intval; 593 bs.bs_nexttbtt = nexttbtt; 594 bs.bs_dtimperiod = dtimperiod*intval; 595 bs.bs_nextdtim = bs.bs_nexttbtt + dtimcount*intval; 596 bs.bs_cfpperiod = cfpperiod*bs.bs_dtimperiod; 597 bs.bs_cfpnext = bs.bs_nextdtim + cfpcount*bs.bs_dtimperiod; 598 bs.bs_cfpmaxduration = 0; 599 600 /* 601 * Calculate the number of consecutive beacons to miss* before taking 602 * a BMISS interrupt. The configuration is specified in TU so we only 603 * need calculate based on the beacon interval. Note that we clamp the 604 * result to at most 15 beacons. 605 */ 606 if (sleepduration > intval) { 607 bs.bs_bmissthreshold = conf->listen_interval * 608 ATH_DEFAULT_BMISS_LIMIT / 2; 609 } else { 610 bs.bs_bmissthreshold = DIV_ROUND_UP(conf->bmiss_timeout, intval); 611 if (bs.bs_bmissthreshold > 15) 612 bs.bs_bmissthreshold = 15; 613 else if (bs.bs_bmissthreshold <= 0) 614 bs.bs_bmissthreshold = 1; 615 } 616 617 /* 618 * Calculate sleep duration. The configuration is given in ms. 619 * We ensure a multiple of the beacon period is used. Also, if the sleep 620 * duration is greater than the DTIM period then it makes senses 621 * to make it a multiple of that. 622 * 623 * XXX fixed at 100ms 624 */ 625 626 bs.bs_sleepduration = roundup(IEEE80211_MS_TO_TU(100), sleepduration); 627 if (bs.bs_sleepduration > bs.bs_dtimperiod) 628 bs.bs_sleepduration = bs.bs_dtimperiod; 629 630 /* TSF out of range threshold fixed at 1 second */ 631 bs.bs_tsfoor_threshold = ATH9K_TSFOOR_THRESHOLD; 632 633 ath_print(common, ATH_DBG_BEACON, "tsf: %llu tsftu: %u\n", tsf, tsftu); 634 ath_print(common, ATH_DBG_BEACON, 635 "bmiss: %u sleep: %u cfp-period: %u maxdur: %u next: %u\n", 636 bs.bs_bmissthreshold, bs.bs_sleepduration, 637 bs.bs_cfpperiod, bs.bs_cfpmaxduration, bs.bs_cfpnext); 638 639 /* Set the computed STA beacon timers */ 640 641 ath9k_hw_disable_interrupts(ah); 642 ath9k_hw_set_sta_beacon_timers(ah, &bs); 643 ah->imask |= ATH9K_INT_BMISS; 644 ath9k_hw_set_interrupts(ah, ah->imask); 645} 646 647static void ath_beacon_config_adhoc(struct ath_softc *sc, 648 struct ath_beacon_config *conf, 649 struct ieee80211_vif *vif) 650{ 651 struct ath_hw *ah = sc->sc_ah; 652 struct ath_common *common = ath9k_hw_common(ah); 653 u64 tsf; 654 u32 tsftu, intval, nexttbtt; 655 656 intval = conf->beacon_interval & ATH9K_BEACON_PERIOD; 657 658 659 /* Pull nexttbtt forward to reflect the current TSF */ 660 661 nexttbtt = TSF_TO_TU(sc->beacon.bc_tstamp >> 32, sc->beacon.bc_tstamp); 662 if (nexttbtt == 0) 663 nexttbtt = intval; 664 else if (intval) 665 nexttbtt = roundup(nexttbtt, intval); 666 667 tsf = ath9k_hw_gettsf64(ah); 668 tsftu = TSF_TO_TU((u32)(tsf>>32), (u32)tsf) + FUDGE; 669 do { 670 nexttbtt += intval; 671 } while (nexttbtt < tsftu); 672 673 ath_print(common, ATH_DBG_BEACON, 674 "IBSS nexttbtt %u intval %u (%u)\n", 675 nexttbtt, intval, conf->beacon_interval); 676 677 /* 678 * In IBSS mode enable the beacon timers but only enable SWBA interrupts 679 * if we need to manually prepare beacon frames. Otherwise we use a 680 * self-linked tx descriptor and let the hardware deal with things. 681 */ 682 intval |= ATH9K_BEACON_ENA; 683 ah->imask |= ATH9K_INT_SWBA; 684 685 ath_beaconq_config(sc); 686 687 /* Set the computed ADHOC beacon timers */ 688 689 ath9k_hw_disable_interrupts(ah); 690 ath9k_beacon_init(sc, nexttbtt, intval); 691 sc->beacon.bmisscnt = 0; 692 ath9k_hw_set_interrupts(ah, ah->imask); 693} 694 695void ath_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif) 696{ 697 struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; 698 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 699 enum nl80211_iftype iftype; 700 701 /* Setup the beacon configuration parameters */ 702 if (vif) { 703 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; 704 705 iftype = vif->type; 706 707 cur_conf->beacon_interval = bss_conf->beacon_int; 708 cur_conf->dtim_period = bss_conf->dtim_period; 709 cur_conf->listen_interval = 1; 710 cur_conf->dtim_count = 1; 711 cur_conf->bmiss_timeout = 712 ATH_DEFAULT_BMISS_LIMIT * cur_conf->beacon_interval; 713 } else { 714 iftype = sc->sc_ah->opmode; 715 } 716 717 /* 718 * It looks like mac80211 may end up using beacon interval of zero in 719 * some cases (at least for mesh point). Avoid getting into an 720 * infinite loop by using a bit safer value instead. To be safe, 721 * do sanity check on beacon interval for all operating modes. 722 */ 723 if (cur_conf->beacon_interval == 0) 724 cur_conf->beacon_interval = 100; 725 726 switch (iftype) { 727 case NL80211_IFTYPE_AP: 728 ath_beacon_config_ap(sc, cur_conf); 729 break; 730 case NL80211_IFTYPE_ADHOC: 731 case NL80211_IFTYPE_MESH_POINT: 732 ath_beacon_config_adhoc(sc, cur_conf, vif); 733 break; 734 case NL80211_IFTYPE_STATION: 735 ath_beacon_config_sta(sc, cur_conf); 736 break; 737 default: 738 ath_print(common, ATH_DBG_CONFIG, 739 "Unsupported beaconing mode\n"); 740 return; 741 } 742 743 sc->sc_flags |= SC_OP_BEACONS; 744} 745