drivers/net/wireless/iwlwifi/dvm/tt.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2014 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/slab.h>
  33 #include <net/mac80211.h>
  34 #include "iwl-io.h"
  35 #include "iwl-modparams.h"
  36 #include "iwl-debug.h"
  37 #include "agn.h"
  38 #include "dev.h"
  39 #include "commands.h"
  40 #include "tt.h"
  41
  42 /* default Thermal Throttling transaction table
  43  * Current state   |         Throttling Down               |  Throttling Up
  44  *=============================================================================
  45  *                 Condition Nxt State  Condition Nxt State Condition Nxt State
  46  *-----------------------------------------------------------------------------
  47  *     IWL_TI_0     T >= 114   CT_KILL  114>T>=105   TI_1      N/A      N/A
  48  *     IWL_TI_1     T >= 114   CT_KILL  114>T>=110   TI_2     T<=95     TI_0
  49  *     IWL_TI_2     T >= 114   CT_KILL                        T<=100    TI_1
  50  *    IWL_CT_KILL      N/A       N/A       N/A        N/A     T<=95     TI_0
  51  *=============================================================================
  52  */
  53 static const struct iwl_tt_trans tt_range_0[IWL_TI_STATE_MAX - 1] = {
  54         {IWL_TI_0, IWL_ABSOLUTE_ZERO, 104},
  55         {IWL_TI_1, 105, CT_KILL_THRESHOLD - 1},
  56         {IWL_TI_CT_KILL, CT_KILL_THRESHOLD, IWL_ABSOLUTE_MAX}
  57 };
  58 static const struct iwl_tt_trans tt_range_1[IWL_TI_STATE_MAX - 1] = {
  59         {IWL_TI_0, IWL_ABSOLUTE_ZERO, 95},
  60         {IWL_TI_2, 110, CT_KILL_THRESHOLD - 1},
  61         {IWL_TI_CT_KILL, CT_KILL_THRESHOLD, IWL_ABSOLUTE_MAX}
  62 };
  63 static const struct iwl_tt_trans tt_range_2[IWL_TI_STATE_MAX - 1] = {
  64         {IWL_TI_1, IWL_ABSOLUTE_ZERO, 100},
  65         {IWL_TI_CT_KILL, CT_KILL_THRESHOLD, IWL_ABSOLUTE_MAX},
  66         {IWL_TI_CT_KILL, CT_KILL_THRESHOLD, IWL_ABSOLUTE_MAX}
  67 };
  68 static const struct iwl_tt_trans tt_range_3[IWL_TI_STATE_MAX - 1] = {
  69         {IWL_TI_0, IWL_ABSOLUTE_ZERO, CT_KILL_EXIT_THRESHOLD},
  70         {IWL_TI_CT_KILL, CT_KILL_EXIT_THRESHOLD + 1, IWL_ABSOLUTE_MAX},
  71         {IWL_TI_CT_KILL, CT_KILL_EXIT_THRESHOLD + 1, IWL_ABSOLUTE_MAX}
  72 };
  73
  74 /* Advance Thermal Throttling default restriction table */
  75 static const struct iwl_tt_restriction restriction_range[IWL_TI_STATE_MAX] = {
  76         {IWL_ANT_OK_MULTI, IWL_ANT_OK_MULTI, true },
  77         {IWL_ANT_OK_SINGLE, IWL_ANT_OK_MULTI, true },
  78         {IWL_ANT_OK_SINGLE, IWL_ANT_OK_SINGLE, false },
  79         {IWL_ANT_OK_NONE, IWL_ANT_OK_NONE, false }
  80 };
  81
  82 bool iwl_tt_is_low_power_state(struct iwl_priv *priv)
  83 {
  84         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
  85
  86         if (tt->state >= IWL_TI_1)
  87                 return true;
  88         return false;
  89 }
  90
  91 u8 iwl_tt_current_power_mode(struct iwl_priv *priv)
  92 {
  93         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
  94
  95         return tt->tt_power_mode;
  96 }
  97
  98 bool iwl_ht_enabled(struct iwl_priv *priv)
  99 {
 100         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 101         struct iwl_tt_restriction *restriction;
 102
 103         if (!priv->thermal_throttle.advanced_tt)
 104                 return true;
 105         restriction = tt->restriction + tt->state;
 106         return restriction->is_ht;
 107 }
 108
 109 static bool iwl_within_ct_kill_margin(struct iwl_priv *priv)
 110 {
 111         s32 temp = priv->temperature; /* degrees CELSIUS except specified */
 112         bool within_margin = false;
 113
 114         if (!priv->thermal_throttle.advanced_tt)
 115                 within_margin = ((temp + IWL_TT_CT_KILL_MARGIN) >=
 116                                 CT_KILL_THRESHOLD_LEGACY) ? true : false;
 117         else
 118                 within_margin = ((temp + IWL_TT_CT_KILL_MARGIN) >=
 119                                 CT_KILL_THRESHOLD) ? true : false;
 120         return within_margin;
 121 }
 122
 123 bool iwl_check_for_ct_kill(struct iwl_priv *priv)
 124 {
 125         bool is_ct_kill = false;
 126
 127         if (iwl_within_ct_kill_margin(priv)) {
 128                 iwl_tt_enter_ct_kill(priv);
 129                 is_ct_kill = true;
 130         }
 131         return is_ct_kill;
 132 }
 133
 134 enum iwl_antenna_ok iwl_tx_ant_restriction(struct iwl_priv *priv)
 135 {
 136         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 137         struct iwl_tt_restriction *restriction;
 138
 139         if (!priv->thermal_throttle.advanced_tt)
 140                 return IWL_ANT_OK_MULTI;
 141         restriction = tt->restriction + tt->state;
 142         return restriction->tx_stream;
 143 }
 144
 145 enum iwl_antenna_ok iwl_rx_ant_restriction(struct iwl_priv *priv)
 146 {
 147         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 148         struct iwl_tt_restriction *restriction;
 149
 150         if (!priv->thermal_throttle.advanced_tt)
 151                 return IWL_ANT_OK_MULTI;
 152         restriction = tt->restriction + tt->state;
 153         return restriction->rx_stream;
 154 }
 155
 156 #define CT_KILL_EXIT_DURATION (5)       /* 5 seconds duration */
 157 #define CT_KILL_WAITING_DURATION (300)  /* 300ms duration */
 158
 159 /*
 160  * toggle the bit to wake up uCode and check the temperature
 161  * if the temperature is below CT, uCode will stay awake and send card
 162  * state notification with CT_KILL bit clear to inform Thermal Throttling
 163  * Management to change state. Otherwise, uCode will go back to sleep
 164  * without doing anything, driver should continue the 5 seconds timer
 165  * to wake up uCode for temperature check until temperature drop below CT
 166  */
 167 static void iwl_tt_check_exit_ct_kill(unsigned long data)
 168 {
 169         struct iwl_priv *priv = (struct iwl_priv *)data;
 170         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 171         unsigned long flags;
 172
 173         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 174                 return;
 175
 176         if (tt->state == IWL_TI_CT_KILL) {
 177                 if (priv->thermal_throttle.ct_kill_toggle) {
 178                         iwl_write32(priv->trans, CSR_UCODE_DRV_GP1_CLR,
 179                                     CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
 180                         priv->thermal_throttle.ct_kill_toggle = false;
 181                 } else {
 182                         iwl_write32(priv->trans, CSR_UCODE_DRV_GP1_SET,
 183                                     CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
 184                         priv->thermal_throttle.ct_kill_toggle = true;
 185                 }
 186                 iwl_read32(priv->trans, CSR_UCODE_DRV_GP1);
 187                 if (iwl_trans_grab_nic_access(priv->trans, false, &flags))
 188                         iwl_trans_release_nic_access(priv->trans, &flags);
 189
 190                 /* Reschedule the ct_kill timer to occur in
 191                  * CT_KILL_EXIT_DURATION seconds to ensure we get a
 192                  * thermal update */
 193                 IWL_DEBUG_TEMP(priv, "schedule ct_kill exit timer\n");
 194                 mod_timer(&priv->thermal_throttle.ct_kill_exit_tm,
 195                           jiffies + CT_KILL_EXIT_DURATION * HZ);
 196         }
 197 }
 198
 199 static void iwl_perform_ct_kill_task(struct iwl_priv *priv,
 200                            bool stop)
 201 {
 202         if (stop) {
 203                 IWL_DEBUG_TEMP(priv, "Stop all queues\n");
 204                 if (priv->mac80211_registered)
 205                         ieee80211_stop_queues(priv->hw);
 206                 IWL_DEBUG_TEMP(priv,
 207                                 "Schedule 5 seconds CT_KILL Timer\n");
 208                 mod_timer(&priv->thermal_throttle.ct_kill_exit_tm,
 209                           jiffies + CT_KILL_EXIT_DURATION * HZ);
 210         } else {
 211                 IWL_DEBUG_TEMP(priv, "Wake all queues\n");
 212                 if (priv->mac80211_registered)
 213                         ieee80211_wake_queues(priv->hw);
 214         }
 215 }
 216
 217 static void iwl_tt_ready_for_ct_kill(unsigned long data)
 218 {
 219         struct iwl_priv *priv = (struct iwl_priv *)data;
 220         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 221
 222         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 223                 return;
 224
 225         /* temperature timer expired, ready to go into CT_KILL state */
 226         if (tt->state != IWL_TI_CT_KILL) {
 227                 IWL_DEBUG_TEMP(priv, "entering CT_KILL state when "
 228                                 "temperature timer expired\n");
 229                 tt->state = IWL_TI_CT_KILL;
 230                 set_bit(STATUS_CT_KILL, &priv->status);
 231                 iwl_perform_ct_kill_task(priv, true);
 232         }
 233 }
 234
 235 static void iwl_prepare_ct_kill_task(struct iwl_priv *priv)
 236 {
 237         IWL_DEBUG_TEMP(priv, "Prepare to enter IWL_TI_CT_KILL\n");
 238         /* make request to retrieve statistics information */
 239         iwl_send_statistics_request(priv, 0, false);
 240         /* Reschedule the ct_kill wait timer */
 241         mod_timer(&priv->thermal_throttle.ct_kill_waiting_tm,
 242                  jiffies + msecs_to_jiffies(CT_KILL_WAITING_DURATION));
 243 }
 244
 245 #define IWL_MINIMAL_POWER_THRESHOLD             (CT_KILL_THRESHOLD_LEGACY)
 246 #define IWL_REDUCED_PERFORMANCE_THRESHOLD_2     (100)
 247 #define IWL_REDUCED_PERFORMANCE_THRESHOLD_1     (90)
 248
 249 /*
 250  * Legacy thermal throttling
 251  * 1) Avoid NIC destruction due to high temperatures
 252  *      Chip will identify dangerously high temperatures that can
 253  *      harm the device and will power down
 254  * 2) Avoid the NIC power down due to high temperature
 255  *      Throttle early enough to lower the power consumption before
 256  *      drastic steps are needed
 257  */
 258 static void iwl_legacy_tt_handler(struct iwl_priv *priv, s32 temp, bool force)
 259 {
 260         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 261         enum iwl_tt_state old_state;
 262
 263 #ifdef CONFIG_IWLWIFI_DEBUG
 264         if ((tt->tt_previous_temp) &&
 265             (temp > tt->tt_previous_temp) &&
 266             ((temp - tt->tt_previous_temp) >
 267             IWL_TT_INCREASE_MARGIN)) {
 268                 IWL_DEBUG_TEMP(priv,
 269                         "Temperature increase %d degree Celsius\n",
 270                         (temp - tt->tt_previous_temp));
 271         }
 272 #endif
 273         old_state = tt->state;
 274         /* in Celsius */
 275         if (temp >= IWL_MINIMAL_POWER_THRESHOLD)
 276                 tt->state = IWL_TI_CT_KILL;
 277         else if (temp >= IWL_REDUCED_PERFORMANCE_THRESHOLD_2)
 278                 tt->state = IWL_TI_2;
 279         else if (temp >= IWL_REDUCED_PERFORMANCE_THRESHOLD_1)
 280                 tt->state = IWL_TI_1;
 281         else
 282                 tt->state = IWL_TI_0;
 283
 284 #ifdef CONFIG_IWLWIFI_DEBUG
 285         tt->tt_previous_temp = temp;
 286 #endif
 287         /* stop ct_kill_waiting_tm timer */
 288         del_timer_sync(&priv->thermal_throttle.ct_kill_waiting_tm);
 289         if (tt->state != old_state) {
 290                 switch (tt->state) {
 291                 case IWL_TI_0:
 292                         /*
 293                          * When the system is ready to go back to IWL_TI_0
 294                          * we only have to call iwl_power_update_mode() to
 295                          * do so.
 296                          */
 297                         break;
 298                 case IWL_TI_1:
 299                         tt->tt_power_mode = IWL_POWER_INDEX_3;
 300                         break;
 301                 case IWL_TI_2:
 302                         tt->tt_power_mode = IWL_POWER_INDEX_4;
 303                         break;
 304                 default:
 305                         tt->tt_power_mode = IWL_POWER_INDEX_5;
 306                         break;
 307                 }
 308                 mutex_lock(&priv->mutex);
 309                 if (old_state == IWL_TI_CT_KILL)
 310                         clear_bit(STATUS_CT_KILL, &priv->status);
 311                 if (tt->state != IWL_TI_CT_KILL &&
 312                     iwl_power_update_mode(priv, true)) {
 313                         /* TT state not updated
 314                          * try again during next temperature read
 315                          */
 316                         if (old_state == IWL_TI_CT_KILL)
 317                                 set_bit(STATUS_CT_KILL, &priv->status);
 318                         tt->state = old_state;
 319                         IWL_ERR(priv, "Cannot update power mode, "
 320                                         "TT state not updated\n");
 321                 } else {
 322                         if (tt->state == IWL_TI_CT_KILL) {
 323                                 if (force) {
 324                                         set_bit(STATUS_CT_KILL, &priv->status);
 325                                         iwl_perform_ct_kill_task(priv, true);
 326                                 } else {
 327                                         iwl_prepare_ct_kill_task(priv);
 328                                         tt->state = old_state;
 329                                 }
 330                         } else if (old_state == IWL_TI_CT_KILL &&
 331                                  tt->state != IWL_TI_CT_KILL)
 332                                 iwl_perform_ct_kill_task(priv, false);
 333                         IWL_DEBUG_TEMP(priv, "Temperature state changed %u\n",
 334                                         tt->state);
 335                         IWL_DEBUG_TEMP(priv, "Power Index change to %u\n",
 336                                         tt->tt_power_mode);
 337                 }
 338                 mutex_unlock(&priv->mutex);
 339         }
 340 }
 341
 342 /*
 343  * Advance thermal throttling
 344  * 1) Avoid NIC destruction due to high temperatures
 345  *      Chip will identify dangerously high temperatures that can
 346  *      harm the device and will power down
 347  * 2) Avoid the NIC power down due to high temperature
 348  *      Throttle early enough to lower the power consumption before
 349  *      drastic steps are needed
 350  *      Actions include relaxing the power down sleep thresholds and
 351  *      decreasing the number of TX streams
 352  * 3) Avoid throughput performance impact as much as possible
 353  *
 354  *=============================================================================
 355  *                 Condition Nxt State  Condition Nxt State Condition Nxt State
 356  *-----------------------------------------------------------------------------
 357  *     IWL_TI_0     T >= 114   CT_KILL  114>T>=105   TI_1      N/A      N/A
 358  *     IWL_TI_1     T >= 114   CT_KILL  114>T>=110   TI_2     T<=95     TI_0
 359  *     IWL_TI_2     T >= 114   CT_KILL                        T<=100    TI_1
 360  *    IWL_CT_KILL      N/A       N/A       N/A        N/A     T<=95     TI_0
 361  *=============================================================================
 362  */
 363 static void iwl_advance_tt_handler(struct iwl_priv *priv, s32 temp, bool force)
 364 {
 365         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 366         int i;
 367         bool changed = false;
 368         enum iwl_tt_state old_state;
 369         struct iwl_tt_trans *transaction;
 370
 371         old_state = tt->state;
 372         for (i = 0; i < IWL_TI_STATE_MAX - 1; i++) {
 373                 /* based on the current TT state,
 374                  * find the curresponding transaction table
 375                  * each table has (IWL_TI_STATE_MAX - 1) entries
 376                  * tt->transaction + ((old_state * (IWL_TI_STATE_MAX - 1))
 377                  * will advance to the correct table.
 378                  * then based on the current temperature
 379                  * find the next state need to transaction to
 380                  * go through all the possible (IWL_TI_STATE_MAX - 1) entries
 381                  * in the current table to see if transaction is needed
 382                  */
 383                 transaction = tt->transaction +
 384                         ((old_state * (IWL_TI_STATE_MAX - 1)) + i);
 385                 if (temp >= transaction->tt_low &&
 386                     temp <= transaction->tt_high) {
 387 #ifdef CONFIG_IWLWIFI_DEBUG
 388                         if ((tt->tt_previous_temp) &&
 389                             (temp > tt->tt_previous_temp) &&
 390                             ((temp - tt->tt_previous_temp) >
 391                             IWL_TT_INCREASE_MARGIN)) {
 392                                 IWL_DEBUG_TEMP(priv,
 393                                         "Temperature increase %d "
 394                                         "degree Celsius\n",
 395                                         (temp - tt->tt_previous_temp));
 396                         }
 397                         tt->tt_previous_temp = temp;
 398 #endif
 399                         if (old_state !=
 400                             transaction->next_state) {
 401                                 changed = true;
 402                                 tt->state =
 403                                         transaction->next_state;
 404                         }
 405                         break;
 406                 }
 407         }
 408         /* stop ct_kill_waiting_tm timer */
 409         del_timer_sync(&priv->thermal_throttle.ct_kill_waiting_tm);
 410         if (changed) {
 411                 if (tt->state >= IWL_TI_1) {
 412                         /* force PI = IWL_POWER_INDEX_5 in the case of TI > 0 */
 413                         tt->tt_power_mode = IWL_POWER_INDEX_5;
 414
 415                         if (!iwl_ht_enabled(priv)) {
 416                                 struct iwl_rxon_context *ctx;
 417
 418                                 for_each_context(priv, ctx) {
 419                                         struct iwl_rxon_cmd *rxon;
 420
 421                                         rxon = &ctx->staging;
 422
 423                                         /* disable HT */
 424                                         rxon->flags &= ~(
 425                                                 RXON_FLG_CHANNEL_MODE_MSK |
 426                                                 RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK |
 427                                                 RXON_FLG_HT40_PROT_MSK |
 428                                                 RXON_FLG_HT_PROT_MSK);
 429                                 }
 430                         } else {
 431                                 /* check HT capability and set
 432                                  * according to the system HT capability
 433                                  * in case get disabled before */
 434                                 iwl_set_rxon_ht(priv, &priv->current_ht_config);
 435                         }
 436
 437                 } else {
 438                         /*
 439                          * restore system power setting -- it will be
 440                          * recalculated automatically.
 441                          */
 442
 443                         /* check HT capability and set
 444                          * according to the system HT capability
 445                          * in case get disabled before */
 446                         iwl_set_rxon_ht(priv, &priv->current_ht_config);
 447                 }
 448                 mutex_lock(&priv->mutex);
 449                 if (old_state == IWL_TI_CT_KILL)
 450                         clear_bit(STATUS_CT_KILL, &priv->status);
 451                 if (tt->state != IWL_TI_CT_KILL &&
 452                     iwl_power_update_mode(priv, true)) {
 453                         /* TT state not updated
 454                          * try again during next temperature read
 455                          */
 456                         IWL_ERR(priv, "Cannot update power mode, "
 457                                         "TT state not updated\n");
 458                         if (old_state == IWL_TI_CT_KILL)
 459                                 set_bit(STATUS_CT_KILL, &priv->status);
 460                         tt->state = old_state;
 461                 } else {
 462                         IWL_DEBUG_TEMP(priv,
 463                                         "Thermal Throttling to new state: %u\n",
 464                                         tt->state);
 465                         if (old_state != IWL_TI_CT_KILL &&
 466                             tt->state == IWL_TI_CT_KILL) {
 467                                 if (force) {
 468                                         IWL_DEBUG_TEMP(priv,
 469                                                 "Enter IWL_TI_CT_KILL\n");
 470                                         set_bit(STATUS_CT_KILL, &priv->status);
 471                                         iwl_perform_ct_kill_task(priv, true);
 472                                 } else {
 473                                         tt->state = old_state;
 474                                         iwl_prepare_ct_kill_task(priv);
 475                                 }
 476                         } else if (old_state == IWL_TI_CT_KILL &&
 477                                   tt->state != IWL_TI_CT_KILL) {
 478                                 IWL_DEBUG_TEMP(priv, "Exit IWL_TI_CT_KILL\n");
 479                                 iwl_perform_ct_kill_task(priv, false);
 480                         }
 481                 }
 482                 mutex_unlock(&priv->mutex);
 483         }
 484 }
 485
 486 /* Card State Notification indicated reach critical temperature
 487  * if PSP not enable, no Thermal Throttling function will be performed
 488  * just set the GP1 bit to acknowledge the event
 489  * otherwise, go into IWL_TI_CT_KILL state
 490  * since Card State Notification will not provide any temperature reading
 491  * for Legacy mode
 492  * so just pass the CT_KILL temperature to iwl_legacy_tt_handler()
 493  * for advance mode
 494  * pass CT_KILL_THRESHOLD+1 to make sure move into IWL_TI_CT_KILL state
 495  */
 496 static void iwl_bg_ct_enter(struct work_struct *work)
 497 {
 498         struct iwl_priv *priv = container_of(work, struct iwl_priv, ct_enter);
 499         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 500
 501         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 502                 return;
 503
 504         if (!iwl_is_ready(priv))
 505                 return;
 506
 507         if (tt->state != IWL_TI_CT_KILL) {
 508                 IWL_ERR(priv, "Device reached critical temperature "
 509                               "- ucode going to sleep!\n");
 510                 if (!priv->thermal_throttle.advanced_tt)
 511                         iwl_legacy_tt_handler(priv,
 512                                               IWL_MINIMAL_POWER_THRESHOLD,
 513                                               true);
 514                 else
 515                         iwl_advance_tt_handler(priv,
 516                                                CT_KILL_THRESHOLD + 1, true);
 517         }
 518 }
 519
 520 /* Card State Notification indicated out of critical temperature
 521  * since Card State Notification will not provide any temperature reading
 522  * so pass the IWL_REDUCED_PERFORMANCE_THRESHOLD_2 temperature
 523  * to iwl_legacy_tt_handler() to get out of IWL_CT_KILL state
 524  */
 525 static void iwl_bg_ct_exit(struct work_struct *work)
 526 {
 527         struct iwl_priv *priv = container_of(work, struct iwl_priv, ct_exit);
 528         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 529
 530         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 531                 return;
 532
 533         if (!iwl_is_ready(priv))
 534                 return;
 535
 536         /* stop ct_kill_exit_tm timer */
 537         del_timer_sync(&priv->thermal_throttle.ct_kill_exit_tm);
 538
 539         if (tt->state == IWL_TI_CT_KILL) {
 540                 IWL_ERR(priv,
 541                         "Device temperature below critical"
 542                         "- ucode awake!\n");
 543                 /*
 544                  * exit from CT_KILL state
 545                  * reset the current temperature reading
 546                  */
 547                 priv->temperature = 0;
 548                 if (!priv->thermal_throttle.advanced_tt)
 549                         iwl_legacy_tt_handler(priv,
 550                                       IWL_REDUCED_PERFORMANCE_THRESHOLD_2,
 551                                       true);
 552                 else
 553                         iwl_advance_tt_handler(priv, CT_KILL_EXIT_THRESHOLD,
 554                                                true);
 555         }
 556 }
 557
 558 void iwl_tt_enter_ct_kill(struct iwl_priv *priv)
 559 {
 560         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 561                 return;
 562
 563         IWL_DEBUG_TEMP(priv, "Queueing critical temperature enter.\n");
 564         queue_work(priv->workqueue, &priv->ct_enter);
 565 }
 566
 567 void iwl_tt_exit_ct_kill(struct iwl_priv *priv)
 568 {
 569         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 570                 return;
 571
 572         IWL_DEBUG_TEMP(priv, "Queueing critical temperature exit.\n");
 573         queue_work(priv->workqueue, &priv->ct_exit);
 574 }
 575
 576 static void iwl_bg_tt_work(struct work_struct *work)
 577 {
 578         struct iwl_priv *priv = container_of(work, struct iwl_priv, tt_work);
 579         s32 temp = priv->temperature; /* degrees CELSIUS except specified */
 580
 581         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 582                 return;
 583
 584         if (!priv->thermal_throttle.advanced_tt)
 585                 iwl_legacy_tt_handler(priv, temp, false);
 586         else
 587                 iwl_advance_tt_handler(priv, temp, false);
 588 }
 589
 590 void iwl_tt_handler(struct iwl_priv *priv)
 591 {
 592         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 593                 return;
 594
 595         IWL_DEBUG_TEMP(priv, "Queueing thermal throttling work.\n");
 596         queue_work(priv->workqueue, &priv->tt_work);
 597 }
 598
 599 /* Thermal throttling initialization
 600  * For advance thermal throttling:
 601  *     Initialize Thermal Index and temperature threshold table
 602  *     Initialize thermal throttling restriction table
 603  */
 604 void iwl_tt_initialize(struct iwl_priv *priv)
 605 {
 606         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 607         int size = sizeof(struct iwl_tt_trans) * (IWL_TI_STATE_MAX - 1);
 608         struct iwl_tt_trans *transaction;
 609
 610         IWL_DEBUG_TEMP(priv, "Initialize Thermal Throttling\n");
 611
 612         memset(tt, 0, sizeof(struct iwl_tt_mgmt));
 613
 614         tt->state = IWL_TI_0;
 615         setup_timer(&priv->thermal_throttle.ct_kill_exit_tm,
 616                     iwl_tt_check_exit_ct_kill, (unsigned long)priv);
 617         setup_timer(&priv->thermal_throttle.ct_kill_waiting_tm,
 618                     iwl_tt_ready_for_ct_kill, (unsigned long)priv);
 619         /* setup deferred ct kill work */
 620         INIT_WORK(&priv->tt_work, iwl_bg_tt_work);
 621         INIT_WORK(&priv->ct_enter, iwl_bg_ct_enter);
 622         INIT_WORK(&priv->ct_exit, iwl_bg_ct_exit);
 623
 624         if (priv->lib->adv_thermal_throttle) {
 625                 IWL_DEBUG_TEMP(priv, "Advanced Thermal Throttling\n");
 626                 tt->restriction = kcalloc(IWL_TI_STATE_MAX,
 627                                           sizeof(struct iwl_tt_restriction),
 628                                           GFP_KERNEL);
 629                 tt->transaction = kcalloc(IWL_TI_STATE_MAX *
 630                                           (IWL_TI_STATE_MAX - 1),
 631                                           sizeof(struct iwl_tt_trans),
 632                                           GFP_KERNEL);
 633                 if (!tt->restriction || !tt->transaction) {
 634                         IWL_ERR(priv, "Fallback to Legacy Throttling\n");
 635                         priv->thermal_throttle.advanced_tt = false;
 636                         kfree(tt->restriction);
 637                         tt->restriction = NULL;
 638                         kfree(tt->transaction);
 639                         tt->transaction = NULL;
 640                 } else {
 641                         transaction = tt->transaction +
 642                                 (IWL_TI_0 * (IWL_TI_STATE_MAX - 1));
 643                         memcpy(transaction, &tt_range_0[0], size);
 644                         transaction = tt->transaction +
 645                                 (IWL_TI_1 * (IWL_TI_STATE_MAX - 1));
 646                         memcpy(transaction, &tt_range_1[0], size);
 647                         transaction = tt->transaction +
 648                                 (IWL_TI_2 * (IWL_TI_STATE_MAX - 1));
 649                         memcpy(transaction, &tt_range_2[0], size);
 650                         transaction = tt->transaction +
 651                                 (IWL_TI_CT_KILL * (IWL_TI_STATE_MAX - 1));
 652                         memcpy(transaction, &tt_range_3[0], size);
 653                         size = sizeof(struct iwl_tt_restriction) *
 654                                 IWL_TI_STATE_MAX;
 655                         memcpy(tt->restriction,
 656                                 &restriction_range[0], size);
 657                         priv->thermal_throttle.advanced_tt = true;
 658                 }
 659         } else {
 660                 IWL_DEBUG_TEMP(priv, "Legacy Thermal Throttling\n");
 661                 priv->thermal_throttle.advanced_tt = false;
 662         }
 663 }
 664
 665 /* cleanup thermal throttling management related memory and timer */
 666 void iwl_tt_exit(struct iwl_priv *priv)
 667 {
 668         struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
 669
 670         /* stop ct_kill_exit_tm timer if activated */
 671         del_timer_sync(&priv->thermal_throttle.ct_kill_exit_tm);
 672         /* stop ct_kill_waiting_tm timer if activated */
 673         del_timer_sync(&priv->thermal_throttle.ct_kill_waiting_tm);
 674         cancel_work_sync(&priv->tt_work);
 675         cancel_work_sync(&priv->ct_enter);
 676         cancel_work_sync(&priv->ct_exit);
 677
 678         if (priv->thermal_throttle.advanced_tt) {
 679                 /* free advance thermal throttling memory */
 680                 kfree(tt->restriction);
 681                 tt->restriction = NULL;
 682                 kfree(tt->transaction);
 683                 tt->transaction = NULL;
 684         }
 685 }