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