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 }
669