kernel/drivers/net/wireless/iwlwifi/mvm/sf.c

   1 /******************************************************************************
   2  *
   3  * This file is provided under a dual BSD/GPLv2 license.  When using or
   4  * redistributing this file, you may do so under either license.
   5  *
   6  * GPL LICENSE SUMMARY
   7  *
   8  * Copyright(c) 2013 - 2014 Intel Corporation. All rights reserved.
   9  * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of version 2 of the GNU General Public License as
  13  * published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful, but
  16  * WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
  23  * USA
  24  *
  25  * The full GNU General Public License is included in this distribution
  26  * in the file called COPYING.
  27  *
  28  * Contact Information:
  29  *  Intel Linux Wireless <ilw@linux.intel.com>
  30  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  31  *
  32  * BSD LICENSE
  33  *
  34  * Copyright(c) 2013 - 2014 Intel Corporation. All rights reserved.
  35  * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
  36  * All rights reserved.
  37  *
  38  * Redistribution and use in source and binary forms, with or without
  39  * modification, are permitted provided that the following conditions
  40  * are met:
  41  *
  42  *  * Redistributions of source code must retain the above copyright
  43  *    notice, this list of conditions and the following disclaimer.
  44  *  * Redistributions in binary form must reproduce the above copyright
  45  *    notice, this list of conditions and the following disclaimer in
  46  *    the documentation and/or other materials provided with the
  47  *    distribution.
  48  *  * Neither the name Intel Corporation nor the names of its
  49  *    contributors may be used to endorse or promote products derived
  50  *    from this software without specific prior written permission.
  51  *
  52  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  53  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  54  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  55  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  56  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  57  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  58  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  59  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  60  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  61  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  62  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  63  *
  64  *****************************************************************************/
  65 #include "mvm.h"
  66
  67 /* For counting bound interfaces */
  68 struct iwl_mvm_active_iface_iterator_data {
  69         struct ieee80211_vif *ignore_vif;
  70         u8 sta_vif_ap_sta_id;
  71         enum iwl_sf_state sta_vif_state;
  72         int num_active_macs;
  73 };
  74
  75 /*
  76  * Count bound interfaces which are not p2p, besides data->ignore_vif.
  77  * data->station_vif will point to one bound vif of type station, if exists.
  78  */
  79 static void iwl_mvm_bound_iface_iterator(void *_data, u8 *mac,
  80                                          struct ieee80211_vif *vif)
  81 {
  82         struct iwl_mvm_active_iface_iterator_data *data = _data;
  83         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
  84
  85         if (vif == data->ignore_vif || !mvmvif->phy_ctxt ||
  86             vif->type == NL80211_IFTYPE_P2P_DEVICE)
  87                 return;
  88
  89         data->num_active_macs++;
  90
  91         if (vif->type == NL80211_IFTYPE_STATION) {
  92                 data->sta_vif_ap_sta_id = mvmvif->ap_sta_id;
  93                 if (vif->bss_conf.assoc)
  94                         data->sta_vif_state = SF_FULL_ON;
  95                 else
  96                         data->sta_vif_state = SF_INIT_OFF;
  97         }
  98 }
  99
 100 /*
 101  * Aging and idle timeouts for the different possible scenarios
 102  * in default configuration
 103  */
 104 static const
 105 __le32 sf_full_timeout_def[SF_NUM_SCENARIO][SF_NUM_TIMEOUT_TYPES] = {
 106         {
 107                 cpu_to_le32(SF_SINGLE_UNICAST_AGING_TIMER_DEF),
 108                 cpu_to_le32(SF_SINGLE_UNICAST_IDLE_TIMER_DEF)
 109         },
 110         {
 111                 cpu_to_le32(SF_AGG_UNICAST_AGING_TIMER_DEF),
 112                 cpu_to_le32(SF_AGG_UNICAST_IDLE_TIMER_DEF)
 113         },
 114         {
 115                 cpu_to_le32(SF_MCAST_AGING_TIMER_DEF),
 116                 cpu_to_le32(SF_MCAST_IDLE_TIMER_DEF)
 117         },
 118         {
 119                 cpu_to_le32(SF_BA_AGING_TIMER_DEF),
 120                 cpu_to_le32(SF_BA_IDLE_TIMER_DEF)
 121         },
 122         {
 123                 cpu_to_le32(SF_TX_RE_AGING_TIMER_DEF),
 124                 cpu_to_le32(SF_TX_RE_IDLE_TIMER_DEF)
 125         },
 126 };
 127
 128 /*
 129  * Aging and idle timeouts for the different possible scenarios
 130  * in single BSS MAC configuration.
 131  */
 132 static const __le32 sf_full_timeout[SF_NUM_SCENARIO][SF_NUM_TIMEOUT_TYPES] = {
 133         {
 134                 cpu_to_le32(SF_SINGLE_UNICAST_AGING_TIMER),
 135                 cpu_to_le32(SF_SINGLE_UNICAST_IDLE_TIMER)
 136         },
 137         {
 138                 cpu_to_le32(SF_AGG_UNICAST_AGING_TIMER),
 139                 cpu_to_le32(SF_AGG_UNICAST_IDLE_TIMER)
 140         },
 141         {
 142                 cpu_to_le32(SF_MCAST_AGING_TIMER),
 143                 cpu_to_le32(SF_MCAST_IDLE_TIMER)
 144         },
 145         {
 146                 cpu_to_le32(SF_BA_AGING_TIMER),
 147                 cpu_to_le32(SF_BA_IDLE_TIMER)
 148         },
 149         {
 150                 cpu_to_le32(SF_TX_RE_AGING_TIMER),
 151                 cpu_to_le32(SF_TX_RE_IDLE_TIMER)
 152         },
 153 };
 154
 155 static void iwl_mvm_fill_sf_command(struct iwl_mvm *mvm,
 156                                     struct iwl_sf_cfg_cmd *sf_cmd,
 157                                     struct ieee80211_sta *sta)
 158 {
 159         int i, j, watermark;
 160
 161         sf_cmd->watermark[SF_LONG_DELAY_ON] = cpu_to_le32(SF_W_MARK_SCAN);
 162
 163         /*
 164          * If we are in association flow - check antenna configuration
 165          * capabilities of the AP station, and choose the watermark accordingly.
 166          */
 167         if (sta) {
 168                 if (sta->ht_cap.ht_supported || sta->vht_cap.vht_supported) {
 169                         switch (sta->rx_nss) {
 170                         case 1:
 171                                 watermark = SF_W_MARK_SISO;
 172                                 break;
 173                         case 2:
 174                                 watermark = SF_W_MARK_MIMO2;
 175                                 break;
 176                         default:
 177                                 watermark = SF_W_MARK_MIMO3;
 178                                 break;
 179                         }
 180                 } else {
 181                         watermark = SF_W_MARK_LEGACY;
 182                 }
 183         /* default watermark value for unassociated mode. */
 184         } else {
 185                 watermark = SF_W_MARK_MIMO2;
 186         }
 187         sf_cmd->watermark[SF_FULL_ON] = cpu_to_le32(watermark);
 188
 189         for (i = 0; i < SF_NUM_SCENARIO; i++) {
 190                 for (j = 0; j < SF_NUM_TIMEOUT_TYPES; j++) {
 191                         sf_cmd->long_delay_timeouts[i][j] =
 192                                         cpu_to_le32(SF_LONG_DELAY_AGING_TIMER);
 193                 }
 194         }
 195
 196         if (sta || IWL_UCODE_API(mvm->fw->ucode_ver) < 13) {
 197                 BUILD_BUG_ON(sizeof(sf_full_timeout) !=
 198                              sizeof(__le32) * SF_NUM_SCENARIO *
 199                              SF_NUM_TIMEOUT_TYPES);
 200
 201                 memcpy(sf_cmd->full_on_timeouts, sf_full_timeout,
 202                        sizeof(sf_full_timeout));
 203         } else {
 204                 BUILD_BUG_ON(sizeof(sf_full_timeout_def) !=
 205                              sizeof(__le32) * SF_NUM_SCENARIO *
 206                              SF_NUM_TIMEOUT_TYPES);
 207
 208                 memcpy(sf_cmd->full_on_timeouts, sf_full_timeout_def,
 209                        sizeof(sf_full_timeout_def));
 210         }
 211
 212 }
 213
 214 static int iwl_mvm_sf_config(struct iwl_mvm *mvm, u8 sta_id,
 215                              enum iwl_sf_state new_state)
 216 {
 217         struct iwl_sf_cfg_cmd sf_cmd = {
 218                 .state = cpu_to_le32(SF_FULL_ON),
 219         };
 220         struct ieee80211_sta *sta;
 221         int ret = 0;
 222
 223         if (IWL_UCODE_API(mvm->fw->ucode_ver) < 13)
 224                 sf_cmd.state = cpu_to_le32(new_state);
 225
 226         if (mvm->cfg->disable_dummy_notification)
 227                 sf_cmd.state |= cpu_to_le32(SF_CFG_DUMMY_NOTIF_OFF);
 228
 229         /*
 230          * If an associated AP sta changed its antenna configuration, the state
 231          * will remain FULL_ON but SF parameters need to be reconsidered.
 232          */
 233         if (new_state != SF_FULL_ON && mvm->sf_state == new_state)
 234                 return 0;
 235
 236         switch (new_state) {
 237         case SF_UNINIT:
 238                 if (IWL_UCODE_API(mvm->fw->ucode_ver) >= 13)
 239                         iwl_mvm_fill_sf_command(mvm, &sf_cmd, NULL);
 240                 break;
 241         case SF_FULL_ON:
 242                 if (sta_id == IWL_MVM_STATION_COUNT) {
 243                         IWL_ERR(mvm,
 244                                 "No station: Cannot switch SF to FULL_ON\n");
 245                         return -EINVAL;
 246                 }
 247                 rcu_read_lock();
 248                 sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]);
 249                 if (IS_ERR_OR_NULL(sta)) {
 250                         IWL_ERR(mvm, "Invalid station id\n");
 251                         rcu_read_unlock();
 252                         return -EINVAL;
 253                 }
 254                 iwl_mvm_fill_sf_command(mvm, &sf_cmd, sta);
 255                 rcu_read_unlock();
 256                 break;
 257         case SF_INIT_OFF:
 258                 iwl_mvm_fill_sf_command(mvm, &sf_cmd, NULL);
 259                 break;
 260         default:
 261                 WARN_ONCE(1, "Invalid state: %d. not sending Smart Fifo cmd\n",
 262                           new_state);
 263                 return -EINVAL;
 264         }
 265
 266         ret = iwl_mvm_send_cmd_pdu(mvm, REPLY_SF_CFG_CMD, CMD_ASYNC,
 267                                    sizeof(sf_cmd), &sf_cmd);
 268         if (!ret)
 269                 mvm->sf_state = new_state;
 270
 271         return ret;
 272 }
 273
 274 /*
 275  * Update Smart fifo:
 276  * Count bound interfaces that are not to be removed, ignoring p2p devices,
 277  * and set new state accordingly.
 278  */
 279 int iwl_mvm_sf_update(struct iwl_mvm *mvm, struct ieee80211_vif *changed_vif,
 280                       bool remove_vif)
 281 {
 282         enum iwl_sf_state new_state;
 283         u8 sta_id = IWL_MVM_STATION_COUNT;
 284         struct iwl_mvm_vif *mvmvif = NULL;
 285         struct iwl_mvm_active_iface_iterator_data data = {
 286                 .ignore_vif = changed_vif,
 287                 .sta_vif_state = SF_UNINIT,
 288                 .sta_vif_ap_sta_id = IWL_MVM_STATION_COUNT,
 289         };
 290
 291         /*
 292          * Ignore the call if we are in HW Restart flow, or if the handled
 293          * vif is a p2p device.
 294          */
 295         if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) ||
 296             (changed_vif && changed_vif->type == NL80211_IFTYPE_P2P_DEVICE))
 297                 return 0;
 298
 299         ieee80211_iterate_active_interfaces_atomic(mvm->hw,
 300                                                    IEEE80211_IFACE_ITER_NORMAL,
 301                                                    iwl_mvm_bound_iface_iterator,
 302                                                    &data);
 303
 304         /* If changed_vif exists and is not to be removed, add to the count */
 305         if (changed_vif && !remove_vif)
 306                 data.num_active_macs++;
 307
 308         switch (data.num_active_macs) {
 309         case 0:
 310                 /* If there are no active macs - change state to SF_INIT_OFF */
 311                 new_state = SF_INIT_OFF;
 312                 break;
 313         case 1:
 314                 if (remove_vif) {
 315                         /* The one active mac left is of type station
 316                          * and we filled the relevant data during iteration
 317                          */
 318                         new_state = data.sta_vif_state;
 319                         sta_id = data.sta_vif_ap_sta_id;
 320                 } else {
 321                         if (WARN_ON(!changed_vif))
 322                                 return -EINVAL;
 323                         if (changed_vif->type != NL80211_IFTYPE_STATION) {
 324                                 new_state = SF_UNINIT;
 325                         } else if (changed_vif->bss_conf.assoc &&
 326                                    changed_vif->bss_conf.dtim_period) {
 327                                 mvmvif = iwl_mvm_vif_from_mac80211(changed_vif);
 328                                 sta_id = mvmvif->ap_sta_id;
 329                                 new_state = SF_FULL_ON;
 330                         } else {
 331                                 new_state = SF_INIT_OFF;
 332                         }
 333                 }
 334                 break;
 335         default:
 336                 /* If there are multiple active macs - change to SF_UNINIT */
 337                 new_state = SF_UNINIT;
 338         }
 339         return iwl_mvm_sf_config(mvm, sta_id, new_state);
 340 }