drivers/net/wireless/iwlwifi/iwl-power.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2010 Intel Corporation. All rights reserved.
   4  *
   5  * Portions of this file are derived from the ipw3945 project, as well
   6  * as portions of the ieee80211 subsystem header files.
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of version 2 of the GNU General Public License as
  10  * published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along with
  18  * this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  20  *
  21  * The full GNU General Public License is included in this distribution in the
  22  * file called LICENSE.
  23  *
  24  * Contact Information:
  25  *  Intel Linux Wireless <ilw@linux.intel.com>
  26  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  27  *****************************************************************************/
  28
  29
  30 #include <linux/kernel.h>
  31 #include <linux/module.h>
  32 #include <linux/init.h>
  33
  34 #include <net/mac80211.h>
  35
  36 #include "iwl-eeprom.h"
  37 #include "iwl-dev.h"
  38 #include "iwl-core.h"
  39 #include "iwl-io.h"
  40 #include "iwl-commands.h"
  41 #include "iwl-debug.h"
  42 #include "iwl-power.h"
  43
  44 /*
  45  * Setting power level allows the card to go to sleep when not busy.
  46  *
  47  * We calculate a sleep command based on the required latency, which
  48  * we get from mac80211. In order to handle thermal throttling, we can
  49  * also use pre-defined power levels.
  50  */
  51
  52 /*
  53  * For now, keep using power level 1 instead of automatically
  54  * adjusting ...
  55  */
  56 bool no_sleep_autoadjust = true;
  57 module_param(no_sleep_autoadjust, bool, S_IRUGO);
  58 MODULE_PARM_DESC(no_sleep_autoadjust,
  59                  "don't automatically adjust sleep level "
  60                  "according to maximum network latency");
  61
  62 /*
  63  * This defines the old power levels. They are still used by default
  64  * (level 1) and for thermal throttle (levels 3 through 5)
  65  */
  66
  67 struct iwl_power_vec_entry {
  68         struct iwl_powertable_cmd cmd;
  69         u8 no_dtim;     /* number of skip dtim */
  70 };
  71
  72 #define IWL_DTIM_RANGE_0_MAX    2
  73 #define IWL_DTIM_RANGE_1_MAX    10
  74
  75 #define NOSLP cpu_to_le16(0), 0, 0
  76 #define SLP IWL_POWER_DRIVER_ALLOW_SLEEP_MSK, 0, 0
  77 #define TU_TO_USEC 1024
  78 #define SLP_TOUT(T) cpu_to_le32((T) * TU_TO_USEC)
  79 #define SLP_VEC(X0, X1, X2, X3, X4) {cpu_to_le32(X0), \
  80                                      cpu_to_le32(X1), \
  81                                      cpu_to_le32(X2), \
  82                                      cpu_to_le32(X3), \
  83                                      cpu_to_le32(X4)}
  84 /* default power management (not Tx power) table values */
  85 /* for DTIM period 0 through IWL_DTIM_RANGE_0_MAX */
  86 /* DTIM 0 - 2 */
  87 static const struct iwl_power_vec_entry range_0[IWL_POWER_NUM] = {
  88         {{SLP, SLP_TOUT(200), SLP_TOUT(500), SLP_VEC(1, 1, 2, 2, 0xFF)}, 0},
  89         {{SLP, SLP_TOUT(200), SLP_TOUT(300), SLP_VEC(1, 2, 2, 2, 0xFF)}, 0},
  90         {{SLP, SLP_TOUT(50), SLP_TOUT(100), SLP_VEC(2, 2, 2, 2, 0xFF)}, 0},
  91         {{SLP, SLP_TOUT(50), SLP_TOUT(25), SLP_VEC(2, 2, 4, 4, 0xFF)}, 1},
  92         {{SLP, SLP_TOUT(25), SLP_TOUT(25), SLP_VEC(2, 2, 4, 6, 0xFF)}, 2}
  93 };
  94
  95
  96 /* for DTIM period IWL_DTIM_RANGE_0_MAX + 1 through IWL_DTIM_RANGE_1_MAX */
  97 /* DTIM 3 - 10 */
  98 static const struct iwl_power_vec_entry range_1[IWL_POWER_NUM] = {
  99         {{SLP, SLP_TOUT(200), SLP_TOUT(500), SLP_VEC(1, 2, 3, 4, 4)}, 0},
 100         {{SLP, SLP_TOUT(200), SLP_TOUT(300), SLP_VEC(1, 2, 3, 4, 7)}, 0},
 101         {{SLP, SLP_TOUT(50), SLP_TOUT(100), SLP_VEC(2, 4, 6, 7, 9)}, 0},
 102         {{SLP, SLP_TOUT(50), SLP_TOUT(25), SLP_VEC(2, 4, 6, 9, 10)}, 1},
 103         {{SLP, SLP_TOUT(25), SLP_TOUT(25), SLP_VEC(2, 4, 6, 10, 10)}, 2}
 104 };
 105
 106 /* for DTIM period > IWL_DTIM_RANGE_1_MAX */
 107 /* DTIM 11 - */
 108 static const struct iwl_power_vec_entry range_2[IWL_POWER_NUM] = {
 109         {{SLP, SLP_TOUT(200), SLP_TOUT(500), SLP_VEC(1, 2, 3, 4, 0xFF)}, 0},
 110         {{SLP, SLP_TOUT(200), SLP_TOUT(300), SLP_VEC(2, 4, 6, 7, 0xFF)}, 0},
 111         {{SLP, SLP_TOUT(50), SLP_TOUT(100), SLP_VEC(2, 7, 9, 9, 0xFF)}, 0},
 112         {{SLP, SLP_TOUT(50), SLP_TOUT(25), SLP_VEC(2, 7, 9, 9, 0xFF)}, 0},
 113         {{SLP, SLP_TOUT(25), SLP_TOUT(25), SLP_VEC(4, 7, 10, 10, 0xFF)}, 0}
 114 };
 115
 116 static void iwl_static_sleep_cmd(struct iwl_priv *priv,
 117                                  struct iwl_powertable_cmd *cmd,
 118                                  enum iwl_power_level lvl, int period)
 119 {
 120         const struct iwl_power_vec_entry *table;
 121         int max_sleep[IWL_POWER_VEC_SIZE] = { 0 };
 122         int i;
 123         u8 skip;
 124         u32 slp_itrvl;
 125
 126         table = range_2;
 127         if (period <= IWL_DTIM_RANGE_1_MAX)
 128                 table = range_1;
 129         if (period <= IWL_DTIM_RANGE_0_MAX)
 130                 table = range_0;
 131
 132         BUG_ON(lvl < 0 || lvl >= IWL_POWER_NUM);
 133
 134         *cmd = table[lvl].cmd;
 135
 136         if (period == 0) {
 137                 skip = 0;
 138                 period = 1;
 139                 for (i = 0; i < IWL_POWER_VEC_SIZE; i++)
 140                         max_sleep[i] =  1;
 141
 142         } else {
 143                 skip = table[lvl].no_dtim;
 144                 for (i = 0; i < IWL_POWER_VEC_SIZE; i++)
 145                         max_sleep[i] = le32_to_cpu(cmd->sleep_interval[i]);
 146                 max_sleep[IWL_POWER_VEC_SIZE - 1] = skip + 1;
 147         }
 148
 149         slp_itrvl = le32_to_cpu(cmd->sleep_interval[IWL_POWER_VEC_SIZE - 1]);
 150         /* figure out the listen interval based on dtim period and skip */
 151         if (slp_itrvl == 0xFF)
 152                 cmd->sleep_interval[IWL_POWER_VEC_SIZE - 1] =
 153                         cpu_to_le32(period * (skip + 1));
 154
 155         slp_itrvl = le32_to_cpu(cmd->sleep_interval[IWL_POWER_VEC_SIZE - 1]);
 156         if (slp_itrvl > period)
 157                 cmd->sleep_interval[IWL_POWER_VEC_SIZE - 1] =
 158                         cpu_to_le32((slp_itrvl / period) * period);
 159
 160         if (skip)
 161                 cmd->flags |= IWL_POWER_SLEEP_OVER_DTIM_MSK;
 162         else
 163                 cmd->flags &= ~IWL_POWER_SLEEP_OVER_DTIM_MSK;
 164
 165         slp_itrvl = le32_to_cpu(cmd->sleep_interval[IWL_POWER_VEC_SIZE - 1]);
 166         if (slp_itrvl > IWL_CONN_MAX_LISTEN_INTERVAL)
 167                 cmd->sleep_interval[IWL_POWER_VEC_SIZE - 1] =
 168                         cpu_to_le32(IWL_CONN_MAX_LISTEN_INTERVAL);
 169
 170         /* enforce max sleep interval */
 171         for (i = IWL_POWER_VEC_SIZE - 1; i >= 0 ; i--) {
 172                 if (le32_to_cpu(cmd->sleep_interval[i]) >
 173                     (max_sleep[i] * period))
 174                         cmd->sleep_interval[i] =
 175                                 cpu_to_le32(max_sleep[i] * period);
 176                 if (i != (IWL_POWER_VEC_SIZE - 1)) {
 177                         if (le32_to_cpu(cmd->sleep_interval[i]) >
 178                             le32_to_cpu(cmd->sleep_interval[i+1]))
 179                                 cmd->sleep_interval[i] =
 180                                         cmd->sleep_interval[i+1];
 181                 }
 182         }
 183
 184         if (priv->power_data.pci_pm)
 185                 cmd->flags |= IWL_POWER_PCI_PM_MSK;
 186         else
 187                 cmd->flags &= ~IWL_POWER_PCI_PM_MSK;
 188
 189         IWL_DEBUG_POWER(priv, "numSkipDtim = %u, dtimPeriod = %d\n",
 190                         skip, period);
 191         IWL_DEBUG_POWER(priv, "Sleep command for index %d\n", lvl + 1);
 192 }
 193
 194 /* default Thermal Throttling transaction table
 195  * Current state   |         Throttling Down               |  Throttling Up
 196  *=============================================================================
 197  *                 Condition Nxt State  Condition Nxt State Condition Nxt State
 198  *-----------------------------------------------------------------------------
 199  *     IWL_TI_0     T >= 114   CT_KILL  114>T>=105   TI_1      N/A      N/A
 200  *     IWL_TI_1     T >= 114   CT_KILL  114>T>=110   TI_2     T<=95     TI_0
 201  *     IWL_TI_2     T >= 114   CT_KILL                        T<=100    TI_1
 202  *    IWL_CT_KILL      N/A       N/A       N/A        N/A     T<=95     TI_0
 203  *=============================================================================
 204  */
 205 static const struct iwl_tt_trans tt_range_0[IWL_TI_STATE_MAX - 1] = {
 206         {IWL_TI_0, IWL_ABSOLUTE_ZERO, 104},
 207         {IWL_TI_1, 105, CT_KILL_THRESHOLD - 1},
 208         {IWL_TI_CT_KILL, CT_KILL_THRESHOLD, IWL_ABSOLUTE_MAX}
 209 };
 210 static const struct iwl_tt_trans tt_range_1[IWL_TI_STATE_MAX - 1] = {
 211         {IWL_TI_0, IWL_ABSOLUTE_ZERO, 95},
 212         {IWL_TI_2, 110, CT_KILL_THRESHOLD - 1},
 213         {IWL_TI_CT_KILL, CT_KILL_THRESHOLD, IWL_ABSOLUTE_MAX}
 214 };
 215 static const struct iwl_tt_trans tt_range_2[IWL_TI_STATE_MAX - 1] = {
 216         {IWL_TI_1, IWL_ABSOLUTE_ZERO, 100},
 217         {IWL_TI_CT_KILL, CT_KILL_THRESHOLD, IWL_ABSOLUTE_MAX},
 218         {IWL_TI_CT_KILL, CT_KILL_THRESHOLD, IWL_ABSOLUTE_MAX}
 219 };
 220 static const struct iwl_tt_trans tt_range_3[IWL_TI_STATE_MAX - 1] = {
 221         {IWL_TI_0, IWL_ABSOLUTE_ZERO, CT_KILL_EXIT_THRESHOLD},
 222         {IWL_TI_CT_KILL, CT_KILL_EXIT_THRESHOLD + 1, IWL_ABSOLUTE_MAX},
 223         {IWL_TI_CT_KILL, CT_KILL_EXIT_THRESHOLD + 1, IWL_ABSOLUTE_MAX}
 224 };
 225
 226 /* Advance Thermal Throttling default restriction table */
 227 static const struct iwl_tt_restriction restriction_range[IWL_TI_STATE_MAX] = {
 228         {IWL_ANT_OK_MULTI, IWL_ANT_OK_MULTI, true },
 229         {IWL_ANT_OK_SINGLE, IWL_ANT_OK_MULTI, true },
 230         {IWL_ANT_OK_SINGLE, IWL_ANT_OK_SINGLE, false },
 231         {IWL_ANT_OK_NONE, IWL_ANT_OK_NONE, false }
 232 };
 233
 234
 235 static void iwl_power_sleep_cam_cmd(struct iwl_priv *priv,
 236                                     struct iwl_powertable_cmd *cmd)
 237 {
 238         memset(cmd, 0, sizeof(*cmd));
 239
 240         if (priv->power_data.pci_pm)
 241                 cmd->flags |= IWL_POWER_PCI_PM_MSK;
 242
 243         IWL_DEBUG_POWER(priv, "Sleep command for CAM\n");
 244 }
 245
 246 static void iwl_power_fill_sleep_cmd(struct iwl_priv *priv,
 247                                      struct iwl_powertable_cmd *cmd,
 248                                      int dynps_ms, int wakeup_period)
 249 {
 250         /*
 251          * These are the original power level 3 sleep successions. The
 252          * device may behave better with such succession and was also
 253          * only tested with that. Just like the original sleep commands,
 254          * also adjust the succession here to the wakeup_period below.
 255          * The ranges are the same as for the sleep commands, 0-2, 3-9
 256          * and >10, which is selected based on the DTIM interval for
 257          * the sleep index but here we use the wakeup period since that
 258          * is what we need to do for the latency requirements.
 259          */
 260         static const u8 slp_succ_r0[IWL_POWER_VEC_SIZE] = { 2, 2, 2, 2, 2 };
 261         static const u8 slp_succ_r1[IWL_POWER_VEC_SIZE] = { 2, 4, 6, 7, 9 };
 262         static const u8 slp_succ_r2[IWL_POWER_VEC_SIZE] = { 2, 7, 9, 9, 0xFF };
 263         const u8 *slp_succ = slp_succ_r0;
 264         int i;
 265
 266         if (wakeup_period > IWL_DTIM_RANGE_0_MAX)
 267                 slp_succ = slp_succ_r1;
 268         if (wakeup_period > IWL_DTIM_RANGE_1_MAX)
 269                 slp_succ = slp_succ_r2;
 270
 271         memset(cmd, 0, sizeof(*cmd));
 272
 273         cmd->flags = IWL_POWER_DRIVER_ALLOW_SLEEP_MSK |
 274                      IWL_POWER_FAST_PD; /* no use seeing frames for others */
 275
 276         if (priv->power_data.pci_pm)
 277                 cmd->flags |= IWL_POWER_PCI_PM_MSK;
 278
 279         cmd->rx_data_timeout = cpu_to_le32(1000 * dynps_ms);
 280         cmd->tx_data_timeout = cpu_to_le32(1000 * dynps_ms);
 281
 282         for (i = 0; i < IWL_POWER_VEC_SIZE; i++)
 283                 cmd->sleep_interval[i] =
 284                         cpu_to_le32(min_t(int, slp_succ[i], wakeup_period));
 285
 286         IWL_DEBUG_POWER(priv, "Automatic sleep command\n");
 287 }
 288
 289 static int iwl_set_power(struct iwl_priv *priv, struct iwl_powertable_cmd *cmd)
 290 {
 291         IWL_DEBUG_POWER(priv, "Sending power/sleep command\n");
 292         IWL_DEBUG_POWER(priv, "Flags value = 0x%08X\n", cmd->flags);
 293         IWL_DEBUG_POWER(priv, "Tx timeout = %u\n", le32_to_cpu(cmd->tx_data_timeout));
 294         IWL_DEBUG_POWER(priv, "Rx timeout = %u\n", le32_to_cpu(cmd->rx_data_timeout));
 295         IWL_DEBUG_POWER(priv, "Sleep interval vector = { %d , %d , %d , %d , %d }\n",
 296                         le32_to_cpu(cmd->sleep_interval[0]),
 297                         le32_to_cpu(cmd->sleep_interval[1]),
 298                         le32_to_cpu(cmd->sleep_interval[2]),
 299                         le32_to_cpu(cmd->sleep_interval[3]),
 300                         le32_to_cpu(cmd->sleep_interval[4]));
 301
 302         return iwl_send_cmd_pdu(priv, POWER_TABLE_CMD,
 303                                 sizeof(struct iwl_powertable_cmd), cmd);
 304 }
 305
 306 /* priv->mutex must be held */
 307 int iwl_power_update_mode(struct iwl_priv *priv, bool force)
 308 {
 309         int ret = 0;
 310         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 311         bool enabled = priv->hw->conf.flags & IEEE80211_CONF_PS;
 312         bool update_chains;
 313         struct iwl_powertable_cmd cmd;
 314         int dtimper;
 315
 316         /* Don't update the RX chain when chain noise calibration is running */
 317         update_chains = priv->chain_noise_data.state == IWL_CHAIN_NOISE_DONE ||
 318                         priv->chain_noise_data.state == IWL_CHAIN_NOISE_ALIVE;
 319
 320         if (priv->vif)
 321                 dtimper = priv->hw->conf.ps_dtim_period;
 322         else
 323                 dtimper = 1;
 324
 325         if (priv->cfg->broken_powersave)
 326                 iwl_power_sleep_cam_cmd(priv, &cmd);
 327         else if (priv->cfg->supports_idle &&
 328                  priv->hw->conf.flags & IEEE80211_CONF_IDLE)
 329                 iwl_static_sleep_cmd(priv, &cmd, IWL_POWER_INDEX_5, 20);
 330         else if (tt->state >= IWL_TI_1)
 331                 iwl_static_sleep_cmd(priv, &cmd, tt->tt_power_mode, dtimper);
 332         else if (!enabled)
 333                 iwl_power_sleep_cam_cmd(priv, &cmd);
 334         else if (priv->power_data.debug_sleep_level_override >= 0)
 335                 iwl_static_sleep_cmd(priv, &cmd,
 336                                      priv->power_data.debug_sleep_level_override,
 337                                      dtimper);
 338         else if (no_sleep_autoadjust)
 339                 iwl_static_sleep_cmd(priv, &cmd, IWL_POWER_INDEX_1, dtimper);
 340         else
 341                 iwl_power_fill_sleep_cmd(priv, &cmd,
 342                                          priv->hw->conf.dynamic_ps_timeout,
 343                                          priv->hw->conf.max_sleep_period);
 344
 345         if (iwl_is_ready_rf(priv) &&
 346             (memcmp(&priv->power_data.sleep_cmd, &cmd, sizeof(cmd)) || force)) {
 347                 if (cmd.flags & IWL_POWER_DRIVER_ALLOW_SLEEP_MSK)
 348                         set_bit(STATUS_POWER_PMI, &priv->status);
 349
 350                 ret = iwl_set_power(priv, &cmd);
 351                 if (!ret) {
 352                         if (!(cmd.flags & IWL_POWER_DRIVER_ALLOW_SLEEP_MSK))
 353                                 clear_bit(STATUS_POWER_PMI, &priv->status);
 354
 355                         if (priv->cfg->ops->lib->update_chain_flags &&
 356                             update_chains)
 357                                 priv->cfg->ops->lib->update_chain_flags(priv);
 358                         else if (priv->cfg->ops->lib->update_chain_flags)
 359                                 IWL_DEBUG_POWER(priv,
 360                                         "Cannot update the power, chain noise "
 361                                         "calibration running: %d\n",
 362                                         priv->chain_noise_data.state);
 363                         memcpy(&priv->power_data.sleep_cmd, &cmd, sizeof(cmd));
 364                 } else
 365                         IWL_ERR(priv, "set power fail, ret = %d", ret);
 366         }
 367
 368         return ret;
 369 }
 370 EXPORT_SYMBOL(iwl_power_update_mode);
 371
 372 bool iwl_ht_enabled(struct iwl_priv *priv)
 373 {
 374         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 375         struct iwl_tt_restriction *restriction;
 376
 377         if (!priv->thermal_throttle.advanced_tt)
 378                 return true;
 379         restriction = tt->restriction + tt->state;
 380         return restriction->is_ht;
 381 }
 382 EXPORT_SYMBOL(iwl_ht_enabled);
 383
 384 bool iwl_within_ct_kill_margin(struct iwl_priv *priv)
 385 {
 386         s32 temp = priv->temperature; /* degrees CELSIUS except specified */
 387         bool within_margin = false;
 388
 389         if (priv->cfg->temperature_kelvin)
 390                 temp = KELVIN_TO_CELSIUS(priv->temperature);
 391
 392         if (!priv->thermal_throttle.advanced_tt)
 393                 within_margin = ((temp + IWL_TT_CT_KILL_MARGIN) >=
 394                                 CT_KILL_THRESHOLD_LEGACY) ? true : false;
 395         else
 396                 within_margin = ((temp + IWL_TT_CT_KILL_MARGIN) >=
 397                                 CT_KILL_THRESHOLD) ? true : false;
 398         return within_margin;
 399 }
 400
 401 enum iwl_antenna_ok iwl_tx_ant_restriction(struct iwl_priv *priv)
 402 {
 403         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 404         struct iwl_tt_restriction *restriction;
 405
 406         if (!priv->thermal_throttle.advanced_tt)
 407                 return IWL_ANT_OK_MULTI;
 408         restriction = tt->restriction + tt->state;
 409         return restriction->tx_stream;
 410 }
 411 EXPORT_SYMBOL(iwl_tx_ant_restriction);
 412
 413 enum iwl_antenna_ok iwl_rx_ant_restriction(struct iwl_priv *priv)
 414 {
 415         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 416         struct iwl_tt_restriction *restriction;
 417
 418         if (!priv->thermal_throttle.advanced_tt)
 419                 return IWL_ANT_OK_MULTI;
 420         restriction = tt->restriction + tt->state;
 421         return restriction->rx_stream;
 422 }
 423
 424 #define CT_KILL_EXIT_DURATION (5)       /* 5 seconds duration */
 425 #define CT_KILL_WAITING_DURATION (300)  /* 300ms duration */
 426
 427 /*
 428  * toggle the bit to wake up uCode and check the temperature
 429  * if the temperature is below CT, uCode will stay awake and send card
 430  * state notification with CT_KILL bit clear to inform Thermal Throttling
 431  * Management to change state. Otherwise, uCode will go back to sleep
 432  * without doing anything, driver should continue the 5 seconds timer
 433  * to wake up uCode for temperature check until temperature drop below CT
 434  */
 435 static void iwl_tt_check_exit_ct_kill(unsigned long data)
 436 {
 437         struct iwl_priv *priv = (struct iwl_priv *)data;
 438         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 439         unsigned long flags;
 440
 441         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 442                 return;
 443
 444         if (tt->state == IWL_TI_CT_KILL) {
 445                 if (priv->thermal_throttle.ct_kill_toggle) {
 446                         iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
 447                                     CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
 448                         priv->thermal_throttle.ct_kill_toggle = false;
 449                 } else {
 450                         iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
 451                                     CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
 452                         priv->thermal_throttle.ct_kill_toggle = true;
 453                 }
 454                 iwl_read32(priv, CSR_UCODE_DRV_GP1);
 455                 spin_lock_irqsave(&priv->reg_lock, flags);
 456                 if (!iwl_grab_nic_access(priv))
 457                         iwl_release_nic_access(priv);
 458                 spin_unlock_irqrestore(&priv->reg_lock, flags);
 459
 460                 /* Reschedule the ct_kill timer to occur in
 461                  * CT_KILL_EXIT_DURATION seconds to ensure we get a
 462                  * thermal update */
 463                 IWL_DEBUG_POWER(priv, "schedule ct_kill exit timer\n");
 464                 mod_timer(&priv->thermal_throttle.ct_kill_exit_tm, jiffies +
 465                           CT_KILL_EXIT_DURATION * HZ);
 466         }
 467 }
 468
 469 static void iwl_perform_ct_kill_task(struct iwl_priv *priv,
 470                            bool stop)
 471 {
 472         if (stop) {
 473                 IWL_DEBUG_POWER(priv, "Stop all queues\n");
 474                 if (priv->mac80211_registered)
 475                         ieee80211_stop_queues(priv->hw);
 476                 IWL_DEBUG_POWER(priv,
 477                                 "Schedule 5 seconds CT_KILL Timer\n");
 478                 mod_timer(&priv->thermal_throttle.ct_kill_exit_tm, jiffies +
 479                           CT_KILL_EXIT_DURATION * HZ);
 480         } else {
 481                 IWL_DEBUG_POWER(priv, "Wake all queues\n");
 482                 if (priv->mac80211_registered)
 483                         ieee80211_wake_queues(priv->hw);
 484         }
 485 }
 486
 487 static void iwl_tt_ready_for_ct_kill(unsigned long data)
 488 {
 489         struct iwl_priv *priv = (struct iwl_priv *)data;
 490         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 491
 492         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 493                 return;
 494
 495         /* temperature timer expired, ready to go into CT_KILL state */
 496         if (tt->state != IWL_TI_CT_KILL) {
 497                 IWL_DEBUG_POWER(priv, "entering CT_KILL state when temperature timer expired\n");
 498                 tt->state = IWL_TI_CT_KILL;
 499                 set_bit(STATUS_CT_KILL, &priv->status);
 500                 iwl_perform_ct_kill_task(priv, true);
 501         }
 502 }
 503
 504 static void iwl_prepare_ct_kill_task(struct iwl_priv *priv)
 505 {
 506         IWL_DEBUG_POWER(priv, "Prepare to enter IWL_TI_CT_KILL\n");
 507         /* make request to retrieve statistics information */
 508         iwl_send_statistics_request(priv, CMD_SYNC, false);
 509         /* Reschedule the ct_kill wait timer */
 510         mod_timer(&priv->thermal_throttle.ct_kill_waiting_tm,
 511                  jiffies + msecs_to_jiffies(CT_KILL_WAITING_DURATION));
 512 }
 513
 514 #define IWL_MINIMAL_POWER_THRESHOLD             (CT_KILL_THRESHOLD_LEGACY)
 515 #define IWL_REDUCED_PERFORMANCE_THRESHOLD_2     (100)
 516 #define IWL_REDUCED_PERFORMANCE_THRESHOLD_1     (90)
 517
 518 /*
 519  * Legacy thermal throttling
 520  * 1) Avoid NIC destruction due to high temperatures
 521  *      Chip will identify dangerously high temperatures that can
 522  *      harm the device and will power down
 523  * 2) Avoid the NIC power down due to high temperature
 524  *      Throttle early enough to lower the power consumption before
 525  *      drastic steps are needed
 526  */
 527 static void iwl_legacy_tt_handler(struct iwl_priv *priv, s32 temp, bool force)
 528 {
 529         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 530         enum iwl_tt_state old_state;
 531
 532 #ifdef CONFIG_IWLWIFI_DEBUG
 533         if ((tt->tt_previous_temp) &&
 534             (temp > tt->tt_previous_temp) &&
 535             ((temp - tt->tt_previous_temp) >
 536             IWL_TT_INCREASE_MARGIN)) {
 537                 IWL_DEBUG_POWER(priv,
 538                         "Temperature increase %d degree Celsius\n",
 539                         (temp - tt->tt_previous_temp));
 540         }
 541 #endif
 542         old_state = tt->state;
 543         /* in Celsius */
 544         if (temp >= IWL_MINIMAL_POWER_THRESHOLD)
 545                 tt->state = IWL_TI_CT_KILL;
 546         else if (temp >= IWL_REDUCED_PERFORMANCE_THRESHOLD_2)
 547                 tt->state = IWL_TI_2;
 548         else if (temp >= IWL_REDUCED_PERFORMANCE_THRESHOLD_1)
 549                 tt->state = IWL_TI_1;
 550         else
 551                 tt->state = IWL_TI_0;
 552
 553 #ifdef CONFIG_IWLWIFI_DEBUG
 554         tt->tt_previous_temp = temp;
 555 #endif
 556         /* stop ct_kill_waiting_tm timer */
 557         del_timer_sync(&priv->thermal_throttle.ct_kill_waiting_tm);
 558         if (tt->state != old_state) {
 559                 switch (tt->state) {
 560                 case IWL_TI_0:
 561                         /*
 562                          * When the system is ready to go back to IWL_TI_0
 563                          * we only have to call iwl_power_update_mode() to
 564                          * do so.
 565                          */
 566                         break;
 567                 case IWL_TI_1:
 568                         tt->tt_power_mode = IWL_POWER_INDEX_3;
 569                         break;
 570                 case IWL_TI_2:
 571                         tt->tt_power_mode = IWL_POWER_INDEX_4;
 572                         break;
 573                 default:
 574                         tt->tt_power_mode = IWL_POWER_INDEX_5;
 575                         break;
 576                 }
 577                 mutex_lock(&priv->mutex);
 578                 if (old_state == IWL_TI_CT_KILL)
 579                         clear_bit(STATUS_CT_KILL, &priv->status);
 580                 if (tt->state != IWL_TI_CT_KILL &&
 581                     iwl_power_update_mode(priv, true)) {
 582                         /* TT state not updated
 583                          * try again during next temperature read
 584                          */
 585                         if (old_state == IWL_TI_CT_KILL)
 586                                 set_bit(STATUS_CT_KILL, &priv->status);
 587                         tt->state = old_state;
 588                         IWL_ERR(priv, "Cannot update power mode, "
 589                                         "TT state not updated\n");
 590                 } else {
 591                         if (tt->state == IWL_TI_CT_KILL) {
 592                                 if (force) {
 593                                         set_bit(STATUS_CT_KILL, &priv->status);
 594                                         iwl_perform_ct_kill_task(priv, true);
 595                                 } else {
 596                                         iwl_prepare_ct_kill_task(priv);
 597                                         tt->state = old_state;
 598                                 }
 599                         } else if (old_state == IWL_TI_CT_KILL &&
 600                                  tt->state != IWL_TI_CT_KILL)
 601                                 iwl_perform_ct_kill_task(priv, false);
 602                         IWL_DEBUG_POWER(priv, "Temperature state changed %u\n",
 603                                         tt->state);
 604                         IWL_DEBUG_POWER(priv, "Power Index change to %u\n",
 605                                         tt->tt_power_mode);
 606                 }
 607                 mutex_unlock(&priv->mutex);
 608         }
 609 }
 610
 611 /*
 612  * Advance thermal throttling
 613  * 1) Avoid NIC destruction due to high temperatures
 614  *      Chip will identify dangerously high temperatures that can
 615  *      harm the device and will power down
 616  * 2) Avoid the NIC power down due to high temperature
 617  *      Throttle early enough to lower the power consumption before
 618  *      drastic steps are needed
 619  *      Actions include relaxing the power down sleep thresholds and
 620  *      decreasing the number of TX streams
 621  * 3) Avoid throughput performance impact as much as possible
 622  *
 623  *=============================================================================
 624  *                 Condition Nxt State  Condition Nxt State Condition Nxt State
 625  *-----------------------------------------------------------------------------
 626  *     IWL_TI_0     T >= 114   CT_KILL  114>T>=105   TI_1      N/A      N/A
 627  *     IWL_TI_1     T >= 114   CT_KILL  114>T>=110   TI_2     T<=95     TI_0
 628  *     IWL_TI_2     T >= 114   CT_KILL                        T<=100    TI_1
 629  *    IWL_CT_KILL      N/A       N/A       N/A        N/A     T<=95     TI_0
 630  *=============================================================================
 631  */
 632 static void iwl_advance_tt_handler(struct iwl_priv *priv, s32 temp, bool force)
 633 {
 634         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 635         int i;
 636         bool changed = false;
 637         enum iwl_tt_state old_state;
 638         struct iwl_tt_trans *transaction;
 639
 640         old_state = tt->state;
 641         for (i = 0; i < IWL_TI_STATE_MAX - 1; i++) {
 642                 /* based on the current TT state,
 643                  * find the curresponding transaction table
 644                  * each table has (IWL_TI_STATE_MAX - 1) entries
 645                  * tt->transaction + ((old_state * (IWL_TI_STATE_MAX - 1))
 646                  * will advance to the correct table.
 647                  * then based on the current temperature
 648                  * find the next state need to transaction to
 649                  * go through all the possible (IWL_TI_STATE_MAX - 1) entries
 650                  * in the current table to see if transaction is needed
 651                  */
 652                 transaction = tt->transaction +
 653                         ((old_state * (IWL_TI_STATE_MAX - 1)) + i);
 654                 if (temp >= transaction->tt_low &&
 655                     temp <= transaction->tt_high) {
 656 #ifdef CONFIG_IWLWIFI_DEBUG
 657                         if ((tt->tt_previous_temp) &&
 658                             (temp > tt->tt_previous_temp) &&
 659                             ((temp - tt->tt_previous_temp) >
 660                             IWL_TT_INCREASE_MARGIN)) {
 661                                 IWL_DEBUG_POWER(priv,
 662                                         "Temperature increase %d "
 663                                         "degree Celsius\n",
 664                                         (temp - tt->tt_previous_temp));
 665                         }
 666                         tt->tt_previous_temp = temp;
 667 #endif
 668                         if (old_state !=
 669                             transaction->next_state) {
 670                                 changed = true;
 671                                 tt->state =
 672                                         transaction->next_state;
 673                         }
 674                         break;
 675                 }
 676         }
 677         /* stop ct_kill_waiting_tm timer */
 678         del_timer_sync(&priv->thermal_throttle.ct_kill_waiting_tm);
 679         if (changed) {
 680                 struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
 681
 682                 if (tt->state >= IWL_TI_1) {
 683                         /* force PI = IWL_POWER_INDEX_5 in the case of TI > 0 */
 684                         tt->tt_power_mode = IWL_POWER_INDEX_5;
 685                         if (!iwl_ht_enabled(priv))
 686                                 /* disable HT */
 687                                 rxon->flags &= ~(RXON_FLG_CHANNEL_MODE_MSK |
 688                                         RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK |
 689                                         RXON_FLG_HT40_PROT_MSK |
 690                                         RXON_FLG_HT_PROT_MSK);
 691                         else {
 692                                 /* check HT capability and set
 693                                  * according to the system HT capability
 694                                  * in case get disabled before */
 695                                 iwl_set_rxon_ht(priv, &priv->current_ht_config);
 696                         }
 697
 698                 } else {
 699                         /*
 700                          * restore system power setting -- it will be
 701                          * recalculated automatically.
 702                          */
 703
 704                         /* check HT capability and set
 705                          * according to the system HT capability
 706                          * in case get disabled before */
 707                         iwl_set_rxon_ht(priv, &priv->current_ht_config);
 708                 }
 709                 mutex_lock(&priv->mutex);
 710                 if (old_state == IWL_TI_CT_KILL)
 711                         clear_bit(STATUS_CT_KILL, &priv->status);
 712                 if (tt->state != IWL_TI_CT_KILL &&
 713                     iwl_power_update_mode(priv, true)) {
 714                         /* TT state not updated
 715                          * try again during next temperature read
 716                          */
 717                         IWL_ERR(priv, "Cannot update power mode, "
 718                                         "TT state not updated\n");
 719                         if (old_state == IWL_TI_CT_KILL)
 720                                 set_bit(STATUS_CT_KILL, &priv->status);
 721                         tt->state = old_state;
 722                 } else {
 723                         IWL_DEBUG_POWER(priv,
 724                                         "Thermal Throttling to new state: %u\n",
 725                                         tt->state);
 726                         if (old_state != IWL_TI_CT_KILL &&
 727                             tt->state == IWL_TI_CT_KILL) {
 728                                 if (force) {
 729                                         IWL_DEBUG_POWER(priv,
 730                                                 "Enter IWL_TI_CT_KILL\n");
 731                                         set_bit(STATUS_CT_KILL, &priv->status);
 732                                         iwl_perform_ct_kill_task(priv, true);
 733                                 } else {
 734                                         iwl_prepare_ct_kill_task(priv);
 735                                         tt->state = old_state;
 736                                 }
 737                         } else if (old_state == IWL_TI_CT_KILL &&
 738                                   tt->state != IWL_TI_CT_KILL) {
 739                                 IWL_DEBUG_POWER(priv, "Exit IWL_TI_CT_KILL\n");
 740                                 iwl_perform_ct_kill_task(priv, false);
 741                         }
 742                 }
 743                 mutex_unlock(&priv->mutex);
 744         }
 745 }
 746
 747 /* Card State Notification indicated reach critical temperature
 748  * if PSP not enable, no Thermal Throttling function will be performed
 749  * just set the GP1 bit to acknowledge the event
 750  * otherwise, go into IWL_TI_CT_KILL state
 751  * since Card State Notification will not provide any temperature reading
 752  * for Legacy mode
 753  * so just pass the CT_KILL temperature to iwl_legacy_tt_handler()
 754  * for advance mode
 755  * pass CT_KILL_THRESHOLD+1 to make sure move into IWL_TI_CT_KILL state
 756  */
 757 static void iwl_bg_ct_enter(struct work_struct *work)
 758 {
 759         struct iwl_priv *priv = container_of(work, struct iwl_priv, ct_enter);
 760         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 761
 762         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 763                 return;
 764
 765         if (!iwl_is_ready(priv))
 766                 return;
 767
 768         if (tt->state != IWL_TI_CT_KILL) {
 769                 IWL_ERR(priv, "Device reached critical temperature "
 770                               "- ucode going to sleep!\n");
 771                 if (!priv->thermal_throttle.advanced_tt)
 772                         iwl_legacy_tt_handler(priv,
 773                                               IWL_MINIMAL_POWER_THRESHOLD,
 774                                               true);
 775                 else
 776                         iwl_advance_tt_handler(priv,
 777                                                CT_KILL_THRESHOLD + 1, true);
 778         }
 779 }
 780
 781 /* Card State Notification indicated out of critical temperature
 782  * since Card State Notification will not provide any temperature reading
 783  * so pass the IWL_REDUCED_PERFORMANCE_THRESHOLD_2 temperature
 784  * to iwl_legacy_tt_handler() to get out of IWL_CT_KILL state
 785  */
 786 static void iwl_bg_ct_exit(struct work_struct *work)
 787 {
 788         struct iwl_priv *priv = container_of(work, struct iwl_priv, ct_exit);
 789         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 790
 791         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 792                 return;
 793
 794         if (!iwl_is_ready(priv))
 795                 return;
 796
 797         /* stop ct_kill_exit_tm timer */
 798         del_timer_sync(&priv->thermal_throttle.ct_kill_exit_tm);
 799
 800         if (tt->state == IWL_TI_CT_KILL) {
 801                 IWL_ERR(priv,
 802                         "Device temperature below critical"
 803                         "- ucode awake!\n");
 804                 /*
 805                  * exit from CT_KILL state
 806                  * reset the current temperature reading
 807                  */
 808                 priv->temperature = 0;
 809                 if (!priv->thermal_throttle.advanced_tt)
 810                         iwl_legacy_tt_handler(priv,
 811                                               IWL_REDUCED_PERFORMANCE_THRESHOLD_2,
 812                                               true);
 813                 else
 814                         iwl_advance_tt_handler(priv, CT_KILL_EXIT_THRESHOLD,
 815                                                true);
 816         }
 817 }
 818
 819 void iwl_tt_enter_ct_kill(struct iwl_priv *priv)
 820 {
 821         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 822                 return;
 823
 824         IWL_DEBUG_POWER(priv, "Queueing critical temperature enter.\n");
 825         queue_work(priv->workqueue, &priv->ct_enter);
 826 }
 827 EXPORT_SYMBOL(iwl_tt_enter_ct_kill);
 828
 829 void iwl_tt_exit_ct_kill(struct iwl_priv *priv)
 830 {
 831         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 832                 return;
 833
 834         IWL_DEBUG_POWER(priv, "Queueing critical temperature exit.\n");
 835         queue_work(priv->workqueue, &priv->ct_exit);
 836 }
 837 EXPORT_SYMBOL(iwl_tt_exit_ct_kill);
 838
 839 static void iwl_bg_tt_work(struct work_struct *work)
 840 {
 841         struct iwl_priv *priv = container_of(work, struct iwl_priv, tt_work);
 842         s32 temp = priv->temperature; /* degrees CELSIUS except specified */
 843
 844         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 845                 return;
 846
 847         if (priv->cfg->temperature_kelvin)
 848                 temp = KELVIN_TO_CELSIUS(priv->temperature);
 849
 850         if (!priv->thermal_throttle.advanced_tt)
 851                 iwl_legacy_tt_handler(priv, temp, false);
 852         else
 853                 iwl_advance_tt_handler(priv, temp, false);
 854 }
 855
 856 void iwl_tt_handler(struct iwl_priv *priv)
 857 {
 858         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 859                 return;
 860
 861         IWL_DEBUG_POWER(priv, "Queueing thermal throttling work.\n");
 862         queue_work(priv->workqueue, &priv->tt_work);
 863 }
 864 EXPORT_SYMBOL(iwl_tt_handler);
 865
 866 /* Thermal throttling initialization
 867  * For advance thermal throttling:
 868  *     Initialize Thermal Index and temperature threshold table
 869  *     Initialize thermal throttling restriction table
 870  */
 871 void iwl_tt_initialize(struct iwl_priv *priv)
 872 {
 873         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 874         int size = sizeof(struct iwl_tt_trans) * (IWL_TI_STATE_MAX - 1);
 875         struct iwl_tt_trans *transaction;
 876
 877         IWL_DEBUG_POWER(priv, "Initialize Thermal Throttling\n");
 878
 879         memset(tt, 0, sizeof(struct iwl_tt_mgmt));
 880
 881         tt->state = IWL_TI_0;
 882         init_timer(&priv->thermal_throttle.ct_kill_exit_tm);
 883         priv->thermal_throttle.ct_kill_exit_tm.data = (unsigned long)priv;
 884         priv->thermal_throttle.ct_kill_exit_tm.function =
 885                 iwl_tt_check_exit_ct_kill;
 886         init_timer(&priv->thermal_throttle.ct_kill_waiting_tm);
 887         priv->thermal_throttle.ct_kill_waiting_tm.data = (unsigned long)priv;
 888         priv->thermal_throttle.ct_kill_waiting_tm.function =
 889                 iwl_tt_ready_for_ct_kill;
 890         /* setup deferred ct kill work */
 891         INIT_WORK(&priv->tt_work, iwl_bg_tt_work);
 892         INIT_WORK(&priv->ct_enter, iwl_bg_ct_enter);
 893         INIT_WORK(&priv->ct_exit, iwl_bg_ct_exit);
 894
 895         if (priv->cfg->adv_thermal_throttle) {
 896                 IWL_DEBUG_POWER(priv, "Advanced Thermal Throttling\n");
 897                 tt->restriction = kzalloc(sizeof(struct iwl_tt_restriction) *
 898                                          IWL_TI_STATE_MAX, GFP_KERNEL);
 899                 tt->transaction = kzalloc(sizeof(struct iwl_tt_trans) *
 900                         IWL_TI_STATE_MAX * (IWL_TI_STATE_MAX - 1),
 901                         GFP_KERNEL);
 902                 if (!tt->restriction || !tt->transaction) {
 903                         IWL_ERR(priv, "Fallback to Legacy Throttling\n");
 904                         priv->thermal_throttle.advanced_tt = false;
 905                         kfree(tt->restriction);
 906                         tt->restriction = NULL;
 907                         kfree(tt->transaction);
 908                         tt->transaction = NULL;
 909                 } else {
 910                         transaction = tt->transaction +
 911                                 (IWL_TI_0 * (IWL_TI_STATE_MAX - 1));
 912                         memcpy(transaction, &tt_range_0[0], size);
 913                         transaction = tt->transaction +
 914                                 (IWL_TI_1 * (IWL_TI_STATE_MAX - 1));
 915                         memcpy(transaction, &tt_range_1[0], size);
 916                         transaction = tt->transaction +
 917                                 (IWL_TI_2 * (IWL_TI_STATE_MAX - 1));
 918                         memcpy(transaction, &tt_range_2[0], size);
 919                         transaction = tt->transaction +
 920                                 (IWL_TI_CT_KILL * (IWL_TI_STATE_MAX - 1));
 921                         memcpy(transaction, &tt_range_3[0], size);
 922                         size = sizeof(struct iwl_tt_restriction) *
 923                                 IWL_TI_STATE_MAX;
 924                         memcpy(tt->restriction,
 925                                 &restriction_range[0], size);
 926                         priv->thermal_throttle.advanced_tt = true;
 927                 }
 928         } else {
 929                 IWL_DEBUG_POWER(priv, "Legacy Thermal Throttling\n");
 930                 priv->thermal_throttle.advanced_tt = false;
 931         }
 932 }
 933 EXPORT_SYMBOL(iwl_tt_initialize);
 934
 935 /* cleanup thermal throttling management related memory and timer */
 936 void iwl_tt_exit(struct iwl_priv *priv)
 937 {
 938         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 939
 940         /* stop ct_kill_exit_tm timer if activated */
 941         del_timer_sync(&priv->thermal_throttle.ct_kill_exit_tm);
 942         /* stop ct_kill_waiting_tm timer if activated */
 943         del_timer_sync(&priv->thermal_throttle.ct_kill_waiting_tm);
 944         cancel_work_sync(&priv->tt_work);
 945         cancel_work_sync(&priv->ct_enter);
 946         cancel_work_sync(&priv->ct_exit);
 947
 948         if (priv->thermal_throttle.advanced_tt) {
 949                 /* free advance thermal throttling memory */
 950                 kfree(tt->restriction);
 951                 tt->restriction = NULL;
 952                 kfree(tt->transaction);
 953                 tt->transaction = NULL;
 954         }
 955 }
 956 EXPORT_SYMBOL(iwl_tt_exit);
 957
 958 /* initialize to default */
 959 void iwl_power_initialize(struct iwl_priv *priv)
 960 {
 961         u16 lctl = iwl_pcie_link_ctl(priv);
 962
 963         priv->power_data.pci_pm = !(lctl & PCI_CFG_LINK_CTRL_VAL_L0S_EN);
 964
 965         priv->power_data.debug_sleep_level_override = -1;
 966
 967         memset(&priv->power_data.sleep_cmd, 0,
 968                 sizeof(priv->power_data.sleep_cmd));
 969 }
 970 EXPORT_SYMBOL(iwl_power_initialize);