drivers/net/wireless/ath9k/beacon.c

   1 /*
   2  * Copyright (c) 2008 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 /*
  20  *  This function will modify certain transmit queue properties depending on
  21  *  the operating mode of the station (AP or AdHoc).  Parameters are AIFS
  22  *  settings and channel width min/max
  23 */
  24 static int ath_beaconq_config(struct ath_softc *sc)
  25 {
  26         struct ath_hw *ah = sc->sc_ah;
  27         struct ath9k_tx_queue_info qi;
  28
  29         ath9k_hw_get_txq_props(ah, sc->beacon.beaconq, &qi);
  30         if (sc->sc_ah->opmode == NL80211_IFTYPE_AP) {
  31                 /* Always burst out beacon and CAB traffic. */
  32                 qi.tqi_aifs = 1;
  33                 qi.tqi_cwmin = 0;
  34                 qi.tqi_cwmax = 0;
  35         } else {
  36                 /* Adhoc mode; important thing is to use 2x cwmin. */
  37                 qi.tqi_aifs = sc->beacon.beacon_qi.tqi_aifs;
  38                 qi.tqi_cwmin = 2*sc->beacon.beacon_qi.tqi_cwmin;
  39                 qi.tqi_cwmax = sc->beacon.beacon_qi.tqi_cwmax;
  40         }
  41
  42         if (!ath9k_hw_set_txq_props(ah, sc->beacon.beaconq, &qi)) {
  43                 DPRINTF(sc, ATH_DBG_FATAL,
  44                         "unable to update h/w beacon queue parameters\n");
  45                 return 0;
  46         } else {
  47                 ath9k_hw_resettxqueue(ah, sc->beacon.beaconq);
  48                 return 1;
  49         }
  50 }
  51
  52 static void ath_bstuck_process(struct ath_softc *sc)
  53 {
  54         DPRINTF(sc, ATH_DBG_BEACON, "stuck beacon; resetting (bmiss count %u)\n",
  55                 sc->beacon.bmisscnt);
  56         ath_reset(sc, false);
  57 }
  58
  59 /*
  60  *  Associates the beacon frame buffer with a transmit descriptor.  Will set
  61  *  up all required antenna switch parameters, rate codes, and channel flags.
  62  *  Beacons are always sent out at the lowest rate, and are not retried.
  63 */
  64 static void ath_beacon_setup(struct ath_softc *sc, struct ath_vif *avp,
  65                              struct ath_buf *bf)
  66 {
  67         struct sk_buff *skb = (struct sk_buff *)bf->bf_mpdu;
  68         struct ath_hw *ah = sc->sc_ah;
  69         struct ath_desc *ds;
  70         struct ath9k_11n_rate_series series[4];
  71         struct ath_rate_table *rt;
  72         int flags, antenna, ctsrate = 0, ctsduration = 0;
  73         u8 rate;
  74
  75         ds = bf->bf_desc;
  76         flags = ATH9K_TXDESC_NOACK;
  77
  78         if (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC &&
  79             (ah->caps.hw_caps & ATH9K_HW_CAP_VEOL)) {
  80                 ds->ds_link = bf->bf_daddr; /* self-linked */
  81                 flags |= ATH9K_TXDESC_VEOL;
  82                 /* Let hardware handle antenna switching. */
  83                 antenna = 0;
  84         } else {
  85                 ds->ds_link = 0;
  86                 /*
  87                  * Switch antenna every beacon.
  88                  * Should only switch every beacon period, not for every SWBA
  89                  * XXX assumes two antennae
  90                  */
  91                 antenna = ((sc->beacon.ast_be_xmit / sc->nbcnvifs) & 1 ? 2 : 1);
  92         }
  93
  94         ds->ds_data = bf->bf_buf_addr;
  95
  96         rt = sc->cur_rate_table;
  97         rate = rt->info[0].ratecode;
  98         if (sc->sc_flags & SC_OP_PREAMBLE_SHORT)
  99                 rate |= rt->info[0].short_preamble;
 100
 101         ath9k_hw_set11n_txdesc(ah, ds, skb->len + FCS_LEN,
 102                                ATH9K_PKT_TYPE_BEACON,
 103                                MAX_RATE_POWER,
 104                                ATH9K_TXKEYIX_INVALID,
 105                                ATH9K_KEY_TYPE_CLEAR,
 106                                flags);
 107
 108         /* NB: beacon's BufLen must be a multiple of 4 bytes */
 109         ath9k_hw_filltxdesc(ah, ds, roundup(skb->len, 4),
 110                             true, true, ds);
 111
 112         memset(series, 0, sizeof(struct ath9k_11n_rate_series) * 4);
 113         series[0].Tries = 1;
 114         series[0].Rate = rate;
 115         series[0].ChSel = sc->tx_chainmask;
 116         series[0].RateFlags = (ctsrate) ? ATH9K_RATESERIES_RTS_CTS : 0;
 117         ath9k_hw_set11n_ratescenario(ah, ds, ds, 0, ctsrate, ctsduration,
 118                                      series, 4, 0);
 119 }
 120
 121 static struct ath_buf *ath_beacon_generate(struct ath_softc *sc, int if_id)
 122 {
 123         struct ath_buf *bf;
 124         struct ath_vif *avp;
 125         struct sk_buff *skb;
 126         struct ath_txq *cabq;
 127         struct ieee80211_vif *vif;
 128         struct ieee80211_tx_info *info;
 129         int cabq_depth;
 130
 131         vif = sc->vifs[if_id];
 132         avp = (void *)vif->drv_priv;
 133         cabq = sc->beacon.cabq;
 134
 135         if (avp->av_bcbuf == NULL) {
 136                 DPRINTF(sc, ATH_DBG_BEACON, "avp=%p av_bcbuf=%p\n",
 137                         avp, avp->av_bcbuf);
 138                 return NULL;
 139         }
 140
 141         /* Release the old beacon first */
 142
 143         bf = avp->av_bcbuf;
 144         skb = (struct sk_buff *)bf->bf_mpdu;
 145         if (skb) {
 146                 dma_unmap_single(sc->dev, bf->bf_dmacontext,
 147                                  skb->len, DMA_TO_DEVICE);
 148                 dev_kfree_skb_any(skb);
 149         }
 150
 151         /* Get a new beacon from mac80211 */
 152
 153         skb = ieee80211_beacon_get(sc->hw, vif);
 154         bf->bf_mpdu = skb;
 155         if (skb == NULL)
 156                 return NULL;
 157
 158         info = IEEE80211_SKB_CB(skb);
 159         if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
 160                 /*
 161                  * TODO: make sure the seq# gets assigned properly (vs. other
 162                  * TX frames)
 163                  */
 164                 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
 165                 sc->tx.seq_no += 0x10;
 166                 hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
 167                 hdr->seq_ctrl |= cpu_to_le16(sc->tx.seq_no);
 168         }
 169
 170         bf->bf_buf_addr = bf->bf_dmacontext =
 171                 dma_map_single(sc->dev, skb->data,
 172                                skb->len, DMA_TO_DEVICE);
 173         if (unlikely(dma_mapping_error(sc->dev, bf->bf_buf_addr))) {
 174                 dev_kfree_skb_any(skb);
 175                 bf->bf_mpdu = NULL;
 176                 DPRINTF(sc, ATH_DBG_FATAL, "dma_mapping_error on beaconing\n");
 177                 return NULL;
 178         }
 179
 180         skb = ieee80211_get_buffered_bc(sc->hw, vif);
 181
 182         /*
 183          * if the CABQ traffic from previous DTIM is pending and the current
 184          *  beacon is also a DTIM.
 185          *  1) if there is only one vif let the cab traffic continue.
 186          *  2) if there are more than one vif and we are using staggered
 187          *     beacons, then drain the cabq by dropping all the frames in
 188          *     the cabq so that the current vifs cab traffic can be scheduled.
 189          */
 190         spin_lock_bh(&cabq->axq_lock);
 191         cabq_depth = cabq->axq_depth;
 192         spin_unlock_bh(&cabq->axq_lock);
 193
 194         if (skb && cabq_depth) {
 195                 if (sc->nvifs > 1) {
 196                         DPRINTF(sc, ATH_DBG_BEACON,
 197                                 "Flushing previous cabq traffic\n");
 198                         ath_draintxq(sc, cabq, false);
 199                 }
 200         }
 201
 202         ath_beacon_setup(sc, avp, bf);
 203
 204         while (skb) {
 205                 ath_tx_cabq(sc, skb);
 206                 skb = ieee80211_get_buffered_bc(sc->hw, vif);
 207         }
 208
 209         return bf;
 210 }
 211
 212 /*
 213  * Startup beacon transmission for adhoc mode when they are sent entirely
 214  * by the hardware using the self-linked descriptor + veol trick.
 215 */
 216 static void ath_beacon_start_adhoc(struct ath_softc *sc, int if_id)
 217 {
 218         struct ieee80211_vif *vif;
 219         struct ath_hw *ah = sc->sc_ah;
 220         struct ath_buf *bf;
 221         struct ath_vif *avp;
 222         struct sk_buff *skb;
 223
 224         vif = sc->vifs[if_id];
 225         avp = (void *)vif->drv_priv;
 226
 227         if (avp->av_bcbuf == NULL)
 228                 return;
 229
 230         bf = avp->av_bcbuf;
 231         skb = (struct sk_buff *) bf->bf_mpdu;
 232
 233         ath_beacon_setup(sc, avp, bf);
 234
 235         /* NB: caller is known to have already stopped tx dma */
 236         ath9k_hw_puttxbuf(ah, sc->beacon.beaconq, bf->bf_daddr);
 237         ath9k_hw_txstart(ah, sc->beacon.beaconq);
 238         DPRINTF(sc, ATH_DBG_BEACON, "TXDP%u = %llx (%p)\n",
 239                 sc->beacon.beaconq, ito64(bf->bf_daddr), bf->bf_desc);
 240 }
 241
 242 int ath_beaconq_setup(struct ath_hw *ah)
 243 {
 244         struct ath9k_tx_queue_info qi;
 245
 246         memset(&qi, 0, sizeof(qi));
 247         qi.tqi_aifs = 1;
 248         qi.tqi_cwmin = 0;
 249         qi.tqi_cwmax = 0;
 250         /* NB: don't enable any interrupts */
 251         return ath9k_hw_setuptxqueue(ah, ATH9K_TX_QUEUE_BEACON, &qi);
 252 }
 253
 254 int ath_beacon_alloc(struct ath_softc *sc, int if_id)
 255 {
 256         struct ieee80211_vif *vif;
 257         struct ath_vif *avp;
 258         struct ieee80211_hdr *hdr;
 259         struct ath_buf *bf;
 260         struct sk_buff *skb;
 261         __le64 tstamp;
 262
 263         vif = sc->vifs[if_id];
 264         avp = (void *)vif->drv_priv;
 265
 266         /* Allocate a beacon descriptor if we haven't done so. */
 267         if (!avp->av_bcbuf) {
 268                 /* Allocate beacon state for hostap/ibss.  We know
 269                  * a buffer is available. */
 270                 avp->av_bcbuf = list_first_entry(&sc->beacon.bbuf,
 271                                                  struct ath_buf, list);
 272                 list_del(&avp->av_bcbuf->list);
 273
 274                 if (sc->sc_ah->opmode == NL80211_IFTYPE_AP ||
 275                     !(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_VEOL)) {
 276                         int slot;
 277                         /*
 278                          * Assign the vif to a beacon xmit slot. As
 279                          * above, this cannot fail to find one.
 280                          */
 281                         avp->av_bslot = 0;
 282                         for (slot = 0; slot < ATH_BCBUF; slot++)
 283                                 if (sc->beacon.bslot[slot] == ATH_IF_ID_ANY) {
 284                                         /*
 285                                          * XXX hack, space out slots to better
 286                                          * deal with misses
 287                                          */
 288                                         if (slot+1 < ATH_BCBUF &&
 289                                             sc->beacon.bslot[slot+1] ==
 290                                                 ATH_IF_ID_ANY) {
 291                                                 avp->av_bslot = slot+1;
 292                                                 break;
 293                                         }
 294                                         avp->av_bslot = slot;
 295                                         /* NB: keep looking for a double slot */
 296                                 }
 297                         BUG_ON(sc->beacon.bslot[avp->av_bslot] != ATH_IF_ID_ANY);
 298                         sc->beacon.bslot[avp->av_bslot] = if_id;
 299                         sc->nbcnvifs++;
 300                 }
 301         }
 302
 303         /* release the previous beacon frame, if it already exists. */
 304         bf = avp->av_bcbuf;
 305         if (bf->bf_mpdu != NULL) {
 306                 skb = (struct sk_buff *)bf->bf_mpdu;
 307                 dma_unmap_single(sc->dev, bf->bf_dmacontext,
 308                                  skb->len, DMA_TO_DEVICE);
 309                 dev_kfree_skb_any(skb);
 310                 bf->bf_mpdu = NULL;
 311         }
 312
 313         /* NB: the beacon data buffer must be 32-bit aligned. */
 314         skb = ieee80211_beacon_get(sc->hw, vif);
 315         if (skb == NULL) {
 316                 DPRINTF(sc, ATH_DBG_BEACON, "cannot get skb\n");
 317                 return -ENOMEM;
 318         }
 319
 320         tstamp = ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp;
 321         sc->beacon.bc_tstamp = le64_to_cpu(tstamp);
 322
 323         /*
 324          * Calculate a TSF adjustment factor required for
 325          * staggered beacons.  Note that we assume the format
 326          * of the beacon frame leaves the tstamp field immediately
 327          * following the header.
 328          */
 329         if (avp->av_bslot > 0) {
 330                 u64 tsfadjust;
 331                 __le64 val;
 332                 int intval;
 333
 334                 intval = sc->hw->conf.beacon_int ?
 335                         sc->hw->conf.beacon_int : ATH_DEFAULT_BINTVAL;
 336
 337                 /*
 338                  * The beacon interval is in TU's; the TSF in usecs.
 339                  * We figure out how many TU's to add to align the
 340                  * timestamp then convert to TSF units and handle
 341                  * byte swapping before writing it in the frame.
 342                  * The hardware will then add this each time a beacon
 343                  * frame is sent.  Note that we align vif's 1..N
 344                  * and leave vif 0 untouched.  This means vap 0
 345                  * has a timestamp in one beacon interval while the
 346                  * others get a timestamp aligned to the next interval.
 347                  */
 348                 tsfadjust = (intval * (ATH_BCBUF - avp->av_bslot)) / ATH_BCBUF;
 349                 val = cpu_to_le64(tsfadjust << 10);     /* TU->TSF */
 350
 351                 DPRINTF(sc, ATH_DBG_BEACON,
 352                         "stagger beacons, bslot %d intval %u tsfadjust %llu\n",
 353                         avp->av_bslot, intval, (unsigned long long)tsfadjust);
 354
 355                 hdr = (struct ieee80211_hdr *)skb->data;
 356                 memcpy(&hdr[1], &val, sizeof(val));
 357         }
 358
 359         bf->bf_mpdu = skb;
 360         bf->bf_buf_addr = bf->bf_dmacontext =
 361                 dma_map_single(sc->dev, skb->data,
 362                                skb->len, DMA_TO_DEVICE);
 363         if (unlikely(dma_mapping_error(sc->dev, bf->bf_buf_addr))) {
 364                 dev_kfree_skb_any(skb);
 365                 bf->bf_mpdu = NULL;
 366                 DPRINTF(sc, ATH_DBG_FATAL,
 367                         "dma_mapping_error on beacon alloc\n");
 368                 return -ENOMEM;
 369         }
 370
 371         return 0;
 372 }
 373
 374 void ath_beacon_return(struct ath_softc *sc, struct ath_vif *avp)
 375 {
 376         if (avp->av_bcbuf != NULL) {
 377                 struct ath_buf *bf;
 378
 379                 if (avp->av_bslot != -1) {
 380                         sc->beacon.bslot[avp->av_bslot] = ATH_IF_ID_ANY;
 381                         sc->nbcnvifs--;
 382                 }
 383
 384                 bf = avp->av_bcbuf;
 385                 if (bf->bf_mpdu != NULL) {
 386                         struct sk_buff *skb = (struct sk_buff *)bf->bf_mpdu;
 387                         dma_unmap_single(sc->dev, bf->bf_dmacontext,
 388                                          skb->len, DMA_TO_DEVICE);
 389                         dev_kfree_skb_any(skb);
 390                         bf->bf_mpdu = NULL;
 391                 }
 392                 list_add_tail(&bf->list, &sc->beacon.bbuf);
 393
 394                 avp->av_bcbuf = NULL;
 395         }
 396 }
 397
 398 void ath_beacon_tasklet(unsigned long data)
 399 {
 400         struct ath_softc *sc = (struct ath_softc *)data;
 401         struct ath_hw *ah = sc->sc_ah;
 402         struct ath_buf *bf = NULL;
 403         int slot, if_id;
 404         u32 bfaddr, show_cycles = 0, bc = 0, tsftu;
 405         u32 rx_clear = 0, rx_frame = 0, tx_frame = 0;
 406         u64 tsf;
 407         u16 intval;
 408
 409         if (sc->sc_flags & SC_OP_NO_RESET) {
 410                 show_cycles = ath9k_hw_GetMibCycleCountsPct(ah,
 411                                             &rx_clear, &rx_frame, &tx_frame);
 412         }
 413
 414         /*
 415          * Check if the previous beacon has gone out.  If
 416          * not don't try to post another, skip this period
 417          * and wait for the next.  Missed beacons indicate
 418          * a problem and should not occur.  If we miss too
 419          * many consecutive beacons reset the device.
 420          *
 421          * FIXME: Clean up this mess !!
 422          */
 423         if (ath9k_hw_numtxpending(ah, sc->beacon.beaconq) != 0) {
 424                 sc->beacon.bmisscnt++;
 425                 /* XXX: doth needs the chanchange IE countdown decremented.
 426                  *      We should consider adding a mac80211 call to indicate
 427                  *      a beacon miss so appropriate action could be taken
 428                  *      (in that layer).
 429                  */
 430                 if (sc->beacon.bmisscnt < BSTUCK_THRESH) {
 431                         if (sc->sc_flags & SC_OP_NO_RESET) {
 432                                 DPRINTF(sc, ATH_DBG_BEACON,
 433                                         "missed %u consecutive beacons\n",
 434                                         sc->beacon.bmisscnt);
 435                                 if (show_cycles) {
 436                                         /*
 437                                          * Display cycle counter stats from HW
 438                                          * to aide in debug of stickiness.
 439                                          */
 440                                         DPRINTF(sc, ATH_DBG_BEACON,
 441                                                 "busy times: rx_clear=%d, "
 442                                                 "rx_frame=%d, tx_frame=%d\n",
 443                                                 rx_clear, rx_frame,
 444                                                 tx_frame);
 445                                 } else {
 446                                         DPRINTF(sc, ATH_DBG_BEACON,
 447                                                 "unable to obtain "
 448                                                 "busy times\n");
 449                                 }
 450                         } else {
 451                                 DPRINTF(sc, ATH_DBG_BEACON,
 452                                         "missed %u consecutive beacons\n",
 453                                         sc->beacon.bmisscnt);
 454                         }
 455                 } else if (sc->beacon.bmisscnt >= BSTUCK_THRESH) {
 456                         if (sc->sc_flags & SC_OP_NO_RESET) {
 457                                 if (sc->beacon.bmisscnt == BSTUCK_THRESH) {
 458                                         DPRINTF(sc, ATH_DBG_BEACON,
 459                                                 "beacon is officially "
 460                                                 "stuck\n");
 461                                 }
 462                         } else {
 463                                 DPRINTF(sc, ATH_DBG_BEACON,
 464                                         "beacon is officially stuck\n");
 465                                 ath_bstuck_process(sc);
 466                         }
 467                 }
 468                 return;
 469         }
 470
 471         if (sc->beacon.bmisscnt != 0) {
 472                 if (sc->sc_flags & SC_OP_NO_RESET) {
 473                         DPRINTF(sc, ATH_DBG_BEACON,
 474                                 "resume beacon xmit after %u misses\n",
 475                                 sc->beacon.bmisscnt);
 476                 } else {
 477                         DPRINTF(sc, ATH_DBG_BEACON,
 478                                 "resume beacon xmit after %u misses\n",
 479                                 sc->beacon.bmisscnt);
 480                 }
 481                 sc->beacon.bmisscnt = 0;
 482         }
 483
 484         /*
 485          * Generate beacon frames. we are sending frames
 486          * staggered so calculate the slot for this frame based
 487          * on the tsf to safeguard against missing an swba.
 488          */
 489
 490         intval = sc->hw->conf.beacon_int ?
 491                 sc->hw->conf.beacon_int : ATH_DEFAULT_BINTVAL;
 492
 493         tsf = ath9k_hw_gettsf64(ah);
 494         tsftu = TSF_TO_TU(tsf>>32, tsf);
 495         slot = ((tsftu % intval) * ATH_BCBUF) / intval;
 496         if_id = sc->beacon.bslot[(slot + 1) % ATH_BCBUF];
 497
 498         DPRINTF(sc, ATH_DBG_BEACON,
 499                 "slot %d [tsf %llu tsftu %u intval %u] if_id %d\n",
 500                 slot, (unsigned long long)tsf, tsftu,
 501                 intval, if_id);
 502
 503         bfaddr = 0;
 504         if (if_id != ATH_IF_ID_ANY) {
 505                 bf = ath_beacon_generate(sc, if_id);
 506                 if (bf != NULL) {
 507                         bfaddr = bf->bf_daddr;
 508                         bc = 1;
 509                 }
 510         }
 511         /*
 512          * Handle slot time change when a non-ERP station joins/leaves
 513          * an 11g network.  The 802.11 layer notifies us via callback,
 514          * we mark updateslot, then wait one beacon before effecting
 515          * the change.  This gives associated stations at least one
 516          * beacon interval to note the state change.
 517          *
 518          * NB: The slot time change state machine is clocked according
 519          *     to whether we are bursting or staggering beacons.  We
 520          *     recognize the request to update and record the current
 521          *     slot then don't transition until that slot is reached
 522          *     again.  If we miss a beacon for that slot then we'll be
 523          *     slow to transition but we'll be sure at least one beacon
 524          *     interval has passed.  When bursting slot is always left
 525          *     set to ATH_BCBUF so this check is a noop.
 526          */
 527         /* XXX locking */
 528         if (sc->beacon.updateslot == UPDATE) {
 529                 sc->beacon.updateslot = COMMIT; /* commit next beacon */
 530                 sc->beacon.slotupdate = slot;
 531         } else if (sc->beacon.updateslot == COMMIT && sc->beacon.slotupdate == slot) {
 532                 ath9k_hw_setslottime(sc->sc_ah, sc->beacon.slottime);
 533                 sc->beacon.updateslot = OK;
 534         }
 535         if (bfaddr != 0) {
 536                 /*
 537                  * Stop any current dma and put the new frame(s) on the queue.
 538                  * This should never fail since we check above that no frames
 539                  * are still pending on the queue.
 540                  */
 541                 if (!ath9k_hw_stoptxdma(ah, sc->beacon.beaconq)) {
 542                         DPRINTF(sc, ATH_DBG_FATAL,
 543                                 "beacon queue %u did not stop?\n", sc->beacon.beaconq);
 544                         /* NB: the HAL still stops DMA, so proceed */
 545                 }
 546
 547                 /* NB: cabq traffic should already be queued and primed */
 548                 ath9k_hw_puttxbuf(ah, sc->beacon.beaconq, bfaddr);
 549                 ath9k_hw_txstart(ah, sc->beacon.beaconq);
 550
 551                 sc->beacon.ast_be_xmit += bc;     /* XXX per-vif? */
 552         }
 553 }
 554
 555 /*
 556  * Configure the beacon and sleep timers.
 557  *
 558  * When operating as an AP this resets the TSF and sets
 559  * up the hardware to notify us when we need to issue beacons.
 560  *
 561  * When operating in station mode this sets up the beacon
 562  * timers according to the timestamp of the last received
 563  * beacon and the current TSF, configures PCF and DTIM
 564  * handling, programs the sleep registers so the hardware
 565  * will wakeup in time to receive beacons, and configures
 566  * the beacon miss handling so we'll receive a BMISS
 567  * interrupt when we stop seeing beacons from the AP
 568  * we've associated with.
 569  */
 570 void ath_beacon_config(struct ath_softc *sc, int if_id)
 571 {
 572         struct ieee80211_vif *vif;
 573         struct ath_hw *ah = sc->sc_ah;
 574         struct ath_beacon_config conf;
 575         struct ath_vif *avp;
 576         enum nl80211_iftype opmode;
 577         u32 nexttbtt, intval;
 578
 579         if (if_id != ATH_IF_ID_ANY) {
 580                 vif = sc->vifs[if_id];
 581                 avp = (void *)vif->drv_priv;
 582                 opmode = avp->av_opmode;
 583         } else {
 584                 opmode = sc->sc_ah->opmode;
 585         }
 586
 587         memset(&conf, 0, sizeof(struct ath_beacon_config));
 588
 589         conf.beacon_interval = sc->hw->conf.beacon_int ?
 590                 sc->hw->conf.beacon_int : ATH_DEFAULT_BINTVAL;
 591         conf.listen_interval = 1;
 592         conf.dtim_period = conf.beacon_interval;
 593         conf.dtim_count = 1;
 594         conf.bmiss_timeout = ATH_DEFAULT_BMISS_LIMIT * conf.beacon_interval;
 595
 596         /* extract tstamp from last beacon and convert to TU */
 597         nexttbtt = TSF_TO_TU(sc->beacon.bc_tstamp >> 32, sc->beacon.bc_tstamp);
 598
 599         /* XXX conditionalize multi-bss support? */
 600         if (sc->sc_ah->opmode == NL80211_IFTYPE_AP) {
 601                 /*
 602                  * For multi-bss ap support beacons are either staggered
 603                  * evenly over N slots or burst together.  For the former
 604                  * arrange for the SWBA to be delivered for each slot.
 605                  * Slots that are not occupied will generate nothing.
 606                  */
 607                 /* NB: the beacon interval is kept internally in TU's */
 608                 intval = conf.beacon_interval & ATH9K_BEACON_PERIOD;
 609                 intval /= ATH_BCBUF;    /* for staggered beacons */
 610         } else {
 611                 intval = conf.beacon_interval & ATH9K_BEACON_PERIOD;
 612         }
 613
 614         if (nexttbtt == 0)      /* e.g. for ap mode */
 615                 nexttbtt = intval;
 616         else if (intval)        /* NB: can be 0 for monitor mode */
 617                 nexttbtt = roundup(nexttbtt, intval);
 618
 619         DPRINTF(sc, ATH_DBG_BEACON, "nexttbtt %u intval %u (%u)\n",
 620                 nexttbtt, intval, conf.beacon_interval);
 621
 622         /* Check for NL80211_IFTYPE_AP and sc_nostabeacons for WDS client */
 623         if (sc->sc_ah->opmode == NL80211_IFTYPE_STATION) {
 624                 struct ath9k_beacon_state bs;
 625                 u64 tsf;
 626                 u32 tsftu;
 627                 int dtimperiod, dtimcount, sleepduration;
 628                 int cfpperiod, cfpcount;
 629
 630                 /*
 631                  * Setup dtim and cfp parameters according to
 632                  * last beacon we received (which may be none).
 633                  */
 634                 dtimperiod = conf.dtim_period;
 635                 if (dtimperiod <= 0)            /* NB: 0 if not known */
 636                         dtimperiod = 1;
 637                 dtimcount = conf.dtim_count;
 638                 if (dtimcount >= dtimperiod)    /* NB: sanity check */
 639                         dtimcount = 0;
 640                 cfpperiod = 1;                  /* NB: no PCF support yet */
 641                 cfpcount = 0;
 642
 643                 sleepduration = conf.listen_interval * intval;
 644                 if (sleepduration <= 0)
 645                         sleepduration = intval;
 646
 647 #define FUDGE 2
 648                 /*
 649                  * Pull nexttbtt forward to reflect the current
 650                  * TSF and calculate dtim+cfp state for the result.
 651                  */
 652                 tsf = ath9k_hw_gettsf64(ah);
 653                 tsftu = TSF_TO_TU(tsf>>32, tsf) + FUDGE;
 654                 do {
 655                         nexttbtt += intval;
 656                         if (--dtimcount < 0) {
 657                                 dtimcount = dtimperiod - 1;
 658                                 if (--cfpcount < 0)
 659                                         cfpcount = cfpperiod - 1;
 660                         }
 661                 } while (nexttbtt < tsftu);
 662 #undef FUDGE
 663                 memset(&bs, 0, sizeof(bs));
 664                 bs.bs_intval = intval;
 665                 bs.bs_nexttbtt = nexttbtt;
 666                 bs.bs_dtimperiod = dtimperiod*intval;
 667                 bs.bs_nextdtim = bs.bs_nexttbtt + dtimcount*intval;
 668                 bs.bs_cfpperiod = cfpperiod*bs.bs_dtimperiod;
 669                 bs.bs_cfpnext = bs.bs_nextdtim + cfpcount*bs.bs_dtimperiod;
 670                 bs.bs_cfpmaxduration = 0;
 671
 672                 /*
 673                  * Calculate the number of consecutive beacons to miss
 674                  * before taking a BMISS interrupt.  The configuration
 675                  * is specified in TU so we only need calculate based
 676                  * on the beacon interval.  Note that we clamp the
 677                  * result to at most 15 beacons.
 678                  */
 679                 if (sleepduration > intval) {
 680                         bs.bs_bmissthreshold = conf.listen_interval *
 681                                 ATH_DEFAULT_BMISS_LIMIT / 2;
 682                 } else {
 683                         bs.bs_bmissthreshold =
 684                                 DIV_ROUND_UP(conf.bmiss_timeout, intval);
 685                         if (bs.bs_bmissthreshold > 15)
 686                                 bs.bs_bmissthreshold = 15;
 687                         else if (bs.bs_bmissthreshold <= 0)
 688                                 bs.bs_bmissthreshold = 1;
 689                 }
 690
 691                 /*
 692                  * Calculate sleep duration.  The configuration is
 693                  * given in ms.  We insure a multiple of the beacon
 694                  * period is used.  Also, if the sleep duration is
 695                  * greater than the DTIM period then it makes senses
 696                  * to make it a multiple of that.
 697                  *
 698                  * XXX fixed at 100ms
 699                  */
 700
 701                 bs.bs_sleepduration = roundup(IEEE80211_MS_TO_TU(100),
 702                                               sleepduration);
 703                 if (bs.bs_sleepduration > bs.bs_dtimperiod)
 704                         bs.bs_sleepduration = bs.bs_dtimperiod;
 705
 706                 /* TSF out of range threshold fixed at 1 second */
 707                 bs.bs_tsfoor_threshold = ATH9K_TSFOOR_THRESHOLD;
 708
 709                 DPRINTF(sc, ATH_DBG_BEACON,
 710                         "tsf: %llu tsftu: %u\n", tsf, tsftu);
 711                 DPRINTF(sc, ATH_DBG_BEACON,
 712                         "bmiss: %u sleep: %u cfp-period: %u maxdur: %u next: %u\n",
 713                         bs.bs_bmissthreshold, bs.bs_sleepduration,
 714                         bs.bs_cfpperiod, bs.bs_cfpmaxduration, bs.bs_cfpnext);
 715
 716                 ath9k_hw_set_interrupts(ah, 0);
 717                 ath9k_hw_set_sta_beacon_timers(ah, &bs);
 718                 sc->imask |= ATH9K_INT_BMISS;
 719                 ath9k_hw_set_interrupts(ah, sc->imask);
 720         } else {
 721                 u64 tsf;
 722                 u32 tsftu;
 723
 724                 ath9k_hw_set_interrupts(ah, 0);
 725                 if (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC) {
 726                         /* Pull nexttbtt forward to reflect the current TSF */
 727 #define FUDGE 2
 728                         if (!(intval & ATH9K_BEACON_RESET_TSF)) {
 729                                 tsf = ath9k_hw_gettsf64(ah);
 730                                 tsftu = TSF_TO_TU((u32)(tsf>>32),
 731                                                   (u32)tsf) + FUDGE;
 732                                 do {
 733                                         nexttbtt += intval;
 734                                 } while (nexttbtt < tsftu);
 735                         }
 736 #undef FUDGE
 737                         DPRINTF(sc, ATH_DBG_BEACON,
 738                                 "IBSS nexttbtt %u intval %u (%u)\n",
 739                                 nexttbtt, intval & ~ATH9K_BEACON_RESET_TSF,
 740                                 conf.beacon_interval);
 741
 742                         /*
 743                          * In IBSS mode enable the beacon timers but only
 744                          * enable SWBA interrupts if we need to manually
 745                          * prepare beacon frames.  Otherwise we use a
 746                          * self-linked tx descriptor and let the hardware
 747                          * deal with things.
 748                          */
 749                         intval |= ATH9K_BEACON_ENA;
 750                         if (!(ah->caps.hw_caps & ATH9K_HW_CAP_VEOL))
 751                                 sc->imask |= ATH9K_INT_SWBA;
 752                         ath_beaconq_config(sc);
 753                 } else if (sc->sc_ah->opmode == NL80211_IFTYPE_AP) {
 754                         if (nexttbtt == intval)
 755                                 intval |= ATH9K_BEACON_RESET_TSF;
 756                         /*
 757                          * In AP mode we enable the beacon timers and
 758                          * SWBA interrupts to prepare beacon frames.
 759                          */
 760                         intval |= ATH9K_BEACON_ENA;
 761                         sc->imask |= ATH9K_INT_SWBA;
 762                         ath_beaconq_config(sc);
 763                 }
 764
 765                 ath9k_hw_beaconinit(ah, nexttbtt, intval);
 766                 sc->beacon.bmisscnt = 0;
 767                 ath9k_hw_set_interrupts(ah, sc->imask);
 768
 769                 /*
 770                  * When using a self-linked beacon descriptor in
 771                  * ibss mode load it once here.
 772                  */
 773                 if (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC &&
 774                     (ah->caps.hw_caps & ATH9K_HW_CAP_VEOL))
 775                         ath_beacon_start_adhoc(sc, 0);
 776         }
 777 }
 778
 779 void ath_beacon_sync(struct ath_softc *sc, int if_id)
 780 {
 781         /*
 782          * Resync beacon timers using the tsf of the
 783          * beacon frame we just received.
 784          */
 785         ath_beacon_config(sc, if_id);
 786         sc->sc_flags |= SC_OP_BEACONS;
 787 }