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

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