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 static 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
;
32 ath9k_hw_get_txq_props(ah
, sc
->beacon
.beaconq
, &qi
);
33 if (sc
->sc_ah
->opmode
== NL80211_IFTYPE_AP
) {
34 /* Always burst out beacon and CAB traffic. */
39 /* Adhoc mode; important thing is to use 2x cwmin. */
40 qi
.tqi_aifs
= sc
->beacon
.beacon_qi
.tqi_aifs
;
41 qi
.tqi_cwmin
= 2*sc
->beacon
.beacon_qi
.tqi_cwmin
;
42 qi
.tqi_cwmax
= sc
->beacon
.beacon_qi
.tqi_cwmax
;
45 if (!ath9k_hw_set_txq_props(ah
, sc
->beacon
.beaconq
, &qi
)) {
46 ath_print(common
, ATH_DBG_FATAL
,
47 "Unable to update h/w beacon queue parameters\n");
50 ath9k_hw_resettxqueue(ah
, sc
->beacon
.beaconq
);
56 * Associates the beacon frame buffer with a transmit descriptor. Will set
57 * up all required antenna switch parameters, rate codes, and channel flags.
58 * Beacons are always sent out at the lowest rate, and are not retried.
60 static void ath_beacon_setup(struct ath_softc
*sc
, struct ath_vif
*avp
,
63 struct sk_buff
*skb
= bf
->bf_mpdu
;
64 struct ath_hw
*ah
= sc
->sc_ah
;
66 struct ath9k_11n_rate_series series
[4];
67 const struct ath_rate_table
*rt
;
68 int flags
, antenna
, ctsrate
= 0, ctsduration
= 0;
72 flags
= ATH9K_TXDESC_NOACK
;
74 if (((sc
->sc_ah
->opmode
== NL80211_IFTYPE_ADHOC
) ||
75 (sc
->sc_ah
->opmode
== NL80211_IFTYPE_MESH_POINT
)) &&
76 (ah
->caps
.hw_caps
& ATH9K_HW_CAP_VEOL
)) {
77 ds
->ds_link
= bf
->bf_daddr
; /* self-linked */
78 flags
|= ATH9K_TXDESC_VEOL
;
79 /* Let hardware handle antenna switching. */
84 * Switch antenna every beacon.
85 * Should only switch every beacon period, not for every SWBA
86 * XXX assumes two antennae
88 antenna
= ((sc
->beacon
.ast_be_xmit
/ sc
->nbcnvifs
) & 1 ? 2 : 1);
91 ds
->ds_data
= bf
->bf_buf_addr
;
93 rt
= sc
->cur_rate_table
;
94 rate
= rt
->info
[0].ratecode
;
95 if (sc
->sc_flags
& SC_OP_PREAMBLE_SHORT
)
96 rate
|= rt
->info
[0].short_preamble
;
98 ath9k_hw_set11n_txdesc(ah
, ds
, skb
->len
+ FCS_LEN
,
99 ATH9K_PKT_TYPE_BEACON
,
101 ATH9K_TXKEYIX_INVALID
,
102 ATH9K_KEY_TYPE_CLEAR
,
105 /* NB: beacon's BufLen must be a multiple of 4 bytes */
106 ath9k_hw_filltxdesc(ah
, ds
, roundup(skb
->len
, 4),
109 memset(series
, 0, sizeof(struct ath9k_11n_rate_series
) * 4);
111 series
[0].Rate
= rate
;
112 series
[0].ChSel
= sc
->tx_chainmask
;
113 series
[0].RateFlags
= (ctsrate
) ? ATH9K_RATESERIES_RTS_CTS
: 0;
114 ath9k_hw_set11n_ratescenario(ah
, ds
, ds
, 0, ctsrate
, ctsduration
,
118 static struct ath_buf
*ath_beacon_generate(struct ieee80211_hw
*hw
,
119 struct ieee80211_vif
*vif
)
121 struct ath_wiphy
*aphy
= hw
->priv
;
122 struct ath_softc
*sc
= aphy
->sc
;
123 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
127 struct ath_txq
*cabq
;
128 struct ieee80211_tx_info
*info
;
131 if (aphy
->state
!= ATH_WIPHY_ACTIVE
)
134 avp
= (void *)vif
->drv_priv
;
135 cabq
= sc
->beacon
.cabq
;
137 if (avp
->av_bcbuf
== NULL
)
140 /* Release the old beacon first */
145 dma_unmap_single(sc
->dev
, bf
->bf_dmacontext
,
146 skb
->len
, DMA_TO_DEVICE
);
147 dev_kfree_skb_any(skb
);
150 /* Get a new beacon from mac80211 */
152 skb
= ieee80211_beacon_get(hw
, vif
);
156 ((struct ieee80211_mgmt
*)skb
->data
)->u
.beacon
.timestamp
=
159 info
= IEEE80211_SKB_CB(skb
);
160 if (info
->flags
& IEEE80211_TX_CTL_ASSIGN_SEQ
) {
162 * TODO: make sure the seq# gets assigned properly (vs. other
165 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
166 sc
->tx
.seq_no
+= 0x10;
167 hdr
->seq_ctrl
&= cpu_to_le16(IEEE80211_SCTL_FRAG
);
168 hdr
->seq_ctrl
|= cpu_to_le16(sc
->tx
.seq_no
);
171 bf
->bf_buf_addr
= bf
->bf_dmacontext
=
172 dma_map_single(sc
->dev
, skb
->data
,
173 skb
->len
, DMA_TO_DEVICE
);
174 if (unlikely(dma_mapping_error(sc
->dev
, bf
->bf_buf_addr
))) {
175 dev_kfree_skb_any(skb
);
177 ath_print(common
, ATH_DBG_FATAL
,
178 "dma_mapping_error on beaconing\n");
182 skb
= ieee80211_get_buffered_bc(hw
, vif
);
185 * if the CABQ traffic from previous DTIM is pending and the current
186 * beacon is also a DTIM.
187 * 1) if there is only one vif let the cab traffic continue.
188 * 2) if there are more than one vif and we are using staggered
189 * beacons, then drain the cabq by dropping all the frames in
190 * the cabq so that the current vifs cab traffic can be scheduled.
192 spin_lock_bh(&cabq
->axq_lock
);
193 cabq_depth
= cabq
->axq_depth
;
194 spin_unlock_bh(&cabq
->axq_lock
);
196 if (skb
&& cabq_depth
) {
198 ath_print(common
, ATH_DBG_BEACON
,
199 "Flushing previous cabq traffic\n");
200 ath_draintxq(sc
, cabq
, false);
204 ath_beacon_setup(sc
, avp
, bf
);
207 ath_tx_cabq(hw
, skb
);
208 skb
= ieee80211_get_buffered_bc(hw
, vif
);
215 * Startup beacon transmission for adhoc mode when they are sent entirely
216 * by the hardware using the self-linked descriptor + veol trick.
218 static void ath_beacon_start_adhoc(struct ath_softc
*sc
,
219 struct ieee80211_vif
*vif
)
221 struct ath_hw
*ah
= sc
->sc_ah
;
222 struct ath_common
*common
= ath9k_hw_common(ah
);
227 avp
= (void *)vif
->drv_priv
;
229 if (avp
->av_bcbuf
== NULL
)
235 ath_beacon_setup(sc
, avp
, bf
);
237 /* NB: caller is known to have already stopped tx dma */
238 ath9k_hw_puttxbuf(ah
, sc
->beacon
.beaconq
, bf
->bf_daddr
);
239 ath9k_hw_txstart(ah
, sc
->beacon
.beaconq
);
240 ath_print(common
, ATH_DBG_BEACON
, "TXDP%u = %llx (%p)\n",
241 sc
->beacon
.beaconq
, ito64(bf
->bf_daddr
), bf
->bf_desc
);
244 int ath_beaconq_setup(struct ath_hw
*ah
)
246 struct ath9k_tx_queue_info qi
;
248 memset(&qi
, 0, sizeof(qi
));
252 /* NB: don't enable any interrupts */
253 return ath9k_hw_setuptxqueue(ah
, ATH9K_TX_QUEUE_BEACON
, &qi
);
256 int ath_beacon_alloc(struct ath_wiphy
*aphy
, struct ieee80211_vif
*vif
)
258 struct ath_softc
*sc
= aphy
->sc
;
259 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
265 avp
= (void *)vif
->drv_priv
;
267 /* Allocate a beacon descriptor if we haven't done so. */
268 if (!avp
->av_bcbuf
) {
269 /* Allocate beacon state for hostap/ibss. We know
270 * a buffer is available. */
271 avp
->av_bcbuf
= list_first_entry(&sc
->beacon
.bbuf
,
272 struct ath_buf
, list
);
273 list_del(&avp
->av_bcbuf
->list
);
275 if (sc
->sc_ah
->opmode
== NL80211_IFTYPE_AP
||
276 !(sc
->sc_ah
->caps
.hw_caps
& ATH9K_HW_CAP_VEOL
)) {
279 * Assign the vif to a beacon xmit slot. As
280 * above, this cannot fail to find one.
283 for (slot
= 0; slot
< ATH_BCBUF
; slot
++)
284 if (sc
->beacon
.bslot
[slot
] == NULL
) {
286 * XXX hack, space out slots to better
289 if (slot
+1 < ATH_BCBUF
&&
290 sc
->beacon
.bslot
[slot
+1] == NULL
) {
291 avp
->av_bslot
= slot
+1;
294 avp
->av_bslot
= slot
;
295 /* NB: keep looking for a double slot */
297 BUG_ON(sc
->beacon
.bslot
[avp
->av_bslot
] != NULL
);
298 sc
->beacon
.bslot
[avp
->av_bslot
] = vif
;
299 sc
->beacon
.bslot_aphy
[avp
->av_bslot
] = aphy
;
304 /* release the previous beacon frame, if it already exists. */
306 if (bf
->bf_mpdu
!= NULL
) {
308 dma_unmap_single(sc
->dev
, bf
->bf_dmacontext
,
309 skb
->len
, DMA_TO_DEVICE
);
310 dev_kfree_skb_any(skb
);
314 /* NB: the beacon data buffer must be 32-bit aligned. */
315 skb
= ieee80211_beacon_get(sc
->hw
, vif
);
317 ath_print(common
, ATH_DBG_BEACON
, "cannot get skb\n");
321 tstamp
= ((struct ieee80211_mgmt
*)skb
->data
)->u
.beacon
.timestamp
;
322 sc
->beacon
.bc_tstamp
= le64_to_cpu(tstamp
);
323 /* Calculate a TSF adjustment factor required for staggered beacons. */
324 if (avp
->av_bslot
> 0) {
328 intval
= sc
->beacon_interval
? : ATH_DEFAULT_BINTVAL
;
331 * Calculate the TSF offset for this beacon slot, i.e., the
332 * number of usecs that need to be added to the timestamp field
333 * in Beacon and Probe Response frames. Beacon slot 0 is
334 * processed at the correct offset, so it does not require TSF
335 * adjustment. Other slots are adjusted to get the timestamp
336 * close to the TBTT for the BSS.
338 tsfadjust
= intval
* avp
->av_bslot
/ ATH_BCBUF
;
339 avp
->tsf_adjust
= cpu_to_le64(TU_TO_USEC(tsfadjust
));
341 ath_print(common
, ATH_DBG_BEACON
,
342 "stagger beacons, bslot %d intval "
343 "%u tsfadjust %llu\n",
344 avp
->av_bslot
, intval
, (unsigned long long)tsfadjust
);
346 ((struct ieee80211_mgmt
*)skb
->data
)->u
.beacon
.timestamp
=
349 avp
->tsf_adjust
= cpu_to_le64(0);
352 bf
->bf_buf_addr
= bf
->bf_dmacontext
=
353 dma_map_single(sc
->dev
, skb
->data
,
354 skb
->len
, DMA_TO_DEVICE
);
355 if (unlikely(dma_mapping_error(sc
->dev
, bf
->bf_buf_addr
))) {
356 dev_kfree_skb_any(skb
);
358 ath_print(common
, ATH_DBG_FATAL
,
359 "dma_mapping_error on beacon alloc\n");
366 void ath_beacon_return(struct ath_softc
*sc
, struct ath_vif
*avp
)
368 if (avp
->av_bcbuf
!= NULL
) {
371 if (avp
->av_bslot
!= -1) {
372 sc
->beacon
.bslot
[avp
->av_bslot
] = NULL
;
373 sc
->beacon
.bslot_aphy
[avp
->av_bslot
] = NULL
;
378 if (bf
->bf_mpdu
!= NULL
) {
379 struct sk_buff
*skb
= bf
->bf_mpdu
;
380 dma_unmap_single(sc
->dev
, bf
->bf_dmacontext
,
381 skb
->len
, DMA_TO_DEVICE
);
382 dev_kfree_skb_any(skb
);
385 list_add_tail(&bf
->list
, &sc
->beacon
.bbuf
);
387 avp
->av_bcbuf
= NULL
;
391 void ath_beacon_tasklet(unsigned long data
)
393 struct ath_softc
*sc
= (struct ath_softc
*)data
;
394 struct ath_hw
*ah
= sc
->sc_ah
;
395 struct ath_common
*common
= ath9k_hw_common(ah
);
396 struct ath_buf
*bf
= NULL
;
397 struct ieee80211_vif
*vif
;
398 struct ath_wiphy
*aphy
;
400 u32 bfaddr
, bc
= 0, tsftu
;
405 * Check if the previous beacon has gone out. If
406 * not don't try to post another, skip this period
407 * and wait for the next. Missed beacons indicate
408 * a problem and should not occur. If we miss too
409 * many consecutive beacons reset the device.
411 if (ath9k_hw_numtxpending(ah
, sc
->beacon
.beaconq
) != 0) {
412 sc
->beacon
.bmisscnt
++;
414 if (sc
->beacon
.bmisscnt
< BSTUCK_THRESH
) {
415 ath_print(common
, ATH_DBG_BEACON
,
416 "missed %u consecutive beacons\n",
417 sc
->beacon
.bmisscnt
);
418 } else if (sc
->beacon
.bmisscnt
>= BSTUCK_THRESH
) {
419 ath_print(common
, ATH_DBG_BEACON
,
420 "beacon is officially stuck\n");
421 sc
->sc_flags
|= SC_OP_TSF_RESET
;
422 ath_reset(sc
, false);
428 if (sc
->beacon
.bmisscnt
!= 0) {
429 ath_print(common
, ATH_DBG_BEACON
,
430 "resume beacon xmit after %u misses\n",
431 sc
->beacon
.bmisscnt
);
432 sc
->beacon
.bmisscnt
= 0;
436 * Generate beacon frames. we are sending frames
437 * staggered so calculate the slot for this frame based
438 * on the tsf to safeguard against missing an swba.
441 intval
= sc
->beacon_interval
? : ATH_DEFAULT_BINTVAL
;
443 tsf
= ath9k_hw_gettsf64(ah
);
444 tsftu
= TSF_TO_TU(tsf
>>32, tsf
);
445 slot
= ((tsftu
% intval
) * ATH_BCBUF
) / intval
;
447 * Reverse the slot order to get slot 0 on the TBTT offset that does
448 * not require TSF adjustment and other slots adding
449 * slot/ATH_BCBUF * beacon_int to timestamp. For example, with
450 * ATH_BCBUF = 4, we process beacon slots as follows: 3 2 1 0 3 2 1 ..
451 * and slot 0 is at correct offset to TBTT.
453 slot
= ATH_BCBUF
- slot
- 1;
454 vif
= sc
->beacon
.bslot
[slot
];
455 aphy
= sc
->beacon
.bslot_aphy
[slot
];
457 ath_print(common
, ATH_DBG_BEACON
,
458 "slot %d [tsf %llu tsftu %u intval %u] vif %p\n",
459 slot
, tsf
, tsftu
, intval
, vif
);
463 bf
= ath_beacon_generate(aphy
->hw
, vif
);
465 bfaddr
= bf
->bf_daddr
;
471 * Handle slot time change when a non-ERP station joins/leaves
472 * an 11g network. The 802.11 layer notifies us via callback,
473 * we mark updateslot, then wait one beacon before effecting
474 * the change. This gives associated stations at least one
475 * beacon interval to note the state change.
477 * NB: The slot time change state machine is clocked according
478 * to whether we are bursting or staggering beacons. We
479 * recognize the request to update and record the current
480 * slot then don't transition until that slot is reached
481 * again. If we miss a beacon for that slot then we'll be
482 * slow to transition but we'll be sure at least one beacon
483 * interval has passed. When bursting slot is always left
484 * set to ATH_BCBUF so this check is a noop.
486 if (sc
->beacon
.updateslot
== UPDATE
) {
487 sc
->beacon
.updateslot
= COMMIT
; /* commit next beacon */
488 sc
->beacon
.slotupdate
= slot
;
489 } else if (sc
->beacon
.updateslot
== COMMIT
&& sc
->beacon
.slotupdate
== slot
) {
490 ath9k_hw_setslottime(sc
->sc_ah
, sc
->beacon
.slottime
);
491 sc
->beacon
.updateslot
= OK
;
495 * Stop any current dma and put the new frame(s) on the queue.
496 * This should never fail since we check above that no frames
497 * are still pending on the queue.
499 if (!ath9k_hw_stoptxdma(ah
, sc
->beacon
.beaconq
)) {
500 ath_print(common
, ATH_DBG_FATAL
,
501 "beacon queue %u did not stop?\n", sc
->beacon
.beaconq
);
504 /* NB: cabq traffic should already be queued and primed */
505 ath9k_hw_puttxbuf(ah
, sc
->beacon
.beaconq
, bfaddr
);
506 ath9k_hw_txstart(ah
, sc
->beacon
.beaconq
);
508 sc
->beacon
.ast_be_xmit
+= bc
; /* XXX per-vif? */
512 static void ath9k_beacon_init(struct ath_softc
*sc
,
516 if (beacon_period
& ATH9K_BEACON_RESET_TSF
)
519 ath9k_hw_beaconinit(sc
->sc_ah
, next_beacon
, beacon_period
);
521 if (beacon_period
& ATH9K_BEACON_RESET_TSF
)
522 ath9k_ps_restore(sc
);
526 * For multi-bss ap support beacons are either staggered evenly over N slots or
527 * burst together. For the former arrange for the SWBA to be delivered for each
528 * slot. Slots that are not occupied will generate nothing.
530 static void ath_beacon_config_ap(struct ath_softc
*sc
,
531 struct ath_beacon_config
*conf
)
533 u32 nexttbtt
, intval
;
535 /* Configure the timers only when the TSF has to be reset */
537 if (!(sc
->sc_flags
& SC_OP_TSF_RESET
))
540 /* NB: the beacon interval is kept internally in TU's */
541 intval
= conf
->beacon_interval
& ATH9K_BEACON_PERIOD
;
542 intval
/= ATH_BCBUF
; /* for staggered beacons */
544 intval
|= ATH9K_BEACON_RESET_TSF
;
547 * In AP mode we enable the beacon timers and SWBA interrupts to
548 * prepare beacon frames.
550 intval
|= ATH9K_BEACON_ENA
;
551 sc
->imask
|= ATH9K_INT_SWBA
;
552 ath_beaconq_config(sc
);
554 /* Set the computed AP beacon timers */
556 ath9k_hw_set_interrupts(sc
->sc_ah
, 0);
557 ath9k_beacon_init(sc
, nexttbtt
, intval
);
558 sc
->beacon
.bmisscnt
= 0;
559 ath9k_hw_set_interrupts(sc
->sc_ah
, sc
->imask
);
561 /* Clear the reset TSF flag, so that subsequent beacon updation
562 will not reset the HW TSF. */
564 sc
->sc_flags
&= ~SC_OP_TSF_RESET
;
568 * This sets up the beacon timers according to the timestamp of the last
569 * received beacon and the current TSF, configures PCF and DTIM
570 * handling, programs the sleep registers so the hardware will wakeup in
571 * time to receive beacons, and configures the beacon miss handling so
572 * we'll receive a BMISS interrupt when we stop seeing beacons from the AP
573 * we've associated with.
575 static void ath_beacon_config_sta(struct ath_softc
*sc
,
576 struct ath_beacon_config
*conf
)
578 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
579 struct ath9k_beacon_state bs
;
580 int dtimperiod
, dtimcount
, sleepduration
;
581 int cfpperiod
, cfpcount
;
582 u32 nexttbtt
= 0, intval
, tsftu
;
584 int num_beacons
, offset
, dtim_dec_count
, cfp_dec_count
;
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(sc
->sc_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(sc
->sc_ah
, 0);
684 ath9k_hw_set_sta_beacon_timers(sc
->sc_ah
, &bs
);
685 sc
->imask
|= ATH9K_INT_BMISS
;
686 ath9k_hw_set_interrupts(sc
->sc_ah
, sc
->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_common
*common
= ath9k_hw_common(sc
->sc_ah
);
695 u32 tsftu
, intval
, nexttbtt
;
697 intval
= conf
->beacon_interval
& ATH9K_BEACON_PERIOD
;
700 /* Pull nexttbtt forward to reflect the current TSF */
702 nexttbtt
= TSF_TO_TU(sc
->beacon
.bc_tstamp
>> 32, sc
->beacon
.bc_tstamp
);
706 nexttbtt
= roundup(nexttbtt
, intval
);
708 tsf
= ath9k_hw_gettsf64(sc
->sc_ah
);
709 tsftu
= TSF_TO_TU((u32
)(tsf
>>32), (u32
)tsf
) + FUDGE
;
712 } while (nexttbtt
< tsftu
);
714 ath_print(common
, ATH_DBG_BEACON
,
715 "IBSS nexttbtt %u intval %u (%u)\n",
716 nexttbtt
, intval
, conf
->beacon_interval
);
719 * In IBSS mode enable the beacon timers but only enable SWBA interrupts
720 * if we need to manually prepare beacon frames. Otherwise we use a
721 * self-linked tx descriptor and let the hardware deal with things.
723 intval
|= ATH9K_BEACON_ENA
;
724 if (!(sc
->sc_ah
->caps
.hw_caps
& ATH9K_HW_CAP_VEOL
))
725 sc
->imask
|= ATH9K_INT_SWBA
;
727 ath_beaconq_config(sc
);
729 /* Set the computed ADHOC beacon timers */
731 ath9k_hw_set_interrupts(sc
->sc_ah
, 0);
732 ath9k_beacon_init(sc
, nexttbtt
, intval
);
733 sc
->beacon
.bmisscnt
= 0;
734 ath9k_hw_set_interrupts(sc
->sc_ah
, sc
->imask
);
736 /* FIXME: Handle properly when vif is NULL */
737 if (vif
&& sc
->sc_ah
->caps
.hw_caps
& ATH9K_HW_CAP_VEOL
)
738 ath_beacon_start_adhoc(sc
, vif
);
741 void ath_beacon_config(struct ath_softc
*sc
, struct ieee80211_vif
*vif
)
743 struct ath_beacon_config
*cur_conf
= &sc
->cur_beacon_conf
;
744 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
745 enum nl80211_iftype iftype
;
747 /* 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
;