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