drivers/net/wireless/ath/ath9k/beacon.c

   1 /*
   2  * Copyright (c) 2008-2011 Atheros Communications Inc.
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include <linux/dma-mapping.h>
  18 #include "ath9k.h"
  19
  20 #define FUDGE 2
  21
  22 static void ath9k_reset_beacon_status(struct ath_softc *sc)
  23 {
  24         sc->beacon.tx_processed = false;
  25         sc->beacon.tx_last = false;
  26 }
  27
  28 /*
  29  *  This function will modify certain transmit queue properties depending on
  30  *  the operating mode of the station (AP or AdHoc).  Parameters are AIFS
  31  *  settings and channel width min/max
  32 */
  33 static void ath9k_beaconq_config(struct ath_softc *sc)
  34 {
  35         struct ath_hw *ah = sc->sc_ah;
  36         struct ath_common *common = ath9k_hw_common(ah);
  37         struct ath9k_tx_queue_info qi, qi_be;
  38         struct ath_txq *txq;
  39
  40         ath9k_hw_get_txq_props(ah, sc->beacon.beaconq, &qi);
  41
  42         if (sc->sc_ah->opmode == NL80211_IFTYPE_AP ||
  43             sc->sc_ah->opmode == NL80211_IFTYPE_MESH_POINT) {
  44                 /* Always burst out beacon and CAB traffic. */
  45                 qi.tqi_aifs = 1;
  46                 qi.tqi_cwmin = 0;
  47                 qi.tqi_cwmax = 0;
  48         } else {
  49                 /* Adhoc mode; important thing is to use 2x cwmin. */
  50                 txq = sc->tx.txq_map[IEEE80211_AC_BE];
  51                 ath9k_hw_get_txq_props(ah, txq->axq_qnum, &qi_be);
  52                 qi.tqi_aifs = qi_be.tqi_aifs;
  53                 if (ah->slottime == ATH9K_SLOT_TIME_20)
  54                         qi.tqi_cwmin = 2*qi_be.tqi_cwmin;
  55                 else
  56                         qi.tqi_cwmin = 4*qi_be.tqi_cwmin;
  57                 qi.tqi_cwmax = qi_be.tqi_cwmax;
  58         }
  59
  60         if (!ath9k_hw_set_txq_props(ah, sc->beacon.beaconq, &qi)) {
  61                 ath_err(common, "Unable to update h/w beacon queue parameters\n");
  62         } else {
  63                 ath9k_hw_resettxqueue(ah, sc->beacon.beaconq);
  64         }
  65 }
  66
  67 /*
  68  *  Associates the beacon frame buffer with a transmit descriptor.  Will set
  69  *  up rate codes, and channel flags. Beacons are always sent out at the
  70  *  lowest rate, and are not retried.
  71 */
  72 static void ath9k_beacon_setup(struct ath_softc *sc, struct ieee80211_vif *vif,
  73                              struct ath_buf *bf, int rateidx)
  74 {
  75         struct sk_buff *skb = bf->bf_mpdu;
  76         struct ath_hw *ah = sc->sc_ah;
  77         struct ath_common *common = ath9k_hw_common(ah);
  78         struct ath_tx_info info;
  79         struct ieee80211_supported_band *sband;
  80         u8 chainmask = ah->txchainmask;
  81         u8 rate = 0;
  82
  83         sband = &common->sbands[sc->cur_chandef.chan->band];
  84         rate = sband->bitrates[rateidx].hw_value;
  85         if (vif->bss_conf.use_short_preamble)
  86                 rate |= sband->bitrates[rateidx].hw_value_short;
  87
  88         memset(&info, 0, sizeof(info));
  89         info.pkt_len = skb->len + FCS_LEN;
  90         info.type = ATH9K_PKT_TYPE_BEACON;
  91         info.txpower = MAX_RATE_POWER;
  92         info.keyix = ATH9K_TXKEYIX_INVALID;
  93         info.keytype = ATH9K_KEY_TYPE_CLEAR;
  94         info.flags = ATH9K_TXDESC_NOACK | ATH9K_TXDESC_CLRDMASK;
  95
  96         info.buf_addr[0] = bf->bf_buf_addr;
  97         info.buf_len[0] = roundup(skb->len, 4);
  98
  99         info.is_first = true;
 100         info.is_last = true;
 101
 102         info.qcu = sc->beacon.beaconq;
 103
 104         info.rates[0].Tries = 1;
 105         info.rates[0].Rate = rate;
 106         info.rates[0].ChSel = ath_txchainmask_reduction(sc, chainmask, rate);
 107
 108         ath9k_hw_set_txdesc(ah, bf->bf_desc, &info);
 109 }
 110
 111 static void ath9k_beacon_add_noa(struct ath_softc *sc, struct ath_vif *avp,
 112                                  struct sk_buff *skb)
 113 {
 114         static const u8 noa_ie_hdr[] = {
 115                 WLAN_EID_VENDOR_SPECIFIC,       /* type */
 116                 0,                              /* length */
 117                 0x50, 0x6f, 0x9a,               /* WFA OUI */
 118                 0x09,                           /* P2P subtype */
 119                 0x0c,                           /* Notice of Absence */
 120                 0x00,                           /* LSB of little-endian len */
 121                 0x00,                           /* MSB of little-endian len */
 122         };
 123
 124         struct ieee80211_p2p_noa_attr *noa;
 125         int noa_len = 2 + sizeof(struct ieee80211_p2p_noa_desc);
 126         u8 *hdr;
 127
 128         if (!avp->offchannel_duration)
 129                 return;
 130
 131         hdr = skb_put(skb, sizeof(noa_ie_hdr));
 132         memcpy(hdr, noa_ie_hdr, sizeof(noa_ie_hdr));
 133         hdr[1] = sizeof(noa_ie_hdr) + noa_len - 2;
 134         hdr[7] = noa_len;
 135
 136         noa = (void *) skb_put(skb, noa_len);
 137         memset(noa, 0, noa_len);
 138
 139         noa->index = avp->noa_index;
 140         noa->desc[0].count = 1;
 141         noa->desc[0].duration = cpu_to_le32(avp->offchannel_duration);
 142         noa->desc[0].start_time = cpu_to_le32(avp->offchannel_start);
 143 }
 144
 145 static struct ath_buf *ath9k_beacon_generate(struct ieee80211_hw *hw,
 146                                              struct ieee80211_vif *vif)
 147 {
 148         struct ath_softc *sc = hw->priv;
 149         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 150         struct ath_buf *bf;
 151         struct ath_vif *avp = (void *)vif->drv_priv;
 152         struct sk_buff *skb;
 153         struct ath_txq *cabq = sc->beacon.cabq;
 154         struct ieee80211_tx_info *info;
 155         struct ieee80211_mgmt *mgmt_hdr;
 156         int cabq_depth;
 157
 158         if (avp->av_bcbuf == NULL)
 159                 return NULL;
 160
 161         bf = avp->av_bcbuf;
 162         skb = bf->bf_mpdu;
 163         if (skb) {
 164                 dma_unmap_single(sc->dev, bf->bf_buf_addr,
 165                                  skb->len, DMA_TO_DEVICE);
 166                 dev_kfree_skb_any(skb);
 167                 bf->bf_buf_addr = 0;
 168                 bf->bf_mpdu = NULL;
 169         }
 170
 171         skb = ieee80211_beacon_get(hw, vif);
 172         if (skb == NULL)
 173                 return NULL;
 174
 175         bf->bf_mpdu = skb;
 176
 177         mgmt_hdr = (struct ieee80211_mgmt *)skb->data;
 178         mgmt_hdr->u.beacon.timestamp = avp->tsf_adjust;
 179
 180         info = IEEE80211_SKB_CB(skb);
 181         if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
 182                 /*
 183                  * TODO: make sure the seq# gets assigned properly (vs. other
 184                  * TX frames)
 185                  */
 186                 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
 187                 sc->tx.seq_no += 0x10;
 188                 hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
 189                 hdr->seq_ctrl |= cpu_to_le16(sc->tx.seq_no);
 190         }
 191
 192         if (vif->p2p)
 193                 ath9k_beacon_add_noa(sc, avp, skb);
 194
 195         bf->bf_buf_addr = dma_map_single(sc->dev, skb->data,
 196                                          skb->len, DMA_TO_DEVICE);
 197         if (unlikely(dma_mapping_error(sc->dev, bf->bf_buf_addr))) {
 198                 dev_kfree_skb_any(skb);
 199                 bf->bf_mpdu = NULL;
 200                 bf->bf_buf_addr = 0;
 201                 ath_err(common, "dma_mapping_error on beaconing\n");
 202                 return NULL;
 203         }
 204
 205         skb = ieee80211_get_buffered_bc(hw, vif);
 206
 207         /*
 208          * if the CABQ traffic from previous DTIM is pending and the current
 209          *  beacon is also a DTIM.
 210          *  1) if there is only one vif let the cab traffic continue.
 211          *  2) if there are more than one vif and we are using staggered
 212          *     beacons, then drain the cabq by dropping all the frames in
 213          *     the cabq so that the current vifs cab traffic can be scheduled.
 214          */
 215         spin_lock_bh(&cabq->axq_lock);
 216         cabq_depth = cabq->axq_depth;
 217         spin_unlock_bh(&cabq->axq_lock);
 218
 219         if (skb && cabq_depth) {
 220                 if (sc->nvifs > 1) {
 221                         ath_dbg(common, BEACON,
 222                                 "Flushing previous cabq traffic\n");
 223                         ath_draintxq(sc, cabq);
 224                 }
 225         }
 226
 227         ath9k_beacon_setup(sc, vif, bf, info->control.rates[0].idx);
 228
 229         if (skb)
 230                 ath_tx_cabq(hw, vif, skb);
 231
 232         return bf;
 233 }
 234
 235 void ath9k_beacon_assign_slot(struct ath_softc *sc, struct ieee80211_vif *vif)
 236 {
 237         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 238         struct ath_vif *avp = (void *)vif->drv_priv;
 239         int slot;
 240
 241         avp->av_bcbuf = list_first_entry(&sc->beacon.bbuf, struct ath_buf, list);
 242         list_del(&avp->av_bcbuf->list);
 243
 244         for (slot = 0; slot < ATH_BCBUF; slot++) {
 245                 if (sc->beacon.bslot[slot] == NULL) {
 246                         avp->av_bslot = slot;
 247                         break;
 248                 }
 249         }
 250
 251         sc->beacon.bslot[avp->av_bslot] = vif;
 252         sc->nbcnvifs++;
 253
 254         ath_dbg(common, CONFIG, "Added interface at beacon slot: %d\n",
 255                 avp->av_bslot);
 256 }
 257
 258 void ath9k_beacon_remove_slot(struct ath_softc *sc, struct ieee80211_vif *vif)
 259 {
 260         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 261         struct ath_vif *avp = (void *)vif->drv_priv;
 262         struct ath_buf *bf = avp->av_bcbuf;
 263
 264         ath_dbg(common, CONFIG, "Removing interface at beacon slot: %d\n",
 265                 avp->av_bslot);
 266
 267         tasklet_disable(&sc->bcon_tasklet);
 268
 269         if (bf && bf->bf_mpdu) {
 270                 struct sk_buff *skb = bf->bf_mpdu;
 271                 dma_unmap_single(sc->dev, bf->bf_buf_addr,
 272                                  skb->len, DMA_TO_DEVICE);
 273                 dev_kfree_skb_any(skb);
 274                 bf->bf_mpdu = NULL;
 275                 bf->bf_buf_addr = 0;
 276         }
 277
 278         avp->av_bcbuf = NULL;
 279         sc->beacon.bslot[avp->av_bslot] = NULL;
 280         sc->nbcnvifs--;
 281         list_add_tail(&bf->list, &sc->beacon.bbuf);
 282
 283         tasklet_enable(&sc->bcon_tasklet);
 284 }
 285
 286 static int ath9k_beacon_choose_slot(struct ath_softc *sc)
 287 {
 288         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 289         struct ath_beacon_config *cur_conf = &sc->cur_chan->beacon;
 290         u16 intval;
 291         u32 tsftu;
 292         u64 tsf;
 293         int slot;
 294
 295         if (sc->sc_ah->opmode != NL80211_IFTYPE_AP &&
 296             sc->sc_ah->opmode != NL80211_IFTYPE_MESH_POINT) {
 297                 ath_dbg(common, BEACON, "slot 0, tsf: %llu\n",
 298                         ath9k_hw_gettsf64(sc->sc_ah));
 299                 return 0;
 300         }
 301
 302         intval = cur_conf->beacon_interval ? : ATH_DEFAULT_BINTVAL;
 303         tsf = ath9k_hw_gettsf64(sc->sc_ah);
 304         tsf += TU_TO_USEC(sc->sc_ah->config.sw_beacon_response_time);
 305         tsftu = TSF_TO_TU((tsf * ATH_BCBUF) >>32, tsf * ATH_BCBUF);
 306         slot = (tsftu % (intval * ATH_BCBUF)) / intval;
 307
 308         ath_dbg(common, BEACON, "slot: %d tsf: %llu tsftu: %u\n",
 309                 slot, tsf, tsftu / ATH_BCBUF);
 310
 311         return slot;
 312 }
 313
 314 static void ath9k_set_tsfadjust(struct ath_softc *sc, struct ieee80211_vif *vif)
 315 {
 316         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 317         struct ath_vif *avp = (void *)vif->drv_priv;
 318         struct ath_beacon_config *cur_conf = &avp->chanctx->beacon;
 319         u32 tsfadjust;
 320
 321         if (avp->av_bslot == 0)
 322                 return;
 323
 324         tsfadjust = cur_conf->beacon_interval * avp->av_bslot;
 325         tsfadjust = TU_TO_USEC(tsfadjust) / ATH_BCBUF;
 326         avp->tsf_adjust = cpu_to_le64(tsfadjust);
 327
 328         ath_dbg(common, CONFIG, "tsfadjust is: %llu for bslot: %d\n",
 329                 (unsigned long long)tsfadjust, avp->av_bslot);
 330 }
 331
 332 bool ath9k_csa_is_finished(struct ath_softc *sc, struct ieee80211_vif *vif)
 333 {
 334         if (!vif || !vif->csa_active)
 335                 return false;
 336
 337         if (!ieee80211_csa_is_complete(vif))
 338                 return false;
 339
 340         ieee80211_csa_finish(vif);
 341         return true;
 342 }
 343
 344 static void ath9k_csa_update_vif(void *data, u8 *mac, struct ieee80211_vif *vif)
 345 {
 346         struct ath_softc *sc = data;
 347         ath9k_csa_is_finished(sc, vif);
 348 }
 349
 350 void ath9k_csa_update(struct ath_softc *sc)
 351 {
 352         ieee80211_iterate_active_interfaces_atomic(sc->hw,
 353                                                    IEEE80211_IFACE_ITER_NORMAL,
 354                                                    ath9k_csa_update_vif, sc);
 355 }
 356
 357 void ath9k_beacon_tasklet(unsigned long data)
 358 {
 359         struct ath_softc *sc = (struct ath_softc *)data;
 360         struct ath_hw *ah = sc->sc_ah;
 361         struct ath_common *common = ath9k_hw_common(ah);
 362         struct ath_buf *bf = NULL;
 363         struct ieee80211_vif *vif;
 364         bool edma = !!(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA);
 365         int slot;
 366
 367         if (test_bit(ATH_OP_HW_RESET, &common->op_flags)) {
 368                 ath_dbg(common, RESET,
 369                         "reset work is pending, skip beaconing now\n");
 370                 return;
 371         }
 372
 373         /*
 374          * Check if the previous beacon has gone out.  If
 375          * not don't try to post another, skip this period
 376          * and wait for the next.  Missed beacons indicate
 377          * a problem and should not occur.  If we miss too
 378          * many consecutive beacons reset the device.
 379          */
 380         if (ath9k_hw_numtxpending(ah, sc->beacon.beaconq) != 0) {
 381                 sc->beacon.bmisscnt++;
 382
 383                 ath9k_hw_check_nav(ah);
 384
 385                 /*
 386                  * If the previous beacon has not been transmitted
 387                  * and a MAC/BB hang has been identified, return
 388                  * here because a chip reset would have been
 389                  * initiated.
 390                  */
 391                 if (!ath_hw_check(sc))
 392                         return;
 393
 394                 if (sc->beacon.bmisscnt < BSTUCK_THRESH * sc->nbcnvifs) {
 395                         ath_dbg(common, BSTUCK,
 396                                 "missed %u consecutive beacons\n",
 397                                 sc->beacon.bmisscnt);
 398                         ath9k_hw_stop_dma_queue(ah, sc->beacon.beaconq);
 399                         if (sc->beacon.bmisscnt > 3)
 400                                 ath9k_hw_bstuck_nfcal(ah);
 401                 } else if (sc->beacon.bmisscnt >= BSTUCK_THRESH) {
 402                         ath_dbg(common, BSTUCK, "beacon is officially stuck\n");
 403                         sc->beacon.bmisscnt = 0;
 404                         ath9k_queue_reset(sc, RESET_TYPE_BEACON_STUCK);
 405                 }
 406
 407                 return;
 408         }
 409
 410         slot = ath9k_beacon_choose_slot(sc);
 411         vif = sc->beacon.bslot[slot];
 412
 413         /* EDMA devices check that in the tx completion function. */
 414         if (!edma) {
 415                 if (sc->sched.beacon_pending)
 416                         ath_chanctx_event(sc, NULL,
 417                                           ATH_CHANCTX_EVENT_BEACON_SENT);
 418
 419                 if (ath9k_csa_is_finished(sc, vif))
 420                         return;
 421         }
 422
 423         if (!vif || !vif->bss_conf.enable_beacon)
 424                 return;
 425
 426         ath_chanctx_event(sc, vif, ATH_CHANCTX_EVENT_BEACON_PREPARE);
 427         bf = ath9k_beacon_generate(sc->hw, vif);
 428
 429         if (sc->beacon.bmisscnt != 0) {
 430                 ath_dbg(common, BSTUCK, "resume beacon xmit after %u misses\n",
 431                         sc->beacon.bmisscnt);
 432                 sc->beacon.bmisscnt = 0;
 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;
 453                 sc->beacon.slotupdate = slot;
 454         } else if (sc->beacon.updateslot == COMMIT &&
 455                    sc->beacon.slotupdate == slot) {
 456                 ah->slottime = sc->beacon.slottime;
 457                 ath9k_hw_init_global_settings(ah);
 458                 sc->beacon.updateslot = OK;
 459         }
 460
 461         if (bf) {
 462                 ath9k_reset_beacon_status(sc);
 463
 464                 ath_dbg(common, BEACON,
 465                         "Transmitting beacon for slot: %d\n", slot);
 466
 467                 /* NB: cabq traffic should already be queued and primed */
 468                 ath9k_hw_puttxbuf(ah, sc->beacon.beaconq, bf->bf_daddr);
 469
 470                 if (!edma)
 471                         ath9k_hw_txstart(ah, sc->beacon.beaconq);
 472         }
 473 }
 474
 475 /*
 476  * Both nexttbtt and intval have to be in usecs.
 477  */
 478 static void ath9k_beacon_init(struct ath_softc *sc, u32 nexttbtt,
 479                               u32 intval, bool reset_tsf)
 480 {
 481         struct ath_hw *ah = sc->sc_ah;
 482
 483         ath9k_hw_disable_interrupts(ah);
 484         if (reset_tsf)
 485                 ath9k_hw_reset_tsf(ah);
 486         ath9k_beaconq_config(sc);
 487         ath9k_hw_beaconinit(ah, nexttbtt, intval);
 488         sc->beacon.bmisscnt = 0;
 489         ath9k_hw_set_interrupts(ah);
 490         ath9k_hw_enable_interrupts(ah);
 491 }
 492
 493 /*
 494  * For multi-bss ap support beacons are either staggered evenly over N slots or
 495  * burst together.  For the former arrange for the SWBA to be delivered for each
 496  * slot. Slots that are not occupied will generate nothing.
 497  */
 498 static void ath9k_beacon_config_ap(struct ath_softc *sc,
 499                                    struct ath_beacon_config *conf)
 500 {
 501         struct ath_hw *ah = sc->sc_ah;
 502
 503         ath9k_cmn_beacon_config_ap(ah, conf, ATH_BCBUF);
 504         ath9k_beacon_init(sc, conf->nexttbtt, conf->intval, false);
 505 }
 506
 507 static void ath9k_beacon_config_sta(struct ath_hw *ah,
 508                                     struct ath_beacon_config *conf)
 509 {
 510         struct ath9k_beacon_state bs;
 511
 512         if (ath9k_cmn_beacon_config_sta(ah, conf, &bs) == -EPERM)
 513                 return;
 514
 515         ath9k_hw_disable_interrupts(ah);
 516         ath9k_hw_set_sta_beacon_timers(ah, &bs);
 517         ah->imask |= ATH9K_INT_BMISS;
 518
 519         ath9k_hw_set_interrupts(ah);
 520         ath9k_hw_enable_interrupts(ah);
 521 }
 522
 523 static void ath9k_beacon_config_adhoc(struct ath_softc *sc,
 524                                       struct ath_beacon_config *conf)
 525 {
 526         struct ath_hw *ah = sc->sc_ah;
 527         struct ath_common *common = ath9k_hw_common(ah);
 528
 529         ath9k_reset_beacon_status(sc);
 530
 531         ath9k_cmn_beacon_config_adhoc(ah, conf);
 532
 533         ath9k_beacon_init(sc, conf->nexttbtt, conf->intval, conf->ibss_creator);
 534
 535         /*
 536          * Set the global 'beacon has been configured' flag for the
 537          * joiner case in IBSS mode.
 538          */
 539         if (!conf->ibss_creator && conf->enable_beacon)
 540                 set_bit(ATH_OP_BEACONS, &common->op_flags);
 541 }
 542
 543 static bool ath9k_allow_beacon_config(struct ath_softc *sc,
 544                                       struct ieee80211_vif *vif)
 545 {
 546         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 547
 548         if (sc->sc_ah->opmode == NL80211_IFTYPE_AP) {
 549                 if ((vif->type != NL80211_IFTYPE_AP) ||
 550                     (sc->nbcnvifs > 1)) {
 551                         ath_dbg(common, CONFIG,
 552                                 "An AP interface is already present !\n");
 553                         return false;
 554                 }
 555         }
 556
 557         if (sc->sc_ah->opmode == NL80211_IFTYPE_STATION) {
 558                 if ((vif->type == NL80211_IFTYPE_STATION) &&
 559                     test_bit(ATH_OP_BEACONS, &common->op_flags) &&
 560                     vif != sc->cur_chan->primary_sta) {
 561                         ath_dbg(common, CONFIG,
 562                                 "Beacon already configured for a station interface\n");
 563                         return false;
 564                 }
 565         }
 566
 567         return true;
 568 }
 569
 570 static void ath9k_cache_beacon_config(struct ath_softc *sc,
 571                                       struct ath_chanctx *ctx,
 572                                       struct ieee80211_bss_conf *bss_conf)
 573 {
 574         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 575         struct ath_beacon_config *cur_conf = &ctx->beacon;
 576
 577         ath_dbg(common, BEACON,
 578                 "Caching beacon data for BSS: %pM\n", bss_conf->bssid);
 579
 580         cur_conf->beacon_interval = bss_conf->beacon_int;
 581         cur_conf->dtim_period = bss_conf->dtim_period;
 582         cur_conf->dtim_count = 1;
 583         cur_conf->ibss_creator = bss_conf->ibss_creator;
 584
 585         /*
 586          * It looks like mac80211 may end up using beacon interval of zero in
 587          * some cases (at least for mesh point). Avoid getting into an
 588          * infinite loop by using a bit safer value instead. To be safe,
 589          * do sanity check on beacon interval for all operating modes.
 590          */
 591         if (cur_conf->beacon_interval == 0)
 592                 cur_conf->beacon_interval = 100;
 593
 594         cur_conf->bmiss_timeout =
 595                 ATH_DEFAULT_BMISS_LIMIT * cur_conf->beacon_interval;
 596
 597         /*
 598          * We don't parse dtim period from mac80211 during the driver
 599          * initialization as it breaks association with hidden-ssid
 600          * AP and it causes latency in roaming
 601          */
 602         if (cur_conf->dtim_period == 0)
 603                 cur_conf->dtim_period = 1;
 604
 605 }
 606
 607 void ath9k_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif,
 608                          u32 changed)
 609 {
 610         struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
 611         struct ath_hw *ah = sc->sc_ah;
 612         struct ath_common *common = ath9k_hw_common(ah);
 613         struct ath_vif *avp = (void *)vif->drv_priv;
 614         struct ath_chanctx *ctx = avp->chanctx;
 615         struct ath_beacon_config *cur_conf;
 616         unsigned long flags;
 617         bool skip_beacon = false;
 618
 619         if (!ctx)
 620                 return;
 621
 622         cur_conf = &avp->chanctx->beacon;
 623         if (vif->type == NL80211_IFTYPE_AP)
 624                 ath9k_set_tsfadjust(sc, vif);
 625
 626         if (!ath9k_allow_beacon_config(sc, vif))
 627                 return;
 628
 629         if (vif->type == NL80211_IFTYPE_STATION) {
 630                 ath9k_cache_beacon_config(sc, ctx, bss_conf);
 631                 if (ctx != sc->cur_chan)
 632                         return;
 633
 634                 ath9k_set_beacon(sc);
 635                 set_bit(ATH_OP_BEACONS, &common->op_flags);
 636                 return;
 637         }
 638
 639         /*
 640          * Take care of multiple interfaces when
 641          * enabling/disabling SWBA.
 642          */
 643         if (changed & BSS_CHANGED_BEACON_ENABLED) {
 644                 if (!bss_conf->enable_beacon &&
 645                     (sc->nbcnvifs <= 1)) {
 646                         cur_conf->enable_beacon = false;
 647                 } else if (bss_conf->enable_beacon) {
 648                         cur_conf->enable_beacon = true;
 649                         ath9k_cache_beacon_config(sc, ctx, bss_conf);
 650                 }
 651         }
 652
 653         if (ctx != sc->cur_chan)
 654                 return;
 655
 656         /*
 657          * Configure the HW beacon registers only when we have a valid
 658          * beacon interval.
 659          */
 660         if (cur_conf->beacon_interval) {
 661                 /*
 662                  * If we are joining an existing IBSS network, start beaconing
 663                  * only after a TSF-sync has taken place. Ensure that this
 664                  * happens by setting the appropriate flags.
 665                  */
 666                 if ((changed & BSS_CHANGED_IBSS) && !bss_conf->ibss_creator &&
 667                     bss_conf->enable_beacon) {
 668                         spin_lock_irqsave(&sc->sc_pm_lock, flags);
 669                         sc->ps_flags |= PS_BEACON_SYNC | PS_WAIT_FOR_BEACON;
 670                         spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
 671                         skip_beacon = true;
 672                 } else {
 673                         ath9k_set_beacon(sc);
 674                 }
 675
 676                 /*
 677                  * Do not set the ATH_OP_BEACONS flag for IBSS joiner mode
 678                  * here, it is done in ath9k_beacon_config_adhoc().
 679                  */
 680                 if (cur_conf->enable_beacon && !skip_beacon)
 681                         set_bit(ATH_OP_BEACONS, &common->op_flags);
 682                 else
 683                         clear_bit(ATH_OP_BEACONS, &common->op_flags);
 684         }
 685 }
 686
 687 void ath9k_set_beacon(struct ath_softc *sc)
 688 {
 689         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 690         struct ath_beacon_config *cur_conf = &sc->cur_chan->beacon;
 691
 692         switch (sc->sc_ah->opmode) {
 693         case NL80211_IFTYPE_AP:
 694         case NL80211_IFTYPE_MESH_POINT:
 695                 ath9k_beacon_config_ap(sc, cur_conf);
 696                 break;
 697         case NL80211_IFTYPE_ADHOC:
 698                 ath9k_beacon_config_adhoc(sc, cur_conf);
 699                 break;
 700         case NL80211_IFTYPE_STATION:
 701                 ath9k_beacon_config_sta(sc->sc_ah, cur_conf);
 702                 break;
 703         default:
 704                 ath_dbg(common, CONFIG, "Unsupported beaconing mode\n");
 705                 return;
 706         }
 707 }