drivers/net/wireless/iwlwifi/iwl-agn-tt.c

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