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

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2009 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 allow the card to go to sleep when not busy.
  46  *
  47  * The power level is set to INDEX_1 (the least deep state) by
  48  * default, and will, in the future, be the deepest state unless
  49  * otherwise required by pm_qos network latency requirements.
  50  *
  51  * Using INDEX_1 without pm_qos is ok because mac80211 will disable
  52  * PS when even checking every beacon for the TIM bit would exceed
  53  * the required latency.
  54  */
  55
  56 #define IWL_POWER_RANGE_0_MAX  (2)
  57 #define IWL_POWER_RANGE_1_MAX  (10)
  58
  59
  60 #define NOSLP cpu_to_le16(0), 0, 0
  61 #define SLP IWL_POWER_DRIVER_ALLOW_SLEEP_MSK, 0, 0
  62 #define TU_TO_USEC 1024
  63 #define SLP_TOUT(T) cpu_to_le32((T) * TU_TO_USEC)
  64 #define SLP_VEC(X0, X1, X2, X3, X4) {cpu_to_le32(X0), \
  65                                      cpu_to_le32(X1), \
  66                                      cpu_to_le32(X2), \
  67                                      cpu_to_le32(X3), \
  68                                      cpu_to_le32(X4)}
  69 /* default power management (not Tx power) table values */
  70 /* for DTIM period 0 through IWL_POWER_RANGE_0_MAX */
  71 static const struct iwl_power_vec_entry range_0[IWL_POWER_NUM] = {
  72         {{NOSLP, SLP_TOUT(0), SLP_TOUT(0), SLP_VEC(0, 0, 0, 0, 0)}, 0},
  73         {{SLP, SLP_TOUT(200), SLP_TOUT(500), SLP_VEC(1, 2, 2, 2, 0xFF)}, 0},
  74         {{SLP, SLP_TOUT(200), SLP_TOUT(300), SLP_VEC(1, 2, 2, 2, 0xFF)}, 0},
  75         {{SLP, SLP_TOUT(50), SLP_TOUT(100), SLP_VEC(2, 2, 2, 2, 0xFF)}, 0},
  76         {{SLP, SLP_TOUT(50), SLP_TOUT(25), SLP_VEC(2, 2, 4, 4, 0xFF)}, 1},
  77         {{SLP, SLP_TOUT(25), SLP_TOUT(25), SLP_VEC(2, 2, 4, 6, 0xFF)}, 2}
  78 };
  79
  80
  81 /* for DTIM period IWL_POWER_RANGE_0_MAX + 1 through IWL_POWER_RANGE_1_MAX */
  82 static const struct iwl_power_vec_entry range_1[IWL_POWER_NUM] = {
  83         {{NOSLP, SLP_TOUT(0), SLP_TOUT(0), SLP_VEC(0, 0, 0, 0, 0)}, 0},
  84         {{SLP, SLP_TOUT(200), SLP_TOUT(500), SLP_VEC(1, 2, 3, 4, 4)}, 0},
  85         {{SLP, SLP_TOUT(200), SLP_TOUT(300), SLP_VEC(1, 2, 3, 4, 7)}, 0},
  86         {{SLP, SLP_TOUT(50), SLP_TOUT(100), SLP_VEC(2, 4, 6, 7, 9)}, 0},
  87         {{SLP, SLP_TOUT(50), SLP_TOUT(25), SLP_VEC(2, 4, 6, 9, 10)}, 1},
  88         {{SLP, SLP_TOUT(25), SLP_TOUT(25), SLP_VEC(2, 4, 7, 10, 10)}, 2}
  89 };
  90
  91 /* for DTIM period > IWL_POWER_RANGE_1_MAX */
  92 static const struct iwl_power_vec_entry range_2[IWL_POWER_NUM] = {
  93         {{NOSLP, SLP_TOUT(0), SLP_TOUT(0), SLP_VEC(0, 0, 0, 0, 0)}, 0},
  94         {{SLP, SLP_TOUT(200), SLP_TOUT(500), SLP_VEC(1, 2, 3, 4, 0xFF)}, 0},
  95         {{SLP, SLP_TOUT(200), SLP_TOUT(300), SLP_VEC(2, 4, 6, 7, 0xFF)}, 0},
  96         {{SLP, SLP_TOUT(50), SLP_TOUT(100), SLP_VEC(2, 7, 9, 9, 0xFF)}, 0},
  97         {{SLP, SLP_TOUT(50), SLP_TOUT(25), SLP_VEC(2, 7, 9, 9, 0xFF)}, 0},
  98         {{SLP, SLP_TOUT(25), SLP_TOUT(25), SLP_VEC(4, 7, 10, 10, 0xFF)}, 0}
  99 };
 100
 101 /* default Thermal Throttling transaction table
 102  * Current state   |         Throttling Down               |  Throttling Up
 103  *=============================================================================
 104  *                 Condition Nxt State  Condition Nxt State Condition Nxt State
 105  *-----------------------------------------------------------------------------
 106  *     IWL_TI_0     T >= 115   CT_KILL  115>T>=105   TI_1      N/A      N/A
 107  *     IWL_TI_1     T >= 115   CT_KILL  115>T>=110   TI_2     T<=95     TI_0
 108  *     IWL_TI_2     T >= 115   CT_KILL                        T<=100    TI_1
 109  *    IWL_CT_KILL      N/A       N/A       N/A        N/A     T<=95     TI_0
 110  *=============================================================================
 111  */
 112 static const struct iwl_tt_trans tt_range_0[IWL_TI_STATE_MAX - 1] = {
 113         {IWL_TI_0, IWL_ABSOLUTE_ZERO, 104},
 114         {IWL_TI_1, 105, CT_KILL_THRESHOLD},
 115         {IWL_TI_CT_KILL, CT_KILL_THRESHOLD + 1, IWL_ABSOLUTE_MAX}
 116 };
 117 static const struct iwl_tt_trans tt_range_1[IWL_TI_STATE_MAX - 1] = {
 118         {IWL_TI_0, IWL_ABSOLUTE_ZERO, 95},
 119         {IWL_TI_2, 110, CT_KILL_THRESHOLD},
 120         {IWL_TI_CT_KILL, CT_KILL_THRESHOLD + 1, IWL_ABSOLUTE_MAX}
 121 };
 122 static const struct iwl_tt_trans tt_range_2[IWL_TI_STATE_MAX - 1] = {
 123         {IWL_TI_1, IWL_ABSOLUTE_ZERO, 100},
 124         {IWL_TI_CT_KILL, CT_KILL_THRESHOLD + 1, IWL_ABSOLUTE_MAX},
 125         {IWL_TI_CT_KILL, CT_KILL_THRESHOLD + 1, IWL_ABSOLUTE_MAX}
 126 };
 127 static const struct iwl_tt_trans tt_range_3[IWL_TI_STATE_MAX - 1] = {
 128         {IWL_TI_0, IWL_ABSOLUTE_ZERO, CT_KILL_EXIT_THRESHOLD},
 129         {IWL_TI_CT_KILL, CT_KILL_EXIT_THRESHOLD + 1, IWL_ABSOLUTE_MAX},
 130         {IWL_TI_CT_KILL, CT_KILL_EXIT_THRESHOLD + 1, IWL_ABSOLUTE_MAX}
 131 };
 132
 133 /* Advance Thermal Throttling default restriction table */
 134 static const struct iwl_tt_restriction restriction_range[IWL_TI_STATE_MAX] = {
 135         {IWL_TX_MULTI, true, IWL_RX_MULTI},
 136         {IWL_TX_SINGLE, true, IWL_RX_MULTI},
 137         {IWL_TX_SINGLE, false, IWL_RX_SINGLE},
 138         {IWL_TX_NONE, false, IWL_RX_NONE}
 139 };
 140
 141 /* set card power command */
 142 static int iwl_set_power(struct iwl_priv *priv, void *cmd)
 143 {
 144         return iwl_send_cmd_pdu(priv, POWER_TABLE_CMD,
 145                                 sizeof(struct iwl_powertable_cmd), cmd);
 146 }
 147
 148 /* initialize to default */
 149 static void iwl_power_init_handle(struct iwl_priv *priv)
 150 {
 151         struct iwl_power_mgr *pow_data;
 152         int size = sizeof(struct iwl_power_vec_entry) * IWL_POWER_NUM;
 153         struct iwl_powertable_cmd *cmd;
 154         int i;
 155         u16 lctl;
 156
 157         IWL_DEBUG_POWER(priv, "Initialize power \n");
 158
 159         pow_data = &priv->power_data;
 160
 161         memset(pow_data, 0, sizeof(*pow_data));
 162
 163         memcpy(&pow_data->pwr_range_0[0], &range_0[0], size);
 164         memcpy(&pow_data->pwr_range_1[0], &range_1[0], size);
 165         memcpy(&pow_data->pwr_range_2[0], &range_2[0], size);
 166
 167         lctl = iwl_pcie_link_ctl(priv);
 168
 169         IWL_DEBUG_POWER(priv, "adjust power command flags\n");
 170
 171         for (i = 0; i < IWL_POWER_NUM; i++) {
 172                 cmd = &pow_data->pwr_range_0[i].cmd;
 173
 174                 if (lctl & PCI_CFG_LINK_CTRL_VAL_L0S_EN)
 175                         cmd->flags &= ~IWL_POWER_PCI_PM_MSK;
 176                 else
 177                         cmd->flags |= IWL_POWER_PCI_PM_MSK;
 178         }
 179 }
 180
 181 /* adjust power command according to DTIM period and power level*/
 182 static int iwl_update_power_cmd(struct iwl_priv *priv,
 183                                 struct iwl_powertable_cmd *cmd, u16 mode)
 184 {
 185         struct iwl_power_vec_entry *range;
 186         struct iwl_power_mgr *pow_data;
 187         int i;
 188         u32 max_sleep = 0;
 189         u8 period;
 190         bool skip;
 191
 192         if (mode > IWL_POWER_INDEX_5) {
 193                 IWL_DEBUG_POWER(priv, "Error invalid power mode \n");
 194                 return -EINVAL;
 195         }
 196
 197         pow_data = &priv->power_data;
 198
 199         if (pow_data->dtim_period <= IWL_POWER_RANGE_0_MAX)
 200                 range = &pow_data->pwr_range_0[0];
 201         else if (pow_data->dtim_period <= IWL_POWER_RANGE_1_MAX)
 202                 range = &pow_data->pwr_range_1[0];
 203         else
 204                 range = &pow_data->pwr_range_2[0];
 205
 206         period = pow_data->dtim_period;
 207         memcpy(cmd, &range[mode].cmd, sizeof(struct iwl_powertable_cmd));
 208
 209         if (period == 0) {
 210                 period = 1;
 211                 skip = false;
 212         } else {
 213                 skip = !!range[mode].no_dtim;
 214         }
 215
 216         if (skip) {
 217                 __le32 slp_itrvl = cmd->sleep_interval[IWL_POWER_VEC_SIZE - 1];
 218                 max_sleep = le32_to_cpu(slp_itrvl);
 219                 if (max_sleep == 0xFF)
 220                         max_sleep = period * (skip + 1);
 221                 else if (max_sleep >  period)
 222                         max_sleep = (le32_to_cpu(slp_itrvl) / period) * period;
 223                 cmd->flags |= IWL_POWER_SLEEP_OVER_DTIM_MSK;
 224         } else {
 225                 max_sleep = period;
 226                 cmd->flags &= ~IWL_POWER_SLEEP_OVER_DTIM_MSK;
 227         }
 228
 229         for (i = 0; i < IWL_POWER_VEC_SIZE; i++)
 230                 if (le32_to_cpu(cmd->sleep_interval[i]) > max_sleep)
 231                         cmd->sleep_interval[i] = cpu_to_le32(max_sleep);
 232
 233         IWL_DEBUG_POWER(priv, "Flags value = 0x%08X\n", cmd->flags);
 234         IWL_DEBUG_POWER(priv, "Tx timeout = %u\n", le32_to_cpu(cmd->tx_data_timeout));
 235         IWL_DEBUG_POWER(priv, "Rx timeout = %u\n", le32_to_cpu(cmd->rx_data_timeout));
 236         IWL_DEBUG_POWER(priv, "Sleep interval vector = { %d , %d , %d , %d , %d }\n",
 237                         le32_to_cpu(cmd->sleep_interval[0]),
 238                         le32_to_cpu(cmd->sleep_interval[1]),
 239                         le32_to_cpu(cmd->sleep_interval[2]),
 240                         le32_to_cpu(cmd->sleep_interval[3]),
 241                         le32_to_cpu(cmd->sleep_interval[4]));
 242
 243         return 0;
 244 }
 245
 246
 247 /*
 248  * compute the final power mode index
 249  */
 250 int iwl_power_update_mode(struct iwl_priv *priv, bool force)
 251 {
 252         struct iwl_power_mgr *setting = &(priv->power_data);
 253         int ret = 0;
 254         struct iwl_tt_mgmt *tt = &priv->power_data.tt;
 255         u16 uninitialized_var(final_mode);
 256         bool update_chains;
 257
 258         /* Don't update the RX chain when chain noise calibration is running */
 259         update_chains = priv->chain_noise_data.state == IWL_CHAIN_NOISE_DONE ||
 260                         priv->chain_noise_data.state == IWL_CHAIN_NOISE_ALIVE;
 261
 262         final_mode = priv->power_data.user_power_setting;
 263
 264         if (setting->power_disabled)
 265                 final_mode = IWL_POWER_MODE_CAM;
 266
 267         if (tt->state >= IWL_TI_1) {
 268                 /* TT power setting overwrite user & system power setting */
 269                 final_mode = tt->tt_power_mode;
 270         }
 271         if (iwl_is_ready_rf(priv) &&
 272             ((setting->power_mode != final_mode) || force)) {
 273                 struct iwl_powertable_cmd cmd;
 274
 275                 if (final_mode != IWL_POWER_MODE_CAM)
 276                         set_bit(STATUS_POWER_PMI, &priv->status);
 277
 278                 iwl_update_power_cmd(priv, &cmd, final_mode);
 279                 cmd.keep_alive_beacons = 0;
 280
 281                 if (final_mode == IWL_POWER_INDEX_5)
 282                         cmd.flags |= IWL_POWER_FAST_PD;
 283
 284                 ret = iwl_set_power(priv, &cmd);
 285
 286                 if (final_mode == IWL_POWER_MODE_CAM)
 287                         clear_bit(STATUS_POWER_PMI, &priv->status);
 288
 289                 if (priv->cfg->ops->lib->update_chain_flags && update_chains)
 290                         priv->cfg->ops->lib->update_chain_flags(priv);
 291                 else
 292                         IWL_DEBUG_POWER(priv, "Cannot update the power, chain noise "
 293                                         "calibration running: %d\n",
 294                                         priv->chain_noise_data.state);
 295                 if (!ret)
 296                         setting->power_mode = final_mode;
 297         }
 298
 299         return ret;
 300 }
 301 EXPORT_SYMBOL(iwl_power_update_mode);
 302
 303 /* set user_power_setting */
 304 int iwl_power_set_user_mode(struct iwl_priv *priv, u16 mode)
 305 {
 306         if (mode >= IWL_POWER_NUM)
 307                 return -EINVAL;
 308
 309         priv->power_data.user_power_setting = mode;
 310
 311         return iwl_power_update_mode(priv, 0);
 312 }
 313 EXPORT_SYMBOL(iwl_power_set_user_mode);
 314
 315 bool iwl_ht_enabled(struct iwl_priv *priv)
 316 {
 317         struct iwl_tt_mgmt *tt = &priv->power_data.tt;
 318         struct iwl_tt_restriction *restriction;
 319
 320         if (!priv->power_data.adv_tt)
 321                 return true;
 322         restriction = tt->restriction + tt->state;
 323         return restriction->is_ht;
 324 }
 325 EXPORT_SYMBOL(iwl_ht_enabled);
 326
 327 u8 iwl_tx_ant_restriction(struct iwl_priv *priv)
 328 {
 329         struct iwl_tt_mgmt *tt = &priv->power_data.tt;
 330         struct iwl_tt_restriction *restriction;
 331
 332         if (!priv->power_data.adv_tt)
 333                 return IWL_TX_MULTI;
 334         restriction = tt->restriction + tt->state;
 335         return restriction->tx_stream;
 336 }
 337 EXPORT_SYMBOL(iwl_tx_ant_restriction);
 338
 339 u8 iwl_rx_ant_restriction(struct iwl_priv *priv)
 340 {
 341         struct iwl_tt_mgmt *tt = &priv->power_data.tt;
 342         struct iwl_tt_restriction *restriction;
 343
 344         if (!priv->power_data.adv_tt)
 345                 return IWL_RX_MULTI;
 346         restriction = tt->restriction + tt->state;
 347         return restriction->rx_stream;
 348 }
 349 EXPORT_SYMBOL(iwl_rx_ant_restriction);
 350
 351 #define CT_KILL_EXIT_DURATION (5)       /* 5 seconds duration */
 352
 353 /*
 354  * toggle the bit to wake up uCode and check the temperature
 355  * if the temperature is below CT, uCode will stay awake and send card
 356  * state notification with CT_KILL bit clear to inform Thermal Throttling
 357  * Management to change state. Otherwise, uCode will go back to sleep
 358  * without doing anything, driver should continue the 5 seconds timer
 359  * to wake up uCode for temperature check until temperature drop below CT
 360  */
 361 static void iwl_tt_check_exit_ct_kill(unsigned long data)
 362 {
 363         struct iwl_priv *priv = (struct iwl_priv *)data;
 364         struct iwl_tt_mgmt *tt = &priv->power_data.tt;
 365         unsigned long flags;
 366
 367         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 368                 return;
 369
 370         if (tt->state == IWL_TI_CT_KILL) {
 371                 if (priv->power_data.ct_kill_toggle) {
 372                         iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
 373                                     CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
 374                         priv->power_data.ct_kill_toggle = false;
 375                 } else {
 376                         iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
 377                                     CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
 378                         priv->power_data.ct_kill_toggle = true;
 379                 }
 380                 iwl_read32(priv, CSR_UCODE_DRV_GP1);
 381                 spin_lock_irqsave(&priv->reg_lock, flags);
 382                 if (!iwl_grab_nic_access(priv))
 383                         iwl_release_nic_access(priv);
 384                 spin_unlock_irqrestore(&priv->reg_lock, flags);
 385
 386                 /* Reschedule the ct_kill timer to occur in
 387                  * CT_KILL_EXIT_DURATION seconds to ensure we get a
 388                  * thermal update */
 389                 mod_timer(&priv->power_data.ct_kill_exit_tm, jiffies +
 390                           CT_KILL_EXIT_DURATION * HZ);
 391         }
 392 }
 393
 394 static void iwl_perform_ct_kill_task(struct iwl_priv *priv,
 395                            bool stop)
 396 {
 397         if (stop) {
 398                 IWL_DEBUG_POWER(priv, "Stop all queues\n");
 399                 if (priv->mac80211_registered)
 400                         ieee80211_stop_queues(priv->hw);
 401                 IWL_DEBUG_POWER(priv,
 402                                 "Schedule 5 seconds CT_KILL Timer\n");
 403                 mod_timer(&priv->power_data.ct_kill_exit_tm, jiffies +
 404                           CT_KILL_EXIT_DURATION * HZ);
 405         } else {
 406                 IWL_DEBUG_POWER(priv, "Wake all queues\n");
 407                 if (priv->mac80211_registered)
 408                         ieee80211_wake_queues(priv->hw);
 409         }
 410 }
 411
 412 #define IWL_MINIMAL_POWER_THRESHOLD             (CT_KILL_THRESHOLD_LEGACY)
 413 #define IWL_REDUCED_PERFORMANCE_THRESHOLD_2     (100)
 414 #define IWL_REDUCED_PERFORMANCE_THRESHOLD_1     (90)
 415
 416 /*
 417  * Legacy thermal throttling
 418  * 1) Avoid NIC destruction due to high temperatures
 419  *      Chip will identify dangerously high temperatures that can
 420  *      harm the device and will power down
 421  * 2) Avoid the NIC power down due to high temperature
 422  *      Throttle early enough to lower the power consumption before
 423  *      drastic steps are needed
 424  */
 425 static void iwl_legacy_tt_handler(struct iwl_priv *priv, s32 temp)
 426 {
 427         struct iwl_tt_mgmt *tt = &priv->power_data.tt;
 428         enum iwl_tt_state new_state;
 429         struct iwl_power_mgr *setting = &priv->power_data;
 430
 431 #ifdef CONFIG_IWLWIFI_DEBUG
 432         if ((tt->tt_previous_temp) &&
 433             (temp > tt->tt_previous_temp) &&
 434             ((temp - tt->tt_previous_temp) >
 435             IWL_TT_INCREASE_MARGIN)) {
 436                 IWL_DEBUG_POWER(priv,
 437                         "Temperature increase %d degree Celsius\n",
 438                         (temp - tt->tt_previous_temp));
 439         }
 440 #endif
 441         /* in Celsius */
 442         if (temp >= IWL_MINIMAL_POWER_THRESHOLD)
 443                 new_state = IWL_TI_CT_KILL;
 444         else if (temp >= IWL_REDUCED_PERFORMANCE_THRESHOLD_2)
 445                 new_state = IWL_TI_2;
 446         else if (temp >= IWL_REDUCED_PERFORMANCE_THRESHOLD_1)
 447                 new_state = IWL_TI_1;
 448         else
 449                 new_state = IWL_TI_0;
 450
 451 #ifdef CONFIG_IWLWIFI_DEBUG
 452         tt->tt_previous_temp = temp;
 453 #endif
 454         if (tt->state != new_state) {
 455                 if (tt->state == IWL_TI_0) {
 456                         tt->sys_power_mode = setting->power_mode;
 457                         IWL_DEBUG_POWER(priv, "current power mode: %u\n",
 458                                 setting->power_mode);
 459                 }
 460                 switch (new_state) {
 461                 case IWL_TI_0:
 462                         /* when system ready to go back to IWL_TI_0 state
 463                          * using system power mode instead of TT power mode
 464                          * revert back to the orginal power mode which was saved
 465                          * before enter Thermal Throttling state
 466                          * update priv->power_data.user_power_setting to the
 467                          * required power mode to make sure
 468                          * iwl_power_update_mode() will update power correctly.
 469                          */
 470                         priv->power_data.user_power_setting =
 471                                 tt->sys_power_mode;
 472                         tt->tt_power_mode = tt->sys_power_mode;
 473                         break;
 474                 case IWL_TI_1:
 475                         tt->tt_power_mode = IWL_POWER_INDEX_3;
 476                         break;
 477                 case IWL_TI_2:
 478                         tt->tt_power_mode = IWL_POWER_INDEX_4;
 479                         break;
 480                 default:
 481                         tt->tt_power_mode = IWL_POWER_INDEX_5;
 482                         break;
 483                 }
 484                 mutex_lock(&priv->mutex);
 485                 if (iwl_power_update_mode(priv, true)) {
 486                         /* TT state not updated
 487                          * try again during next temperature read
 488                          */
 489                         IWL_ERR(priv, "Cannot update power mode, "
 490                                         "TT state not updated\n");
 491                 } else {
 492                         if (new_state == IWL_TI_CT_KILL)
 493                                 iwl_perform_ct_kill_task(priv, true);
 494                         else if (tt->state == IWL_TI_CT_KILL &&
 495                                  new_state != IWL_TI_CT_KILL)
 496                                 iwl_perform_ct_kill_task(priv, false);
 497                         tt->state = new_state;
 498                         IWL_DEBUG_POWER(priv, "Temperature state changed %u\n",
 499                                         tt->state);
 500                         IWL_DEBUG_POWER(priv, "Power Index change to %u\n",
 501                                         tt->tt_power_mode);
 502                 }
 503                 mutex_unlock(&priv->mutex);
 504         }
 505 }
 506
 507 /*
 508  * Advance thermal throttling
 509  * 1) Avoid NIC destruction due to high temperatures
 510  *      Chip will identify dangerously high temperatures that can
 511  *      harm the device and will power down
 512  * 2) Avoid the NIC power down due to high temperature
 513  *      Throttle early enough to lower the power consumption before
 514  *      drastic steps are needed
 515  *      Actions include relaxing the power down sleep thresholds and
 516  *      decreasing the number of TX streams
 517  * 3) Avoid throughput performance impact as much as possible
 518  *
 519  *=============================================================================
 520  *                 Condition Nxt State  Condition Nxt State Condition Nxt State
 521  *-----------------------------------------------------------------------------
 522  *     IWL_TI_0     T >= 115   CT_KILL  115>T>=105   TI_1      N/A      N/A
 523  *     IWL_TI_1     T >= 115   CT_KILL  115>T>=110   TI_2     T<=95     TI_0
 524  *     IWL_TI_2     T >= 115   CT_KILL                        T<=100    TI_1
 525  *    IWL_CT_KILL      N/A       N/A       N/A        N/A     T<=95     TI_0
 526  *=============================================================================
 527  */
 528 static void iwl_advance_tt_handler(struct iwl_priv *priv, s32 temp)
 529 {
 530         struct iwl_tt_mgmt *tt = &priv->power_data.tt;
 531         int i;
 532         bool changed = false;
 533         enum iwl_tt_state old_state;
 534         struct iwl_tt_trans *transaction;
 535
 536         old_state = tt->state;
 537         for (i = 0; i < IWL_TI_STATE_MAX - 1; i++) {
 538                 /* based on the current TT state,
 539                  * find the curresponding transaction table
 540                  * each table has (IWL_TI_STATE_MAX - 1) entries
 541                  * tt->transaction + ((old_state * (IWL_TI_STATE_MAX - 1))
 542                  * will advance to the correct table.
 543                  * then based on the current temperature
 544                  * find the next state need to transaction to
 545                  * go through all the possible (IWL_TI_STATE_MAX - 1) entries
 546                  * in the current table to see if transaction is needed
 547                  */
 548                 transaction = tt->transaction +
 549                         ((old_state * (IWL_TI_STATE_MAX - 1)) + i);
 550                 if (temp >= transaction->tt_low &&
 551                     temp <= transaction->tt_high) {
 552 #ifdef CONFIG_IWLWIFI_DEBUG
 553                         if ((tt->tt_previous_temp) &&
 554                             (temp > tt->tt_previous_temp) &&
 555                             ((temp - tt->tt_previous_temp) >
 556                             IWL_TT_INCREASE_MARGIN)) {
 557                                 IWL_DEBUG_POWER(priv,
 558                                         "Temperature increase %d "
 559                                         "degree Celsius\n",
 560                                         (temp - tt->tt_previous_temp));
 561                         }
 562                         tt->tt_previous_temp = temp;
 563 #endif
 564                         if (old_state !=
 565                             transaction->next_state) {
 566                                 changed = true;
 567                                 tt->state =
 568                                         transaction->next_state;
 569                         }
 570                         break;
 571                 }
 572         }
 573         if (changed) {
 574                 struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
 575                 struct iwl_power_mgr *setting = &priv->power_data;
 576
 577                 if (tt->state >= IWL_TI_1) {
 578                         /* if switching from IWL_TI_0 to other TT state
 579                          * save previous power setting in tt->sys_power_mode */
 580                         if (old_state == IWL_TI_0)
 581                                 tt->sys_power_mode = setting->power_mode;
 582                         /* force PI = IWL_POWER_INDEX_5 in the case of TI > 0 */
 583                         tt->tt_power_mode = IWL_POWER_INDEX_5;
 584                         if (!iwl_ht_enabled(priv))
 585                                 /* disable HT */
 586                                 rxon->flags &= ~(RXON_FLG_CHANNEL_MODE_MSK |
 587                                         RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK |
 588                                         RXON_FLG_HT40_PROT_MSK |
 589                                         RXON_FLG_HT_PROT_MSK);
 590                         else {
 591                                 /* check HT capability and set
 592                                  * according to the system HT capability
 593                                  * in case get disabled before */
 594                                 iwl_set_rxon_ht(priv, &priv->current_ht_config);
 595                         }
 596
 597                 } else {
 598                         /* restore system power setting */
 599                         /* the previous power mode was saved in
 600                          * tt->sys_power_mode when system move into
 601                          * Thermal Throttling state
 602                          * set power_data.user_power_setting to the previous
 603                          * system power mode to make sure power will get
 604                          * updated correctly
 605                          */
 606                         priv->power_data.user_power_setting =
 607                                 tt->sys_power_mode;
 608                         tt->tt_power_mode = tt->sys_power_mode;
 609                         /* check HT capability and set
 610                          * according to the system HT capability
 611                          * in case get disabled before */
 612                         iwl_set_rxon_ht(priv, &priv->current_ht_config);
 613                 }
 614                 mutex_lock(&priv->mutex);
 615                 if (iwl_power_update_mode(priv, true)) {
 616                         /* TT state not updated
 617                          * try again during next temperature read
 618                          */
 619                         IWL_ERR(priv, "Cannot update power mode, "
 620                                         "TT state not updated\n");
 621                         tt->state = old_state;
 622                 } else {
 623                         IWL_DEBUG_POWER(priv,
 624                                         "Thermal Throttling to new state: %u\n",
 625                                         tt->state);
 626                         if (old_state != IWL_TI_CT_KILL &&
 627                             tt->state == IWL_TI_CT_KILL) {
 628                                 IWL_DEBUG_POWER(priv, "Enter IWL_TI_CT_KILL\n");
 629                                 iwl_perform_ct_kill_task(priv, true);
 630
 631                         } else if (old_state == IWL_TI_CT_KILL &&
 632                                   tt->state != IWL_TI_CT_KILL) {
 633                                 IWL_DEBUG_POWER(priv, "Exit IWL_TI_CT_KILL\n");
 634                                 iwl_perform_ct_kill_task(priv, false);
 635                         }
 636                 }
 637                 mutex_unlock(&priv->mutex);
 638         }
 639 }
 640
 641 /* Card State Notification indicated reach critical temperature
 642  * if PSP not enable, no Thermal Throttling function will be performed
 643  * just set the GP1 bit to acknowledge the event
 644  * otherwise, go into IWL_TI_CT_KILL state
 645  * since Card State Notification will not provide any temperature reading
 646  * for Legacy mode
 647  * so just pass the CT_KILL temperature to iwl_legacy_tt_handler()
 648  * for advance mode
 649  * pass CT_KILL_THRESHOLD+1 to make sure move into IWL_TI_CT_KILL state
 650  */
 651 static void iwl_bg_ct_enter(struct work_struct *work)
 652 {
 653         struct iwl_priv *priv = container_of(work, struct iwl_priv, ct_enter);
 654         struct iwl_tt_mgmt *tt = &priv->power_data.tt;
 655
 656         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 657                 return;
 658
 659         if (!iwl_is_ready(priv))
 660                 return;
 661
 662         if (tt->state != IWL_TI_CT_KILL) {
 663                 IWL_ERR(priv, "Device reached critical temperature "
 664                               "- ucode going to sleep!\n");
 665                 if (!priv->power_data.adv_tt)
 666                         iwl_legacy_tt_handler(priv,
 667                                               IWL_MINIMAL_POWER_THRESHOLD);
 668                 else
 669                         iwl_advance_tt_handler(priv,
 670                                                CT_KILL_THRESHOLD + 1);
 671         }
 672 }
 673
 674 /* Card State Notification indicated out of critical temperature
 675  * since Card State Notification will not provide any temperature reading
 676  * so pass the IWL_REDUCED_PERFORMANCE_THRESHOLD_2 temperature
 677  * to iwl_legacy_tt_handler() to get out of IWL_CT_KILL state
 678  */
 679 static void iwl_bg_ct_exit(struct work_struct *work)
 680 {
 681         struct iwl_priv *priv = container_of(work, struct iwl_priv, ct_exit);
 682         struct iwl_tt_mgmt *tt = &priv->power_data.tt;
 683
 684         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 685                 return;
 686
 687         if (!iwl_is_ready(priv))
 688                 return;
 689
 690         /* stop ct_kill_exit_tm timer */
 691         del_timer_sync(&priv->power_data.ct_kill_exit_tm);
 692
 693         if (tt->state == IWL_TI_CT_KILL) {
 694                 IWL_ERR(priv,
 695                         "Device temperature below critical"
 696                         "- ucode awake!\n");
 697                 if (!priv->power_data.adv_tt)
 698                         iwl_legacy_tt_handler(priv,
 699                                         IWL_REDUCED_PERFORMANCE_THRESHOLD_2);
 700                 else
 701                         iwl_advance_tt_handler(priv, CT_KILL_EXIT_THRESHOLD);
 702         }
 703 }
 704
 705 void iwl_tt_enter_ct_kill(struct iwl_priv *priv)
 706 {
 707         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 708                 return;
 709
 710         IWL_DEBUG_POWER(priv, "Queueing critical temperature enter.\n");
 711         queue_work(priv->workqueue, &priv->ct_enter);
 712 }
 713 EXPORT_SYMBOL(iwl_tt_enter_ct_kill);
 714
 715 void iwl_tt_exit_ct_kill(struct iwl_priv *priv)
 716 {
 717         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 718                 return;
 719
 720         IWL_DEBUG_POWER(priv, "Queueing critical temperature exit.\n");
 721         queue_work(priv->workqueue, &priv->ct_exit);
 722 }
 723 EXPORT_SYMBOL(iwl_tt_exit_ct_kill);
 724
 725 static void iwl_bg_tt_work(struct work_struct *work)
 726 {
 727         struct iwl_priv *priv = container_of(work, struct iwl_priv, tt_work);
 728         s32 temp = priv->temperature; /* degrees CELSIUS except 4965 */
 729
 730         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 731                 return;
 732
 733         if ((priv->hw_rev & CSR_HW_REV_TYPE_MSK) == CSR_HW_REV_TYPE_4965)
 734                 temp = KELVIN_TO_CELSIUS(priv->temperature);
 735
 736         if (!priv->power_data.adv_tt)
 737                 iwl_legacy_tt_handler(priv, temp);
 738         else
 739                 iwl_advance_tt_handler(priv, temp);
 740 }
 741
 742 void iwl_tt_handler(struct iwl_priv *priv)
 743 {
 744         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 745                 return;
 746
 747         IWL_DEBUG_POWER(priv, "Queueing thermal throttling work.\n");
 748         queue_work(priv->workqueue, &priv->tt_work);
 749 }
 750 EXPORT_SYMBOL(iwl_tt_handler);
 751
 752 /* Thermal throttling initialization
 753  * For advance thermal throttling:
 754  *     Initialize Thermal Index and temperature threshold table
 755  *     Initialize thermal throttling restriction table
 756  */
 757 void iwl_tt_initialize(struct iwl_priv *priv)
 758 {
 759         struct iwl_tt_mgmt *tt = &priv->power_data.tt;
 760         struct iwl_power_mgr *setting = &priv->power_data;
 761         int size = sizeof(struct iwl_tt_trans) * (IWL_TI_STATE_MAX - 1);
 762         struct iwl_tt_trans *transaction;
 763
 764         IWL_DEBUG_POWER(priv, "Initialize Thermal Throttling \n");
 765
 766         memset(tt, 0, sizeof(struct iwl_tt_mgmt));
 767
 768         tt->state = IWL_TI_0;
 769         tt->sys_power_mode = setting->power_mode;
 770         tt->tt_power_mode = tt->sys_power_mode;
 771         init_timer(&priv->power_data.ct_kill_exit_tm);
 772         priv->power_data.ct_kill_exit_tm.data = (unsigned long)priv;
 773         priv->power_data.ct_kill_exit_tm.function = iwl_tt_check_exit_ct_kill;
 774
 775         /* setup deferred ct kill work */
 776         INIT_WORK(&priv->tt_work, iwl_bg_tt_work);
 777         INIT_WORK(&priv->ct_enter, iwl_bg_ct_enter);
 778         INIT_WORK(&priv->ct_exit, iwl_bg_ct_exit);
 779
 780         switch (priv->hw_rev & CSR_HW_REV_TYPE_MSK) {
 781         case CSR_HW_REV_TYPE_6x00:
 782         case CSR_HW_REV_TYPE_6x50:
 783                 IWL_DEBUG_POWER(priv, "Advanced Thermal Throttling\n");
 784                 tt->restriction = kzalloc(sizeof(struct iwl_tt_restriction) *
 785                                          IWL_TI_STATE_MAX, GFP_KERNEL);
 786                 tt->transaction = kzalloc(sizeof(struct iwl_tt_trans) *
 787                         IWL_TI_STATE_MAX * (IWL_TI_STATE_MAX - 1),
 788                         GFP_KERNEL);
 789                 if (!tt->restriction || !tt->transaction) {
 790                         IWL_ERR(priv, "Fallback to Legacy Throttling\n");
 791                         priv->power_data.adv_tt = false;
 792                         kfree(tt->restriction);
 793                         tt->restriction = NULL;
 794                         kfree(tt->transaction);
 795                         tt->transaction = NULL;
 796                 } else {
 797                         transaction = tt->transaction +
 798                                 (IWL_TI_0 * (IWL_TI_STATE_MAX - 1));
 799                         memcpy(transaction, &tt_range_0[0], size);
 800                         transaction = tt->transaction +
 801                                 (IWL_TI_1 * (IWL_TI_STATE_MAX - 1));
 802                         memcpy(transaction, &tt_range_1[0], size);
 803                         transaction = tt->transaction +
 804                                 (IWL_TI_2 * (IWL_TI_STATE_MAX - 1));
 805                         memcpy(transaction, &tt_range_2[0], size);
 806                         transaction = tt->transaction +
 807                                 (IWL_TI_CT_KILL * (IWL_TI_STATE_MAX - 1));
 808                         memcpy(transaction, &tt_range_3[0], size);
 809                         size = sizeof(struct iwl_tt_restriction) *
 810                                 IWL_TI_STATE_MAX;
 811                         memcpy(tt->restriction,
 812                                 &restriction_range[0], size);
 813                         priv->power_data.adv_tt = true;
 814                 }
 815                 break;
 816         default:
 817                 IWL_DEBUG_POWER(priv, "Legacy Thermal Throttling\n");
 818                 priv->power_data.adv_tt = false;
 819                 break;
 820         }
 821 }
 822 EXPORT_SYMBOL(iwl_tt_initialize);
 823
 824 /* cleanup thermal throttling management related memory and timer */
 825 void iwl_tt_exit(struct iwl_priv *priv)
 826 {
 827         struct iwl_tt_mgmt *tt = &priv->power_data.tt;
 828
 829         /* stop ct_kill_exit_tm timer if activated */
 830         del_timer_sync(&priv->power_data.ct_kill_exit_tm);
 831         cancel_work_sync(&priv->tt_work);
 832         cancel_work_sync(&priv->ct_enter);
 833         cancel_work_sync(&priv->ct_exit);
 834
 835         if (priv->power_data.adv_tt) {
 836                 /* free advance thermal throttling memory */
 837                 kfree(tt->restriction);
 838                 tt->restriction = NULL;
 839                 kfree(tt->transaction);
 840                 tt->transaction = NULL;
 841         }
 842 }
 843 EXPORT_SYMBOL(iwl_tt_exit);
 844
 845 /* initialize to default */
 846 void iwl_power_initialize(struct iwl_priv *priv)
 847 {
 848         iwl_power_init_handle(priv);
 849         priv->power_data.user_power_setting = IWL_POWER_INDEX_1;
 850         /* default to disabled until mac80211 says otherwise */
 851         priv->power_data.power_disabled = 1;
 852 }
 853 EXPORT_SYMBOL(iwl_power_initialize);