SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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
 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->iw_mode == NL80211_IFTYPE_STATION) &&
 312                         (priv->hw->conf.flags & IEEE80211_CONF_PS);
 313         bool update_chains;
 314         struct iwl_powertable_cmd cmd;
 315         int dtimper;
 316
 317         /* Don't update the RX chain when chain noise calibration is running */
 318         update_chains = priv->chain_noise_data.state == IWL_CHAIN_NOISE_DONE ||
 319                         priv->chain_noise_data.state == IWL_CHAIN_NOISE_ALIVE;
 320
 321         if (priv->vif)
 322                 dtimper = priv->hw->conf.ps_dtim_period;
 323         else
 324                 dtimper = 1;
 325
 326         if (priv->cfg->broken_powersave)
 327                 iwl_power_sleep_cam_cmd(priv, &cmd);
 328         else if (priv->cfg->supports_idle &&
 329                  priv->hw->conf.flags & IEEE80211_CONF_IDLE)
 330                 iwl_static_sleep_cmd(priv, &cmd, IWL_POWER_INDEX_5, 20);
 331         else if (tt->state >= IWL_TI_1)
 332                 iwl_static_sleep_cmd(priv, &cmd, tt->tt_power_mode, dtimper);
 333         else if (!enabled)
 334                 iwl_power_sleep_cam_cmd(priv, &cmd);
 335         else if (priv->power_data.debug_sleep_level_override >= 0)
 336                 iwl_static_sleep_cmd(priv, &cmd,
 337                                      priv->power_data.debug_sleep_level_override,
 338                                      dtimper);
 339         else if (no_sleep_autoadjust)
 340                 iwl_static_sleep_cmd(priv, &cmd, IWL_POWER_INDEX_1, dtimper);
 341         else
 342                 iwl_power_fill_sleep_cmd(priv, &cmd,
 343                                          priv->hw->conf.dynamic_ps_timeout,
 344                                          priv->hw->conf.max_sleep_period);
 345
 346         if (iwl_is_ready_rf(priv) &&
 347             (memcmp(&priv->power_data.sleep_cmd, &cmd, sizeof(cmd)) || force)) {
 348                 if (cmd.flags & IWL_POWER_DRIVER_ALLOW_SLEEP_MSK)
 349                         set_bit(STATUS_POWER_PMI, &priv->status);
 350
 351                 ret = iwl_set_power(priv, &cmd);
 352                 if (!ret) {
 353                         if (!(cmd.flags & IWL_POWER_DRIVER_ALLOW_SLEEP_MSK))
 354                                 clear_bit(STATUS_POWER_PMI, &priv->status);
 355
 356                         if (priv->cfg->ops->lib->update_chain_flags &&
 357                             update_chains)
 358                                 priv->cfg->ops->lib->update_chain_flags(priv);
 359                         else if (priv->cfg->ops->lib->update_chain_flags)
 360                                 IWL_DEBUG_POWER(priv,
 361                                         "Cannot update the power, chain noise "
 362                                         "calibration running: %d\n",
 363                                         priv->chain_noise_data.state);
 364                         memcpy(&priv->power_data.sleep_cmd, &cmd, sizeof(cmd));
 365                 } else
 366                         IWL_ERR(priv, "set power fail, ret = %d", ret);
 367         }
 368
 369         return ret;
 370 }
 371 EXPORT_SYMBOL(iwl_power_update_mode);
 372
 373 bool iwl_ht_enabled(struct iwl_priv *priv)
 374 {
 375         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 376         struct iwl_tt_restriction *restriction;
 377
 378         if (!priv->thermal_throttle.advanced_tt)
 379                 return true;
 380         restriction = tt->restriction + tt->state;
 381         return restriction->is_ht;
 382 }
 383 EXPORT_SYMBOL(iwl_ht_enabled);
 384
 385 bool iwl_within_ct_kill_margin(struct iwl_priv *priv)
 386 {
 387         s32 temp = priv->temperature; /* degrees CELSIUS except 4965 */
 388         bool within_margin = false;
 389
 390         if ((priv->hw_rev & CSR_HW_REV_TYPE_MSK) == CSR_HW_REV_TYPE_4965)
 391                 temp = KELVIN_TO_CELSIUS(priv->temperature);
 392
 393         if (!priv->thermal_throttle.advanced_tt)
 394                 within_margin = ((temp + IWL_TT_CT_KILL_MARGIN) >=
 395                                 CT_KILL_THRESHOLD_LEGACY) ? true : false;
 396         else
 397                 within_margin = ((temp + IWL_TT_CT_KILL_MARGIN) >=
 398                                 CT_KILL_THRESHOLD) ? true : false;
 399         return within_margin;
 400 }
 401
 402 enum iwl_antenna_ok iwl_tx_ant_restriction(struct iwl_priv *priv)
 403 {
 404         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 405         struct iwl_tt_restriction *restriction;
 406
 407         if (!priv->thermal_throttle.advanced_tt)
 408                 return IWL_ANT_OK_MULTI;
 409         restriction = tt->restriction + tt->state;
 410         return restriction->tx_stream;
 411 }
 412 EXPORT_SYMBOL(iwl_tx_ant_restriction);
 413
 414 enum iwl_antenna_ok iwl_rx_ant_restriction(struct iwl_priv *priv)
 415 {
 416         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 417         struct iwl_tt_restriction *restriction;
 418
 419         if (!priv->thermal_throttle.advanced_tt)
 420                 return IWL_ANT_OK_MULTI;
 421         restriction = tt->restriction + tt->state;
 422         return restriction->rx_stream;
 423 }
 424
 425 #define CT_KILL_EXIT_DURATION (5)       /* 5 seconds duration */
 426 #define CT_KILL_WAITING_DURATION (300)  /* 300ms duration */
 427
 428 /*
 429  * toggle the bit to wake up uCode and check the temperature
 430  * if the temperature is below CT, uCode will stay awake and send card
 431  * state notification with CT_KILL bit clear to inform Thermal Throttling
 432  * Management to change state. Otherwise, uCode will go back to sleep
 433  * without doing anything, driver should continue the 5 seconds timer
 434  * to wake up uCode for temperature check until temperature drop below CT
 435  */
 436 static void iwl_tt_check_exit_ct_kill(unsigned long data)
 437 {
 438         struct iwl_priv *priv = (struct iwl_priv *)data;
 439         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 440         unsigned long flags;
 441
 442         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 443                 return;
 444
 445         if (tt->state == IWL_TI_CT_KILL) {
 446                 if (priv->thermal_throttle.ct_kill_toggle) {
 447                         iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
 448                                     CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
 449                         priv->thermal_throttle.ct_kill_toggle = false;
 450                 } else {
 451                         iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
 452                                     CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
 453                         priv->thermal_throttle.ct_kill_toggle = true;
 454                 }
 455                 iwl_read32(priv, CSR_UCODE_DRV_GP1);
 456                 spin_lock_irqsave(&priv->reg_lock, flags);
 457                 if (!iwl_grab_nic_access(priv))
 458                         iwl_release_nic_access(priv);
 459                 spin_unlock_irqrestore(&priv->reg_lock, flags);
 460
 461                 /* Reschedule the ct_kill timer to occur in
 462                  * CT_KILL_EXIT_DURATION seconds to ensure we get a
 463                  * thermal update */
 464                 IWL_DEBUG_POWER(priv, "schedule ct_kill exit timer\n");
 465                 mod_timer(&priv->thermal_throttle.ct_kill_exit_tm, jiffies +
 466                           CT_KILL_EXIT_DURATION * HZ);
 467         }
 468 }
 469
 470 static void iwl_perform_ct_kill_task(struct iwl_priv *priv,
 471                            bool stop)
 472 {
 473         if (stop) {
 474                 IWL_DEBUG_POWER(priv, "Stop all queues\n");
 475                 if (priv->mac80211_registered)
 476                         ieee80211_stop_queues(priv->hw);
 477                 IWL_DEBUG_POWER(priv,
 478                                 "Schedule 5 seconds CT_KILL Timer\n");
 479                 mod_timer(&priv->thermal_throttle.ct_kill_exit_tm, jiffies +
 480                           CT_KILL_EXIT_DURATION * HZ);
 481         } else {
 482                 IWL_DEBUG_POWER(priv, "Wake all queues\n");
 483                 if (priv->mac80211_registered)
 484                         ieee80211_wake_queues(priv->hw);
 485         }
 486 }
 487
 488 static void iwl_tt_ready_for_ct_kill(unsigned long data)
 489 {
 490         struct iwl_priv *priv = (struct iwl_priv *)data;
 491         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 492
 493         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 494                 return;
 495
 496         /* temperature timer expired, ready to go into CT_KILL state */
 497         if (tt->state != IWL_TI_CT_KILL) {
 498                 IWL_DEBUG_POWER(priv, "entering CT_KILL state when temperature timer expired\n");
 499                 tt->state = IWL_TI_CT_KILL;
 500                 set_bit(STATUS_CT_KILL, &priv->status);
 501                 iwl_perform_ct_kill_task(priv, true);
 502         }
 503 }
 504
 505 static void iwl_prepare_ct_kill_task(struct iwl_priv *priv)
 506 {
 507         IWL_DEBUG_POWER(priv, "Prepare to enter IWL_TI_CT_KILL\n");
 508         /* make request to retrieve statistics information */
 509         iwl_send_statistics_request(priv, CMD_SYNC, false);
 510         /* Reschedule the ct_kill wait timer */
 511         mod_timer(&priv->thermal_throttle.ct_kill_waiting_tm,
 512                  jiffies + msecs_to_jiffies(CT_KILL_WAITING_DURATION));
 513 }
 514
 515 #define IWL_MINIMAL_POWER_THRESHOLD             (CT_KILL_THRESHOLD_LEGACY)
 516 #define IWL_REDUCED_PERFORMANCE_THRESHOLD_2     (100)
 517 #define IWL_REDUCED_PERFORMANCE_THRESHOLD_1     (90)
 518
 519 /*
 520  * Legacy thermal throttling
 521  * 1) Avoid NIC destruction due to high temperatures
 522  *      Chip will identify dangerously high temperatures that can
 523  *      harm the device and will power down
 524  * 2) Avoid the NIC power down due to high temperature
 525  *      Throttle early enough to lower the power consumption before
 526  *      drastic steps are needed
 527  */
 528 static void iwl_legacy_tt_handler(struct iwl_priv *priv, s32 temp, bool force)
 529 {
 530         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 531         enum iwl_tt_state old_state;
 532
 533 #ifdef CONFIG_IWLWIFI_DEBUG
 534         if ((tt->tt_previous_temp) &&
 535             (temp > tt->tt_previous_temp) &&
 536             ((temp - tt->tt_previous_temp) >
 537             IWL_TT_INCREASE_MARGIN)) {
 538                 IWL_DEBUG_POWER(priv,
 539                         "Temperature increase %d degree Celsius\n",
 540                         (temp - tt->tt_previous_temp));
 541         }
 542 #endif
 543         old_state = tt->state;
 544         /* in Celsius */
 545         if (temp >= IWL_MINIMAL_POWER_THRESHOLD)
 546                 tt->state = IWL_TI_CT_KILL;
 547         else if (temp >= IWL_REDUCED_PERFORMANCE_THRESHOLD_2)
 548                 tt->state = IWL_TI_2;
 549         else if (temp >= IWL_REDUCED_PERFORMANCE_THRESHOLD_1)
 550                 tt->state = IWL_TI_1;
 551         else
 552                 tt->state = IWL_TI_0;
 553
 554 #ifdef CONFIG_IWLWIFI_DEBUG
 555         tt->tt_previous_temp = temp;
 556 #endif
 557         /* stop ct_kill_waiting_tm timer */
 558         del_timer_sync(&priv->thermal_throttle.ct_kill_waiting_tm);
 559         if (tt->state != old_state) {
 560                 switch (tt->state) {
 561                 case IWL_TI_0:
 562                         /*
 563                          * When the system is ready to go back to IWL_TI_0
 564                          * we only have to call iwl_power_update_mode() to
 565                          * do so.
 566                          */
 567                         break;
 568                 case IWL_TI_1:
 569                         tt->tt_power_mode = IWL_POWER_INDEX_3;
 570                         break;
 571                 case IWL_TI_2:
 572                         tt->tt_power_mode = IWL_POWER_INDEX_4;
 573                         break;
 574                 default:
 575                         tt->tt_power_mode = IWL_POWER_INDEX_5;
 576                         break;
 577                 }
 578                 mutex_lock(&priv->mutex);
 579                 if (old_state == IWL_TI_CT_KILL)
 580                         clear_bit(STATUS_CT_KILL, &priv->status);
 581                 if (tt->state != IWL_TI_CT_KILL &&
 582                     iwl_power_update_mode(priv, true)) {
 583                         /* TT state not updated
 584                          * try again during next temperature read
 585                          */
 586                         if (old_state == IWL_TI_CT_KILL)
 587                                 set_bit(STATUS_CT_KILL, &priv->status);
 588                         tt->state = old_state;
 589                         IWL_ERR(priv, "Cannot update power mode, "
 590                                         "TT state not updated\n");
 591                 } else {
 592                         if (tt->state == IWL_TI_CT_KILL) {
 593                                 if (force) {
 594                                         set_bit(STATUS_CT_KILL, &priv->status);
 595                                         iwl_perform_ct_kill_task(priv, true);
 596                                 } else {
 597                                         iwl_prepare_ct_kill_task(priv);
 598                                         tt->state = old_state;
 599                                 }
 600                         } else if (old_state == IWL_TI_CT_KILL &&
 601                                  tt->state != IWL_TI_CT_KILL)
 602                                 iwl_perform_ct_kill_task(priv, false);
 603                         IWL_DEBUG_POWER(priv, "Temperature state changed %u\n",
 604                                         tt->state);
 605                         IWL_DEBUG_POWER(priv, "Power Index change to %u\n",
 606                                         tt->tt_power_mode);
 607                 }
 608                 mutex_unlock(&priv->mutex);
 609         }
 610 }
 611
 612 /*
 613  * Advance thermal throttling
 614  * 1) Avoid NIC destruction due to high temperatures
 615  *      Chip will identify dangerously high temperatures that can
 616  *      harm the device and will power down
 617  * 2) Avoid the NIC power down due to high temperature
 618  *      Throttle early enough to lower the power consumption before
 619  *      drastic steps are needed
 620  *      Actions include relaxing the power down sleep thresholds and
 621  *      decreasing the number of TX streams
 622  * 3) Avoid throughput performance impact as much as possible
 623  *
 624  *=============================================================================
 625  *                 Condition Nxt State  Condition Nxt State Condition Nxt State
 626  *-----------------------------------------------------------------------------
 627  *     IWL_TI_0     T >= 114   CT_KILL  114>T>=105   TI_1      N/A      N/A
 628  *     IWL_TI_1     T >= 114   CT_KILL  114>T>=110   TI_2     T<=95     TI_0
 629  *     IWL_TI_2     T >= 114   CT_KILL                        T<=100    TI_1
 630  *    IWL_CT_KILL      N/A       N/A       N/A        N/A     T<=95     TI_0
 631  *=============================================================================
 632  */
 633 static void iwl_advance_tt_handler(struct iwl_priv *priv, s32 temp, bool force)
 634 {
 635         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 636         int i;
 637         bool changed = false;
 638         enum iwl_tt_state old_state;
 639         struct iwl_tt_trans *transaction;
 640
 641         old_state = tt->state;
 642         for (i = 0; i < IWL_TI_STATE_MAX - 1; i++) {
 643                 /* based on the current TT state,
 644                  * find the curresponding transaction table
 645                  * each table has (IWL_TI_STATE_MAX - 1) entries
 646                  * tt->transaction + ((old_state * (IWL_TI_STATE_MAX - 1))
 647                  * will advance to the correct table.
 648                  * then based on the current temperature
 649                  * find the next state need to transaction to
 650                  * go through all the possible (IWL_TI_STATE_MAX - 1) entries
 651                  * in the current table to see if transaction is needed
 652                  */
 653                 transaction = tt->transaction +
 654                         ((old_state * (IWL_TI_STATE_MAX - 1)) + i);
 655                 if (temp >= transaction->tt_low &&
 656                     temp <= transaction->tt_high) {
 657 #ifdef CONFIG_IWLWIFI_DEBUG
 658                         if ((tt->tt_previous_temp) &&
 659                             (temp > tt->tt_previous_temp) &&
 660                             ((temp - tt->tt_previous_temp) >
 661                             IWL_TT_INCREASE_MARGIN)) {
 662                                 IWL_DEBUG_POWER(priv,
 663                                         "Temperature increase %d "
 664                                         "degree Celsius\n",
 665                                         (temp - tt->tt_previous_temp));
 666                         }
 667                         tt->tt_previous_temp = temp;
 668 #endif
 669                         if (old_state !=
 670                             transaction->next_state) {
 671                                 changed = true;
 672                                 tt->state =
 673                                         transaction->next_state;
 674                         }
 675                         break;
 676                 }
 677         }
 678         /* stop ct_kill_waiting_tm timer */
 679         del_timer_sync(&priv->thermal_throttle.ct_kill_waiting_tm);
 680         if (changed) {
 681                 struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
 682
 683                 if (tt->state >= IWL_TI_1) {
 684                         /* force PI = IWL_POWER_INDEX_5 in the case of TI > 0 */
 685                         tt->tt_power_mode = IWL_POWER_INDEX_5;
 686                         if (!iwl_ht_enabled(priv))
 687                                 /* disable HT */
 688                                 rxon->flags &= ~(RXON_FLG_CHANNEL_MODE_MSK |
 689                                         RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK |
 690                                         RXON_FLG_HT40_PROT_MSK |
 691                                         RXON_FLG_HT_PROT_MSK);
 692                         else {
 693                                 /* check HT capability and set
 694                                  * according to the system HT capability
 695                                  * in case get disabled before */
 696                                 iwl_set_rxon_ht(priv, &priv->current_ht_config);
 697                         }
 698
 699                 } else {
 700                         /*
 701                          * restore system power setting -- it will be
 702                          * recalculated automatically.
 703                          */
 704
 705                         /* check HT capability and set
 706                          * according to the system HT capability
 707                          * in case get disabled before */
 708                         iwl_set_rxon_ht(priv, &priv->current_ht_config);
 709                 }
 710                 mutex_lock(&priv->mutex);
 711                 if (old_state == IWL_TI_CT_KILL)
 712                         clear_bit(STATUS_CT_KILL, &priv->status);
 713                 if (tt->state != IWL_TI_CT_KILL &&
 714                     iwl_power_update_mode(priv, true)) {
 715                         /* TT state not updated
 716                          * try again during next temperature read
 717                          */
 718                         IWL_ERR(priv, "Cannot update power mode, "
 719                                         "TT state not updated\n");
 720                         if (old_state == IWL_TI_CT_KILL)
 721                                 set_bit(STATUS_CT_KILL, &priv->status);
 722                         tt->state = old_state;
 723                 } else {
 724                         IWL_DEBUG_POWER(priv,
 725                                         "Thermal Throttling to new state: %u\n",
 726                                         tt->state);
 727                         if (old_state != IWL_TI_CT_KILL &&
 728                             tt->state == IWL_TI_CT_KILL) {
 729                                 if (force) {
 730                                         IWL_DEBUG_POWER(priv,
 731                                                 "Enter IWL_TI_CT_KILL\n");
 732                                         set_bit(STATUS_CT_KILL, &priv->status);
 733                                         iwl_perform_ct_kill_task(priv, true);
 734                                 } else {
 735                                         iwl_prepare_ct_kill_task(priv);
 736                                         tt->state = old_state;
 737                                 }
 738                         } else if (old_state == IWL_TI_CT_KILL &&
 739                                   tt->state != IWL_TI_CT_KILL) {
 740                                 IWL_DEBUG_POWER(priv, "Exit IWL_TI_CT_KILL\n");
 741                                 iwl_perform_ct_kill_task(priv, false);
 742                         }
 743                 }
 744                 mutex_unlock(&priv->mutex);
 745         }
 746 }
 747
 748 /* Card State Notification indicated reach critical temperature
 749  * if PSP not enable, no Thermal Throttling function will be performed
 750  * just set the GP1 bit to acknowledge the event
 751  * otherwise, go into IWL_TI_CT_KILL state
 752  * since Card State Notification will not provide any temperature reading
 753  * for Legacy mode
 754  * so just pass the CT_KILL temperature to iwl_legacy_tt_handler()
 755  * for advance mode
 756  * pass CT_KILL_THRESHOLD+1 to make sure move into IWL_TI_CT_KILL state
 757  */
 758 static void iwl_bg_ct_enter(struct work_struct *work)
 759 {
 760         struct iwl_priv *priv = container_of(work, struct iwl_priv, ct_enter);
 761         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 762
 763         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 764                 return;
 765
 766         if (!iwl_is_ready(priv))
 767                 return;
 768
 769         if (tt->state != IWL_TI_CT_KILL) {
 770                 IWL_ERR(priv, "Device reached critical temperature "
 771                               "- ucode going to sleep!\n");
 772                 if (!priv->thermal_throttle.advanced_tt)
 773                         iwl_legacy_tt_handler(priv,
 774                                               IWL_MINIMAL_POWER_THRESHOLD,
 775                                               true);
 776                 else
 777                         iwl_advance_tt_handler(priv,
 778                                                CT_KILL_THRESHOLD + 1, true);
 779         }
 780 }
 781
 782 /* Card State Notification indicated out of critical temperature
 783  * since Card State Notification will not provide any temperature reading
 784  * so pass the IWL_REDUCED_PERFORMANCE_THRESHOLD_2 temperature
 785  * to iwl_legacy_tt_handler() to get out of IWL_CT_KILL state
 786  */
 787 static void iwl_bg_ct_exit(struct work_struct *work)
 788 {
 789         struct iwl_priv *priv = container_of(work, struct iwl_priv, ct_exit);
 790         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 791
 792         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 793                 return;
 794
 795         if (!iwl_is_ready(priv))
 796                 return;
 797
 798         /* stop ct_kill_exit_tm timer */
 799         del_timer_sync(&priv->thermal_throttle.ct_kill_exit_tm);
 800
 801         if (tt->state == IWL_TI_CT_KILL) {
 802                 IWL_ERR(priv,
 803                         "Device temperature below critical"
 804                         "- ucode awake!\n");
 805                 /*
 806                  * exit from CT_KILL state
 807                  * reset the current temperature reading
 808                  */
 809                 priv->temperature = 0;
 810                 if (!priv->thermal_throttle.advanced_tt)
 811                         iwl_legacy_tt_handler(priv,
 812                                               IWL_REDUCED_PERFORMANCE_THRESHOLD_2,
 813                                               true);
 814                 else
 815                         iwl_advance_tt_handler(priv, CT_KILL_EXIT_THRESHOLD,
 816                                                true);
 817         }
 818 }
 819
 820 void iwl_tt_enter_ct_kill(struct iwl_priv *priv)
 821 {
 822         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 823                 return;
 824
 825         IWL_DEBUG_POWER(priv, "Queueing critical temperature enter.\n");
 826         queue_work(priv->workqueue, &priv->ct_enter);
 827 }
 828 EXPORT_SYMBOL(iwl_tt_enter_ct_kill);
 829
 830 void iwl_tt_exit_ct_kill(struct iwl_priv *priv)
 831 {
 832         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 833                 return;
 834
 835         IWL_DEBUG_POWER(priv, "Queueing critical temperature exit.\n");
 836         queue_work(priv->workqueue, &priv->ct_exit);
 837 }
 838 EXPORT_SYMBOL(iwl_tt_exit_ct_kill);
 839
 840 static void iwl_bg_tt_work(struct work_struct *work)
 841 {
 842         struct iwl_priv *priv = container_of(work, struct iwl_priv, tt_work);
 843         s32 temp = priv->temperature; /* degrees CELSIUS except 4965 */
 844
 845         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 846                 return;
 847
 848         if ((priv->hw_rev & CSR_HW_REV_TYPE_MSK) == CSR_HW_REV_TYPE_4965)
 849                 temp = KELVIN_TO_CELSIUS(priv->temperature);
 850
 851         if (!priv->thermal_throttle.advanced_tt)
 852                 iwl_legacy_tt_handler(priv, temp, false);
 853         else
 854                 iwl_advance_tt_handler(priv, temp, false);
 855 }
 856
 857 void iwl_tt_handler(struct iwl_priv *priv)
 858 {
 859         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 860                 return;
 861
 862         IWL_DEBUG_POWER(priv, "Queueing thermal throttling work.\n");
 863         queue_work(priv->workqueue, &priv->tt_work);
 864 }
 865 EXPORT_SYMBOL(iwl_tt_handler);
 866
 867 /* Thermal throttling initialization
 868  * For advance thermal throttling:
 869  *     Initialize Thermal Index and temperature threshold table
 870  *     Initialize thermal throttling restriction table
 871  */
 872 void iwl_tt_initialize(struct iwl_priv *priv)
 873 {
 874         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 875         int size = sizeof(struct iwl_tt_trans) * (IWL_TI_STATE_MAX - 1);
 876         struct iwl_tt_trans *transaction;
 877
 878         IWL_DEBUG_POWER(priv, "Initialize Thermal Throttling \n");
 879
 880         memset(tt, 0, sizeof(struct iwl_tt_mgmt));
 881
 882         tt->state = IWL_TI_0;
 883         init_timer(&priv->thermal_throttle.ct_kill_exit_tm);
 884         priv->thermal_throttle.ct_kill_exit_tm.data = (unsigned long)priv;
 885         priv->thermal_throttle.ct_kill_exit_tm.function =
 886                 iwl_tt_check_exit_ct_kill;
 887         init_timer(&priv->thermal_throttle.ct_kill_waiting_tm);
 888         priv->thermal_throttle.ct_kill_waiting_tm.data = (unsigned long)priv;
 889         priv->thermal_throttle.ct_kill_waiting_tm.function =
 890                 iwl_tt_ready_for_ct_kill;
 891         /* setup deferred ct kill work */
 892         INIT_WORK(&priv->tt_work, iwl_bg_tt_work);
 893         INIT_WORK(&priv->ct_enter, iwl_bg_ct_enter);
 894         INIT_WORK(&priv->ct_exit, iwl_bg_ct_exit);
 895
 896         if (priv->cfg->adv_thermal_throttle) {
 897                 IWL_DEBUG_POWER(priv, "Advanced Thermal Throttling\n");
 898                 tt->restriction = kzalloc(sizeof(struct iwl_tt_restriction) *
 899                                          IWL_TI_STATE_MAX, GFP_KERNEL);
 900                 tt->transaction = kzalloc(sizeof(struct iwl_tt_trans) *
 901                         IWL_TI_STATE_MAX * (IWL_TI_STATE_MAX - 1),
 902                         GFP_KERNEL);
 903                 if (!tt->restriction || !tt->transaction) {
 904                         IWL_ERR(priv, "Fallback to Legacy Throttling\n");
 905                         priv->thermal_throttle.advanced_tt = false;
 906                         kfree(tt->restriction);
 907                         tt->restriction = NULL;
 908                         kfree(tt->transaction);
 909                         tt->transaction = NULL;
 910                 } else {
 911                         transaction = tt->transaction +
 912                                 (IWL_TI_0 * (IWL_TI_STATE_MAX - 1));
 913                         memcpy(transaction, &tt_range_0[0], size);
 914                         transaction = tt->transaction +
 915                                 (IWL_TI_1 * (IWL_TI_STATE_MAX - 1));
 916                         memcpy(transaction, &tt_range_1[0], size);
 917                         transaction = tt->transaction +
 918                                 (IWL_TI_2 * (IWL_TI_STATE_MAX - 1));
 919                         memcpy(transaction, &tt_range_2[0], size);
 920                         transaction = tt->transaction +
 921                                 (IWL_TI_CT_KILL * (IWL_TI_STATE_MAX - 1));
 922                         memcpy(transaction, &tt_range_3[0], size);
 923                         size = sizeof(struct iwl_tt_restriction) *
 924                                 IWL_TI_STATE_MAX;
 925                         memcpy(tt->restriction,
 926                                 &restriction_range[0], size);
 927                         priv->thermal_throttle.advanced_tt = true;
 928                 }
 929         } else {
 930                 IWL_DEBUG_POWER(priv, "Legacy Thermal Throttling\n");
 931                 priv->thermal_throttle.advanced_tt = false;
 932         }
 933 }
 934 EXPORT_SYMBOL(iwl_tt_initialize);
 935
 936 /* cleanup thermal throttling management related memory and timer */
 937 void iwl_tt_exit(struct iwl_priv *priv)
 938 {
 939         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 940
 941         /* stop ct_kill_exit_tm timer if activated */
 942         del_timer_sync(&priv->thermal_throttle.ct_kill_exit_tm);
 943         /* stop ct_kill_waiting_tm timer if activated */
 944         del_timer_sync(&priv->thermal_throttle.ct_kill_waiting_tm);
 945         cancel_work_sync(&priv->tt_work);
 946         cancel_work_sync(&priv->ct_enter);
 947         cancel_work_sync(&priv->ct_exit);
 948
 949         if (priv->thermal_throttle.advanced_tt) {
 950                 /* free advance thermal throttling memory */
 951                 kfree(tt->restriction);
 952                 tt->restriction = NULL;
 953                 kfree(tt->transaction);
 954                 tt->transaction = NULL;
 955         }
 956 }
 957 EXPORT_SYMBOL(iwl_tt_exit);
 958
 959 /* initialize to default */
 960 void iwl_power_initialize(struct iwl_priv *priv)
 961 {
 962         u16 lctl = iwl_pcie_link_ctl(priv);
 963
 964         priv->power_data.pci_pm = !(lctl & PCI_CFG_LINK_CTRL_VAL_L0S_EN);
 965
 966         priv->power_data.debug_sleep_level_override = -1;
 967
 968         memset(&priv->power_data.sleep_cmd, 0,
 969                 sizeof(priv->power_data.sleep_cmd));
 970 }
 971 EXPORT_SYMBOL(iwl_power_initialize);