2 * Copyright (c) 2008-2009 Atheros Communications Inc.
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.
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.
22 * This function will modify certain transmit queue properties depending on
23 * the operating mode of the station (AP or AdHoc). Parameters are AIFS
24 * settings and channel width min/max
26 int ath_beaconq_config(struct ath_softc
*sc
)
28 struct ath_hw
*ah
= sc
->sc_ah
;
29 struct ath_common
*common
= ath9k_hw_common(ah
);
30 struct ath9k_tx_queue_info qi
, qi_be
;
33 ath9k_hw_get_txq_props(ah
, sc
->beacon
.beaconq
, &qi
);
34 if (sc
->sc_ah
->opmode
== NL80211_IFTYPE_AP
) {
35 /* Always burst out beacon and CAB traffic. */
40 /* Adhoc mode; important thing is to use 2x cwmin. */
41 qnum
= ath_tx_get_qnum(sc
, ATH9K_TX_QUEUE_DATA
,
43 ath9k_hw_get_txq_props(ah
, qnum
, &qi_be
);
44 qi
.tqi_aifs
= qi_be
.tqi_aifs
;
45 qi
.tqi_cwmin
= 4*qi_be
.tqi_cwmin
;
46 qi
.tqi_cwmax
= qi_be
.tqi_cwmax
;
49 if (!ath9k_hw_set_txq_props(ah
, sc
->beacon
.beaconq
, &qi
)) {
50 ath_print(common
, ATH_DBG_FATAL
,
51 "Unable to update h/w beacon queue parameters\n");
54 ath9k_hw_resettxqueue(ah
, sc
->beacon
.beaconq
);
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.
64 static void ath_beacon_setup(struct ath_softc
*sc
, struct ath_vif
*avp
,
65 struct ath_buf
*bf
, int rateidx
)
67 struct sk_buff
*skb
= bf
->bf_mpdu
;
68 struct ath_hw
*ah
= sc
->sc_ah
;
69 struct ath_common
*common
= ath9k_hw_common(ah
);
71 struct ath9k_11n_rate_series series
[4];
72 int flags
, antenna
, ctsrate
= 0, ctsduration
= 0;
73 struct ieee80211_supported_band
*sband
;
77 flags
= ATH9K_TXDESC_NOACK
;
79 if (((sc
->sc_ah
->opmode
== NL80211_IFTYPE_ADHOC
) ||
80 (sc
->sc_ah
->opmode
== NL80211_IFTYPE_MESH_POINT
)) &&
81 (ah
->caps
.hw_caps
& ATH9K_HW_CAP_VEOL
)) {
82 ds
->ds_link
= bf
->bf_daddr
; /* self-linked */
83 flags
|= ATH9K_TXDESC_VEOL
;
84 /* Let hardware handle antenna switching. */
89 * Switch antenna every beacon.
90 * Should only switch every beacon period, not for every SWBA
91 * XXX assumes two antennae
93 antenna
= ((sc
->beacon
.ast_be_xmit
/ sc
->nbcnvifs
) & 1 ? 2 : 1);
96 ds
->ds_data
= bf
->bf_buf_addr
;
98 sband
= &sc
->sbands
[common
->hw
->conf
.channel
->band
];
99 rate
= sband
->bitrates
[rateidx
].hw_value
;
100 if (sc
->sc_flags
& SC_OP_PREAMBLE_SHORT
)
101 rate
|= sband
->bitrates
[rateidx
].hw_value_short
;
103 ath9k_hw_set11n_txdesc(ah
, ds
, skb
->len
+ FCS_LEN
,
104 ATH9K_PKT_TYPE_BEACON
,
106 ATH9K_TXKEYIX_INVALID
,
107 ATH9K_KEY_TYPE_CLEAR
,
110 /* NB: beacon's BufLen must be a multiple of 4 bytes */
111 ath9k_hw_filltxdesc(ah
, ds
, roundup(skb
->len
, 4),
114 memset(series
, 0, sizeof(struct ath9k_11n_rate_series
) * 4);
116 series
[0].Rate
= rate
;
117 series
[0].ChSel
= common
->tx_chainmask
;
118 series
[0].RateFlags
= (ctsrate
) ? ATH9K_RATESERIES_RTS_CTS
: 0;
119 ath9k_hw_set11n_ratescenario(ah
, ds
, ds
, 0, ctsrate
, ctsduration
,
123 static struct ath_buf
*ath_beacon_generate(struct ieee80211_hw
*hw
,
124 struct ieee80211_vif
*vif
)
126 struct ath_wiphy
*aphy
= hw
->priv
;
127 struct ath_softc
*sc
= aphy
->sc
;
128 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
132 struct ath_txq
*cabq
;
133 struct ieee80211_tx_info
*info
;
136 if (aphy
->state
!= ATH_WIPHY_ACTIVE
)
139 avp
= (void *)vif
->drv_priv
;
140 cabq
= sc
->beacon
.cabq
;
142 if (avp
->av_bcbuf
== NULL
)
145 /* Release the old beacon first */
150 dma_unmap_single(sc
->dev
, bf
->bf_dmacontext
,
151 skb
->len
, DMA_TO_DEVICE
);
152 dev_kfree_skb_any(skb
);
155 /* Get a new beacon from mac80211 */
157 skb
= ieee80211_beacon_get(hw
, vif
);
161 ((struct ieee80211_mgmt
*)skb
->data
)->u
.beacon
.timestamp
=
164 info
= IEEE80211_SKB_CB(skb
);
165 if (info
->flags
& IEEE80211_TX_CTL_ASSIGN_SEQ
) {
167 * TODO: make sure the seq# gets assigned properly (vs. other
170 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
171 sc
->tx
.seq_no
+= 0x10;
172 hdr
->seq_ctrl
&= cpu_to_le16(IEEE80211_SCTL_FRAG
);
173 hdr
->seq_ctrl
|= cpu_to_le16(sc
->tx
.seq_no
);
176 bf
->bf_buf_addr
= bf
->bf_dmacontext
=
177 dma_map_single(sc
->dev
, skb
->data
,
178 skb
->len
, DMA_TO_DEVICE
);
179 if (unlikely(dma_mapping_error(sc
->dev
, bf
->bf_buf_addr
))) {
180 dev_kfree_skb_any(skb
);
182 ath_print(common
, ATH_DBG_FATAL
,
183 "dma_mapping_error on beaconing\n");
187 skb
= ieee80211_get_buffered_bc(hw
, vif
);
190 * if the CABQ traffic from previous DTIM is pending and the current
191 * beacon is also a DTIM.
192 * 1) if there is only one vif let the cab traffic continue.
193 * 2) if there are more than one vif and we are using staggered
194 * beacons, then drain the cabq by dropping all the frames in
195 * the cabq so that the current vifs cab traffic can be scheduled.
197 spin_lock_bh(&cabq
->axq_lock
);
198 cabq_depth
= cabq
->axq_depth
;
199 spin_unlock_bh(&cabq
->axq_lock
);
201 if (skb
&& cabq_depth
) {
203 ath_print(common
, ATH_DBG_BEACON
,
204 "Flushing previous cabq traffic\n");
205 ath_draintxq(sc
, cabq
, false);
209 ath_beacon_setup(sc
, avp
, bf
, info
->control
.rates
[0].idx
);
212 ath_tx_cabq(hw
, skb
);
213 skb
= ieee80211_get_buffered_bc(hw
, vif
);
220 * Startup beacon transmission for adhoc mode when they are sent entirely
221 * by the hardware using the self-linked descriptor + veol trick.
223 static void ath_beacon_start_adhoc(struct ath_softc
*sc
,
224 struct ieee80211_vif
*vif
)
226 struct ath_hw
*ah
= sc
->sc_ah
;
227 struct ath_common
*common
= ath9k_hw_common(ah
);
232 avp
= (void *)vif
->drv_priv
;
234 if (avp
->av_bcbuf
== NULL
)
240 ath_beacon_setup(sc
, avp
, bf
, 0);
242 /* NB: caller is known to have already stopped tx dma */
243 ath9k_hw_puttxbuf(ah
, sc
->beacon
.beaconq
, bf
->bf_daddr
);
244 ath9k_hw_txstart(ah
, sc
->beacon
.beaconq
);
245 ath_print(common
, ATH_DBG_BEACON
, "TXDP%u = %llx (%p)\n",
246 sc
->beacon
.beaconq
, ito64(bf
->bf_daddr
), bf
->bf_desc
);
249 int ath_beacon_alloc(struct ath_wiphy
*aphy
, struct ieee80211_vif
*vif
)
251 struct ath_softc
*sc
= aphy
->sc
;
252 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
258 avp
= (void *)vif
->drv_priv
;
260 /* Allocate a beacon descriptor if we haven't done so. */
261 if (!avp
->av_bcbuf
) {
262 /* Allocate beacon state for hostap/ibss. We know
263 * a buffer is available. */
264 avp
->av_bcbuf
= list_first_entry(&sc
->beacon
.bbuf
,
265 struct ath_buf
, list
);
266 list_del(&avp
->av_bcbuf
->list
);
268 if (sc
->sc_ah
->opmode
== NL80211_IFTYPE_AP
||
269 !(sc
->sc_ah
->caps
.hw_caps
& ATH9K_HW_CAP_VEOL
)) {
272 * Assign the vif to a beacon xmit slot. As
273 * above, this cannot fail to find one.
276 for (slot
= 0; slot
< ATH_BCBUF
; slot
++)
277 if (sc
->beacon
.bslot
[slot
] == NULL
) {
279 * XXX hack, space out slots to better
282 if (slot
+1 < ATH_BCBUF
&&
283 sc
->beacon
.bslot
[slot
+1] == NULL
) {
284 avp
->av_bslot
= slot
+1;
287 avp
->av_bslot
= slot
;
288 /* NB: keep looking for a double slot */
290 BUG_ON(sc
->beacon
.bslot
[avp
->av_bslot
] != NULL
);
291 sc
->beacon
.bslot
[avp
->av_bslot
] = vif
;
292 sc
->beacon
.bslot_aphy
[avp
->av_bslot
] = aphy
;
297 /* release the previous beacon frame, if it already exists. */
299 if (bf
->bf_mpdu
!= NULL
) {
301 dma_unmap_single(sc
->dev
, bf
->bf_dmacontext
,
302 skb
->len
, DMA_TO_DEVICE
);
303 dev_kfree_skb_any(skb
);
307 /* NB: the beacon data buffer must be 32-bit aligned. */
308 skb
= ieee80211_beacon_get(sc
->hw
, vif
);
310 ath_print(common
, ATH_DBG_BEACON
, "cannot get skb\n");
314 tstamp
= ((struct ieee80211_mgmt
*)skb
->data
)->u
.beacon
.timestamp
;
315 sc
->beacon
.bc_tstamp
= le64_to_cpu(tstamp
);
316 /* Calculate a TSF adjustment factor required for staggered beacons. */
317 if (avp
->av_bslot
> 0) {
321 intval
= sc
->beacon_interval
? : ATH_DEFAULT_BINTVAL
;
324 * Calculate the TSF offset for this beacon slot, i.e., the
325 * number of usecs that need to be added to the timestamp field
326 * in Beacon and Probe Response frames. Beacon slot 0 is
327 * processed at the correct offset, so it does not require TSF
328 * adjustment. Other slots are adjusted to get the timestamp
329 * close to the TBTT for the BSS.
331 tsfadjust
= intval
* avp
->av_bslot
/ ATH_BCBUF
;
332 avp
->tsf_adjust
= cpu_to_le64(TU_TO_USEC(tsfadjust
));
334 ath_print(common
, ATH_DBG_BEACON
,
335 "stagger beacons, bslot %d intval "
336 "%u tsfadjust %llu\n",
337 avp
->av_bslot
, intval
, (unsigned long long)tsfadjust
);
339 ((struct ieee80211_mgmt
*)skb
->data
)->u
.beacon
.timestamp
=
342 avp
->tsf_adjust
= cpu_to_le64(0);
345 bf
->bf_buf_addr
= bf
->bf_dmacontext
=
346 dma_map_single(sc
->dev
, skb
->data
,
347 skb
->len
, DMA_TO_DEVICE
);
348 if (unlikely(dma_mapping_error(sc
->dev
, bf
->bf_buf_addr
))) {
349 dev_kfree_skb_any(skb
);
351 ath_print(common
, ATH_DBG_FATAL
,
352 "dma_mapping_error on beacon alloc\n");
359 void ath_beacon_return(struct ath_softc
*sc
, struct ath_vif
*avp
)
361 if (avp
->av_bcbuf
!= NULL
) {
364 if (avp
->av_bslot
!= -1) {
365 sc
->beacon
.bslot
[avp
->av_bslot
] = NULL
;
366 sc
->beacon
.bslot_aphy
[avp
->av_bslot
] = NULL
;
371 if (bf
->bf_mpdu
!= NULL
) {
372 struct sk_buff
*skb
= bf
->bf_mpdu
;
373 dma_unmap_single(sc
->dev
, bf
->bf_dmacontext
,
374 skb
->len
, DMA_TO_DEVICE
);
375 dev_kfree_skb_any(skb
);
378 list_add_tail(&bf
->list
, &sc
->beacon
.bbuf
);
380 avp
->av_bcbuf
= NULL
;
384 void ath_beacon_tasklet(unsigned long data
)
386 struct ath_softc
*sc
= (struct ath_softc
*)data
;
387 struct ath_hw
*ah
= sc
->sc_ah
;
388 struct ath_common
*common
= ath9k_hw_common(ah
);
389 struct ath_buf
*bf
= NULL
;
390 struct ieee80211_vif
*vif
;
391 struct ath_wiphy
*aphy
;
393 u32 bfaddr
, bc
= 0, tsftu
;
398 * Check if the previous beacon has gone out. If
399 * not don't try to post another, skip this period
400 * and wait for the next. Missed beacons indicate
401 * a problem and should not occur. If we miss too
402 * many consecutive beacons reset the device.
404 if (ath9k_hw_numtxpending(ah
, sc
->beacon
.beaconq
) != 0) {
405 sc
->beacon
.bmisscnt
++;
407 if (sc
->beacon
.bmisscnt
< BSTUCK_THRESH
) {
408 ath_print(common
, ATH_DBG_BEACON
,
409 "missed %u consecutive beacons\n",
410 sc
->beacon
.bmisscnt
);
411 } else if (sc
->beacon
.bmisscnt
>= BSTUCK_THRESH
) {
412 ath_print(common
, ATH_DBG_BEACON
,
413 "beacon is officially stuck\n");
414 sc
->sc_flags
|= SC_OP_TSF_RESET
;
415 ath_reset(sc
, false);
421 if (sc
->beacon
.bmisscnt
!= 0) {
422 ath_print(common
, ATH_DBG_BEACON
,
423 "resume beacon xmit after %u misses\n",
424 sc
->beacon
.bmisscnt
);
425 sc
->beacon
.bmisscnt
= 0;
429 * Generate beacon frames. we are sending frames
430 * staggered so calculate the slot for this frame based
431 * on the tsf to safeguard against missing an swba.
434 intval
= sc
->beacon_interval
? : ATH_DEFAULT_BINTVAL
;
436 tsf
= ath9k_hw_gettsf64(ah
);
437 tsftu
= TSF_TO_TU(tsf
>>32, tsf
);
438 slot
= ((tsftu
% intval
) * ATH_BCBUF
) / intval
;
440 * Reverse the slot order to get slot 0 on the TBTT offset that does
441 * not require TSF adjustment and other slots adding
442 * slot/ATH_BCBUF * beacon_int to timestamp. For example, with
443 * ATH_BCBUF = 4, we process beacon slots as follows: 3 2 1 0 3 2 1 ..
444 * and slot 0 is at correct offset to TBTT.
446 slot
= ATH_BCBUF
- slot
- 1;
447 vif
= sc
->beacon
.bslot
[slot
];
448 aphy
= sc
->beacon
.bslot_aphy
[slot
];
450 ath_print(common
, ATH_DBG_BEACON
,
451 "slot %d [tsf %llu tsftu %u intval %u] vif %p\n",
452 slot
, tsf
, tsftu
, intval
, vif
);
456 bf
= ath_beacon_generate(aphy
->hw
, vif
);
458 bfaddr
= bf
->bf_daddr
;
464 * Handle slot time change when a non-ERP station joins/leaves
465 * an 11g network. The 802.11 layer notifies us via callback,
466 * we mark updateslot, then wait one beacon before effecting
467 * the change. This gives associated stations at least one
468 * beacon interval to note the state change.
470 * NB: The slot time change state machine is clocked according
471 * to whether we are bursting or staggering beacons. We
472 * recognize the request to update and record the current
473 * slot then don't transition until that slot is reached
474 * again. If we miss a beacon for that slot then we'll be
475 * slow to transition but we'll be sure at least one beacon
476 * interval has passed. When bursting slot is always left
477 * set to ATH_BCBUF so this check is a noop.
479 if (sc
->beacon
.updateslot
== UPDATE
) {
480 sc
->beacon
.updateslot
= COMMIT
; /* commit next beacon */
481 sc
->beacon
.slotupdate
= slot
;
482 } else if (sc
->beacon
.updateslot
== COMMIT
&& sc
->beacon
.slotupdate
== slot
) {
483 ah
->slottime
= sc
->beacon
.slottime
;
484 ath9k_hw_init_global_settings(ah
);
485 sc
->beacon
.updateslot
= OK
;
489 * Stop any current dma and put the new frame(s) on the queue.
490 * This should never fail since we check above that no frames
491 * are still pending on the queue.
493 if (!ath9k_hw_stoptxdma(ah
, sc
->beacon
.beaconq
)) {
494 ath_print(common
, ATH_DBG_FATAL
,
495 "beacon queue %u did not stop?\n", sc
->beacon
.beaconq
);
498 /* NB: cabq traffic should already be queued and primed */
499 ath9k_hw_puttxbuf(ah
, sc
->beacon
.beaconq
, bfaddr
);
500 ath9k_hw_txstart(ah
, sc
->beacon
.beaconq
);
502 sc
->beacon
.ast_be_xmit
+= bc
; /* XXX per-vif? */
506 static void ath9k_beacon_init(struct ath_softc
*sc
,
510 if (beacon_period
& ATH9K_BEACON_RESET_TSF
)
513 ath9k_hw_beaconinit(sc
->sc_ah
, next_beacon
, beacon_period
);
515 if (beacon_period
& ATH9K_BEACON_RESET_TSF
)
516 ath9k_ps_restore(sc
);
520 * For multi-bss ap support beacons are either staggered evenly over N slots or
521 * burst together. For the former arrange for the SWBA to be delivered for each
522 * slot. Slots that are not occupied will generate nothing.
524 static void ath_beacon_config_ap(struct ath_softc
*sc
,
525 struct ath_beacon_config
*conf
)
527 struct ath_hw
*ah
= sc
->sc_ah
;
528 u32 nexttbtt
, intval
;
530 /* NB: the beacon interval is kept internally in TU's */
531 intval
= conf
->beacon_interval
& ATH9K_BEACON_PERIOD
;
532 intval
/= ATH_BCBUF
; /* for staggered beacons */
535 if (sc
->sc_flags
& SC_OP_TSF_RESET
)
536 intval
|= ATH9K_BEACON_RESET_TSF
;
539 * In AP mode we enable the beacon timers and SWBA interrupts to
540 * prepare beacon frames.
542 intval
|= ATH9K_BEACON_ENA
;
543 ah
->imask
|= ATH9K_INT_SWBA
;
544 ath_beaconq_config(sc
);
546 /* Set the computed AP beacon timers */
548 ath9k_hw_set_interrupts(ah
, 0);
549 ath9k_beacon_init(sc
, nexttbtt
, intval
);
550 sc
->beacon
.bmisscnt
= 0;
551 ath9k_hw_set_interrupts(ah
, ah
->imask
);
553 /* Clear the reset TSF flag, so that subsequent beacon updation
554 will not reset the HW TSF. */
556 sc
->sc_flags
&= ~SC_OP_TSF_RESET
;
560 * This sets up the beacon timers according to the timestamp of the last
561 * received beacon and the current TSF, configures PCF and DTIM
562 * handling, programs the sleep registers so the hardware will wakeup in
563 * time to receive beacons, and configures the beacon miss handling so
564 * we'll receive a BMISS interrupt when we stop seeing beacons from the AP
565 * we've associated with.
567 static void ath_beacon_config_sta(struct ath_softc
*sc
,
568 struct ath_beacon_config
*conf
)
570 struct ath_hw
*ah
= sc
->sc_ah
;
571 struct ath_common
*common
= ath9k_hw_common(ah
);
572 struct ath9k_beacon_state bs
;
573 int dtimperiod
, dtimcount
, sleepduration
;
574 int cfpperiod
, cfpcount
;
575 u32 nexttbtt
= 0, intval
, tsftu
;
577 int num_beacons
, offset
, dtim_dec_count
, cfp_dec_count
;
579 /* No need to configure beacon if we are not associated */
580 if (!common
->curaid
) {
581 ath_print(common
, ATH_DBG_BEACON
,
582 "STA is not yet associated..skipping beacon config\n");
586 memset(&bs
, 0, sizeof(bs
));
587 intval
= conf
->beacon_interval
& ATH9K_BEACON_PERIOD
;
590 * Setup dtim and cfp parameters according to
591 * last beacon we received (which may be none).
593 dtimperiod
= conf
->dtim_period
;
594 if (dtimperiod
<= 0) /* NB: 0 if not known */
596 dtimcount
= conf
->dtim_count
;
597 if (dtimcount
>= dtimperiod
) /* NB: sanity check */
599 cfpperiod
= 1; /* NB: no PCF support yet */
602 sleepduration
= conf
->listen_interval
* intval
;
603 if (sleepduration
<= 0)
604 sleepduration
= intval
;
607 * Pull nexttbtt forward to reflect the current
608 * TSF and calculate dtim+cfp state for the result.
610 tsf
= ath9k_hw_gettsf64(ah
);
611 tsftu
= TSF_TO_TU(tsf
>>32, tsf
) + FUDGE
;
613 num_beacons
= tsftu
/ intval
+ 1;
614 offset
= tsftu
% intval
;
615 nexttbtt
= tsftu
- offset
;
619 /* DTIM Beacon every dtimperiod Beacon */
620 dtim_dec_count
= num_beacons
% dtimperiod
;
621 /* CFP every cfpperiod DTIM Beacon */
622 cfp_dec_count
= (num_beacons
/ dtimperiod
) % cfpperiod
;
626 dtimcount
-= dtim_dec_count
;
628 dtimcount
+= dtimperiod
;
630 cfpcount
-= cfp_dec_count
;
632 cfpcount
+= cfpperiod
;
634 bs
.bs_intval
= intval
;
635 bs
.bs_nexttbtt
= nexttbtt
;
636 bs
.bs_dtimperiod
= dtimperiod
*intval
;
637 bs
.bs_nextdtim
= bs
.bs_nexttbtt
+ dtimcount
*intval
;
638 bs
.bs_cfpperiod
= cfpperiod
*bs
.bs_dtimperiod
;
639 bs
.bs_cfpnext
= bs
.bs_nextdtim
+ cfpcount
*bs
.bs_dtimperiod
;
640 bs
.bs_cfpmaxduration
= 0;
643 * Calculate the number of consecutive beacons to miss* before taking
644 * a BMISS interrupt. The configuration is specified in TU so we only
645 * need calculate based on the beacon interval. Note that we clamp the
646 * result to at most 15 beacons.
648 if (sleepduration
> intval
) {
649 bs
.bs_bmissthreshold
= conf
->listen_interval
*
650 ATH_DEFAULT_BMISS_LIMIT
/ 2;
652 bs
.bs_bmissthreshold
= DIV_ROUND_UP(conf
->bmiss_timeout
, intval
);
653 if (bs
.bs_bmissthreshold
> 15)
654 bs
.bs_bmissthreshold
= 15;
655 else if (bs
.bs_bmissthreshold
<= 0)
656 bs
.bs_bmissthreshold
= 1;
660 * Calculate sleep duration. The configuration is given in ms.
661 * We ensure a multiple of the beacon period is used. Also, if the sleep
662 * duration is greater than the DTIM period then it makes senses
663 * to make it a multiple of that.
668 bs
.bs_sleepduration
= roundup(IEEE80211_MS_TO_TU(100), sleepduration
);
669 if (bs
.bs_sleepduration
> bs
.bs_dtimperiod
)
670 bs
.bs_sleepduration
= bs
.bs_dtimperiod
;
672 /* TSF out of range threshold fixed at 1 second */
673 bs
.bs_tsfoor_threshold
= ATH9K_TSFOOR_THRESHOLD
;
675 ath_print(common
, ATH_DBG_BEACON
, "tsf: %llu tsftu: %u\n", tsf
, tsftu
);
676 ath_print(common
, ATH_DBG_BEACON
,
677 "bmiss: %u sleep: %u cfp-period: %u maxdur: %u next: %u\n",
678 bs
.bs_bmissthreshold
, bs
.bs_sleepduration
,
679 bs
.bs_cfpperiod
, bs
.bs_cfpmaxduration
, bs
.bs_cfpnext
);
681 /* Set the computed STA beacon timers */
683 ath9k_hw_set_interrupts(ah
, 0);
684 ath9k_hw_set_sta_beacon_timers(ah
, &bs
);
685 ah
->imask
|= ATH9K_INT_BMISS
;
686 ath9k_hw_set_interrupts(ah
, ah
->imask
);
689 static void ath_beacon_config_adhoc(struct ath_softc
*sc
,
690 struct ath_beacon_config
*conf
,
691 struct ieee80211_vif
*vif
)
693 struct ath_hw
*ah
= sc
->sc_ah
;
694 struct ath_common
*common
= ath9k_hw_common(ah
);
696 u32 tsftu
, intval
, nexttbtt
;
698 intval
= conf
->beacon_interval
& ATH9K_BEACON_PERIOD
;
701 /* Pull nexttbtt forward to reflect the current TSF */
703 nexttbtt
= TSF_TO_TU(sc
->beacon
.bc_tstamp
>> 32, sc
->beacon
.bc_tstamp
);
707 nexttbtt
= roundup(nexttbtt
, intval
);
709 tsf
= ath9k_hw_gettsf64(ah
);
710 tsftu
= TSF_TO_TU((u32
)(tsf
>>32), (u32
)tsf
) + FUDGE
;
713 } while (nexttbtt
< tsftu
);
715 ath_print(common
, ATH_DBG_BEACON
,
716 "IBSS nexttbtt %u intval %u (%u)\n",
717 nexttbtt
, intval
, conf
->beacon_interval
);
720 * In IBSS mode enable the beacon timers but only enable SWBA interrupts
721 * if we need to manually prepare beacon frames. Otherwise we use a
722 * self-linked tx descriptor and let the hardware deal with things.
724 intval
|= ATH9K_BEACON_ENA
;
725 if (!(ah
->caps
.hw_caps
& ATH9K_HW_CAP_VEOL
))
726 ah
->imask
|= ATH9K_INT_SWBA
;
728 ath_beaconq_config(sc
);
730 /* Set the computed ADHOC beacon timers */
732 ath9k_hw_set_interrupts(ah
, 0);
733 ath9k_beacon_init(sc
, nexttbtt
, intval
);
734 sc
->beacon
.bmisscnt
= 0;
735 ath9k_hw_set_interrupts(ah
, ah
->imask
);
737 /* FIXME: Handle properly when vif is NULL */
738 if (vif
&& ah
->caps
.hw_caps
& ATH9K_HW_CAP_VEOL
)
739 ath_beacon_start_adhoc(sc
, vif
);
742 void ath_beacon_config(struct ath_softc
*sc
, struct ieee80211_vif
*vif
)
744 struct ath_beacon_config
*cur_conf
= &sc
->cur_beacon_conf
;
745 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
746 enum nl80211_iftype iftype
;
748 /* Setup the beacon configuration parameters */
750 struct ieee80211_bss_conf
*bss_conf
= &vif
->bss_conf
;
754 cur_conf
->beacon_interval
= bss_conf
->beacon_int
;
755 cur_conf
->dtim_period
= bss_conf
->dtim_period
;
756 cur_conf
->listen_interval
= 1;
757 cur_conf
->dtim_count
= 1;
758 cur_conf
->bmiss_timeout
=
759 ATH_DEFAULT_BMISS_LIMIT
* cur_conf
->beacon_interval
;
761 iftype
= sc
->sc_ah
->opmode
;
765 * It looks like mac80211 may end up using beacon interval of zero in
766 * some cases (at least for mesh point). Avoid getting into an
767 * infinite loop by using a bit safer value instead. To be safe,
768 * do sanity check on beacon interval for all operating modes.
770 if (cur_conf
->beacon_interval
== 0)
771 cur_conf
->beacon_interval
= 100;
774 case NL80211_IFTYPE_AP
:
775 ath_beacon_config_ap(sc
, cur_conf
);
777 case NL80211_IFTYPE_ADHOC
:
778 case NL80211_IFTYPE_MESH_POINT
:
779 ath_beacon_config_adhoc(sc
, cur_conf
, vif
);
781 case NL80211_IFTYPE_STATION
:
782 ath_beacon_config_sta(sc
, cur_conf
);
785 ath_print(common
, ATH_DBG_CONFIG
,
786 "Unsupported beaconing mode\n");
790 sc
->sc_flags
|= SC_OP_BEACONS
;