Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
beacon.c
Go to the documentation of this file.
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  /* Always burst out beacon and CAB traffic. */
44  qi.tqi_aifs = 1;
45  qi.tqi_cwmin = 0;
46  qi.tqi_cwmax = 0;
47  } else {
48  /* Adhoc mode; important thing is to use 2x cwmin. */
49  txq = sc->tx.txq_map[WME_AC_BE];
50  ath9k_hw_get_txq_props(ah, txq->axq_qnum, &qi_be);
51  qi.tqi_aifs = qi_be.tqi_aifs;
52  if (ah->slottime == ATH9K_SLOT_TIME_20)
53  qi.tqi_cwmin = 2*qi_be.tqi_cwmin;
54  else
55  qi.tqi_cwmin = 4*qi_be.tqi_cwmin;
56  qi.tqi_cwmax = qi_be.tqi_cwmax;
57  }
58 
59  if (!ath9k_hw_set_txq_props(ah, sc->beacon.beaconq, &qi)) {
60  ath_err(common, "Unable to update h/w beacon queue parameters\n");
61  } else {
62  ath9k_hw_resettxqueue(ah, sc->beacon.beaconq);
63  }
64 }
65 
66 /*
67  * Associates the beacon frame buffer with a transmit descriptor. Will set
68  * up rate codes, and channel flags. Beacons are always sent out at the
69  * lowest rate, and are not retried.
70 */
71 static void ath9k_beacon_setup(struct ath_softc *sc, struct ieee80211_vif *vif,
72  struct ath_buf *bf, int rateidx)
73 {
74  struct sk_buff *skb = bf->bf_mpdu;
75  struct ath_hw *ah = sc->sc_ah;
76  struct ath_common *common = ath9k_hw_common(ah);
77  struct ath_tx_info info;
78  struct ieee80211_supported_band *sband;
79  u8 chainmask = ah->txchainmask;
80  u8 rate = 0;
81 
82  sband = &sc->sbands[common->hw->conf.channel->band];
83  rate = sband->bitrates[rateidx].hw_value;
84  if (vif->bss_conf.use_short_preamble)
85  rate |= sband->bitrates[rateidx].hw_value_short;
86 
87  memset(&info, 0, sizeof(info));
88  info.pkt_len = skb->len + FCS_LEN;
90  info.txpower = MAX_RATE_POWER;
92  info.keytype = ATH9K_KEY_TYPE_CLEAR;
94 
95  info.buf_addr[0] = bf->bf_buf_addr;
96  info.buf_len[0] = roundup(skb->len, 4);
97 
98  info.is_first = true;
99  info.is_last = true;
100 
101  info.qcu = sc->beacon.beaconq;
102 
103  info.rates[0].Tries = 1;
104  info.rates[0].Rate = rate;
105  info.rates[0].ChSel = ath_txchainmask_reduction(sc, chainmask, rate);
106 
107  ath9k_hw_set_txdesc(ah, bf->bf_desc, &info);
108 }
109 
110 static void ath9k_tx_cabq(struct ieee80211_hw *hw, struct sk_buff *skb)
111 {
112  struct ath_softc *sc = hw->priv;
113  struct ath_common *common = ath9k_hw_common(sc->sc_ah);
114  struct ath_tx_control txctl;
115 
116  memset(&txctl, 0, sizeof(struct ath_tx_control));
117  txctl.txq = sc->beacon.cabq;
118 
119  ath_dbg(common, XMIT, "transmitting CABQ packet, skb: %p\n", skb);
120 
121  if (ath_tx_start(hw, skb, &txctl) != 0) {
122  ath_dbg(common, XMIT, "CABQ TX failed\n");
123  ieee80211_free_txskb(hw, skb);
124  }
125 }
126 
127 static struct ath_buf *ath9k_beacon_generate(struct ieee80211_hw *hw,
128  struct ieee80211_vif *vif)
129 {
130  struct ath_softc *sc = hw->priv;
131  struct ath_common *common = ath9k_hw_common(sc->sc_ah);
132  struct ath_buf *bf;
133  struct ath_vif *avp = (void *)vif->drv_priv;
134  struct sk_buff *skb;
135  struct ath_txq *cabq = sc->beacon.cabq;
136  struct ieee80211_tx_info *info;
137  struct ieee80211_mgmt *mgmt_hdr;
138  int cabq_depth;
139 
140  if (avp->av_bcbuf == NULL)
141  return NULL;
142 
143  bf = avp->av_bcbuf;
144  skb = bf->bf_mpdu;
145  if (skb) {
147  skb->len, DMA_TO_DEVICE);
148  dev_kfree_skb_any(skb);
149  bf->bf_buf_addr = 0;
150  }
151 
152  skb = ieee80211_beacon_get(hw, vif);
153  if (skb == NULL)
154  return NULL;
155 
156  bf->bf_mpdu = skb;
157 
158  mgmt_hdr = (struct ieee80211_mgmt *)skb->data;
159  mgmt_hdr->u.beacon.timestamp = avp->tsf_adjust;
160 
161  info = IEEE80211_SKB_CB(skb);
162  if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
163  /*
164  * TODO: make sure the seq# gets assigned properly (vs. other
165  * TX frames)
166  */
167  struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
168  sc->tx.seq_no += 0x10;
170  hdr->seq_ctrl |= cpu_to_le16(sc->tx.seq_no);
171  }
172 
173  bf->bf_buf_addr = dma_map_single(sc->dev, skb->data,
174  skb->len, DMA_TO_DEVICE);
175  if (unlikely(dma_mapping_error(sc->dev, bf->bf_buf_addr))) {
176  dev_kfree_skb_any(skb);
177  bf->bf_mpdu = NULL;
178  bf->bf_buf_addr = 0;
179  ath_err(common, "dma_mapping_error on beaconing\n");
180  return NULL;
181  }
182 
183  skb = ieee80211_get_buffered_bc(hw, vif);
184 
185  /*
186  * if the CABQ traffic from previous DTIM is pending and the current
187  * beacon is also a DTIM.
188  * 1) if there is only one vif let the cab traffic continue.
189  * 2) if there are more than one vif and we are using staggered
190  * beacons, then drain the cabq by dropping all the frames in
191  * the cabq so that the current vifs cab traffic can be scheduled.
192  */
193  spin_lock_bh(&cabq->axq_lock);
194  cabq_depth = cabq->axq_depth;
195  spin_unlock_bh(&cabq->axq_lock);
196 
197  if (skb && cabq_depth) {
198  if (sc->nvifs > 1) {
199  ath_dbg(common, BEACON,
200  "Flushing previous cabq traffic\n");
201  ath_draintxq(sc, cabq, false);
202  }
203  }
204 
205  ath9k_beacon_setup(sc, vif, bf, info->control.rates[0].idx);
206 
207  while (skb) {
208  ath9k_tx_cabq(hw, skb);
209  skb = ieee80211_get_buffered_bc(hw, vif);
210  }
211 
212  return bf;
213 }
214 
215 void ath9k_beacon_assign_slot(struct ath_softc *sc, struct ieee80211_vif *vif)
216 {
217  struct ath_common *common = ath9k_hw_common(sc->sc_ah);
218  struct ath_vif *avp = (void *)vif->drv_priv;
219  int slot;
220 
221  avp->av_bcbuf = list_first_entry(&sc->beacon.bbuf, struct ath_buf, list);
222  list_del(&avp->av_bcbuf->list);
223 
224  for (slot = 0; slot < ATH_BCBUF; slot++) {
225  if (sc->beacon.bslot[slot] == NULL) {
226  avp->av_bslot = slot;
227  break;
228  }
229  }
230 
231  sc->beacon.bslot[avp->av_bslot] = vif;
232  sc->nbcnvifs++;
233 
234  ath_dbg(common, CONFIG, "Added interface at beacon slot: %d\n",
235  avp->av_bslot);
236 }
237 
238 void ath9k_beacon_remove_slot(struct ath_softc *sc, struct ieee80211_vif *vif)
239 {
240  struct ath_common *common = ath9k_hw_common(sc->sc_ah);
241  struct ath_vif *avp = (void *)vif->drv_priv;
242  struct ath_buf *bf = avp->av_bcbuf;
243 
244  ath_dbg(common, CONFIG, "Removing interface at beacon slot: %d\n",
245  avp->av_bslot);
246 
247  tasklet_disable(&sc->bcon_tasklet);
248 
249  if (bf && bf->bf_mpdu) {
250  struct sk_buff *skb = bf->bf_mpdu;
252  skb->len, DMA_TO_DEVICE);
253  dev_kfree_skb_any(skb);
254  bf->bf_mpdu = NULL;
255  bf->bf_buf_addr = 0;
256  }
257 
258  avp->av_bcbuf = NULL;
259  sc->beacon.bslot[avp->av_bslot] = NULL;
260  sc->nbcnvifs--;
261  list_add_tail(&bf->list, &sc->beacon.bbuf);
262 
263  tasklet_enable(&sc->bcon_tasklet);
264 }
265 
266 static int ath9k_beacon_choose_slot(struct ath_softc *sc)
267 {
268  struct ath_common *common = ath9k_hw_common(sc->sc_ah);
269  struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf;
270  u16 intval;
271  u32 tsftu;
272  u64 tsf;
273  int slot;
274 
275  if (sc->sc_ah->opmode != NL80211_IFTYPE_AP) {
276  ath_dbg(common, BEACON, "slot 0, tsf: %llu\n",
277  ath9k_hw_gettsf64(sc->sc_ah));
278  return 0;
279  }
280 
281  intval = cur_conf->beacon_interval ? : ATH_DEFAULT_BINTVAL;
282  tsf = ath9k_hw_gettsf64(sc->sc_ah);
283  tsf += TU_TO_USEC(sc->sc_ah->config.sw_beacon_response_time);
284  tsftu = TSF_TO_TU((tsf * ATH_BCBUF) >>32, tsf * ATH_BCBUF);
285  slot = (tsftu % (intval * ATH_BCBUF)) / intval;
286 
287  ath_dbg(common, BEACON, "slot: %d tsf: %llu tsftu: %u\n",
288  slot, tsf, tsftu / ATH_BCBUF);
289 
290  return slot;
291 }
292 
293 void ath9k_set_tsfadjust(struct ath_softc *sc, struct ieee80211_vif *vif)
294 {
295  struct ath_common *common = ath9k_hw_common(sc->sc_ah);
296  struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf;
297  struct ath_vif *avp = (void *)vif->drv_priv;
298  u64 tsfadjust;
299 
300  if (avp->av_bslot == 0)
301  return;
302 
303  tsfadjust = cur_conf->beacon_interval * avp->av_bslot / ATH_BCBUF;
304  avp->tsf_adjust = cpu_to_le64(TU_TO_USEC(tsfadjust));
305 
306  ath_dbg(common, CONFIG, "tsfadjust is: %llu for bslot: %d\n",
307  (unsigned long long)tsfadjust, avp->av_bslot);
308 }
309 
310 void ath9k_beacon_tasklet(unsigned long data)
311 {
312  struct ath_softc *sc = (struct ath_softc *)data;
313  struct ath_hw *ah = sc->sc_ah;
314  struct ath_common *common = ath9k_hw_common(ah);
315  struct ath_buf *bf = NULL;
316  struct ieee80211_vif *vif;
317  bool edma = !!(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA);
318  int slot;
319 
320  if (test_bit(SC_OP_HW_RESET, &sc->sc_flags)) {
321  ath_dbg(common, RESET,
322  "reset work is pending, skip beaconing now\n");
323  return;
324  }
325 
326  /*
327  * Check if the previous beacon has gone out. If
328  * not don't try to post another, skip this period
329  * and wait for the next. Missed beacons indicate
330  * a problem and should not occur. If we miss too
331  * many consecutive beacons reset the device.
332  */
333  if (ath9k_hw_numtxpending(ah, sc->beacon.beaconq) != 0) {
334  sc->beacon.bmisscnt++;
335 
336  if (!ath9k_hw_check_alive(ah))
338 
339  if (sc->beacon.bmisscnt < BSTUCK_THRESH * sc->nbcnvifs) {
340  ath_dbg(common, BSTUCK,
341  "missed %u consecutive beacons\n",
342  sc->beacon.bmisscnt);
343  ath9k_hw_stop_dma_queue(ah, sc->beacon.beaconq);
344  if (sc->beacon.bmisscnt > 3)
346  } else if (sc->beacon.bmisscnt >= BSTUCK_THRESH) {
347  ath_dbg(common, BSTUCK, "beacon is officially stuck\n");
348  sc->beacon.bmisscnt = 0;
350  }
351 
352  return;
353  }
354 
355  slot = ath9k_beacon_choose_slot(sc);
356  vif = sc->beacon.bslot[slot];
357 
358  if (!vif || !vif->bss_conf.enable_beacon)
359  return;
360 
361  bf = ath9k_beacon_generate(sc->hw, vif);
362  WARN_ON(!bf);
363 
364  if (sc->beacon.bmisscnt != 0) {
365  ath_dbg(common, BSTUCK, "resume beacon xmit after %u misses\n",
366  sc->beacon.bmisscnt);
367  sc->beacon.bmisscnt = 0;
368  }
369 
370  /*
371  * Handle slot time change when a non-ERP station joins/leaves
372  * an 11g network. The 802.11 layer notifies us via callback,
373  * we mark updateslot, then wait one beacon before effecting
374  * the change. This gives associated stations at least one
375  * beacon interval to note the state change.
376  *
377  * NB: The slot time change state machine is clocked according
378  * to whether we are bursting or staggering beacons. We
379  * recognize the request to update and record the current
380  * slot then don't transition until that slot is reached
381  * again. If we miss a beacon for that slot then we'll be
382  * slow to transition but we'll be sure at least one beacon
383  * interval has passed. When bursting slot is always left
384  * set to ATH_BCBUF so this check is a noop.
385  */
386  if (sc->beacon.updateslot == UPDATE) {
387  sc->beacon.updateslot = COMMIT;
388  sc->beacon.slotupdate = slot;
389  } else if (sc->beacon.updateslot == COMMIT &&
390  sc->beacon.slotupdate == slot) {
391  ah->slottime = sc->beacon.slottime;
393  sc->beacon.updateslot = OK;
394  }
395 
396  if (bf) {
397  ath9k_reset_beacon_status(sc);
398 
399  ath_dbg(common, BEACON,
400  "Transmitting beacon for slot: %d\n", slot);
401 
402  /* NB: cabq traffic should already be queued and primed */
403  ath9k_hw_puttxbuf(ah, sc->beacon.beaconq, bf->bf_daddr);
404 
405  if (!edma)
406  ath9k_hw_txstart(ah, sc->beacon.beaconq);
407  }
408 }
409 
410 static void ath9k_beacon_init(struct ath_softc *sc, u32 nexttbtt, u32 intval)
411 {
412  struct ath_hw *ah = sc->sc_ah;
413 
415  ath9k_hw_reset_tsf(ah);
416  ath9k_beaconq_config(sc);
417  ath9k_hw_beaconinit(ah, nexttbtt, intval);
418  sc->beacon.bmisscnt = 0;
421 }
422 
423 /*
424  * For multi-bss ap support beacons are either staggered evenly over N slots or
425  * burst together. For the former arrange for the SWBA to be delivered for each
426  * slot. Slots that are not occupied will generate nothing.
427  */
428 static void ath9k_beacon_config_ap(struct ath_softc *sc,
429  struct ath_beacon_config *conf)
430 {
431  struct ath_hw *ah = sc->sc_ah;
432  struct ath_common *common = ath9k_hw_common(ah);
433  u32 nexttbtt, intval;
434 
435  /* NB: the beacon interval is kept internally in TU's */
436  intval = TU_TO_USEC(conf->beacon_interval);
437  intval /= ATH_BCBUF;
438  nexttbtt = intval;
439 
440  if (conf->enable_beacon)
441  ah->imask |= ATH9K_INT_SWBA;
442  else
443  ah->imask &= ~ATH9K_INT_SWBA;
444 
445  ath_dbg(common, BEACON, "AP nexttbtt: %u intval: %u conf_intval: %u\n",
446  nexttbtt, intval, conf->beacon_interval);
447 
448  ath9k_beacon_init(sc, nexttbtt, intval);
449 }
450 
451 /*
452  * This sets up the beacon timers according to the timestamp of the last
453  * received beacon and the current TSF, configures PCF and DTIM
454  * handling, programs the sleep registers so the hardware will wakeup in
455  * time to receive beacons, and configures the beacon miss handling so
456  * we'll receive a BMISS interrupt when we stop seeing beacons from the AP
457  * we've associated with.
458  */
459 static void ath9k_beacon_config_sta(struct ath_softc *sc,
460  struct ath_beacon_config *conf)
461 {
462  struct ath_hw *ah = sc->sc_ah;
463  struct ath_common *common = ath9k_hw_common(ah);
464  struct ath9k_beacon_state bs;
465  int dtimperiod, dtimcount, sleepduration;
466  int cfpperiod, cfpcount;
467  u32 nexttbtt = 0, intval, tsftu;
468  u64 tsf;
469  int num_beacons, offset, dtim_dec_count, cfp_dec_count;
470 
471  /* No need to configure beacon if we are not associated */
472  if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) {
473  ath_dbg(common, BEACON,
474  "STA is not yet associated..skipping beacon config\n");
475  return;
476  }
477 
478  memset(&bs, 0, sizeof(bs));
479  intval = conf->beacon_interval;
480 
481  /*
482  * Setup dtim and cfp parameters according to
483  * last beacon we received (which may be none).
484  */
485  dtimperiod = conf->dtim_period;
486  dtimcount = conf->dtim_count;
487  if (dtimcount >= dtimperiod) /* NB: sanity check */
488  dtimcount = 0;
489  cfpperiod = 1; /* NB: no PCF support yet */
490  cfpcount = 0;
491 
492  sleepduration = conf->listen_interval * intval;
493 
494  /*
495  * Pull nexttbtt forward to reflect the current
496  * TSF and calculate dtim+cfp state for the result.
497  */
498  tsf = ath9k_hw_gettsf64(ah);
499  tsftu = TSF_TO_TU(tsf>>32, tsf) + FUDGE;
500 
501  num_beacons = tsftu / intval + 1;
502  offset = tsftu % intval;
503  nexttbtt = tsftu - offset;
504  if (offset)
505  nexttbtt += intval;
506 
507  /* DTIM Beacon every dtimperiod Beacon */
508  dtim_dec_count = num_beacons % dtimperiod;
509  /* CFP every cfpperiod DTIM Beacon */
510  cfp_dec_count = (num_beacons / dtimperiod) % cfpperiod;
511  if (dtim_dec_count)
512  cfp_dec_count++;
513 
514  dtimcount -= dtim_dec_count;
515  if (dtimcount < 0)
516  dtimcount += dtimperiod;
517 
518  cfpcount -= cfp_dec_count;
519  if (cfpcount < 0)
520  cfpcount += cfpperiod;
521 
522  bs.bs_intval = intval;
523  bs.bs_nexttbtt = nexttbtt;
524  bs.bs_dtimperiod = dtimperiod*intval;
525  bs.bs_nextdtim = bs.bs_nexttbtt + dtimcount*intval;
526  bs.bs_cfpperiod = cfpperiod*bs.bs_dtimperiod;
527  bs.bs_cfpnext = bs.bs_nextdtim + cfpcount*bs.bs_dtimperiod;
528  bs.bs_cfpmaxduration = 0;
529 
530  /*
531  * Calculate the number of consecutive beacons to miss* before taking
532  * a BMISS interrupt. The configuration is specified in TU so we only
533  * need calculate based on the beacon interval. Note that we clamp the
534  * result to at most 15 beacons.
535  */
536  if (sleepduration > intval) {
537  bs.bs_bmissthreshold = conf->listen_interval *
539  } else {
540  bs.bs_bmissthreshold = DIV_ROUND_UP(conf->bmiss_timeout, intval);
541  if (bs.bs_bmissthreshold > 15)
542  bs.bs_bmissthreshold = 15;
543  else if (bs.bs_bmissthreshold <= 0)
544  bs.bs_bmissthreshold = 1;
545  }
546 
547  /*
548  * Calculate sleep duration. The configuration is given in ms.
549  * We ensure a multiple of the beacon period is used. Also, if the sleep
550  * duration is greater than the DTIM period then it makes senses
551  * to make it a multiple of that.
552  *
553  * XXX fixed at 100ms
554  */
555 
556  bs.bs_sleepduration = roundup(IEEE80211_MS_TO_TU(100), sleepduration);
557  if (bs.bs_sleepduration > bs.bs_dtimperiod)
558  bs.bs_sleepduration = bs.bs_dtimperiod;
559 
560  /* TSF out of range threshold fixed at 1 second */
561  bs.bs_tsfoor_threshold = ATH9K_TSFOOR_THRESHOLD;
562 
563  ath_dbg(common, BEACON, "tsf: %llu tsftu: %u\n", tsf, tsftu);
564  ath_dbg(common, BEACON,
565  "bmiss: %u sleep: %u cfp-period: %u maxdur: %u next: %u\n",
566  bs.bs_bmissthreshold, bs.bs_sleepduration,
567  bs.bs_cfpperiod, bs.bs_cfpmaxduration, bs.bs_cfpnext);
568 
569  /* Set the computed STA beacon timers */
570 
573  ah->imask |= ATH9K_INT_BMISS;
574 
577 }
578 
579 static void ath9k_beacon_config_adhoc(struct ath_softc *sc,
580  struct ath_beacon_config *conf)
581 {
582  struct ath_hw *ah = sc->sc_ah;
583  struct ath_common *common = ath9k_hw_common(ah);
584  u32 intval, nexttbtt;
585 
586  ath9k_reset_beacon_status(sc);
587 
588  intval = TU_TO_USEC(conf->beacon_interval);
589  nexttbtt = intval;
590 
591  if (conf->enable_beacon)
592  ah->imask |= ATH9K_INT_SWBA;
593  else
594  ah->imask &= ~ATH9K_INT_SWBA;
595 
596  ath_dbg(common, BEACON, "IBSS nexttbtt: %u intval: %u conf_intval: %u\n",
597  nexttbtt, intval, conf->beacon_interval);
598 
599  ath9k_beacon_init(sc, nexttbtt, intval);
600 }
601 
602 bool ath9k_allow_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif)
603 {
604  struct ath_common *common = ath9k_hw_common(sc->sc_ah);
605  struct ath_vif *avp = (void *)vif->drv_priv;
606 
607  if (sc->sc_ah->opmode == NL80211_IFTYPE_AP) {
608  if ((vif->type != NL80211_IFTYPE_AP) ||
609  (sc->nbcnvifs > 1)) {
610  ath_dbg(common, CONFIG,
611  "An AP interface is already present !\n");
612  return false;
613  }
614  }
615 
616  if (sc->sc_ah->opmode == NL80211_IFTYPE_STATION) {
617  if ((vif->type == NL80211_IFTYPE_STATION) &&
619  !avp->primary_sta_vif) {
620  ath_dbg(common, CONFIG,
621  "Beacon already configured for a station interface\n");
622  return false;
623  }
624  }
625 
626  return true;
627 }
628 
629 static void ath9k_cache_beacon_config(struct ath_softc *sc,
630  struct ieee80211_bss_conf *bss_conf)
631 {
632  struct ath_common *common = ath9k_hw_common(sc->sc_ah);
633  struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf;
634 
635  ath_dbg(common, BEACON,
636  "Caching beacon data for BSS: %pM\n", bss_conf->bssid);
637 
638  cur_conf->beacon_interval = bss_conf->beacon_int;
639  cur_conf->dtim_period = bss_conf->dtim_period;
640  cur_conf->listen_interval = 1;
641  cur_conf->dtim_count = 1;
642  cur_conf->bmiss_timeout =
644 
645  /*
646  * It looks like mac80211 may end up using beacon interval of zero in
647  * some cases (at least for mesh point). Avoid getting into an
648  * infinite loop by using a bit safer value instead. To be safe,
649  * do sanity check on beacon interval for all operating modes.
650  */
651  if (cur_conf->beacon_interval == 0)
652  cur_conf->beacon_interval = 100;
653 
654  /*
655  * We don't parse dtim period from mac80211 during the driver
656  * initialization as it breaks association with hidden-ssid
657  * AP and it causes latency in roaming
658  */
659  if (cur_conf->dtim_period == 0)
660  cur_conf->dtim_period = 1;
661 
662 }
663 
664 void ath9k_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif,
665  u32 changed)
666 {
667  struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
668  struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf;
669 
670  if (sc->sc_ah->opmode == NL80211_IFTYPE_STATION) {
671  ath9k_cache_beacon_config(sc, bss_conf);
672  ath9k_set_beacon(sc);
674  } else {
675  /*
676  * Take care of multiple interfaces when
677  * enabling/disabling SWBA.
678  */
679  if (changed & BSS_CHANGED_BEACON_ENABLED) {
680  if (!bss_conf->enable_beacon &&
681  (sc->nbcnvifs <= 1)) {
682  cur_conf->enable_beacon = false;
683  } else if (bss_conf->enable_beacon) {
684  cur_conf->enable_beacon = true;
685  ath9k_cache_beacon_config(sc, bss_conf);
686  }
687  }
688 
689  if (cur_conf->beacon_interval) {
690  ath9k_set_beacon(sc);
691 
692  if (cur_conf->enable_beacon)
694  else
696  }
697  }
698 }
699 
700 void ath9k_set_beacon(struct ath_softc *sc)
701 {
702  struct ath_common *common = ath9k_hw_common(sc->sc_ah);
703  struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf;
704 
705  switch (sc->sc_ah->opmode) {
706  case NL80211_IFTYPE_AP:
707  ath9k_beacon_config_ap(sc, cur_conf);
708  break;
711  ath9k_beacon_config_adhoc(sc, cur_conf);
712  break;
714  ath9k_beacon_config_sta(sc, cur_conf);
715  break;
716  default:
717  ath_dbg(common, CONFIG, "Unsupported beaconing mode\n");
718  return;
719  }
720 }