drivers/net/wireless/ath/ath9k/common-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 "common.h"
  18
  19 #define FUDGE 2
  20
  21 /* Calculate the modulo of a 64 bit TSF snapshot with a TU divisor */
  22 static u32 ath9k_mod_tsf64_tu(u64 tsf, u32 div_tu)
  23 {
  24         u32 tsf_mod, tsf_hi, tsf_lo, mod_hi, mod_lo;
  25
  26         tsf_mod = tsf & (BIT(10) - 1);
  27         tsf_hi = tsf >> 32;
  28         tsf_lo = ((u32) tsf) >> 10;
  29
  30         mod_hi = tsf_hi % div_tu;
  31         mod_lo = ((mod_hi << 22) + tsf_lo) % div_tu;
  32
  33         return (mod_lo << 10) | tsf_mod;
  34 }
  35
  36 static u32 ath9k_get_next_tbtt(struct ath_hw *ah, u64 tsf,
  37                                unsigned int interval)
  38 {
  39         unsigned int offset;
  40
  41         tsf += TU_TO_USEC(FUDGE + ah->config.sw_beacon_response_time);
  42         offset = ath9k_mod_tsf64_tu(tsf, interval);
  43
  44         return (u32) tsf + TU_TO_USEC(interval) - offset;
  45 }
  46
  47 /*
  48  * This sets up the beacon timers according to the timestamp of the last
  49  * received beacon and the current TSF, configures PCF and DTIM
  50  * handling, programs the sleep registers so the hardware will wakeup in
  51  * time to receive beacons, and configures the beacon miss handling so
  52  * we'll receive a BMISS interrupt when we stop seeing beacons from the AP
  53  * we've associated with.
  54  */
  55 int ath9k_cmn_beacon_config_sta(struct ath_hw *ah,
  56                                  struct ath_beacon_config *conf,
  57                                  struct ath9k_beacon_state *bs)
  58 {
  59         struct ath_common *common = ath9k_hw_common(ah);
  60         int dtim_intval, sleepduration;
  61         u64 tsf;
  62
  63         /* No need to configure beacon if we are not associated */
  64         if (!test_bit(ATH_OP_PRIM_STA_VIF, &common->op_flags)) {
  65                 ath_dbg(common, BEACON,
  66                         "STA is not yet associated..skipping beacon config\n");
  67                 return -EPERM;
  68         }
  69
  70         memset(bs, 0, sizeof(*bs));
  71         conf->intval = conf->beacon_interval;
  72
  73         /*
  74          * Setup dtim parameters according to
  75          * last beacon we received (which may be none).
  76          */
  77         dtim_intval = conf->intval * conf->dtim_period;
  78         sleepduration = ah->hw->conf.listen_interval * conf->intval;
  79
  80         /*
  81          * Pull nexttbtt forward to reflect the current
  82          * TSF and calculate dtim state for the result.
  83          */
  84         tsf = ath9k_hw_gettsf64(ah);
  85         conf->nexttbtt = ath9k_get_next_tbtt(ah, tsf, conf->intval);
  86
  87         bs->bs_intval = TU_TO_USEC(conf->intval);
  88         bs->bs_dtimperiod = conf->dtim_period * bs->bs_intval;
  89         bs->bs_nexttbtt = conf->nexttbtt;
  90         bs->bs_nextdtim = conf->nexttbtt;
  91         if (conf->dtim_period > 1)
  92                 bs->bs_nextdtim = ath9k_get_next_tbtt(ah, tsf, dtim_intval);
  93
  94         /*
  95          * Calculate the number of consecutive beacons to miss* before taking
  96          * a BMISS interrupt. The configuration is specified in TU so we only
  97          * need calculate based on the beacon interval.  Note that we clamp the
  98          * result to at most 15 beacons.
  99          */
 100         bs->bs_bmissthreshold = DIV_ROUND_UP(conf->bmiss_timeout, conf->intval);
 101         if (bs->bs_bmissthreshold > 15)
 102                 bs->bs_bmissthreshold = 15;
 103         else if (bs->bs_bmissthreshold <= 0)
 104                 bs->bs_bmissthreshold = 1;
 105
 106         /*
 107          * Calculate sleep duration. The configuration is given in ms.
 108          * We ensure a multiple of the beacon period is used. Also, if the sleep
 109          * duration is greater than the DTIM period then it makes senses
 110          * to make it a multiple of that.
 111          *
 112          * XXX fixed at 100ms
 113          */
 114
 115         bs->bs_sleepduration = TU_TO_USEC(roundup(IEEE80211_MS_TO_TU(100),
 116                                                   sleepduration));
 117         if (bs->bs_sleepduration > bs->bs_dtimperiod)
 118                 bs->bs_sleepduration = bs->bs_dtimperiod;
 119
 120         /* TSF out of range threshold fixed at 1 second */
 121         bs->bs_tsfoor_threshold = ATH9K_TSFOOR_THRESHOLD;
 122
 123         ath_dbg(common, BEACON, "bmiss: %u sleep: %u\n",
 124                 bs->bs_bmissthreshold, bs->bs_sleepduration);
 125         return 0;
 126 }
 127 EXPORT_SYMBOL(ath9k_cmn_beacon_config_sta);
 128
 129 void ath9k_cmn_beacon_config_adhoc(struct ath_hw *ah,
 130                                    struct ath_beacon_config *conf)
 131 {
 132         struct ath_common *common = ath9k_hw_common(ah);
 133
 134         conf->intval = TU_TO_USEC(conf->beacon_interval);
 135
 136         if (conf->ibss_creator)
 137                 conf->nexttbtt = conf->intval;
 138         else
 139                 conf->nexttbtt = ath9k_get_next_tbtt(ah, ath9k_hw_gettsf64(ah),
 140                                                conf->beacon_interval);
 141
 142         if (conf->enable_beacon)
 143                 ah->imask |= ATH9K_INT_SWBA;
 144         else
 145                 ah->imask &= ~ATH9K_INT_SWBA;
 146
 147         ath_dbg(common, BEACON,
 148                 "IBSS (%s) nexttbtt: %u intval: %u conf_intval: %u\n",
 149                 (conf->enable_beacon) ? "Enable" : "Disable",
 150                 conf->nexttbtt, conf->intval, conf->beacon_interval);
 151 }
 152 EXPORT_SYMBOL(ath9k_cmn_beacon_config_adhoc);
 153
 154 /*
 155  * For multi-bss ap support beacons are either staggered evenly over N slots or
 156  * burst together.  For the former arrange for the SWBA to be delivered for each
 157  * slot. Slots that are not occupied will generate nothing.
 158  */
 159 void ath9k_cmn_beacon_config_ap(struct ath_hw *ah,
 160                                 struct ath_beacon_config *conf,
 161                                 unsigned int bc_buf)
 162 {
 163         struct ath_common *common = ath9k_hw_common(ah);
 164
 165         /* NB: the beacon interval is kept internally in TU's */
 166         conf->intval = TU_TO_USEC(conf->beacon_interval);
 167         conf->intval /= bc_buf;
 168         conf->nexttbtt = ath9k_get_next_tbtt(ah, ath9k_hw_gettsf64(ah),
 169                                        conf->beacon_interval);
 170
 171         if (conf->enable_beacon)
 172                 ah->imask |= ATH9K_INT_SWBA;
 173         else
 174                 ah->imask &= ~ATH9K_INT_SWBA;
 175
 176         ath_dbg(common, BEACON,
 177                 "AP (%s) nexttbtt: %u intval: %u conf_intval: %u\n",
 178                 (conf->enable_beacon) ? "Enable" : "Disable",
 179                 conf->nexttbtt, conf->intval, conf->beacon_interval);
 180 }
 181 EXPORT_SYMBOL(ath9k_cmn_beacon_config_ap);