1 /******************************************************************************
3 * Copyright(c) 2007 - 2010 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/init.h>
34 #include <net/mac80211.h>
36 #include "iwl-eeprom.h"
40 #include "iwl-commands.h"
41 #include "iwl-debug.h"
42 #include "iwl-power.h"
45 * Setting power level allows the card to go to sleep when not busy.
47 * We calculate a sleep command based on the required latency, which
48 * we get from mac80211. In order to handle thermal throttling, we can
49 * also use pre-defined power levels.
53 * For now, keep using power level 1 instead of automatically
56 bool no_sleep_autoadjust
= true;
57 module_param(no_sleep_autoadjust
, bool, S_IRUGO
);
58 MODULE_PARM_DESC(no_sleep_autoadjust
,
59 "don't automatically adjust sleep level "
60 "according to maximum network latency");
63 * This defines the old power levels. They are still used by default
64 * (level 1) and for thermal throttle (levels 3 through 5)
67 struct iwl_power_vec_entry
{
68 struct iwl_powertable_cmd cmd
;
69 u8 no_dtim
; /* number of skip dtim */
72 #define IWL_DTIM_RANGE_0_MAX 2
73 #define IWL_DTIM_RANGE_1_MAX 10
75 #define NOSLP cpu_to_le16(0), 0, 0
76 #define SLP IWL_POWER_DRIVER_ALLOW_SLEEP_MSK, 0, 0
77 #define TU_TO_USEC 1024
78 #define SLP_TOUT(T) cpu_to_le32((T) * TU_TO_USEC)
79 #define SLP_VEC(X0, X1, X2, X3, X4) {cpu_to_le32(X0), \
84 /* default power management (not Tx power) table values */
85 /* for DTIM period 0 through IWL_DTIM_RANGE_0_MAX */
87 static const struct iwl_power_vec_entry range_0
[IWL_POWER_NUM
] = {
88 {{SLP
, SLP_TOUT(200), SLP_TOUT(500), SLP_VEC(1, 1, 2, 2, 0xFF)}, 0},
89 {{SLP
, SLP_TOUT(200), SLP_TOUT(300), SLP_VEC(1, 2, 2, 2, 0xFF)}, 0},
90 {{SLP
, SLP_TOUT(50), SLP_TOUT(100), SLP_VEC(2, 2, 2, 2, 0xFF)}, 0},
91 {{SLP
, SLP_TOUT(50), SLP_TOUT(25), SLP_VEC(2, 2, 4, 4, 0xFF)}, 1},
92 {{SLP
, SLP_TOUT(25), SLP_TOUT(25), SLP_VEC(2, 2, 4, 6, 0xFF)}, 2}
96 /* for DTIM period IWL_DTIM_RANGE_0_MAX + 1 through IWL_DTIM_RANGE_1_MAX */
98 static const struct iwl_power_vec_entry range_1
[IWL_POWER_NUM
] = {
99 {{SLP
, SLP_TOUT(200), SLP_TOUT(500), SLP_VEC(1, 2, 3, 4, 4)}, 0},
100 {{SLP
, SLP_TOUT(200), SLP_TOUT(300), SLP_VEC(1, 2, 3, 4, 7)}, 0},
101 {{SLP
, SLP_TOUT(50), SLP_TOUT(100), SLP_VEC(2, 4, 6, 7, 9)}, 0},
102 {{SLP
, SLP_TOUT(50), SLP_TOUT(25), SLP_VEC(2, 4, 6, 9, 10)}, 1},
103 {{SLP
, SLP_TOUT(25), SLP_TOUT(25), SLP_VEC(2, 4, 6, 10, 10)}, 2}
106 /* for DTIM period > IWL_DTIM_RANGE_1_MAX */
108 static const struct iwl_power_vec_entry range_2
[IWL_POWER_NUM
] = {
109 {{SLP
, SLP_TOUT(200), SLP_TOUT(500), SLP_VEC(1, 2, 3, 4, 0xFF)}, 0},
110 {{SLP
, SLP_TOUT(200), SLP_TOUT(300), SLP_VEC(2, 4, 6, 7, 0xFF)}, 0},
111 {{SLP
, SLP_TOUT(50), SLP_TOUT(100), SLP_VEC(2, 7, 9, 9, 0xFF)}, 0},
112 {{SLP
, SLP_TOUT(50), SLP_TOUT(25), SLP_VEC(2, 7, 9, 9, 0xFF)}, 0},
113 {{SLP
, SLP_TOUT(25), SLP_TOUT(25), SLP_VEC(4, 7, 10, 10, 0xFF)}, 0}
116 static void iwl_static_sleep_cmd(struct iwl_priv
*priv
,
117 struct iwl_powertable_cmd
*cmd
,
118 enum iwl_power_level lvl
, int period
)
120 const struct iwl_power_vec_entry
*table
;
121 int max_sleep
[IWL_POWER_VEC_SIZE
] = { 0 };
127 if (period
<= IWL_DTIM_RANGE_1_MAX
)
129 if (period
<= IWL_DTIM_RANGE_0_MAX
)
132 BUG_ON(lvl
< 0 || lvl
>= IWL_POWER_NUM
);
134 *cmd
= table
[lvl
].cmd
;
139 for (i
= 0; i
< IWL_POWER_VEC_SIZE
; i
++)
143 skip
= table
[lvl
].no_dtim
;
144 for (i
= 0; i
< IWL_POWER_VEC_SIZE
; i
++)
145 max_sleep
[i
] = le32_to_cpu(cmd
->sleep_interval
[i
]);
146 max_sleep
[IWL_POWER_VEC_SIZE
- 1] = skip
+ 1;
149 slp_itrvl
= le32_to_cpu(cmd
->sleep_interval
[IWL_POWER_VEC_SIZE
- 1]);
150 /* figure out the listen interval based on dtim period and skip */
151 if (slp_itrvl
== 0xFF)
152 cmd
->sleep_interval
[IWL_POWER_VEC_SIZE
- 1] =
153 cpu_to_le32(period
* (skip
+ 1));
155 slp_itrvl
= le32_to_cpu(cmd
->sleep_interval
[IWL_POWER_VEC_SIZE
- 1]);
156 if (slp_itrvl
> period
)
157 cmd
->sleep_interval
[IWL_POWER_VEC_SIZE
- 1] =
158 cpu_to_le32((slp_itrvl
/ period
) * period
);
161 cmd
->flags
|= IWL_POWER_SLEEP_OVER_DTIM_MSK
;
163 cmd
->flags
&= ~IWL_POWER_SLEEP_OVER_DTIM_MSK
;
165 slp_itrvl
= le32_to_cpu(cmd
->sleep_interval
[IWL_POWER_VEC_SIZE
- 1]);
166 if (slp_itrvl
> IWL_CONN_MAX_LISTEN_INTERVAL
)
167 cmd
->sleep_interval
[IWL_POWER_VEC_SIZE
- 1] =
168 cpu_to_le32(IWL_CONN_MAX_LISTEN_INTERVAL
);
170 /* enforce max sleep interval */
171 for (i
= IWL_POWER_VEC_SIZE
- 1; i
>= 0 ; i
--) {
172 if (le32_to_cpu(cmd
->sleep_interval
[i
]) >
173 (max_sleep
[i
] * period
))
174 cmd
->sleep_interval
[i
] =
175 cpu_to_le32(max_sleep
[i
] * period
);
176 if (i
!= (IWL_POWER_VEC_SIZE
- 1)) {
177 if (le32_to_cpu(cmd
->sleep_interval
[i
]) >
178 le32_to_cpu(cmd
->sleep_interval
[i
+1]))
179 cmd
->sleep_interval
[i
] =
180 cmd
->sleep_interval
[i
+1];
184 if (priv
->power_data
.pci_pm
)
185 cmd
->flags
|= IWL_POWER_PCI_PM_MSK
;
187 cmd
->flags
&= ~IWL_POWER_PCI_PM_MSK
;
189 IWL_DEBUG_POWER(priv
, "numSkipDtim = %u, dtimPeriod = %d\n",
191 IWL_DEBUG_POWER(priv
, "Sleep command for index %d\n", lvl
+ 1);
194 /* default Thermal Throttling transaction table
195 * Current state | Throttling Down | Throttling Up
196 *=============================================================================
197 * Condition Nxt State Condition Nxt State Condition Nxt State
198 *-----------------------------------------------------------------------------
199 * IWL_TI_0 T >= 114 CT_KILL 114>T>=105 TI_1 N/A N/A
200 * IWL_TI_1 T >= 114 CT_KILL 114>T>=110 TI_2 T<=95 TI_0
201 * IWL_TI_2 T >= 114 CT_KILL T<=100 TI_1
202 * IWL_CT_KILL N/A N/A N/A N/A T<=95 TI_0
203 *=============================================================================
205 static const struct iwl_tt_trans tt_range_0
[IWL_TI_STATE_MAX
- 1] = {
206 {IWL_TI_0
, IWL_ABSOLUTE_ZERO
, 104},
207 {IWL_TI_1
, 105, CT_KILL_THRESHOLD
- 1},
208 {IWL_TI_CT_KILL
, CT_KILL_THRESHOLD
, IWL_ABSOLUTE_MAX
}
210 static const struct iwl_tt_trans tt_range_1
[IWL_TI_STATE_MAX
- 1] = {
211 {IWL_TI_0
, IWL_ABSOLUTE_ZERO
, 95},
212 {IWL_TI_2
, 110, CT_KILL_THRESHOLD
- 1},
213 {IWL_TI_CT_KILL
, CT_KILL_THRESHOLD
, IWL_ABSOLUTE_MAX
}
215 static const struct iwl_tt_trans tt_range_2
[IWL_TI_STATE_MAX
- 1] = {
216 {IWL_TI_1
, IWL_ABSOLUTE_ZERO
, 100},
217 {IWL_TI_CT_KILL
, CT_KILL_THRESHOLD
, IWL_ABSOLUTE_MAX
},
218 {IWL_TI_CT_KILL
, CT_KILL_THRESHOLD
, IWL_ABSOLUTE_MAX
}
220 static const struct iwl_tt_trans tt_range_3
[IWL_TI_STATE_MAX
- 1] = {
221 {IWL_TI_0
, IWL_ABSOLUTE_ZERO
, CT_KILL_EXIT_THRESHOLD
},
222 {IWL_TI_CT_KILL
, CT_KILL_EXIT_THRESHOLD
+ 1, IWL_ABSOLUTE_MAX
},
223 {IWL_TI_CT_KILL
, CT_KILL_EXIT_THRESHOLD
+ 1, IWL_ABSOLUTE_MAX
}
226 /* Advance Thermal Throttling default restriction table */
227 static const struct iwl_tt_restriction restriction_range
[IWL_TI_STATE_MAX
] = {
228 {IWL_ANT_OK_MULTI
, IWL_ANT_OK_MULTI
, true },
229 {IWL_ANT_OK_SINGLE
, IWL_ANT_OK_MULTI
, true },
230 {IWL_ANT_OK_SINGLE
, IWL_ANT_OK_SINGLE
, false },
231 {IWL_ANT_OK_NONE
, IWL_ANT_OK_NONE
, false }
235 static void iwl_power_sleep_cam_cmd(struct iwl_priv
*priv
,
236 struct iwl_powertable_cmd
*cmd
)
238 memset(cmd
, 0, sizeof(*cmd
));
240 if (priv
->power_data
.pci_pm
)
241 cmd
->flags
|= IWL_POWER_PCI_PM_MSK
;
243 IWL_DEBUG_POWER(priv
, "Sleep command for CAM\n");
246 static void iwl_power_fill_sleep_cmd(struct iwl_priv
*priv
,
247 struct iwl_powertable_cmd
*cmd
,
248 int dynps_ms
, int wakeup_period
)
251 * These are the original power level 3 sleep successions. The
252 * device may behave better with such succession and was also
253 * only tested with that. Just like the original sleep commands,
254 * also adjust the succession here to the wakeup_period below.
255 * The ranges are the same as for the sleep commands, 0-2, 3-9
256 * and >10, which is selected based on the DTIM interval for
257 * the sleep index but here we use the wakeup period since that
258 * is what we need to do for the latency requirements.
260 static const u8 slp_succ_r0
[IWL_POWER_VEC_SIZE
] = { 2, 2, 2, 2, 2 };
261 static const u8 slp_succ_r1
[IWL_POWER_VEC_SIZE
] = { 2, 4, 6, 7, 9 };
262 static const u8 slp_succ_r2
[IWL_POWER_VEC_SIZE
] = { 2, 7, 9, 9, 0xFF };
263 const u8
*slp_succ
= slp_succ_r0
;
266 if (wakeup_period
> IWL_DTIM_RANGE_0_MAX
)
267 slp_succ
= slp_succ_r1
;
268 if (wakeup_period
> IWL_DTIM_RANGE_1_MAX
)
269 slp_succ
= slp_succ_r2
;
271 memset(cmd
, 0, sizeof(*cmd
));
273 cmd
->flags
= IWL_POWER_DRIVER_ALLOW_SLEEP_MSK
|
274 IWL_POWER_FAST_PD
; /* no use seeing frames for others */
276 if (priv
->power_data
.pci_pm
)
277 cmd
->flags
|= IWL_POWER_PCI_PM_MSK
;
279 cmd
->rx_data_timeout
= cpu_to_le32(1000 * dynps_ms
);
280 cmd
->tx_data_timeout
= cpu_to_le32(1000 * dynps_ms
);
282 for (i
= 0; i
< IWL_POWER_VEC_SIZE
; i
++)
283 cmd
->sleep_interval
[i
] =
284 cpu_to_le32(min_t(int, slp_succ
[i
], wakeup_period
));
286 IWL_DEBUG_POWER(priv
, "Automatic sleep command\n");
289 static int iwl_set_power(struct iwl_priv
*priv
, struct iwl_powertable_cmd
*cmd
)
291 IWL_DEBUG_POWER(priv
, "Sending power/sleep command\n");
292 IWL_DEBUG_POWER(priv
, "Flags value = 0x%08X\n", cmd
->flags
);
293 IWL_DEBUG_POWER(priv
, "Tx timeout = %u\n", le32_to_cpu(cmd
->tx_data_timeout
));
294 IWL_DEBUG_POWER(priv
, "Rx timeout = %u\n", le32_to_cpu(cmd
->rx_data_timeout
));
295 IWL_DEBUG_POWER(priv
, "Sleep interval vector = { %d , %d , %d , %d , %d }\n",
296 le32_to_cpu(cmd
->sleep_interval
[0]),
297 le32_to_cpu(cmd
->sleep_interval
[1]),
298 le32_to_cpu(cmd
->sleep_interval
[2]),
299 le32_to_cpu(cmd
->sleep_interval
[3]),
300 le32_to_cpu(cmd
->sleep_interval
[4]));
302 return iwl_send_cmd_pdu(priv
, POWER_TABLE_CMD
,
303 sizeof(struct iwl_powertable_cmd
), cmd
);
307 int iwl_power_update_mode(struct iwl_priv
*priv
, bool force
)
310 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
311 bool enabled
= priv
->hw
->conf
.flags
& IEEE80211_CONF_PS
;
313 struct iwl_powertable_cmd cmd
;
316 /* Don't update the RX chain when chain noise calibration is running */
317 update_chains
= priv
->chain_noise_data
.state
== IWL_CHAIN_NOISE_DONE
||
318 priv
->chain_noise_data
.state
== IWL_CHAIN_NOISE_ALIVE
;
321 dtimper
= priv
->hw
->conf
.ps_dtim_period
;
325 if (priv
->cfg
->broken_powersave
)
326 iwl_power_sleep_cam_cmd(priv
, &cmd
);
327 else if (priv
->cfg
->supports_idle
&&
328 priv
->hw
->conf
.flags
& IEEE80211_CONF_IDLE
)
329 iwl_static_sleep_cmd(priv
, &cmd
, IWL_POWER_INDEX_5
, 20);
330 else if (tt
->state
>= IWL_TI_1
)
331 iwl_static_sleep_cmd(priv
, &cmd
, tt
->tt_power_mode
, dtimper
);
333 iwl_power_sleep_cam_cmd(priv
, &cmd
);
334 else if (priv
->power_data
.debug_sleep_level_override
>= 0)
335 iwl_static_sleep_cmd(priv
, &cmd
,
336 priv
->power_data
.debug_sleep_level_override
,
338 else if (no_sleep_autoadjust
)
339 iwl_static_sleep_cmd(priv
, &cmd
, IWL_POWER_INDEX_1
, dtimper
);
341 iwl_power_fill_sleep_cmd(priv
, &cmd
,
342 priv
->hw
->conf
.dynamic_ps_timeout
,
343 priv
->hw
->conf
.max_sleep_period
);
345 if (iwl_is_ready_rf(priv
) &&
346 (memcmp(&priv
->power_data
.sleep_cmd
, &cmd
, sizeof(cmd
)) || force
)) {
347 if (cmd
.flags
& IWL_POWER_DRIVER_ALLOW_SLEEP_MSK
)
348 set_bit(STATUS_POWER_PMI
, &priv
->status
);
350 ret
= iwl_set_power(priv
, &cmd
);
352 if (!(cmd
.flags
& IWL_POWER_DRIVER_ALLOW_SLEEP_MSK
))
353 clear_bit(STATUS_POWER_PMI
, &priv
->status
);
355 if (priv
->cfg
->ops
->lib
->update_chain_flags
&&
357 priv
->cfg
->ops
->lib
->update_chain_flags(priv
);
358 else if (priv
->cfg
->ops
->lib
->update_chain_flags
)
359 IWL_DEBUG_POWER(priv
,
360 "Cannot update the power, chain noise "
361 "calibration running: %d\n",
362 priv
->chain_noise_data
.state
);
363 memcpy(&priv
->power_data
.sleep_cmd
, &cmd
, sizeof(cmd
));
365 IWL_ERR(priv
, "set power fail, ret = %d", ret
);
370 EXPORT_SYMBOL(iwl_power_update_mode
);
372 bool iwl_ht_enabled(struct iwl_priv
*priv
)
374 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
375 struct iwl_tt_restriction
*restriction
;
377 if (!priv
->thermal_throttle
.advanced_tt
)
379 restriction
= tt
->restriction
+ tt
->state
;
380 return restriction
->is_ht
;
382 EXPORT_SYMBOL(iwl_ht_enabled
);
384 bool iwl_within_ct_kill_margin(struct iwl_priv
*priv
)
386 s32 temp
= priv
->temperature
; /* degrees CELSIUS except 4965 */
387 bool within_margin
= false;
389 if ((priv
->hw_rev
& CSR_HW_REV_TYPE_MSK
) == CSR_HW_REV_TYPE_4965
)
390 temp
= KELVIN_TO_CELSIUS(priv
->temperature
);
392 if (!priv
->thermal_throttle
.advanced_tt
)
393 within_margin
= ((temp
+ IWL_TT_CT_KILL_MARGIN
) >=
394 CT_KILL_THRESHOLD_LEGACY
) ? true : false;
396 within_margin
= ((temp
+ IWL_TT_CT_KILL_MARGIN
) >=
397 CT_KILL_THRESHOLD
) ? true : false;
398 return within_margin
;
401 enum iwl_antenna_ok
iwl_tx_ant_restriction(struct iwl_priv
*priv
)
403 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
404 struct iwl_tt_restriction
*restriction
;
406 if (!priv
->thermal_throttle
.advanced_tt
)
407 return IWL_ANT_OK_MULTI
;
408 restriction
= tt
->restriction
+ tt
->state
;
409 return restriction
->tx_stream
;
411 EXPORT_SYMBOL(iwl_tx_ant_restriction
);
413 enum iwl_antenna_ok
iwl_rx_ant_restriction(struct iwl_priv
*priv
)
415 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
416 struct iwl_tt_restriction
*restriction
;
418 if (!priv
->thermal_throttle
.advanced_tt
)
419 return IWL_ANT_OK_MULTI
;
420 restriction
= tt
->restriction
+ tt
->state
;
421 return restriction
->rx_stream
;
424 #define CT_KILL_EXIT_DURATION (5) /* 5 seconds duration */
425 #define CT_KILL_WAITING_DURATION (300) /* 300ms duration */
428 * toggle the bit to wake up uCode and check the temperature
429 * if the temperature is below CT, uCode will stay awake and send card
430 * state notification with CT_KILL bit clear to inform Thermal Throttling
431 * Management to change state. Otherwise, uCode will go back to sleep
432 * without doing anything, driver should continue the 5 seconds timer
433 * to wake up uCode for temperature check until temperature drop below CT
435 static void iwl_tt_check_exit_ct_kill(unsigned long data
)
437 struct iwl_priv
*priv
= (struct iwl_priv
*)data
;
438 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
441 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
444 if (tt
->state
== IWL_TI_CT_KILL
) {
445 if (priv
->thermal_throttle
.ct_kill_toggle
) {
446 iwl_write32(priv
, CSR_UCODE_DRV_GP1_CLR
,
447 CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT
);
448 priv
->thermal_throttle
.ct_kill_toggle
= false;
450 iwl_write32(priv
, CSR_UCODE_DRV_GP1_SET
,
451 CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT
);
452 priv
->thermal_throttle
.ct_kill_toggle
= true;
454 iwl_read32(priv
, CSR_UCODE_DRV_GP1
);
455 spin_lock_irqsave(&priv
->reg_lock
, flags
);
456 if (!iwl_grab_nic_access(priv
))
457 iwl_release_nic_access(priv
);
458 spin_unlock_irqrestore(&priv
->reg_lock
, flags
);
460 /* Reschedule the ct_kill timer to occur in
461 * CT_KILL_EXIT_DURATION seconds to ensure we get a
463 IWL_DEBUG_POWER(priv
, "schedule ct_kill exit timer\n");
464 mod_timer(&priv
->thermal_throttle
.ct_kill_exit_tm
, jiffies
+
465 CT_KILL_EXIT_DURATION
* HZ
);
469 static void iwl_perform_ct_kill_task(struct iwl_priv
*priv
,
473 IWL_DEBUG_POWER(priv
, "Stop all queues\n");
474 if (priv
->mac80211_registered
)
475 ieee80211_stop_queues(priv
->hw
);
476 IWL_DEBUG_POWER(priv
,
477 "Schedule 5 seconds CT_KILL Timer\n");
478 mod_timer(&priv
->thermal_throttle
.ct_kill_exit_tm
, jiffies
+
479 CT_KILL_EXIT_DURATION
* HZ
);
481 IWL_DEBUG_POWER(priv
, "Wake all queues\n");
482 if (priv
->mac80211_registered
)
483 ieee80211_wake_queues(priv
->hw
);
487 static void iwl_tt_ready_for_ct_kill(unsigned long data
)
489 struct iwl_priv
*priv
= (struct iwl_priv
*)data
;
490 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
492 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
495 /* temperature timer expired, ready to go into CT_KILL state */
496 if (tt
->state
!= IWL_TI_CT_KILL
) {
497 IWL_DEBUG_POWER(priv
, "entering CT_KILL state when temperature timer expired\n");
498 tt
->state
= IWL_TI_CT_KILL
;
499 set_bit(STATUS_CT_KILL
, &priv
->status
);
500 iwl_perform_ct_kill_task(priv
, true);
504 static void iwl_prepare_ct_kill_task(struct iwl_priv
*priv
)
506 IWL_DEBUG_POWER(priv
, "Prepare to enter IWL_TI_CT_KILL\n");
507 /* make request to retrieve statistics information */
508 iwl_send_statistics_request(priv
, CMD_SYNC
, false);
509 /* Reschedule the ct_kill wait timer */
510 mod_timer(&priv
->thermal_throttle
.ct_kill_waiting_tm
,
511 jiffies
+ msecs_to_jiffies(CT_KILL_WAITING_DURATION
));
514 #define IWL_MINIMAL_POWER_THRESHOLD (CT_KILL_THRESHOLD_LEGACY)
515 #define IWL_REDUCED_PERFORMANCE_THRESHOLD_2 (100)
516 #define IWL_REDUCED_PERFORMANCE_THRESHOLD_1 (90)
519 * Legacy thermal throttling
520 * 1) Avoid NIC destruction due to high temperatures
521 * Chip will identify dangerously high temperatures that can
522 * harm the device and will power down
523 * 2) Avoid the NIC power down due to high temperature
524 * Throttle early enough to lower the power consumption before
525 * drastic steps are needed
527 static void iwl_legacy_tt_handler(struct iwl_priv
*priv
, s32 temp
, bool force
)
529 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
530 enum iwl_tt_state old_state
;
532 #ifdef CONFIG_IWLWIFI_DEBUG
533 if ((tt
->tt_previous_temp
) &&
534 (temp
> tt
->tt_previous_temp
) &&
535 ((temp
- tt
->tt_previous_temp
) >
536 IWL_TT_INCREASE_MARGIN
)) {
537 IWL_DEBUG_POWER(priv
,
538 "Temperature increase %d degree Celsius\n",
539 (temp
- tt
->tt_previous_temp
));
542 old_state
= tt
->state
;
544 if (temp
>= IWL_MINIMAL_POWER_THRESHOLD
)
545 tt
->state
= IWL_TI_CT_KILL
;
546 else if (temp
>= IWL_REDUCED_PERFORMANCE_THRESHOLD_2
)
547 tt
->state
= IWL_TI_2
;
548 else if (temp
>= IWL_REDUCED_PERFORMANCE_THRESHOLD_1
)
549 tt
->state
= IWL_TI_1
;
551 tt
->state
= IWL_TI_0
;
553 #ifdef CONFIG_IWLWIFI_DEBUG
554 tt
->tt_previous_temp
= temp
;
556 /* stop ct_kill_waiting_tm timer */
557 del_timer_sync(&priv
->thermal_throttle
.ct_kill_waiting_tm
);
558 if (tt
->state
!= old_state
) {
562 * When the system is ready to go back to IWL_TI_0
563 * we only have to call iwl_power_update_mode() to
568 tt
->tt_power_mode
= IWL_POWER_INDEX_3
;
571 tt
->tt_power_mode
= IWL_POWER_INDEX_4
;
574 tt
->tt_power_mode
= IWL_POWER_INDEX_5
;
577 mutex_lock(&priv
->mutex
);
578 if (old_state
== IWL_TI_CT_KILL
)
579 clear_bit(STATUS_CT_KILL
, &priv
->status
);
580 if (tt
->state
!= IWL_TI_CT_KILL
&&
581 iwl_power_update_mode(priv
, true)) {
582 /* TT state not updated
583 * try again during next temperature read
585 if (old_state
== IWL_TI_CT_KILL
)
586 set_bit(STATUS_CT_KILL
, &priv
->status
);
587 tt
->state
= old_state
;
588 IWL_ERR(priv
, "Cannot update power mode, "
589 "TT state not updated\n");
591 if (tt
->state
== IWL_TI_CT_KILL
) {
593 set_bit(STATUS_CT_KILL
, &priv
->status
);
594 iwl_perform_ct_kill_task(priv
, true);
596 iwl_prepare_ct_kill_task(priv
);
597 tt
->state
= old_state
;
599 } else if (old_state
== IWL_TI_CT_KILL
&&
600 tt
->state
!= IWL_TI_CT_KILL
)
601 iwl_perform_ct_kill_task(priv
, false);
602 IWL_DEBUG_POWER(priv
, "Temperature state changed %u\n",
604 IWL_DEBUG_POWER(priv
, "Power Index change to %u\n",
607 mutex_unlock(&priv
->mutex
);
612 * Advance thermal throttling
613 * 1) Avoid NIC destruction due to high temperatures
614 * Chip will identify dangerously high temperatures that can
615 * harm the device and will power down
616 * 2) Avoid the NIC power down due to high temperature
617 * Throttle early enough to lower the power consumption before
618 * drastic steps are needed
619 * Actions include relaxing the power down sleep thresholds and
620 * decreasing the number of TX streams
621 * 3) Avoid throughput performance impact as much as possible
623 *=============================================================================
624 * Condition Nxt State Condition Nxt State Condition Nxt State
625 *-----------------------------------------------------------------------------
626 * IWL_TI_0 T >= 114 CT_KILL 114>T>=105 TI_1 N/A N/A
627 * IWL_TI_1 T >= 114 CT_KILL 114>T>=110 TI_2 T<=95 TI_0
628 * IWL_TI_2 T >= 114 CT_KILL T<=100 TI_1
629 * IWL_CT_KILL N/A N/A N/A N/A T<=95 TI_0
630 *=============================================================================
632 static void iwl_advance_tt_handler(struct iwl_priv
*priv
, s32 temp
, bool force
)
634 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
636 bool changed
= false;
637 enum iwl_tt_state old_state
;
638 struct iwl_tt_trans
*transaction
;
640 old_state
= tt
->state
;
641 for (i
= 0; i
< IWL_TI_STATE_MAX
- 1; i
++) {
642 /* based on the current TT state,
643 * find the curresponding transaction table
644 * each table has (IWL_TI_STATE_MAX - 1) entries
645 * tt->transaction + ((old_state * (IWL_TI_STATE_MAX - 1))
646 * will advance to the correct table.
647 * then based on the current temperature
648 * find the next state need to transaction to
649 * go through all the possible (IWL_TI_STATE_MAX - 1) entries
650 * in the current table to see if transaction is needed
652 transaction
= tt
->transaction
+
653 ((old_state
* (IWL_TI_STATE_MAX
- 1)) + i
);
654 if (temp
>= transaction
->tt_low
&&
655 temp
<= transaction
->tt_high
) {
656 #ifdef CONFIG_IWLWIFI_DEBUG
657 if ((tt
->tt_previous_temp
) &&
658 (temp
> tt
->tt_previous_temp
) &&
659 ((temp
- tt
->tt_previous_temp
) >
660 IWL_TT_INCREASE_MARGIN
)) {
661 IWL_DEBUG_POWER(priv
,
662 "Temperature increase %d "
664 (temp
- tt
->tt_previous_temp
));
666 tt
->tt_previous_temp
= temp
;
669 transaction
->next_state
) {
672 transaction
->next_state
;
677 /* stop ct_kill_waiting_tm timer */
678 del_timer_sync(&priv
->thermal_throttle
.ct_kill_waiting_tm
);
680 struct iwl_rxon_cmd
*rxon
= &priv
->staging_rxon
;
682 if (tt
->state
>= IWL_TI_1
) {
683 /* force PI = IWL_POWER_INDEX_5 in the case of TI > 0 */
684 tt
->tt_power_mode
= IWL_POWER_INDEX_5
;
685 if (!iwl_ht_enabled(priv
))
687 rxon
->flags
&= ~(RXON_FLG_CHANNEL_MODE_MSK
|
688 RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK
|
689 RXON_FLG_HT40_PROT_MSK
|
690 RXON_FLG_HT_PROT_MSK
);
692 /* check HT capability and set
693 * according to the system HT capability
694 * in case get disabled before */
695 iwl_set_rxon_ht(priv
, &priv
->current_ht_config
);
700 * restore system power setting -- it will be
701 * recalculated automatically.
704 /* check HT capability and set
705 * according to the system HT capability
706 * in case get disabled before */
707 iwl_set_rxon_ht(priv
, &priv
->current_ht_config
);
709 mutex_lock(&priv
->mutex
);
710 if (old_state
== IWL_TI_CT_KILL
)
711 clear_bit(STATUS_CT_KILL
, &priv
->status
);
712 if (tt
->state
!= IWL_TI_CT_KILL
&&
713 iwl_power_update_mode(priv
, true)) {
714 /* TT state not updated
715 * try again during next temperature read
717 IWL_ERR(priv
, "Cannot update power mode, "
718 "TT state not updated\n");
719 if (old_state
== IWL_TI_CT_KILL
)
720 set_bit(STATUS_CT_KILL
, &priv
->status
);
721 tt
->state
= old_state
;
723 IWL_DEBUG_POWER(priv
,
724 "Thermal Throttling to new state: %u\n",
726 if (old_state
!= IWL_TI_CT_KILL
&&
727 tt
->state
== IWL_TI_CT_KILL
) {
729 IWL_DEBUG_POWER(priv
,
730 "Enter IWL_TI_CT_KILL\n");
731 set_bit(STATUS_CT_KILL
, &priv
->status
);
732 iwl_perform_ct_kill_task(priv
, true);
734 iwl_prepare_ct_kill_task(priv
);
735 tt
->state
= old_state
;
737 } else if (old_state
== IWL_TI_CT_KILL
&&
738 tt
->state
!= IWL_TI_CT_KILL
) {
739 IWL_DEBUG_POWER(priv
, "Exit IWL_TI_CT_KILL\n");
740 iwl_perform_ct_kill_task(priv
, false);
743 mutex_unlock(&priv
->mutex
);
747 /* Card State Notification indicated reach critical temperature
748 * if PSP not enable, no Thermal Throttling function will be performed
749 * just set the GP1 bit to acknowledge the event
750 * otherwise, go into IWL_TI_CT_KILL state
751 * since Card State Notification will not provide any temperature reading
753 * so just pass the CT_KILL temperature to iwl_legacy_tt_handler()
755 * pass CT_KILL_THRESHOLD+1 to make sure move into IWL_TI_CT_KILL state
757 static void iwl_bg_ct_enter(struct work_struct
*work
)
759 struct iwl_priv
*priv
= container_of(work
, struct iwl_priv
, ct_enter
);
760 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
762 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
765 if (!iwl_is_ready(priv
))
768 if (tt
->state
!= IWL_TI_CT_KILL
) {
769 IWL_ERR(priv
, "Device reached critical temperature "
770 "- ucode going to sleep!\n");
771 if (!priv
->thermal_throttle
.advanced_tt
)
772 iwl_legacy_tt_handler(priv
,
773 IWL_MINIMAL_POWER_THRESHOLD
,
776 iwl_advance_tt_handler(priv
,
777 CT_KILL_THRESHOLD
+ 1, true);
781 /* Card State Notification indicated out of critical temperature
782 * since Card State Notification will not provide any temperature reading
783 * so pass the IWL_REDUCED_PERFORMANCE_THRESHOLD_2 temperature
784 * to iwl_legacy_tt_handler() to get out of IWL_CT_KILL state
786 static void iwl_bg_ct_exit(struct work_struct
*work
)
788 struct iwl_priv
*priv
= container_of(work
, struct iwl_priv
, ct_exit
);
789 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
791 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
794 if (!iwl_is_ready(priv
))
797 /* stop ct_kill_exit_tm timer */
798 del_timer_sync(&priv
->thermal_throttle
.ct_kill_exit_tm
);
800 if (tt
->state
== IWL_TI_CT_KILL
) {
802 "Device temperature below critical"
805 * exit from CT_KILL state
806 * reset the current temperature reading
808 priv
->temperature
= 0;
809 if (!priv
->thermal_throttle
.advanced_tt
)
810 iwl_legacy_tt_handler(priv
,
811 IWL_REDUCED_PERFORMANCE_THRESHOLD_2
,
814 iwl_advance_tt_handler(priv
, CT_KILL_EXIT_THRESHOLD
,
819 void iwl_tt_enter_ct_kill(struct iwl_priv
*priv
)
821 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
824 IWL_DEBUG_POWER(priv
, "Queueing critical temperature enter.\n");
825 queue_work(priv
->workqueue
, &priv
->ct_enter
);
827 EXPORT_SYMBOL(iwl_tt_enter_ct_kill
);
829 void iwl_tt_exit_ct_kill(struct iwl_priv
*priv
)
831 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
834 IWL_DEBUG_POWER(priv
, "Queueing critical temperature exit.\n");
835 queue_work(priv
->workqueue
, &priv
->ct_exit
);
837 EXPORT_SYMBOL(iwl_tt_exit_ct_kill
);
839 static void iwl_bg_tt_work(struct work_struct
*work
)
841 struct iwl_priv
*priv
= container_of(work
, struct iwl_priv
, tt_work
);
842 s32 temp
= priv
->temperature
; /* degrees CELSIUS except 4965 */
844 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
847 if ((priv
->hw_rev
& CSR_HW_REV_TYPE_MSK
) == CSR_HW_REV_TYPE_4965
)
848 temp
= KELVIN_TO_CELSIUS(priv
->temperature
);
850 if (!priv
->thermal_throttle
.advanced_tt
)
851 iwl_legacy_tt_handler(priv
, temp
, false);
853 iwl_advance_tt_handler(priv
, temp
, false);
856 void iwl_tt_handler(struct iwl_priv
*priv
)
858 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
861 IWL_DEBUG_POWER(priv
, "Queueing thermal throttling work.\n");
862 queue_work(priv
->workqueue
, &priv
->tt_work
);
864 EXPORT_SYMBOL(iwl_tt_handler
);
866 /* Thermal throttling initialization
867 * For advance thermal throttling:
868 * Initialize Thermal Index and temperature threshold table
869 * Initialize thermal throttling restriction table
871 void iwl_tt_initialize(struct iwl_priv
*priv
)
873 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
874 int size
= sizeof(struct iwl_tt_trans
) * (IWL_TI_STATE_MAX
- 1);
875 struct iwl_tt_trans
*transaction
;
877 IWL_DEBUG_POWER(priv
, "Initialize Thermal Throttling \n");
879 memset(tt
, 0, sizeof(struct iwl_tt_mgmt
));
881 tt
->state
= IWL_TI_0
;
882 init_timer(&priv
->thermal_throttle
.ct_kill_exit_tm
);
883 priv
->thermal_throttle
.ct_kill_exit_tm
.data
= (unsigned long)priv
;
884 priv
->thermal_throttle
.ct_kill_exit_tm
.function
=
885 iwl_tt_check_exit_ct_kill
;
886 init_timer(&priv
->thermal_throttle
.ct_kill_waiting_tm
);
887 priv
->thermal_throttle
.ct_kill_waiting_tm
.data
= (unsigned long)priv
;
888 priv
->thermal_throttle
.ct_kill_waiting_tm
.function
=
889 iwl_tt_ready_for_ct_kill
;
890 /* setup deferred ct kill work */
891 INIT_WORK(&priv
->tt_work
, iwl_bg_tt_work
);
892 INIT_WORK(&priv
->ct_enter
, iwl_bg_ct_enter
);
893 INIT_WORK(&priv
->ct_exit
, iwl_bg_ct_exit
);
895 if (priv
->cfg
->adv_thermal_throttle
) {
896 IWL_DEBUG_POWER(priv
, "Advanced Thermal Throttling\n");
897 tt
->restriction
= kzalloc(sizeof(struct iwl_tt_restriction
) *
898 IWL_TI_STATE_MAX
, GFP_KERNEL
);
899 tt
->transaction
= kzalloc(sizeof(struct iwl_tt_trans
) *
900 IWL_TI_STATE_MAX
* (IWL_TI_STATE_MAX
- 1),
902 if (!tt
->restriction
|| !tt
->transaction
) {
903 IWL_ERR(priv
, "Fallback to Legacy Throttling\n");
904 priv
->thermal_throttle
.advanced_tt
= false;
905 kfree(tt
->restriction
);
906 tt
->restriction
= NULL
;
907 kfree(tt
->transaction
);
908 tt
->transaction
= NULL
;
910 transaction
= tt
->transaction
+
911 (IWL_TI_0
* (IWL_TI_STATE_MAX
- 1));
912 memcpy(transaction
, &tt_range_0
[0], size
);
913 transaction
= tt
->transaction
+
914 (IWL_TI_1
* (IWL_TI_STATE_MAX
- 1));
915 memcpy(transaction
, &tt_range_1
[0], size
);
916 transaction
= tt
->transaction
+
917 (IWL_TI_2
* (IWL_TI_STATE_MAX
- 1));
918 memcpy(transaction
, &tt_range_2
[0], size
);
919 transaction
= tt
->transaction
+
920 (IWL_TI_CT_KILL
* (IWL_TI_STATE_MAX
- 1));
921 memcpy(transaction
, &tt_range_3
[0], size
);
922 size
= sizeof(struct iwl_tt_restriction
) *
924 memcpy(tt
->restriction
,
925 &restriction_range
[0], size
);
926 priv
->thermal_throttle
.advanced_tt
= true;
929 IWL_DEBUG_POWER(priv
, "Legacy Thermal Throttling\n");
930 priv
->thermal_throttle
.advanced_tt
= false;
933 EXPORT_SYMBOL(iwl_tt_initialize
);
935 /* cleanup thermal throttling management related memory and timer */
936 void iwl_tt_exit(struct iwl_priv
*priv
)
938 struct iwl_tt_mgmt
*tt
= &priv
->thermal_throttle
;
940 /* stop ct_kill_exit_tm timer if activated */
941 del_timer_sync(&priv
->thermal_throttle
.ct_kill_exit_tm
);
942 /* stop ct_kill_waiting_tm timer if activated */
943 del_timer_sync(&priv
->thermal_throttle
.ct_kill_waiting_tm
);
944 cancel_work_sync(&priv
->tt_work
);
945 cancel_work_sync(&priv
->ct_enter
);
946 cancel_work_sync(&priv
->ct_exit
);
948 if (priv
->thermal_throttle
.advanced_tt
) {
949 /* free advance thermal throttling memory */
950 kfree(tt
->restriction
);
951 tt
->restriction
= NULL
;
952 kfree(tt
->transaction
);
953 tt
->transaction
= NULL
;
956 EXPORT_SYMBOL(iwl_tt_exit
);
958 /* initialize to default */
959 void iwl_power_initialize(struct iwl_priv
*priv
)
961 u16 lctl
= iwl_pcie_link_ctl(priv
);
963 priv
->power_data
.pci_pm
= !(lctl
& PCI_CFG_LINK_CTRL_VAL_L0S_EN
);
965 priv
->power_data
.debug_sleep_level_override
= -1;
967 memset(&priv
->power_data
.sleep_cmd
, 0,
968 sizeof(priv
->power_data
.sleep_cmd
));
970 EXPORT_SYMBOL(iwl_power_initialize
);