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