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

   1 /*
   2  * Copyright (c) 2014 Qualcomm Atheros, 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 "ath9k.h"
  18
  19 /* Set/change channels.  If the channel is really being changed, it's done
  20  * by reseting the chip.  To accomplish this we must first cleanup any pending
  21  * DMA, then restart stuff.
  22  */
  23 static int ath_set_channel(struct ath_softc *sc)
  24 {
  25         struct ath_hw *ah = sc->sc_ah;
  26         struct ath_common *common = ath9k_hw_common(ah);
  27         struct ieee80211_hw *hw = sc->hw;
  28         struct ath9k_channel *hchan;
  29         struct cfg80211_chan_def *chandef = &sc->cur_chan->chandef;
  30         struct ieee80211_channel *chan = chandef->chan;
  31         int pos = chan->hw_value;
  32         int old_pos = -1;
  33         int r;
  34
  35         if (test_bit(ATH_OP_INVALID, &common->op_flags))
  36                 return -EIO;
  37
  38         if (ah->curchan)
  39                 old_pos = ah->curchan - &ah->channels[0];
  40
  41         ath_dbg(common, CONFIG, "Set channel: %d MHz width: %d\n",
  42                 chan->center_freq, chandef->width);
  43
  44         /* update survey stats for the old channel before switching */
  45         spin_lock_bh(&common->cc_lock);
  46         ath_update_survey_stats(sc);
  47         spin_unlock_bh(&common->cc_lock);
  48
  49         ath9k_cmn_get_channel(hw, ah, chandef);
  50
  51         /* If the operating channel changes, change the survey in-use flags
  52          * along with it.
  53          * Reset the survey data for the new channel, unless we're switching
  54          * back to the operating channel from an off-channel operation.
  55          */
  56         if (!sc->cur_chan->offchannel && sc->cur_survey != &sc->survey[pos]) {
  57                 if (sc->cur_survey)
  58                         sc->cur_survey->filled &= ~SURVEY_INFO_IN_USE;
  59
  60                 sc->cur_survey = &sc->survey[pos];
  61
  62                 memset(sc->cur_survey, 0, sizeof(struct survey_info));
  63                 sc->cur_survey->filled |= SURVEY_INFO_IN_USE;
  64         } else if (!(sc->survey[pos].filled & SURVEY_INFO_IN_USE)) {
  65                 memset(&sc->survey[pos], 0, sizeof(struct survey_info));
  66         }
  67
  68         hchan = &sc->sc_ah->channels[pos];
  69         r = ath_reset_internal(sc, hchan);
  70         if (r)
  71                 return r;
  72
  73         /* The most recent snapshot of channel->noisefloor for the old
  74          * channel is only available after the hardware reset. Copy it to
  75          * the survey stats now.
  76          */
  77         if (old_pos >= 0)
  78                 ath_update_survey_nf(sc, old_pos);
  79
  80         /* Enable radar pulse detection if on a DFS channel. Spectral
  81          * scanning and radar detection can not be used concurrently.
  82          */
  83         if (hw->conf.radar_enabled) {
  84                 u32 rxfilter;
  85
  86                 /* set HW specific DFS configuration */
  87                 ath9k_hw_set_radar_params(ah);
  88                 rxfilter = ath9k_hw_getrxfilter(ah);
  89                 rxfilter |= ATH9K_RX_FILTER_PHYRADAR |
  90                                 ATH9K_RX_FILTER_PHYERR;
  91                 ath9k_hw_setrxfilter(ah, rxfilter);
  92                 ath_dbg(common, DFS, "DFS enabled at freq %d\n",
  93                         chan->center_freq);
  94         } else {
  95                 /* perform spectral scan if requested. */
  96                 if (test_bit(ATH_OP_SCANNING, &common->op_flags) &&
  97                         sc->spectral_mode == SPECTRAL_CHANSCAN)
  98                         ath9k_spectral_scan_trigger(hw);
  99         }
 100
 101         return 0;
 102 }
 103
 104 static bool
 105 ath_chanctx_send_vif_ps_frame(struct ath_softc *sc, struct ath_vif *avp,
 106                               bool powersave)
 107 {
 108         struct ieee80211_vif *vif = avp->vif;
 109         struct ieee80211_sta *sta = NULL;
 110         struct ieee80211_hdr_3addr *nullfunc;
 111         struct ath_tx_control txctl;
 112         struct sk_buff *skb;
 113         int band = sc->cur_chan->chandef.chan->band;
 114
 115         switch (vif->type) {
 116         case NL80211_IFTYPE_STATION:
 117                 if (!vif->bss_conf.assoc)
 118                         return false;
 119
 120                 skb = ieee80211_nullfunc_get(sc->hw, vif);
 121                 if (!skb)
 122                         return false;
 123
 124                 nullfunc = (struct ieee80211_hdr_3addr *) skb->data;
 125                 if (powersave)
 126                         nullfunc->frame_control |=
 127                                 cpu_to_le16(IEEE80211_FCTL_PM);
 128
 129                 skb_set_queue_mapping(skb, IEEE80211_AC_VO);
 130                 if (!ieee80211_tx_prepare_skb(sc->hw, vif, skb, band, &sta)) {
 131                         dev_kfree_skb_any(skb);
 132                         return false;
 133                 }
 134                 break;
 135         default:
 136                 return false;
 137         }
 138
 139         memset(&txctl, 0, sizeof(txctl));
 140         txctl.txq = sc->tx.txq_map[IEEE80211_AC_VO];
 141         txctl.sta = sta;
 142         txctl.force_channel = true;
 143         if (ath_tx_start(sc->hw, skb, &txctl)) {
 144                 ieee80211_free_txskb(sc->hw, skb);
 145                 return false;
 146         }
 147
 148         return true;
 149 }
 150
 151 void ath_chanctx_check_active(struct ath_softc *sc, struct ath_chanctx *ctx)
 152 {
 153         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 154         struct ath_vif *avp;
 155         bool active = false;
 156         u8 n_active = 0;
 157
 158         if (!ctx)
 159                 return;
 160
 161         list_for_each_entry(avp, &ctx->vifs, list) {
 162                 struct ieee80211_vif *vif = avp->vif;
 163
 164                 switch (vif->type) {
 165                 case NL80211_IFTYPE_P2P_CLIENT:
 166                 case NL80211_IFTYPE_STATION:
 167                         if (vif->bss_conf.assoc)
 168                                 active = true;
 169                         break;
 170                 default:
 171                         active = true;
 172                         break;
 173                 }
 174         }
 175         ctx->active = active;
 176
 177         ath_for_each_chanctx(sc, ctx) {
 178                 if (!ctx->assigned || list_empty(&ctx->vifs))
 179                         continue;
 180                 n_active++;
 181         }
 182
 183         if (n_active > 1)
 184                 set_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags);
 185         else
 186                 clear_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags);
 187 }
 188
 189 static bool
 190 ath_chanctx_send_ps_frame(struct ath_softc *sc, bool powersave)
 191 {
 192         struct ath_vif *avp;
 193         bool sent = false;
 194
 195         rcu_read_lock();
 196         list_for_each_entry(avp, &sc->cur_chan->vifs, list) {
 197                 if (ath_chanctx_send_vif_ps_frame(sc, avp, powersave))
 198                         sent = true;
 199         }
 200         rcu_read_unlock();
 201
 202         return sent;
 203 }
 204
 205 static bool ath_chanctx_defer_switch(struct ath_softc *sc)
 206 {
 207         if (sc->cur_chan == &sc->offchannel.chan)
 208                 return false;
 209
 210         switch (sc->sched.state) {
 211         case ATH_CHANCTX_STATE_SWITCH:
 212                 return false;
 213         case ATH_CHANCTX_STATE_IDLE:
 214                 if (!sc->cur_chan->switch_after_beacon)
 215                         return false;
 216
 217                 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 218                 break;
 219         default:
 220                 break;
 221         }
 222
 223         return true;
 224 }
 225
 226 void ath_chanctx_work(struct work_struct *work)
 227 {
 228         struct ath_softc *sc = container_of(work, struct ath_softc,
 229                                             chanctx_work);
 230         struct timespec ts;
 231         bool measure_time = false;
 232         bool send_ps = false;
 233
 234         mutex_lock(&sc->mutex);
 235         spin_lock_bh(&sc->chan_lock);
 236         if (!sc->next_chan) {
 237                 spin_unlock_bh(&sc->chan_lock);
 238                 mutex_unlock(&sc->mutex);
 239                 return;
 240         }
 241
 242         if (ath_chanctx_defer_switch(sc)) {
 243                 spin_unlock_bh(&sc->chan_lock);
 244                 mutex_unlock(&sc->mutex);
 245                 return;
 246         }
 247
 248         if (sc->cur_chan != sc->next_chan) {
 249                 sc->cur_chan->stopped = true;
 250                 spin_unlock_bh(&sc->chan_lock);
 251
 252                 if (sc->next_chan == &sc->offchannel.chan) {
 253                         getrawmonotonic(&ts);
 254                         measure_time = true;
 255                 }
 256                 __ath9k_flush(sc->hw, ~0, true);
 257
 258                 if (ath_chanctx_send_ps_frame(sc, true))
 259                         __ath9k_flush(sc->hw, BIT(IEEE80211_AC_VO), false);
 260
 261                 send_ps = true;
 262                 spin_lock_bh(&sc->chan_lock);
 263
 264                 if (sc->cur_chan != &sc->offchannel.chan) {
 265                         getrawmonotonic(&sc->cur_chan->tsf_ts);
 266                         sc->cur_chan->tsf_val = ath9k_hw_gettsf64(sc->sc_ah);
 267                 }
 268         }
 269         sc->cur_chan = sc->next_chan;
 270         sc->cur_chan->stopped = false;
 271         sc->next_chan = NULL;
 272         sc->sched.state = ATH_CHANCTX_STATE_IDLE;
 273         sc->sched.offchannel_duration = 0;
 274
 275         spin_unlock_bh(&sc->chan_lock);
 276
 277         if (sc->sc_ah->chip_fullsleep ||
 278             memcmp(&sc->cur_chandef, &sc->cur_chan->chandef,
 279                    sizeof(sc->cur_chandef))) {
 280                 ath_set_channel(sc);
 281                 if (measure_time)
 282                         sc->sched.channel_switch_time =
 283                                 ath9k_hw_get_tsf_offset(&ts, NULL);
 284         }
 285         if (send_ps)
 286                 ath_chanctx_send_ps_frame(sc, false);
 287
 288         ath_offchannel_channel_change(sc);
 289         mutex_unlock(&sc->mutex);
 290 }
 291
 292 void ath_chanctx_init(struct ath_softc *sc)
 293 {
 294         struct ath_chanctx *ctx;
 295         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 296         struct ieee80211_supported_band *sband;
 297         struct ieee80211_channel *chan;
 298         int i, j;
 299
 300         sband = &common->sbands[IEEE80211_BAND_2GHZ];
 301         if (!sband->n_channels)
 302                 sband = &common->sbands[IEEE80211_BAND_5GHZ];
 303
 304         chan = &sband->channels[0];
 305         for (i = 0; i < ATH9K_NUM_CHANCTX; i++) {
 306                 ctx = &sc->chanctx[i];
 307                 cfg80211_chandef_create(&ctx->chandef, chan, NL80211_CHAN_HT20);
 308                 INIT_LIST_HEAD(&ctx->vifs);
 309                 ctx->txpower = ATH_TXPOWER_MAX;
 310                 for (j = 0; j < ARRAY_SIZE(ctx->acq); j++)
 311                         INIT_LIST_HEAD(&ctx->acq[j]);
 312         }
 313         ctx = &sc->offchannel.chan;
 314         cfg80211_chandef_create(&ctx->chandef, chan, NL80211_CHAN_HT20);
 315         INIT_LIST_HEAD(&ctx->vifs);
 316         ctx->txpower = ATH_TXPOWER_MAX;
 317         for (j = 0; j < ARRAY_SIZE(ctx->acq); j++)
 318                 INIT_LIST_HEAD(&ctx->acq[j]);
 319         sc->offchannel.chan.offchannel = true;
 320
 321 }
 322
 323 void ath_chanctx_switch(struct ath_softc *sc, struct ath_chanctx *ctx,
 324                         struct cfg80211_chan_def *chandef)
 325 {
 326
 327         spin_lock_bh(&sc->chan_lock);
 328         sc->next_chan = ctx;
 329         if (chandef)
 330                 ctx->chandef = *chandef;
 331
 332         if (sc->next_chan == &sc->offchannel.chan) {
 333                 sc->sched.offchannel_duration =
 334                         TU_TO_USEC(sc->offchannel.duration) +
 335                         sc->sched.channel_switch_time;
 336         }
 337         spin_unlock_bh(&sc->chan_lock);
 338         ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 339 }
 340
 341 void ath_chanctx_set_channel(struct ath_softc *sc, struct ath_chanctx *ctx,
 342                              struct cfg80211_chan_def *chandef)
 343 {
 344         bool cur_chan;
 345
 346         spin_lock_bh(&sc->chan_lock);
 347         if (chandef)
 348                 memcpy(&ctx->chandef, chandef, sizeof(*chandef));
 349         cur_chan = sc->cur_chan == ctx;
 350         spin_unlock_bh(&sc->chan_lock);
 351
 352         if (!cur_chan)
 353                 return;
 354
 355         ath_set_channel(sc);
 356 }
 357
 358 struct ath_chanctx *ath_chanctx_get_oper_chan(struct ath_softc *sc, bool active)
 359 {
 360         struct ath_chanctx *ctx;
 361
 362         ath_for_each_chanctx(sc, ctx) {
 363                 if (!ctx->assigned || list_empty(&ctx->vifs))
 364                         continue;
 365                 if (active && !ctx->active)
 366                         continue;
 367
 368                 return ctx;
 369         }
 370
 371         return &sc->chanctx[0];
 372 }
 373
 374 void ath_chanctx_offchan_switch(struct ath_softc *sc,
 375                                 struct ieee80211_channel *chan)
 376 {
 377         struct cfg80211_chan_def chandef;
 378
 379         cfg80211_chandef_create(&chandef, chan, NL80211_CHAN_NO_HT);
 380
 381         ath_chanctx_switch(sc, &sc->offchannel.chan, &chandef);
 382 }
 383
 384 void ath_chanctx_event(struct ath_softc *sc, struct ieee80211_vif *vif,
 385                        enum ath_chanctx_event ev)
 386 {
 387         struct ath_hw *ah = sc->sc_ah;
 388         struct ath_vif *avp = NULL;
 389         u32 tsf_time;
 390         bool noa_changed = false;
 391
 392         if (vif)
 393                 avp = (struct ath_vif *) vif->drv_priv;
 394
 395         spin_lock_bh(&sc->chan_lock);
 396
 397         switch (ev) {
 398         case ATH_CHANCTX_EVENT_BEACON_PREPARE:
 399                 if (avp->offchannel_duration)
 400                         avp->offchannel_duration = 0;
 401
 402                 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON)
 403                         break;
 404
 405                 sc->sched.beacon_pending = true;
 406                 sc->sched.next_tbtt = REG_READ(ah, AR_NEXT_TBTT_TIMER);
 407
 408                 /* defer channel switch by a quarter beacon interval */
 409                 tsf_time = TU_TO_USEC(sc->cur_chan->beacon.beacon_interval);
 410                 tsf_time = sc->sched.next_tbtt + tsf_time / 4;
 411                 sc->sched.switch_start_time = tsf_time;
 412
 413                 if (sc->sched.offchannel_duration) {
 414                         noa_changed = true;
 415                         avp->offchannel_start = tsf_time;
 416                         avp->offchannel_duration =
 417                                 sc->sched.offchannel_duration;
 418                 }
 419
 420                 if (noa_changed)
 421                         avp->noa_index++;
 422                 break;
 423         case ATH_CHANCTX_EVENT_BEACON_SENT:
 424                 if (!sc->sched.beacon_pending)
 425                         break;
 426
 427                 sc->sched.beacon_pending = false;
 428                 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON)
 429                         break;
 430
 431                 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_TIMER;
 432                 ath9k_hw_gen_timer_start(ah, sc->p2p_ps_timer,
 433                                          sc->sched.switch_start_time,
 434                                          1000000);
 435                 break;
 436         case ATH_CHANCTX_EVENT_TSF_TIMER:
 437                 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_TIMER)
 438                         break;
 439
 440                 sc->sched.state = ATH_CHANCTX_STATE_SWITCH;
 441                 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 442                 break;
 443         }
 444
 445         spin_unlock_bh(&sc->chan_lock);
 446 }