1 /******************************************************************************
3 * Copyright(c) 2007 - 2012 Intel Corporation. All rights reserved.
5 * Portions of this file are derived from the ipw3945 project, as well
6 * as portions of the ieee80211 subsystem header files.
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.
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
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
21 * The full GNU General Public License is included in this distribution in the
22 * file called LICENSE.
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 *****************************************************************************/
30 #include <linux/kernel.h>
31 #include <linux/module.h>
32 #include <linux/slab.h>
33 #include <linux/init.h>
35 #include <net/mac80211.h>
38 #include "iwl-eeprom.h"
41 #include "iwl-commands.h"
42 #include "iwl-debug.h"
43 #include "iwl-agn-tt.h"
44 #include "iwl-modparams.h"
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 *=============================================================================
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
}
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
}
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
}
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
}
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 }
86 bool iwl_tt_is_low_power_state(struct iwl_priv
*priv
)
88 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
90 if (tt
->state
>= IWL_TI_1
)
95 u8
iwl_tt_current_power_mode(struct iwl_priv
*priv
)
97 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
99 return tt
->tt_power_mode
;
102 bool iwl_ht_enabled(struct iwl_priv
*priv
)
104 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
105 struct iwl_tt_restriction
*restriction
;
107 if (!priv
->thermal_throttle
.advanced_tt
)
109 restriction
= tt
->restriction
+ tt
->state
;
110 return restriction
->is_ht
;
113 static bool iwl_within_ct_kill_margin(struct iwl_priv
*priv
)
115 s32 temp
= priv
->temperature
; /* degrees CELSIUS except specified */
116 bool within_margin
= false;
118 if (!priv
->thermal_throttle
.advanced_tt
)
119 within_margin
= ((temp
+ IWL_TT_CT_KILL_MARGIN
) >=
120 CT_KILL_THRESHOLD_LEGACY
) ? true : false;
122 within_margin
= ((temp
+ IWL_TT_CT_KILL_MARGIN
) >=
123 CT_KILL_THRESHOLD
) ? true : false;
124 return within_margin
;
127 bool iwl_check_for_ct_kill(struct iwl_priv
*priv
)
129 bool is_ct_kill
= false;
131 if (iwl_within_ct_kill_margin(priv
)) {
132 iwl_tt_enter_ct_kill(priv
);
138 enum iwl_antenna_ok
iwl_tx_ant_restriction(struct iwl_priv
*priv
)
140 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
141 struct iwl_tt_restriction
*restriction
;
143 if (!priv
->thermal_throttle
.advanced_tt
)
144 return IWL_ANT_OK_MULTI
;
145 restriction
= tt
->restriction
+ tt
->state
;
146 return restriction
->tx_stream
;
149 enum iwl_antenna_ok
iwl_rx_ant_restriction(struct iwl_priv
*priv
)
151 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
152 struct iwl_tt_restriction
*restriction
;
154 if (!priv
->thermal_throttle
.advanced_tt
)
155 return IWL_ANT_OK_MULTI
;
156 restriction
= tt
->restriction
+ tt
->state
;
157 return restriction
->rx_stream
;
160 #define CT_KILL_EXIT_DURATION (5) /* 5 seconds duration */
161 #define CT_KILL_WAITING_DURATION (300) /* 300ms duration */
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
171 static void iwl_tt_check_exit_ct_kill(unsigned long data
)
173 struct iwl_priv
*priv
= (struct iwl_priv
*)data
;
174 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
177 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
180 if (tt
->state
== IWL_TI_CT_KILL
) {
181 if (priv
->thermal_throttle
.ct_kill_toggle
) {
182 iwl_write32(priv
->trans
, CSR_UCODE_DRV_GP1_CLR
,
183 CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT
);
184 priv
->thermal_throttle
.ct_kill_toggle
= false;
186 iwl_write32(priv
->trans
, CSR_UCODE_DRV_GP1_SET
,
187 CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT
);
188 priv
->thermal_throttle
.ct_kill_toggle
= true;
190 iwl_read32(priv
->trans
, CSR_UCODE_DRV_GP1
);
191 spin_lock_irqsave(&priv
->trans
->reg_lock
, flags
);
192 if (likely(iwl_grab_nic_access(priv
->trans
)))
193 iwl_release_nic_access(priv
->trans
);
194 spin_unlock_irqrestore(&priv
->trans
->reg_lock
, flags
);
196 /* Reschedule the ct_kill timer to occur in
197 * CT_KILL_EXIT_DURATION seconds to ensure we get a
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
);
205 static void iwl_perform_ct_kill_task(struct iwl_priv
*priv
,
209 IWL_DEBUG_TEMP(priv
, "Stop all queues\n");
210 if (priv
->mac80211_registered
)
211 ieee80211_stop_queues(priv
->hw
);
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
);
217 IWL_DEBUG_TEMP(priv
, "Wake all queues\n");
218 if (priv
->mac80211_registered
)
219 ieee80211_wake_queues(priv
->hw
);
223 static void iwl_tt_ready_for_ct_kill(unsigned long data
)
225 struct iwl_priv
*priv
= (struct iwl_priv
*)data
;
226 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
228 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
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);
241 static void iwl_prepare_ct_kill_task(struct iwl_priv
*priv
)
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
));
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)
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
264 static void iwl_legacy_tt_handler(struct iwl_priv
*priv
, s32 temp
, bool force
)
266 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
267 enum iwl_tt_state old_state
;
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
)) {
275 "Temperature increase %d degree Celsius\n",
276 (temp
- tt
->tt_previous_temp
));
279 old_state
= tt
->state
;
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
;
288 tt
->state
= IWL_TI_0
;
290 #ifdef CONFIG_IWLWIFI_DEBUG
291 tt
->tt_previous_temp
= temp
;
293 /* stop ct_kill_waiting_tm timer */
294 del_timer_sync(&priv
->thermal_throttle
.ct_kill_waiting_tm
);
295 if (tt
->state
!= old_state
) {
299 * When the system is ready to go back to IWL_TI_0
300 * we only have to call iwl_power_update_mode() to
305 tt
->tt_power_mode
= IWL_POWER_INDEX_3
;
308 tt
->tt_power_mode
= IWL_POWER_INDEX_4
;
311 tt
->tt_power_mode
= IWL_POWER_INDEX_5
;
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
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");
328 if (tt
->state
== IWL_TI_CT_KILL
) {
330 set_bit(STATUS_CT_KILL
, &priv
->status
);
331 iwl_perform_ct_kill_task(priv
, true);
333 iwl_prepare_ct_kill_task(priv
);
334 tt
->state
= old_state
;
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",
341 IWL_DEBUG_TEMP(priv
, "Power Index change to %u\n",
344 mutex_unlock(&priv
->mutex
);
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
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 *=============================================================================
369 static void iwl_advance_tt_handler(struct iwl_priv
*priv
, s32 temp
, bool force
)
371 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
373 bool changed
= false;
374 enum iwl_tt_state old_state
;
375 struct iwl_tt_trans
*transaction
;
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
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
)) {
399 "Temperature increase %d "
401 (temp
- tt
->tt_previous_temp
));
403 tt
->tt_previous_temp
= temp
;
406 transaction
->next_state
) {
409 transaction
->next_state
;
414 /* stop ct_kill_waiting_tm timer */
415 del_timer_sync(&priv
->thermal_throttle
.ct_kill_waiting_tm
);
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
;
421 if (!iwl_ht_enabled(priv
)) {
422 struct iwl_rxon_context
*ctx
;
424 for_each_context(priv
, ctx
) {
425 struct iwl_rxon_cmd
*rxon
;
427 rxon
= &ctx
->staging
;
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
);
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
);
445 * restore system power setting -- it will be
446 * recalculated automatically.
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
);
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
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
;
469 "Thermal Throttling to new state: %u\n",
471 if (old_state
!= IWL_TI_CT_KILL
&&
472 tt
->state
== IWL_TI_CT_KILL
) {
475 "Enter IWL_TI_CT_KILL\n");
476 set_bit(STATUS_CT_KILL
, &priv
->status
);
477 iwl_perform_ct_kill_task(priv
, true);
479 iwl_prepare_ct_kill_task(priv
);
480 tt
->state
= old_state
;
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);
488 mutex_unlock(&priv
->mutex
);
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
498 * so just pass the CT_KILL temperature to iwl_legacy_tt_handler()
500 * pass CT_KILL_THRESHOLD+1 to make sure move into IWL_TI_CT_KILL state
502 static void iwl_bg_ct_enter(struct work_struct
*work
)
504 struct iwl_priv
*priv
= container_of(work
, struct iwl_priv
, ct_enter
);
505 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
507 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
510 if (!iwl_is_ready(priv
))
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
,
521 iwl_advance_tt_handler(priv
,
522 CT_KILL_THRESHOLD
+ 1, true);
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
531 static void iwl_bg_ct_exit(struct work_struct
*work
)
533 struct iwl_priv
*priv
= container_of(work
, struct iwl_priv
, ct_exit
);
534 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
536 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
539 if (!iwl_is_ready(priv
))
542 /* stop ct_kill_exit_tm timer */
543 del_timer_sync(&priv
->thermal_throttle
.ct_kill_exit_tm
);
545 if (tt
->state
== IWL_TI_CT_KILL
) {
547 "Device temperature below critical"
550 * exit from CT_KILL state
551 * reset the current temperature reading
553 priv
->temperature
= 0;
554 if (!priv
->thermal_throttle
.advanced_tt
)
555 iwl_legacy_tt_handler(priv
,
556 IWL_REDUCED_PERFORMANCE_THRESHOLD_2
,
559 iwl_advance_tt_handler(priv
, CT_KILL_EXIT_THRESHOLD
,
564 void iwl_tt_enter_ct_kill(struct iwl_priv
*priv
)
566 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
569 IWL_DEBUG_TEMP(priv
, "Queueing critical temperature enter.\n");
570 queue_work(priv
->workqueue
, &priv
->ct_enter
);
573 void iwl_tt_exit_ct_kill(struct iwl_priv
*priv
)
575 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
578 IWL_DEBUG_TEMP(priv
, "Queueing critical temperature exit.\n");
579 queue_work(priv
->workqueue
, &priv
->ct_exit
);
582 static void iwl_bg_tt_work(struct work_struct
*work
)
584 struct iwl_priv
*priv
= container_of(work
, struct iwl_priv
, tt_work
);
585 s32 temp
= priv
->temperature
; /* degrees CELSIUS except specified */
587 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
590 if (!priv
->thermal_throttle
.advanced_tt
)
591 iwl_legacy_tt_handler(priv
, temp
, false);
593 iwl_advance_tt_handler(priv
, temp
, false);
596 void iwl_tt_handler(struct iwl_priv
*priv
)
598 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
601 IWL_DEBUG_TEMP(priv
, "Queueing thermal throttling work.\n");
602 queue_work(priv
->workqueue
, &priv
->tt_work
);
605 /* Thermal throttling initialization
606 * For advance thermal throttling:
607 * Initialize Thermal Index and temperature threshold table
608 * Initialize thermal throttling restriction table
610 void iwl_tt_initialize(struct iwl_priv
*priv
)
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
;
616 IWL_DEBUG_TEMP(priv
, "Initialize Thermal Throttling\n");
618 memset(tt
, 0, sizeof(struct iwl_tt_mgmt
));
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
=
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
);
635 if (priv
->cfg
->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
),
640 tt
->transaction
= kcalloc(IWL_TI_STATE_MAX
*
641 (IWL_TI_STATE_MAX
- 1),
642 sizeof(struct iwl_tt_trans
),
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
;
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
) *
666 memcpy(tt
->restriction
,
667 &restriction_range
[0], size
);
668 priv
->thermal_throttle
.advanced_tt
= true;
671 IWL_DEBUG_TEMP(priv
, "Legacy Thermal Throttling\n");
672 priv
->thermal_throttle
.advanced_tt
= false;
676 /* cleanup thermal throttling management related memory and timer */
677 void iwl_tt_exit(struct iwl_priv
*priv
)
679 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
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
);
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
;