2019-05-30 07:57:49 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2010-03-09 03:07:30 +08:00
|
|
|
/*
|
|
|
|
* intel_idle.c - native hardware idle loop for modern Intel processors
|
|
|
|
*
|
2013-11-09 13:30:17 +08:00
|
|
|
* Copyright (c) 2013, Intel Corporation.
|
2010-03-09 03:07:30 +08:00
|
|
|
* Len Brown <len.brown@intel.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* intel_idle is a cpuidle driver that loads on specific Intel processors
|
|
|
|
* in lieu of the legacy ACPI processor_idle driver. The intent is to
|
|
|
|
* make Linux more efficient on these processors, as intel_idle knows
|
|
|
|
* more than ACPI, as well as make Linux more immune to ACPI BIOS bugs.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Design Assumptions
|
|
|
|
*
|
|
|
|
* All CPUs have same idle states as boot CPU
|
|
|
|
*
|
|
|
|
* Chipset BM_STS (bus master status) bit is a NOP
|
|
|
|
* for preventing entry into deep C-stats
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Known limitations
|
|
|
|
*
|
|
|
|
* The driver currently initializes for_each_online_cpu() upon modprobe.
|
|
|
|
* It it unaware of subsequent processors hot-added to the system.
|
|
|
|
* This means that if you boot with maxcpus=n and later online
|
|
|
|
* processors above n, those processors will use C1 only.
|
|
|
|
*
|
|
|
|
* ACPI has a .suspend hack to turn off deep c-statees during suspend
|
|
|
|
* to avoid complications with the lapic timer workaround.
|
|
|
|
* Have not seen issues with suspend, but may need same workaround here.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* un-comment DEBUG to enable pr_debug() statements */
|
|
|
|
#define DEBUG
|
|
|
|
|
2017-06-10 03:29:20 +08:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2019-12-13 16:56:01 +08:00
|
|
|
#include <linux/acpi.h>
|
2010-03-09 03:07:30 +08:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/cpuidle.h>
|
2015-04-03 08:02:34 +08:00
|
|
|
#include <linux/tick.h>
|
2010-03-09 03:07:30 +08:00
|
|
|
#include <trace/events/power.h>
|
|
|
|
#include <linux/sched.h>
|
2011-01-10 09:38:12 +08:00
|
|
|
#include <linux/notifier.h>
|
|
|
|
#include <linux/cpu.h>
|
2016-06-17 13:28:33 +08:00
|
|
|
#include <linux/moduleparam.h>
|
2012-01-26 07:09:07 +08:00
|
|
|
#include <asm/cpu_device_id.h>
|
2016-06-03 08:19:32 +08:00
|
|
|
#include <asm/intel-family.h>
|
2010-09-18 06:36:40 +08:00
|
|
|
#include <asm/mwait.h>
|
2011-01-19 09:48:27 +08:00
|
|
|
#include <asm/msr.h>
|
2010-03-09 03:07:30 +08:00
|
|
|
|
2016-03-13 13:33:48 +08:00
|
|
|
#define INTEL_IDLE_VERSION "0.4.1"
|
2010-03-09 03:07:30 +08:00
|
|
|
|
|
|
|
static struct cpuidle_driver intel_idle_driver = {
|
|
|
|
.name = "intel_idle",
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
/* intel_idle.max_cstate=0 disables driver */
|
2013-02-02 10:35:35 +08:00
|
|
|
static int max_cstate = CPUIDLE_STATE_MAX - 1;
|
2010-03-09 03:07:30 +08:00
|
|
|
|
2010-05-28 14:22:03 +08:00
|
|
|
static unsigned int mwait_substates;
|
2010-03-09 03:07:30 +08:00
|
|
|
|
2011-01-10 09:38:12 +08:00
|
|
|
#define LAPIC_TIMER_ALWAYS_RELIABLE 0xFFFFFFFF
|
2010-03-09 03:07:30 +08:00
|
|
|
/* Reliable LAPIC Timer States, bit 1 for C1 etc. */
|
2010-07-07 12:12:03 +08:00
|
|
|
static unsigned int lapic_timer_reliable_states = (1 << 1); /* Default to only C1 */
|
2010-03-09 03:07:30 +08:00
|
|
|
|
2012-01-26 07:09:07 +08:00
|
|
|
struct idle_cpu {
|
|
|
|
struct cpuidle_state *state_table;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Hardware C-state auto-demotion may not always be optimal.
|
|
|
|
* Indicate which enable bits to clear here.
|
|
|
|
*/
|
|
|
|
unsigned long auto_demotion_disable_flags;
|
2014-08-01 03:21:24 +08:00
|
|
|
bool byt_auto_demotion_disable_flag;
|
2013-02-02 14:31:56 +08:00
|
|
|
bool disable_promotion_to_c1e;
|
2019-12-13 16:56:21 +08:00
|
|
|
bool use_acpi;
|
2012-01-26 07:09:07 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct idle_cpu *icpu;
|
2010-08-08 02:10:03 +08:00
|
|
|
static struct cpuidle_device __percpu *intel_idle_cpuidle_devices;
|
2011-10-28 18:50:42 +08:00
|
|
|
static int intel_idle(struct cpuidle_device *dev,
|
|
|
|
struct cpuidle_driver *drv, int index);
|
2017-08-10 06:14:45 +08:00
|
|
|
static void intel_idle_s2idle(struct cpuidle_device *dev,
|
2015-02-11 12:04:17 +08:00
|
|
|
struct cpuidle_driver *drv, int index);
|
2010-03-09 03:07:30 +08:00
|
|
|
static struct cpuidle_state *cpuidle_state_table;
|
|
|
|
|
2019-12-13 16:56:21 +08:00
|
|
|
/*
|
|
|
|
* Enable this state by default even if the ACPI _CST does not list it.
|
|
|
|
*/
|
|
|
|
#define CPUIDLE_FLAG_ALWAYS_ENABLE BIT(15)
|
|
|
|
|
2011-01-12 15:51:20 +08:00
|
|
|
/*
|
|
|
|
* Set this flag for states where the HW flushes the TLB for us
|
|
|
|
* and so we don't need cross-calls to keep it consistent.
|
|
|
|
* If this flag is set, SW flushes the TLB, so even if the
|
|
|
|
* HW doesn't do the flushing, this flag is safe to use.
|
|
|
|
*/
|
|
|
|
#define CPUIDLE_FLAG_TLB_FLUSHED 0x10000
|
|
|
|
|
2013-02-01 08:55:37 +08:00
|
|
|
/*
|
|
|
|
* MWAIT takes an 8-bit "hint" in EAX "suggesting"
|
|
|
|
* the C-state (top nibble) and sub-state (bottom nibble)
|
|
|
|
* 0x00 means "MWAIT(C1)", 0x10 means "MWAIT(C2)" etc.
|
|
|
|
*
|
|
|
|
* We store the hint at the top of our "flags" for each state.
|
|
|
|
*/
|
|
|
|
#define flg2MWAIT(flags) (((flags) >> 24) & 0xFF)
|
|
|
|
#define MWAIT2flg(eax) ((eax & 0xFF) << 24)
|
|
|
|
|
2010-03-09 03:07:30 +08:00
|
|
|
/*
|
|
|
|
* States are indexed by the cstate number,
|
|
|
|
* which is also the index into the MWAIT hint array.
|
|
|
|
* Thus C0 is a dummy.
|
|
|
|
*/
|
2014-01-09 15:30:26 +08:00
|
|
|
static struct cpuidle_state nehalem_cstates[] = {
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1",
|
2010-03-09 03:07:30 +08:00
|
|
|
.desc = "MWAIT 0x00",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x00),
|
2010-03-09 03:07:30 +08:00
|
|
|
.exit_latency = 3,
|
|
|
|
.target_residency = 6,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 14:31:56 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1E",
|
2013-02-02 14:31:56 +08:00
|
|
|
.desc = "MWAIT 0x01",
|
2019-12-13 16:56:38 +08:00
|
|
|
.flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_ALWAYS_ENABLE,
|
2013-02-02 14:31:56 +08:00
|
|
|
.exit_latency = 10,
|
|
|
|
.target_residency = 20,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C3",
|
2010-03-09 03:07:30 +08:00
|
|
|
.desc = "MWAIT 0x10",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2010-03-09 03:07:30 +08:00
|
|
|
.exit_latency = 20,
|
|
|
|
.target_residency = 80,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6",
|
2010-03-09 03:07:30 +08:00
|
|
|
.desc = "MWAIT 0x20",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2010-03-09 03:07:30 +08:00
|
|
|
.exit_latency = 200,
|
|
|
|
.target_residency = 800,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
|
|
|
.enter = NULL }
|
2010-03-09 03:07:30 +08:00
|
|
|
};
|
|
|
|
|
2014-01-09 15:30:26 +08:00
|
|
|
static struct cpuidle_state snb_cstates[] = {
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1",
|
2010-07-07 12:12:03 +08:00
|
|
|
.desc = "MWAIT 0x00",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x00),
|
2013-02-02 14:31:56 +08:00
|
|
|
.exit_latency = 2,
|
|
|
|
.target_residency = 2,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 14:31:56 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1E",
|
2013-02-02 14:31:56 +08:00
|
|
|
.desc = "MWAIT 0x01",
|
2019-12-13 16:56:38 +08:00
|
|
|
.flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_ALWAYS_ENABLE,
|
2013-02-02 14:31:56 +08:00
|
|
|
.exit_latency = 10,
|
|
|
|
.target_residency = 20,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C3",
|
2010-07-07 12:12:03 +08:00
|
|
|
.desc = "MWAIT 0x10",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2010-07-07 12:12:03 +08:00
|
|
|
.exit_latency = 80,
|
2010-12-14 07:28:22 +08:00
|
|
|
.target_residency = 211,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6",
|
2010-07-07 12:12:03 +08:00
|
|
|
.desc = "MWAIT 0x20",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2010-07-07 12:12:03 +08:00
|
|
|
.exit_latency = 104,
|
2010-12-14 07:28:22 +08:00
|
|
|
.target_residency = 345,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C7",
|
2010-07-07 12:12:03 +08:00
|
|
|
.desc = "MWAIT 0x30",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x30) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2010-07-07 12:12:03 +08:00
|
|
|
.exit_latency = 109,
|
2010-12-14 07:28:22 +08:00
|
|
|
.target_residency = 345,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
|
|
|
.enter = NULL }
|
2010-07-07 12:12:03 +08:00
|
|
|
};
|
|
|
|
|
2014-02-14 15:30:00 +08:00
|
|
|
static struct cpuidle_state byt_cstates[] = {
|
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1",
|
2014-02-14 15:30:00 +08:00
|
|
|
.desc = "MWAIT 0x00",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x00),
|
2014-02-14 15:30:00 +08:00
|
|
|
.exit_latency = 1,
|
|
|
|
.target_residency = 1,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-02-14 15:30:00 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6N",
|
2014-02-14 15:30:00 +08:00
|
|
|
.desc = "MWAIT 0x58",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x58) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2015-03-25 11:23:20 +08:00
|
|
|
.exit_latency = 300,
|
2014-02-14 15:30:00 +08:00
|
|
|
.target_residency = 275,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-02-14 15:30:00 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6S",
|
2014-02-14 15:30:00 +08:00
|
|
|
.desc = "MWAIT 0x52",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x52) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2015-03-25 11:23:20 +08:00
|
|
|
.exit_latency = 500,
|
2014-02-14 15:30:00 +08:00
|
|
|
.target_residency = 560,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-02-14 15:30:00 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C7",
|
2014-02-14 15:30:00 +08:00
|
|
|
.desc = "MWAIT 0x60",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x60) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2014-02-14 15:30:00 +08:00
|
|
|
.exit_latency = 1200,
|
2015-03-25 11:23:20 +08:00
|
|
|
.target_residency = 4000,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-02-14 15:30:00 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C7S",
|
2014-02-14 15:30:00 +08:00
|
|
|
.desc = "MWAIT 0x64",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x64) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2014-02-14 15:30:00 +08:00
|
|
|
.exit_latency = 10000,
|
|
|
|
.target_residency = 20000,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-02-14 15:30:00 +08:00
|
|
|
{
|
|
|
|
.enter = NULL }
|
|
|
|
};
|
|
|
|
|
2015-03-28 08:54:01 +08:00
|
|
|
static struct cpuidle_state cht_cstates[] = {
|
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1",
|
2015-03-28 08:54:01 +08:00
|
|
|
.desc = "MWAIT 0x00",
|
|
|
|
.flags = MWAIT2flg(0x00),
|
|
|
|
.exit_latency = 1,
|
|
|
|
.target_residency = 1,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2015-03-28 08:54:01 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6N",
|
2015-03-28 08:54:01 +08:00
|
|
|
.desc = "MWAIT 0x58",
|
|
|
|
.flags = MWAIT2flg(0x58) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 80,
|
|
|
|
.target_residency = 275,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2015-03-28 08:54:01 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6S",
|
2015-03-28 08:54:01 +08:00
|
|
|
.desc = "MWAIT 0x52",
|
|
|
|
.flags = MWAIT2flg(0x52) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 200,
|
|
|
|
.target_residency = 560,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2015-03-28 08:54:01 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C7",
|
2015-03-28 08:54:01 +08:00
|
|
|
.desc = "MWAIT 0x60",
|
|
|
|
.flags = MWAIT2flg(0x60) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 1200,
|
|
|
|
.target_residency = 4000,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2015-03-28 08:54:01 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C7S",
|
2015-03-28 08:54:01 +08:00
|
|
|
.desc = "MWAIT 0x64",
|
|
|
|
.flags = MWAIT2flg(0x64) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 10000,
|
|
|
|
.target_residency = 20000,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2015-03-28 08:54:01 +08:00
|
|
|
{
|
|
|
|
.enter = NULL }
|
|
|
|
};
|
|
|
|
|
2014-01-09 15:30:26 +08:00
|
|
|
static struct cpuidle_state ivb_cstates[] = {
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1",
|
2012-06-02 07:45:32 +08:00
|
|
|
.desc = "MWAIT 0x00",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x00),
|
2012-06-02 07:45:32 +08:00
|
|
|
.exit_latency = 1,
|
|
|
|
.target_residency = 1,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 14:31:56 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1E",
|
2013-02-02 14:31:56 +08:00
|
|
|
.desc = "MWAIT 0x01",
|
2019-12-13 16:56:38 +08:00
|
|
|
.flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_ALWAYS_ENABLE,
|
2013-02-02 14:31:56 +08:00
|
|
|
.exit_latency = 10,
|
|
|
|
.target_residency = 20,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C3",
|
2012-06-02 07:45:32 +08:00
|
|
|
.desc = "MWAIT 0x10",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2012-06-02 07:45:32 +08:00
|
|
|
.exit_latency = 59,
|
|
|
|
.target_residency = 156,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6",
|
2012-06-02 07:45:32 +08:00
|
|
|
.desc = "MWAIT 0x20",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2012-06-02 07:45:32 +08:00
|
|
|
.exit_latency = 80,
|
|
|
|
.target_residency = 300,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C7",
|
2012-06-02 07:45:32 +08:00
|
|
|
.desc = "MWAIT 0x30",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x30) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2012-06-02 07:45:32 +08:00
|
|
|
.exit_latency = 87,
|
|
|
|
.target_residency = 300,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
|
|
|
.enter = NULL }
|
2012-06-02 07:45:32 +08:00
|
|
|
};
|
|
|
|
|
2014-04-04 13:21:07 +08:00
|
|
|
static struct cpuidle_state ivt_cstates[] = {
|
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1",
|
2014-04-04 13:21:07 +08:00
|
|
|
.desc = "MWAIT 0x00",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x00),
|
2014-04-04 13:21:07 +08:00
|
|
|
.exit_latency = 1,
|
|
|
|
.target_residency = 1,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-04-04 13:21:07 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1E",
|
2014-04-04 13:21:07 +08:00
|
|
|
.desc = "MWAIT 0x01",
|
2019-12-13 16:56:38 +08:00
|
|
|
.flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_ALWAYS_ENABLE,
|
2014-04-04 13:21:07 +08:00
|
|
|
.exit_latency = 10,
|
|
|
|
.target_residency = 80,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-04-04 13:21:07 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C3",
|
2014-04-04 13:21:07 +08:00
|
|
|
.desc = "MWAIT 0x10",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2014-04-04 13:21:07 +08:00
|
|
|
.exit_latency = 59,
|
|
|
|
.target_residency = 156,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-04-04 13:21:07 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6",
|
2014-04-04 13:21:07 +08:00
|
|
|
.desc = "MWAIT 0x20",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2014-04-04 13:21:07 +08:00
|
|
|
.exit_latency = 82,
|
|
|
|
.target_residency = 300,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-04-04 13:21:07 +08:00
|
|
|
{
|
|
|
|
.enter = NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct cpuidle_state ivt_cstates_4s[] = {
|
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1",
|
2014-04-04 13:21:07 +08:00
|
|
|
.desc = "MWAIT 0x00",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x00),
|
2014-04-04 13:21:07 +08:00
|
|
|
.exit_latency = 1,
|
|
|
|
.target_residency = 1,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-04-04 13:21:07 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1E",
|
2014-04-04 13:21:07 +08:00
|
|
|
.desc = "MWAIT 0x01",
|
2019-12-13 16:56:38 +08:00
|
|
|
.flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_ALWAYS_ENABLE,
|
2014-04-04 13:21:07 +08:00
|
|
|
.exit_latency = 10,
|
|
|
|
.target_residency = 250,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-04-04 13:21:07 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C3",
|
2014-04-04 13:21:07 +08:00
|
|
|
.desc = "MWAIT 0x10",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2014-04-04 13:21:07 +08:00
|
|
|
.exit_latency = 59,
|
|
|
|
.target_residency = 300,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-04-04 13:21:07 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6",
|
2014-04-04 13:21:07 +08:00
|
|
|
.desc = "MWAIT 0x20",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2014-04-04 13:21:07 +08:00
|
|
|
.exit_latency = 84,
|
|
|
|
.target_residency = 400,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-04-04 13:21:07 +08:00
|
|
|
{
|
|
|
|
.enter = NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct cpuidle_state ivt_cstates_8s[] = {
|
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1",
|
2014-04-04 13:21:07 +08:00
|
|
|
.desc = "MWAIT 0x00",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x00),
|
2014-04-04 13:21:07 +08:00
|
|
|
.exit_latency = 1,
|
|
|
|
.target_residency = 1,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-04-04 13:21:07 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1E",
|
2014-04-04 13:21:07 +08:00
|
|
|
.desc = "MWAIT 0x01",
|
2019-12-13 16:56:38 +08:00
|
|
|
.flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_ALWAYS_ENABLE,
|
2014-04-04 13:21:07 +08:00
|
|
|
.exit_latency = 10,
|
|
|
|
.target_residency = 500,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-04-04 13:21:07 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C3",
|
2014-04-04 13:21:07 +08:00
|
|
|
.desc = "MWAIT 0x10",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2014-04-04 13:21:07 +08:00
|
|
|
.exit_latency = 59,
|
|
|
|
.target_residency = 600,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-04-04 13:21:07 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6",
|
2014-04-04 13:21:07 +08:00
|
|
|
.desc = "MWAIT 0x20",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2014-04-04 13:21:07 +08:00
|
|
|
.exit_latency = 88,
|
|
|
|
.target_residency = 700,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-04-04 13:21:07 +08:00
|
|
|
{
|
|
|
|
.enter = NULL }
|
|
|
|
};
|
|
|
|
|
2014-01-09 15:30:26 +08:00
|
|
|
static struct cpuidle_state hsw_cstates[] = {
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1",
|
2013-02-01 03:40:49 +08:00
|
|
|
.desc = "MWAIT 0x00",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x00),
|
2013-02-01 03:40:49 +08:00
|
|
|
.exit_latency = 2,
|
|
|
|
.target_residency = 2,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 14:31:56 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1E",
|
2013-02-02 14:31:56 +08:00
|
|
|
.desc = "MWAIT 0x01",
|
2019-12-13 16:56:38 +08:00
|
|
|
.flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_ALWAYS_ENABLE,
|
2013-02-02 14:31:56 +08:00
|
|
|
.exit_latency = 10,
|
|
|
|
.target_residency = 20,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C3",
|
2013-02-01 03:40:49 +08:00
|
|
|
.desc = "MWAIT 0x10",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2013-02-01 03:40:49 +08:00
|
|
|
.exit_latency = 33,
|
|
|
|
.target_residency = 100,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6",
|
2013-02-01 03:40:49 +08:00
|
|
|
.desc = "MWAIT 0x20",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2013-02-01 03:40:49 +08:00
|
|
|
.exit_latency = 133,
|
|
|
|
.target_residency = 400,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C7s",
|
2013-02-01 03:40:49 +08:00
|
|
|
.desc = "MWAIT 0x32",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x32) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2013-02-01 03:40:49 +08:00
|
|
|
.exit_latency = 166,
|
|
|
|
.target_residency = 500,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-28 02:18:50 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C8",
|
2013-02-28 02:18:50 +08:00
|
|
|
.desc = "MWAIT 0x40",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x40) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2013-02-28 02:18:50 +08:00
|
|
|
.exit_latency = 300,
|
|
|
|
.target_residency = 900,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-28 02:18:50 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C9",
|
2013-02-28 02:18:50 +08:00
|
|
|
.desc = "MWAIT 0x50",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x50) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2013-02-28 02:18:50 +08:00
|
|
|
.exit_latency = 600,
|
|
|
|
.target_residency = 1800,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-28 02:18:50 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C10",
|
2013-02-28 02:18:50 +08:00
|
|
|
.desc = "MWAIT 0x60",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x60) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2013-02-28 02:18:50 +08:00
|
|
|
.exit_latency = 2600,
|
|
|
|
.target_residency = 7700,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
|
|
|
.enter = NULL }
|
2013-02-01 03:40:49 +08:00
|
|
|
};
|
2014-02-05 12:56:40 +08:00
|
|
|
static struct cpuidle_state bdw_cstates[] = {
|
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1",
|
2014-02-05 12:56:40 +08:00
|
|
|
.desc = "MWAIT 0x00",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x00),
|
2014-02-05 12:56:40 +08:00
|
|
|
.exit_latency = 2,
|
|
|
|
.target_residency = 2,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-02-05 12:56:40 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1E",
|
2014-02-05 12:56:40 +08:00
|
|
|
.desc = "MWAIT 0x01",
|
2019-12-13 16:56:38 +08:00
|
|
|
.flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_ALWAYS_ENABLE,
|
2014-02-05 12:56:40 +08:00
|
|
|
.exit_latency = 10,
|
|
|
|
.target_residency = 20,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-02-05 12:56:40 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C3",
|
2014-02-05 12:56:40 +08:00
|
|
|
.desc = "MWAIT 0x10",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2014-02-05 12:56:40 +08:00
|
|
|
.exit_latency = 40,
|
|
|
|
.target_residency = 100,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-02-05 12:56:40 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6",
|
2014-02-05 12:56:40 +08:00
|
|
|
.desc = "MWAIT 0x20",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2014-02-05 12:56:40 +08:00
|
|
|
.exit_latency = 133,
|
|
|
|
.target_residency = 400,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-02-05 12:56:40 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C7s",
|
2014-02-05 12:56:40 +08:00
|
|
|
.desc = "MWAIT 0x32",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x32) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2014-02-05 12:56:40 +08:00
|
|
|
.exit_latency = 166,
|
|
|
|
.target_residency = 500,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-02-05 12:56:40 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C8",
|
2014-02-05 12:56:40 +08:00
|
|
|
.desc = "MWAIT 0x40",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x40) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2014-02-05 12:56:40 +08:00
|
|
|
.exit_latency = 300,
|
|
|
|
.target_residency = 900,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-02-05 12:56:40 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C9",
|
2014-02-05 12:56:40 +08:00
|
|
|
.desc = "MWAIT 0x50",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x50) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2014-02-05 12:56:40 +08:00
|
|
|
.exit_latency = 600,
|
|
|
|
.target_residency = 1800,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-02-05 12:56:40 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C10",
|
2014-02-05 12:56:40 +08:00
|
|
|
.desc = "MWAIT 0x60",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x60) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2014-02-05 12:56:40 +08:00
|
|
|
.exit_latency = 2600,
|
|
|
|
.target_residency = 7700,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-02-05 12:56:40 +08:00
|
|
|
{
|
|
|
|
.enter = NULL }
|
|
|
|
};
|
2013-02-01 03:40:49 +08:00
|
|
|
|
2015-03-26 11:20:37 +08:00
|
|
|
static struct cpuidle_state skl_cstates[] = {
|
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1",
|
2015-03-26 11:20:37 +08:00
|
|
|
.desc = "MWAIT 0x00",
|
|
|
|
.flags = MWAIT2flg(0x00),
|
|
|
|
.exit_latency = 2,
|
|
|
|
.target_residency = 2,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2015-03-26 11:20:37 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1E",
|
2015-03-26 11:20:37 +08:00
|
|
|
.desc = "MWAIT 0x01",
|
2019-12-13 16:56:38 +08:00
|
|
|
.flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_ALWAYS_ENABLE,
|
2015-03-26 11:20:37 +08:00
|
|
|
.exit_latency = 10,
|
|
|
|
.target_residency = 20,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2015-03-26 11:20:37 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C3",
|
2015-03-26 11:20:37 +08:00
|
|
|
.desc = "MWAIT 0x10",
|
|
|
|
.flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 70,
|
|
|
|
.target_residency = 100,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2015-03-26 11:20:37 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6",
|
2015-03-26 11:20:37 +08:00
|
|
|
.desc = "MWAIT 0x20",
|
|
|
|
.flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2015-09-10 01:35:05 +08:00
|
|
|
.exit_latency = 85,
|
2015-03-26 11:20:37 +08:00
|
|
|
.target_residency = 200,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2015-03-26 11:20:37 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C7s",
|
2015-03-26 11:20:37 +08:00
|
|
|
.desc = "MWAIT 0x33",
|
|
|
|
.flags = MWAIT2flg(0x33) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 124,
|
|
|
|
.target_residency = 800,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2015-03-26 11:20:37 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C8",
|
2015-03-26 11:20:37 +08:00
|
|
|
.desc = "MWAIT 0x40",
|
|
|
|
.flags = MWAIT2flg(0x40) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2015-09-10 01:35:05 +08:00
|
|
|
.exit_latency = 200,
|
2015-03-26 11:20:37 +08:00
|
|
|
.target_residency = 800,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2015-09-10 01:35:05 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C9",
|
2015-09-10 01:35:05 +08:00
|
|
|
.desc = "MWAIT 0x50",
|
|
|
|
.flags = MWAIT2flg(0x50) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 480,
|
|
|
|
.target_residency = 5000,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2015-03-26 11:20:37 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C10",
|
2015-03-26 11:20:37 +08:00
|
|
|
.desc = "MWAIT 0x60",
|
|
|
|
.flags = MWAIT2flg(0x60) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 890,
|
|
|
|
.target_residency = 5000,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2015-03-26 11:20:37 +08:00
|
|
|
{
|
|
|
|
.enter = NULL }
|
|
|
|
};
|
|
|
|
|
2016-04-07 05:00:58 +08:00
|
|
|
static struct cpuidle_state skx_cstates[] = {
|
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1",
|
2016-04-07 05:00:58 +08:00
|
|
|
.desc = "MWAIT 0x00",
|
|
|
|
.flags = MWAIT2flg(0x00),
|
|
|
|
.exit_latency = 2,
|
|
|
|
.target_residency = 2,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2016-04-07 05:00:58 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1E",
|
2016-04-07 05:00:58 +08:00
|
|
|
.desc = "MWAIT 0x01",
|
2019-12-13 16:56:38 +08:00
|
|
|
.flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_ALWAYS_ENABLE,
|
2016-04-07 05:00:58 +08:00
|
|
|
.exit_latency = 10,
|
|
|
|
.target_residency = 20,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2016-04-07 05:00:58 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6",
|
2016-04-07 05:00:58 +08:00
|
|
|
.desc = "MWAIT 0x20",
|
|
|
|
.flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 133,
|
|
|
|
.target_residency = 600,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2016-04-07 05:00:58 +08:00
|
|
|
{
|
|
|
|
.enter = NULL }
|
|
|
|
};
|
|
|
|
|
2014-01-09 15:30:26 +08:00
|
|
|
static struct cpuidle_state atom_cstates[] = {
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1E",
|
2010-03-09 03:07:30 +08:00
|
|
|
.desc = "MWAIT 0x00",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x00),
|
2013-02-02 14:31:56 +08:00
|
|
|
.exit_latency = 10,
|
|
|
|
.target_residency = 20,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C2",
|
2010-03-09 03:07:30 +08:00
|
|
|
.desc = "MWAIT 0x10",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x10),
|
2010-03-09 03:07:30 +08:00
|
|
|
.exit_latency = 20,
|
|
|
|
.target_residency = 80,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C4",
|
2010-03-09 03:07:30 +08:00
|
|
|
.desc = "MWAIT 0x30",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x30) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2010-03-09 03:07:30 +08:00
|
|
|
.exit_latency = 100,
|
|
|
|
.target_residency = 400,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6",
|
2010-10-06 01:43:14 +08:00
|
|
|
.desc = "MWAIT 0x52",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x52) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2010-10-06 01:43:14 +08:00
|
|
|
.exit_latency = 140,
|
|
|
|
.target_residency = 560,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-02-02 12:37:30 +08:00
|
|
|
{
|
|
|
|
.enter = NULL }
|
2010-03-09 03:07:30 +08:00
|
|
|
};
|
2016-10-25 22:11:39 +08:00
|
|
|
static struct cpuidle_state tangier_cstates[] = {
|
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1",
|
2016-10-25 22:11:39 +08:00
|
|
|
.desc = "MWAIT 0x00",
|
|
|
|
.flags = MWAIT2flg(0x00),
|
|
|
|
.exit_latency = 1,
|
|
|
|
.target_residency = 4,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2016-10-25 22:11:39 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C4",
|
2016-10-25 22:11:39 +08:00
|
|
|
.desc = "MWAIT 0x30",
|
|
|
|
.flags = MWAIT2flg(0x30) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 100,
|
|
|
|
.target_residency = 400,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2016-10-25 22:11:39 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6",
|
2016-10-25 22:11:39 +08:00
|
|
|
.desc = "MWAIT 0x52",
|
|
|
|
.flags = MWAIT2flg(0x52) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 140,
|
|
|
|
.target_residency = 560,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2016-10-25 22:11:39 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C7",
|
2016-10-25 22:11:39 +08:00
|
|
|
.desc = "MWAIT 0x60",
|
|
|
|
.flags = MWAIT2flg(0x60) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 1200,
|
|
|
|
.target_residency = 4000,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2016-10-25 22:11:39 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C9",
|
2016-10-25 22:11:39 +08:00
|
|
|
.desc = "MWAIT 0x64",
|
|
|
|
.flags = MWAIT2flg(0x64) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 10000,
|
|
|
|
.target_residency = 20000,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2016-10-25 22:11:39 +08:00
|
|
|
{
|
|
|
|
.enter = NULL }
|
|
|
|
};
|
2014-01-09 15:30:27 +08:00
|
|
|
static struct cpuidle_state avn_cstates[] = {
|
2013-11-09 13:30:17 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1",
|
2013-11-09 13:30:17 +08:00
|
|
|
.desc = "MWAIT 0x00",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x00),
|
2013-11-09 13:30:17 +08:00
|
|
|
.exit_latency = 2,
|
|
|
|
.target_residency = 2,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2013-11-09 13:30:17 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6",
|
2013-11-09 13:30:17 +08:00
|
|
|
.desc = "MWAIT 0x51",
|
2014-11-12 23:03:50 +08:00
|
|
|
.flags = MWAIT2flg(0x51) | CPUIDLE_FLAG_TLB_FLUSHED,
|
2013-11-09 13:30:17 +08:00
|
|
|
.exit_latency = 15,
|
|
|
|
.target_residency = 45,
|
2015-02-11 12:04:17 +08:00
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2014-01-09 15:30:27 +08:00
|
|
|
{
|
|
|
|
.enter = NULL }
|
2013-11-09 13:30:17 +08:00
|
|
|
};
|
2014-09-05 08:22:54 +08:00
|
|
|
static struct cpuidle_state knl_cstates[] = {
|
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1",
|
2014-09-05 08:22:54 +08:00
|
|
|
.desc = "MWAIT 0x00",
|
|
|
|
.flags = MWAIT2flg(0x00),
|
|
|
|
.exit_latency = 1,
|
|
|
|
.target_residency = 2,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle },
|
2014-09-05 08:22:54 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6",
|
2014-09-05 08:22:54 +08:00
|
|
|
.desc = "MWAIT 0x10",
|
|
|
|
.flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 120,
|
|
|
|
.target_residency = 500,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle },
|
2014-09-05 08:22:54 +08:00
|
|
|
{
|
|
|
|
.enter = NULL }
|
|
|
|
};
|
2010-03-09 03:07:30 +08:00
|
|
|
|
2016-04-07 05:00:47 +08:00
|
|
|
static struct cpuidle_state bxt_cstates[] = {
|
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1",
|
2016-04-07 05:00:47 +08:00
|
|
|
.desc = "MWAIT 0x00",
|
|
|
|
.flags = MWAIT2flg(0x00),
|
|
|
|
.exit_latency = 2,
|
|
|
|
.target_residency = 2,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2016-04-07 05:00:47 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1E",
|
2016-04-07 05:00:47 +08:00
|
|
|
.desc = "MWAIT 0x01",
|
2019-12-13 16:56:38 +08:00
|
|
|
.flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_ALWAYS_ENABLE,
|
2016-04-07 05:00:47 +08:00
|
|
|
.exit_latency = 10,
|
|
|
|
.target_residency = 20,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2016-04-07 05:00:47 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6",
|
2016-04-07 05:00:47 +08:00
|
|
|
.desc = "MWAIT 0x20",
|
|
|
|
.flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 133,
|
|
|
|
.target_residency = 133,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2016-04-07 05:00:47 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C7s",
|
2016-04-07 05:00:47 +08:00
|
|
|
.desc = "MWAIT 0x31",
|
|
|
|
.flags = MWAIT2flg(0x31) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 155,
|
|
|
|
.target_residency = 155,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2016-04-07 05:00:47 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C8",
|
2016-04-07 05:00:47 +08:00
|
|
|
.desc = "MWAIT 0x40",
|
|
|
|
.flags = MWAIT2flg(0x40) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 1000,
|
|
|
|
.target_residency = 1000,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2016-04-07 05:00:47 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C9",
|
2016-04-07 05:00:47 +08:00
|
|
|
.desc = "MWAIT 0x50",
|
|
|
|
.flags = MWAIT2flg(0x50) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 2000,
|
|
|
|
.target_residency = 2000,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2016-04-07 05:00:47 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C10",
|
2016-04-07 05:00:47 +08:00
|
|
|
.desc = "MWAIT 0x60",
|
|
|
|
.flags = MWAIT2flg(0x60) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 10000,
|
|
|
|
.target_residency = 10000,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2016-04-07 05:00:47 +08:00
|
|
|
{
|
|
|
|
.enter = NULL }
|
|
|
|
};
|
|
|
|
|
2016-06-17 13:28:34 +08:00
|
|
|
static struct cpuidle_state dnv_cstates[] = {
|
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1",
|
2016-06-17 13:28:34 +08:00
|
|
|
.desc = "MWAIT 0x00",
|
|
|
|
.flags = MWAIT2flg(0x00),
|
|
|
|
.exit_latency = 2,
|
|
|
|
.target_residency = 2,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2016-06-17 13:28:34 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C1E",
|
2016-06-17 13:28:34 +08:00
|
|
|
.desc = "MWAIT 0x01",
|
2019-12-13 16:56:38 +08:00
|
|
|
.flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_ALWAYS_ENABLE,
|
2016-06-17 13:28:34 +08:00
|
|
|
.exit_latency = 10,
|
|
|
|
.target_residency = 20,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2016-06-17 13:28:34 +08:00
|
|
|
{
|
2017-03-01 05:32:44 +08:00
|
|
|
.name = "C6",
|
2016-06-17 13:28:34 +08:00
|
|
|
.desc = "MWAIT 0x20",
|
|
|
|
.flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
|
|
|
|
.exit_latency = 50,
|
|
|
|
.target_residency = 500,
|
|
|
|
.enter = &intel_idle,
|
2017-08-10 06:14:45 +08:00
|
|
|
.enter_s2idle = intel_idle_s2idle, },
|
2016-06-17 13:28:34 +08:00
|
|
|
{
|
|
|
|
.enter = NULL }
|
|
|
|
};
|
|
|
|
|
2010-03-09 03:07:30 +08:00
|
|
|
/**
|
|
|
|
* intel_idle
|
|
|
|
* @dev: cpuidle_device
|
2011-10-28 18:50:42 +08:00
|
|
|
* @drv: cpuidle driver
|
2011-10-28 18:50:09 +08:00
|
|
|
* @index: index of cpuidle state
|
2010-03-09 03:07:30 +08:00
|
|
|
*
|
2012-01-11 07:48:21 +08:00
|
|
|
* Must be called under local_irq_disable().
|
2010-03-09 03:07:30 +08:00
|
|
|
*/
|
2016-10-08 08:02:55 +08:00
|
|
|
static __cpuidle int intel_idle(struct cpuidle_device *dev,
|
|
|
|
struct cpuidle_driver *drv, int index)
|
2010-03-09 03:07:30 +08:00
|
|
|
{
|
|
|
|
unsigned long ecx = 1; /* break on interrupt flag */
|
2011-10-28 18:50:42 +08:00
|
|
|
struct cpuidle_state *state = &drv->states[index];
|
2013-02-01 08:55:37 +08:00
|
|
|
unsigned long eax = flg2MWAIT(state->flags);
|
2010-03-09 03:07:30 +08:00
|
|
|
unsigned int cstate;
|
2017-10-07 01:19:45 +08:00
|
|
|
bool uninitialized_var(tick);
|
2017-11-04 19:16:12 +08:00
|
|
|
int cpu = smp_processor_id();
|
2010-03-09 03:07:30 +08:00
|
|
|
|
2010-10-01 09:19:07 +08:00
|
|
|
/*
|
2017-11-04 19:16:12 +08:00
|
|
|
* leave_mm() to avoid costly and often unnecessary wakeups
|
|
|
|
* for flushing the user TLB's associated with the active mm.
|
2010-10-01 09:19:07 +08:00
|
|
|
*/
|
2017-11-04 19:16:12 +08:00
|
|
|
if (state->flags & CPUIDLE_FLAG_TLB_FLUSHED)
|
|
|
|
leave_mm(cpu);
|
2010-10-01 09:19:07 +08:00
|
|
|
|
2017-10-07 01:19:45 +08:00
|
|
|
if (!static_cpu_has(X86_FEATURE_ARAT)) {
|
|
|
|
cstate = (((eax) >> MWAIT_SUBSTATE_SIZE) &
|
|
|
|
MWAIT_CSTATE_MASK) + 1;
|
|
|
|
tick = false;
|
|
|
|
if (!(lapic_timer_reliable_states & (1 << (cstate)))) {
|
|
|
|
tick = true;
|
|
|
|
tick_broadcast_enter();
|
|
|
|
}
|
|
|
|
}
|
2010-03-09 03:07:30 +08:00
|
|
|
|
2013-12-12 22:08:36 +08:00
|
|
|
mwait_idle_with_hints(eax, ecx);
|
2010-03-09 03:07:30 +08:00
|
|
|
|
2017-10-07 01:19:45 +08:00
|
|
|
if (!static_cpu_has(X86_FEATURE_ARAT) && tick)
|
2015-04-03 08:14:23 +08:00
|
|
|
tick_broadcast_exit();
|
2010-03-09 03:07:30 +08:00
|
|
|
|
2011-10-28 18:50:09 +08:00
|
|
|
return index;
|
2010-03-09 03:07:30 +08:00
|
|
|
}
|
|
|
|
|
2015-02-11 12:04:17 +08:00
|
|
|
/**
|
2017-08-10 06:14:45 +08:00
|
|
|
* intel_idle_s2idle - simplified "enter" callback routine for suspend-to-idle
|
2015-02-11 12:04:17 +08:00
|
|
|
* @dev: cpuidle_device
|
|
|
|
* @drv: cpuidle driver
|
|
|
|
* @index: state index
|
|
|
|
*/
|
2017-08-10 06:14:45 +08:00
|
|
|
static void intel_idle_s2idle(struct cpuidle_device *dev,
|
2015-02-11 12:04:17 +08:00
|
|
|
struct cpuidle_driver *drv, int index)
|
|
|
|
{
|
|
|
|
unsigned long ecx = 1; /* break on interrupt flag */
|
|
|
|
unsigned long eax = flg2MWAIT(drv->states[index].flags);
|
|
|
|
|
|
|
|
mwait_idle_with_hints(eax, ecx);
|
|
|
|
}
|
|
|
|
|
2012-01-26 07:09:07 +08:00
|
|
|
static const struct idle_cpu idle_cpu_nehalem = {
|
|
|
|
.state_table = nehalem_cstates,
|
|
|
|
.auto_demotion_disable_flags = NHM_C1_AUTO_DEMOTE | NHM_C3_AUTO_DEMOTE,
|
2013-02-02 14:31:56 +08:00
|
|
|
.disable_promotion_to_c1e = true,
|
2012-01-26 07:09:07 +08:00
|
|
|
};
|
|
|
|
|
2019-12-13 16:56:38 +08:00
|
|
|
static const struct idle_cpu idle_cpu_nhx = {
|
|
|
|
.state_table = nehalem_cstates,
|
|
|
|
.auto_demotion_disable_flags = NHM_C1_AUTO_DEMOTE | NHM_C3_AUTO_DEMOTE,
|
|
|
|
.disable_promotion_to_c1e = true,
|
|
|
|
.use_acpi = true,
|
|
|
|
};
|
|
|
|
|
2012-01-26 07:09:07 +08:00
|
|
|
static const struct idle_cpu idle_cpu_atom = {
|
|
|
|
.state_table = atom_cstates,
|
|
|
|
};
|
|
|
|
|
2016-10-25 22:11:39 +08:00
|
|
|
static const struct idle_cpu idle_cpu_tangier = {
|
|
|
|
.state_table = tangier_cstates,
|
|
|
|
};
|
|
|
|
|
2012-01-26 07:09:07 +08:00
|
|
|
static const struct idle_cpu idle_cpu_lincroft = {
|
|
|
|
.state_table = atom_cstates,
|
|
|
|
.auto_demotion_disable_flags = ATM_LNC_C6_AUTO_DEMOTE,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct idle_cpu idle_cpu_snb = {
|
|
|
|
.state_table = snb_cstates,
|
2013-02-02 14:31:56 +08:00
|
|
|
.disable_promotion_to_c1e = true,
|
2012-01-26 07:09:07 +08:00
|
|
|
};
|
|
|
|
|
2019-12-13 16:56:38 +08:00
|
|
|
static const struct idle_cpu idle_cpu_snx = {
|
|
|
|
.state_table = snb_cstates,
|
|
|
|
.disable_promotion_to_c1e = true,
|
|
|
|
.use_acpi = true,
|
|
|
|
};
|
|
|
|
|
2014-02-14 15:30:00 +08:00
|
|
|
static const struct idle_cpu idle_cpu_byt = {
|
|
|
|
.state_table = byt_cstates,
|
|
|
|
.disable_promotion_to_c1e = true,
|
2014-08-01 03:21:24 +08:00
|
|
|
.byt_auto_demotion_disable_flag = true,
|
2014-02-14 15:30:00 +08:00
|
|
|
};
|
|
|
|
|
2015-03-28 08:54:01 +08:00
|
|
|
static const struct idle_cpu idle_cpu_cht = {
|
|
|
|
.state_table = cht_cstates,
|
|
|
|
.disable_promotion_to_c1e = true,
|
|
|
|
.byt_auto_demotion_disable_flag = true,
|
|
|
|
};
|
|
|
|
|
2012-06-02 07:45:32 +08:00
|
|
|
static const struct idle_cpu idle_cpu_ivb = {
|
|
|
|
.state_table = ivb_cstates,
|
2013-02-02 14:31:56 +08:00
|
|
|
.disable_promotion_to_c1e = true,
|
2012-06-02 07:45:32 +08:00
|
|
|
};
|
|
|
|
|
2014-04-04 13:21:07 +08:00
|
|
|
static const struct idle_cpu idle_cpu_ivt = {
|
|
|
|
.state_table = ivt_cstates,
|
|
|
|
.disable_promotion_to_c1e = true,
|
2019-12-13 16:56:38 +08:00
|
|
|
.use_acpi = true,
|
2014-04-04 13:21:07 +08:00
|
|
|
};
|
|
|
|
|
2013-02-01 03:40:49 +08:00
|
|
|
static const struct idle_cpu idle_cpu_hsw = {
|
|
|
|
.state_table = hsw_cstates,
|
2013-02-02 14:31:56 +08:00
|
|
|
.disable_promotion_to_c1e = true,
|
2013-02-01 03:40:49 +08:00
|
|
|
};
|
|
|
|
|
2019-12-13 16:56:38 +08:00
|
|
|
static const struct idle_cpu idle_cpu_hsx = {
|
|
|
|
.state_table = hsw_cstates,
|
|
|
|
.disable_promotion_to_c1e = true,
|
|
|
|
.use_acpi = true,
|
|
|
|
};
|
|
|
|
|
2014-02-05 12:56:40 +08:00
|
|
|
static const struct idle_cpu idle_cpu_bdw = {
|
|
|
|
.state_table = bdw_cstates,
|
|
|
|
.disable_promotion_to_c1e = true,
|
|
|
|
};
|
|
|
|
|
2019-12-13 16:56:38 +08:00
|
|
|
static const struct idle_cpu idle_cpu_bdx = {
|
|
|
|
.state_table = bdw_cstates,
|
|
|
|
.disable_promotion_to_c1e = true,
|
|
|
|
.use_acpi = true,
|
|
|
|
};
|
|
|
|
|
2015-03-26 11:20:37 +08:00
|
|
|
static const struct idle_cpu idle_cpu_skl = {
|
|
|
|
.state_table = skl_cstates,
|
|
|
|
.disable_promotion_to_c1e = true,
|
|
|
|
};
|
|
|
|
|
2016-04-07 05:00:58 +08:00
|
|
|
static const struct idle_cpu idle_cpu_skx = {
|
|
|
|
.state_table = skx_cstates,
|
|
|
|
.disable_promotion_to_c1e = true,
|
2019-12-13 16:56:38 +08:00
|
|
|
.use_acpi = true,
|
2016-04-07 05:00:58 +08:00
|
|
|
};
|
2015-03-26 11:20:37 +08:00
|
|
|
|
2013-11-09 13:30:17 +08:00
|
|
|
static const struct idle_cpu idle_cpu_avn = {
|
|
|
|
.state_table = avn_cstates,
|
|
|
|
.disable_promotion_to_c1e = true,
|
2019-12-13 16:56:38 +08:00
|
|
|
.use_acpi = true,
|
2013-11-09 13:30:17 +08:00
|
|
|
};
|
|
|
|
|
2014-09-05 08:22:54 +08:00
|
|
|
static const struct idle_cpu idle_cpu_knl = {
|
|
|
|
.state_table = knl_cstates,
|
2019-12-13 16:56:38 +08:00
|
|
|
.use_acpi = true,
|
2014-09-05 08:22:54 +08:00
|
|
|
};
|
|
|
|
|
2016-04-07 05:00:47 +08:00
|
|
|
static const struct idle_cpu idle_cpu_bxt = {
|
|
|
|
.state_table = bxt_cstates,
|
|
|
|
.disable_promotion_to_c1e = true,
|
|
|
|
};
|
|
|
|
|
2016-06-17 13:28:34 +08:00
|
|
|
static const struct idle_cpu idle_cpu_dnv = {
|
|
|
|
.state_table = dnv_cstates,
|
|
|
|
.disable_promotion_to_c1e = true,
|
2019-12-13 16:56:38 +08:00
|
|
|
.use_acpi = true,
|
2016-06-17 13:28:34 +08:00
|
|
|
};
|
|
|
|
|
2015-03-26 05:15:14 +08:00
|
|
|
static const struct x86_cpu_id intel_idle_ids[] __initconst = {
|
2019-12-13 16:56:38 +08:00
|
|
|
INTEL_CPU_FAM6(NEHALEM_EP, idle_cpu_nhx),
|
2018-08-31 16:22:29 +08:00
|
|
|
INTEL_CPU_FAM6(NEHALEM, idle_cpu_nehalem),
|
|
|
|
INTEL_CPU_FAM6(NEHALEM_G, idle_cpu_nehalem),
|
|
|
|
INTEL_CPU_FAM6(WESTMERE, idle_cpu_nehalem),
|
2019-12-13 16:56:38 +08:00
|
|
|
INTEL_CPU_FAM6(WESTMERE_EP, idle_cpu_nhx),
|
|
|
|
INTEL_CPU_FAM6(NEHALEM_EX, idle_cpu_nhx),
|
Merge branch 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip
Pull perf updates from Ingo Molnar:
"The main updates in this cycle were:
- Lots of perf tooling changes too voluminous to list (big perf trace
and perf stat improvements, lots of libtraceevent reorganization,
etc.), so I'll list the authors and refer to the changelog for
details:
Benjamin Peterson, Jérémie Galarneau, Kim Phillips, Peter
Zijlstra, Ravi Bangoria, Sangwon Hong, Sean V Kelley, Steven
Rostedt, Thomas Gleixner, Ding Xiang, Eduardo Habkost, Thomas
Richter, Andi Kleen, Sanskriti Sharma, Adrian Hunter, Tzvetomir
Stoyanov, Arnaldo Carvalho de Melo, Jiri Olsa.
... with the bulk of the changes written by Jiri Olsa, Tzvetomir
Stoyanov and Arnaldo Carvalho de Melo.
- Continued intel_rdt work with a focus on playing well with perf
events. This also imported some non-perf RDT work due to
dependencies. (Reinette Chatre)
- Implement counter freezing for Arch Perfmon v4 (Skylake and newer).
This allows to speed up the PMI handler by avoiding unnecessary MSR
writes and make it more accurate. (Andi Kleen)
- kprobes cleanups and simplification (Masami Hiramatsu)
- Intel Goldmont PMU updates (Kan Liang)
- ... plus misc other fixes and updates"
* 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (155 commits)
kprobes/x86: Use preempt_enable() in optimized_callback()
x86/intel_rdt: Prevent pseudo-locking from using stale pointers
kprobes, x86/ptrace.h: Make regs_get_kernel_stack_nth() not fault on bad stack
perf/x86/intel: Export mem events only if there's PEBS support
x86/cpu: Drop pointless static qualifier in punit_dev_state_show()
x86/intel_rdt: Fix initial allocation to consider CDP
x86/intel_rdt: CBM overlap should also check for overlap with CDP peer
x86/intel_rdt: Introduce utility to obtain CDP peer
tools lib traceevent, perf tools: Move struct tep_handler definition in a local header file
tools lib traceevent: Separate out tep_strerror() for strerror_r() issues
perf python: More portable way to make CFLAGS work with clang
perf python: Make clang_has_option() work on Python 3
perf tools: Free temporary 'sys' string in read_event_files()
perf tools: Avoid double free in read_event_file()
perf tools: Free 'printk' string in parse_ftrace_printk()
perf tools: Cleanup trace-event-info 'tdata' leak
perf strbuf: Match va_{add,copy} with va_end
perf test: S390 does not support watchpoints in test 22
perf auxtrace: Include missing asm/bitsperlong.h to get BITS_PER_LONG
tools include: Adopt linux/bits.h
...
2018-10-23 20:32:18 +08:00
|
|
|
INTEL_CPU_FAM6(ATOM_BONNELL, idle_cpu_atom),
|
|
|
|
INTEL_CPU_FAM6(ATOM_BONNELL_MID, idle_cpu_lincroft),
|
2019-12-13 16:56:38 +08:00
|
|
|
INTEL_CPU_FAM6(WESTMERE_EX, idle_cpu_nhx),
|
2018-08-31 16:22:29 +08:00
|
|
|
INTEL_CPU_FAM6(SANDYBRIDGE, idle_cpu_snb),
|
2019-12-13 16:56:38 +08:00
|
|
|
INTEL_CPU_FAM6(SANDYBRIDGE_X, idle_cpu_snx),
|
Merge branch 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip
Pull perf updates from Ingo Molnar:
"The main updates in this cycle were:
- Lots of perf tooling changes too voluminous to list (big perf trace
and perf stat improvements, lots of libtraceevent reorganization,
etc.), so I'll list the authors and refer to the changelog for
details:
Benjamin Peterson, Jérémie Galarneau, Kim Phillips, Peter
Zijlstra, Ravi Bangoria, Sangwon Hong, Sean V Kelley, Steven
Rostedt, Thomas Gleixner, Ding Xiang, Eduardo Habkost, Thomas
Richter, Andi Kleen, Sanskriti Sharma, Adrian Hunter, Tzvetomir
Stoyanov, Arnaldo Carvalho de Melo, Jiri Olsa.
... with the bulk of the changes written by Jiri Olsa, Tzvetomir
Stoyanov and Arnaldo Carvalho de Melo.
- Continued intel_rdt work with a focus on playing well with perf
events. This also imported some non-perf RDT work due to
dependencies. (Reinette Chatre)
- Implement counter freezing for Arch Perfmon v4 (Skylake and newer).
This allows to speed up the PMI handler by avoiding unnecessary MSR
writes and make it more accurate. (Andi Kleen)
- kprobes cleanups and simplification (Masami Hiramatsu)
- Intel Goldmont PMU updates (Kan Liang)
- ... plus misc other fixes and updates"
* 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (155 commits)
kprobes/x86: Use preempt_enable() in optimized_callback()
x86/intel_rdt: Prevent pseudo-locking from using stale pointers
kprobes, x86/ptrace.h: Make regs_get_kernel_stack_nth() not fault on bad stack
perf/x86/intel: Export mem events only if there's PEBS support
x86/cpu: Drop pointless static qualifier in punit_dev_state_show()
x86/intel_rdt: Fix initial allocation to consider CDP
x86/intel_rdt: CBM overlap should also check for overlap with CDP peer
x86/intel_rdt: Introduce utility to obtain CDP peer
tools lib traceevent, perf tools: Move struct tep_handler definition in a local header file
tools lib traceevent: Separate out tep_strerror() for strerror_r() issues
perf python: More portable way to make CFLAGS work with clang
perf python: Make clang_has_option() work on Python 3
perf tools: Free temporary 'sys' string in read_event_files()
perf tools: Avoid double free in read_event_file()
perf tools: Free 'printk' string in parse_ftrace_printk()
perf tools: Cleanup trace-event-info 'tdata' leak
perf strbuf: Match va_{add,copy} with va_end
perf test: S390 does not support watchpoints in test 22
perf auxtrace: Include missing asm/bitsperlong.h to get BITS_PER_LONG
tools include: Adopt linux/bits.h
...
2018-10-23 20:32:18 +08:00
|
|
|
INTEL_CPU_FAM6(ATOM_SALTWELL, idle_cpu_atom),
|
|
|
|
INTEL_CPU_FAM6(ATOM_SILVERMONT, idle_cpu_byt),
|
|
|
|
INTEL_CPU_FAM6(ATOM_SILVERMONT_MID, idle_cpu_tangier),
|
2018-08-31 16:22:29 +08:00
|
|
|
INTEL_CPU_FAM6(ATOM_AIRMONT, idle_cpu_cht),
|
|
|
|
INTEL_CPU_FAM6(IVYBRIDGE, idle_cpu_ivb),
|
|
|
|
INTEL_CPU_FAM6(IVYBRIDGE_X, idle_cpu_ivt),
|
2019-08-28 03:48:21 +08:00
|
|
|
INTEL_CPU_FAM6(HASWELL, idle_cpu_hsw),
|
2019-12-13 16:56:38 +08:00
|
|
|
INTEL_CPU_FAM6(HASWELL_X, idle_cpu_hsx),
|
2019-08-28 03:48:22 +08:00
|
|
|
INTEL_CPU_FAM6(HASWELL_L, idle_cpu_hsw),
|
2019-08-28 03:48:23 +08:00
|
|
|
INTEL_CPU_FAM6(HASWELL_G, idle_cpu_hsw),
|
2019-08-28 03:48:24 +08:00
|
|
|
INTEL_CPU_FAM6(ATOM_SILVERMONT_D, idle_cpu_avn),
|
2019-08-28 03:48:21 +08:00
|
|
|
INTEL_CPU_FAM6(BROADWELL, idle_cpu_bdw),
|
2019-08-28 03:48:23 +08:00
|
|
|
INTEL_CPU_FAM6(BROADWELL_G, idle_cpu_bdw),
|
2019-12-13 16:56:38 +08:00
|
|
|
INTEL_CPU_FAM6(BROADWELL_X, idle_cpu_bdx),
|
|
|
|
INTEL_CPU_FAM6(BROADWELL_D, idle_cpu_bdx),
|
2019-08-28 03:48:22 +08:00
|
|
|
INTEL_CPU_FAM6(SKYLAKE_L, idle_cpu_skl),
|
2019-08-28 03:48:21 +08:00
|
|
|
INTEL_CPU_FAM6(SKYLAKE, idle_cpu_skl),
|
2019-08-28 03:48:22 +08:00
|
|
|
INTEL_CPU_FAM6(KABYLAKE_L, idle_cpu_skl),
|
2019-08-28 03:48:21 +08:00
|
|
|
INTEL_CPU_FAM6(KABYLAKE, idle_cpu_skl),
|
2018-08-31 16:22:29 +08:00
|
|
|
INTEL_CPU_FAM6(SKYLAKE_X, idle_cpu_skx),
|
|
|
|
INTEL_CPU_FAM6(XEON_PHI_KNL, idle_cpu_knl),
|
|
|
|
INTEL_CPU_FAM6(XEON_PHI_KNM, idle_cpu_knl),
|
|
|
|
INTEL_CPU_FAM6(ATOM_GOLDMONT, idle_cpu_bxt),
|
Merge branch 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip
Pull perf updates from Ingo Molnar:
"The main updates in this cycle were:
- Lots of perf tooling changes too voluminous to list (big perf trace
and perf stat improvements, lots of libtraceevent reorganization,
etc.), so I'll list the authors and refer to the changelog for
details:
Benjamin Peterson, Jérémie Galarneau, Kim Phillips, Peter
Zijlstra, Ravi Bangoria, Sangwon Hong, Sean V Kelley, Steven
Rostedt, Thomas Gleixner, Ding Xiang, Eduardo Habkost, Thomas
Richter, Andi Kleen, Sanskriti Sharma, Adrian Hunter, Tzvetomir
Stoyanov, Arnaldo Carvalho de Melo, Jiri Olsa.
... with the bulk of the changes written by Jiri Olsa, Tzvetomir
Stoyanov and Arnaldo Carvalho de Melo.
- Continued intel_rdt work with a focus on playing well with perf
events. This also imported some non-perf RDT work due to
dependencies. (Reinette Chatre)
- Implement counter freezing for Arch Perfmon v4 (Skylake and newer).
This allows to speed up the PMI handler by avoiding unnecessary MSR
writes and make it more accurate. (Andi Kleen)
- kprobes cleanups and simplification (Masami Hiramatsu)
- Intel Goldmont PMU updates (Kan Liang)
- ... plus misc other fixes and updates"
* 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (155 commits)
kprobes/x86: Use preempt_enable() in optimized_callback()
x86/intel_rdt: Prevent pseudo-locking from using stale pointers
kprobes, x86/ptrace.h: Make regs_get_kernel_stack_nth() not fault on bad stack
perf/x86/intel: Export mem events only if there's PEBS support
x86/cpu: Drop pointless static qualifier in punit_dev_state_show()
x86/intel_rdt: Fix initial allocation to consider CDP
x86/intel_rdt: CBM overlap should also check for overlap with CDP peer
x86/intel_rdt: Introduce utility to obtain CDP peer
tools lib traceevent, perf tools: Move struct tep_handler definition in a local header file
tools lib traceevent: Separate out tep_strerror() for strerror_r() issues
perf python: More portable way to make CFLAGS work with clang
perf python: Make clang_has_option() work on Python 3
perf tools: Free temporary 'sys' string in read_event_files()
perf tools: Avoid double free in read_event_file()
perf tools: Free 'printk' string in parse_ftrace_printk()
perf tools: Cleanup trace-event-info 'tdata' leak
perf strbuf: Match va_{add,copy} with va_end
perf test: S390 does not support watchpoints in test 22
perf auxtrace: Include missing asm/bitsperlong.h to get BITS_PER_LONG
tools include: Adopt linux/bits.h
...
2018-10-23 20:32:18 +08:00
|
|
|
INTEL_CPU_FAM6(ATOM_GOLDMONT_PLUS, idle_cpu_bxt),
|
2019-08-28 03:48:24 +08:00
|
|
|
INTEL_CPU_FAM6(ATOM_GOLDMONT_D, idle_cpu_dnv),
|
|
|
|
INTEL_CPU_FAM6(ATOM_TREMONT_D, idle_cpu_dnv),
|
2012-01-26 07:09:07 +08:00
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
2019-12-13 16:56:01 +08:00
|
|
|
#define INTEL_CPU_FAM6_MWAIT \
|
|
|
|
{ X86_VENDOR_INTEL, 6, X86_MODEL_ANY, X86_FEATURE_MWAIT, 0 }
|
|
|
|
|
|
|
|
static const struct x86_cpu_id intel_mwait_ids[] __initconst = {
|
|
|
|
INTEL_CPU_FAM6_MWAIT,
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
2020-01-10 18:51:22 +08:00
|
|
|
static bool __init intel_idle_max_cstate_reached(int cstate)
|
2019-12-13 16:56:01 +08:00
|
|
|
{
|
|
|
|
if (cstate + 1 > max_cstate) {
|
|
|
|
pr_info("max_cstate %d reached\n", max_cstate);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_ACPI_PROCESSOR_CSTATE
|
|
|
|
#include <acpi/processor.h>
|
|
|
|
|
2019-12-13 16:56:29 +08:00
|
|
|
static bool no_acpi __read_mostly;
|
|
|
|
module_param(no_acpi, bool, 0444);
|
|
|
|
MODULE_PARM_DESC(no_acpi, "Do not use ACPI _CST for building the idle states list");
|
|
|
|
|
2020-01-10 18:51:22 +08:00
|
|
|
static struct acpi_processor_power acpi_state_table __initdata;
|
2019-12-13 16:56:01 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* intel_idle_cst_usable - Check if the _CST information can be used.
|
|
|
|
*
|
|
|
|
* Check if all of the C-states listed by _CST in the max_cstate range are
|
|
|
|
* ACPI_CSTATE_FFH, which means that they should be entered via MWAIT.
|
|
|
|
*/
|
2020-01-10 18:51:22 +08:00
|
|
|
static bool __init intel_idle_cst_usable(void)
|
2019-12-13 16:56:01 +08:00
|
|
|
{
|
|
|
|
int cstate, limit;
|
|
|
|
|
|
|
|
limit = min_t(int, min_t(int, CPUIDLE_STATE_MAX, max_cstate + 1),
|
|
|
|
acpi_state_table.count);
|
|
|
|
|
|
|
|
for (cstate = 1; cstate < limit; cstate++) {
|
|
|
|
struct acpi_processor_cx *cx = &acpi_state_table.states[cstate];
|
|
|
|
|
|
|
|
if (cx->entry_method != ACPI_CSTATE_FFH)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-01-10 18:51:22 +08:00
|
|
|
static bool __init intel_idle_acpi_cst_extract(void)
|
2019-12-13 16:56:01 +08:00
|
|
|
{
|
|
|
|
unsigned int cpu;
|
|
|
|
|
2019-12-13 16:56:29 +08:00
|
|
|
if (no_acpi) {
|
|
|
|
pr_debug("Not allowed to use ACPI _CST\n");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-12-13 16:56:01 +08:00
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
struct acpi_processor *pr = per_cpu(processors, cpu);
|
|
|
|
|
|
|
|
if (!pr)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (acpi_processor_evaluate_cst(pr->handle, cpu, &acpi_state_table))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
acpi_state_table.count++;
|
|
|
|
|
|
|
|
if (!intel_idle_cst_usable())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!acpi_processor_claim_cst_control()) {
|
|
|
|
acpi_state_table.count = 0;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
pr_debug("ACPI _CST not found or not usable\n");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-01-10 18:51:22 +08:00
|
|
|
static void __init intel_idle_init_cstates_acpi(struct cpuidle_driver *drv)
|
2019-12-13 16:56:01 +08:00
|
|
|
{
|
|
|
|
int cstate, limit = min_t(int, CPUIDLE_STATE_MAX, acpi_state_table.count);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If limit > 0, intel_idle_cst_usable() has returned 'true', so all of
|
|
|
|
* the interesting states are ACPI_CSTATE_FFH.
|
|
|
|
*/
|
|
|
|
for (cstate = 1; cstate < limit; cstate++) {
|
|
|
|
struct acpi_processor_cx *cx;
|
|
|
|
struct cpuidle_state *state;
|
|
|
|
|
|
|
|
if (intel_idle_max_cstate_reached(cstate))
|
|
|
|
break;
|
|
|
|
|
|
|
|
cx = &acpi_state_table.states[cstate];
|
|
|
|
|
|
|
|
state = &drv->states[drv->state_count++];
|
|
|
|
|
|
|
|
snprintf(state->name, CPUIDLE_NAME_LEN, "C%d_ACPI", cstate);
|
|
|
|
strlcpy(state->desc, cx->desc, CPUIDLE_DESC_LEN);
|
|
|
|
state->exit_latency = cx->latency;
|
|
|
|
/*
|
|
|
|
* For C1-type C-states use the same number for both the exit
|
|
|
|
* latency and target residency, because that is the case for
|
|
|
|
* C1 in the majority of the static C-states tables above.
|
|
|
|
* For the other types of C-states, however, set the target
|
|
|
|
* residency to 3 times the exit latency which should lead to
|
|
|
|
* a reasonable balance between energy-efficiency and
|
|
|
|
* performance in the majority of interesting cases.
|
|
|
|
*/
|
|
|
|
state->target_residency = cx->latency;
|
|
|
|
if (cx->type > ACPI_STATE_C1)
|
|
|
|
state->target_residency *= 3;
|
|
|
|
|
|
|
|
state->flags = MWAIT2flg(cx->address);
|
|
|
|
if (cx->type > ACPI_STATE_C2)
|
|
|
|
state->flags |= CPUIDLE_FLAG_TLB_FLUSHED;
|
|
|
|
|
|
|
|
state->enter = intel_idle;
|
|
|
|
state->enter_s2idle = intel_idle_s2idle;
|
|
|
|
}
|
|
|
|
}
|
2019-12-13 16:56:21 +08:00
|
|
|
|
2020-01-10 18:51:22 +08:00
|
|
|
static bool __init intel_idle_off_by_default(u32 mwait_hint)
|
2019-12-13 16:56:21 +08:00
|
|
|
{
|
|
|
|
int cstate, limit;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there are no _CST C-states, do not disable any C-states by
|
|
|
|
* default.
|
|
|
|
*/
|
|
|
|
if (!acpi_state_table.count)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
limit = min_t(int, CPUIDLE_STATE_MAX, acpi_state_table.count);
|
|
|
|
/*
|
|
|
|
* If limit > 0, intel_idle_cst_usable() has returned 'true', so all of
|
|
|
|
* the interesting states are ACPI_CSTATE_FFH.
|
|
|
|
*/
|
|
|
|
for (cstate = 1; cstate < limit; cstate++) {
|
|
|
|
if (acpi_state_table.states[cstate].address == mwait_hint)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
2019-12-13 16:56:01 +08:00
|
|
|
#else /* !CONFIG_ACPI_PROCESSOR_CSTATE */
|
|
|
|
static inline bool intel_idle_acpi_cst_extract(void) { return false; }
|
|
|
|
static inline void intel_idle_init_cstates_acpi(struct cpuidle_driver *drv) { }
|
2019-12-13 16:56:21 +08:00
|
|
|
static inline bool intel_idle_off_by_default(u32 mwait_hint) { return false; }
|
2019-12-13 16:56:01 +08:00
|
|
|
#endif /* !CONFIG_ACPI_PROCESSOR_CSTATE */
|
|
|
|
|
2014-04-04 13:21:07 +08:00
|
|
|
/*
|
2016-03-13 13:33:48 +08:00
|
|
|
* ivt_idle_state_table_update(void)
|
2014-04-04 13:21:07 +08:00
|
|
|
*
|
2016-03-13 13:33:48 +08:00
|
|
|
* Tune IVT multi-socket targets
|
2014-04-04 13:21:07 +08:00
|
|
|
* Assumption: num_sockets == (max_package_num + 1)
|
|
|
|
*/
|
2020-01-10 18:51:22 +08:00
|
|
|
static void __init ivt_idle_state_table_update(void)
|
2014-04-04 13:21:07 +08:00
|
|
|
{
|
|
|
|
/* IVT uses a different table for 1-2, 3-4, and > 4 sockets */
|
2016-03-13 13:33:48 +08:00
|
|
|
int cpu, package_num, num_sockets = 1;
|
|
|
|
|
|
|
|
for_each_online_cpu(cpu) {
|
|
|
|
package_num = topology_physical_package_id(cpu);
|
|
|
|
if (package_num + 1 > num_sockets) {
|
|
|
|
num_sockets = package_num + 1;
|
|
|
|
|
|
|
|
if (num_sockets > 4) {
|
|
|
|
cpuidle_state_table = ivt_cstates_8s;
|
|
|
|
return;
|
2014-04-04 13:21:07 +08:00
|
|
|
}
|
|
|
|
}
|
2016-03-13 13:33:48 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (num_sockets > 2)
|
|
|
|
cpuidle_state_table = ivt_cstates_4s;
|
|
|
|
|
|
|
|
/* else, 1 and 2 socket systems use default ivt_cstates */
|
|
|
|
}
|
2016-04-07 05:00:47 +08:00
|
|
|
|
2020-01-17 18:46:24 +08:00
|
|
|
/**
|
|
|
|
* irtl_2_usec - IRTL to microseconds conversion.
|
|
|
|
* @irtl: IRTL MSR value.
|
|
|
|
*
|
|
|
|
* Translate the IRTL (Interrupt Response Time Limit) MSR value to microseconds.
|
2016-04-07 05:00:47 +08:00
|
|
|
*/
|
2020-01-10 18:51:22 +08:00
|
|
|
static unsigned long long __init irtl_2_usec(unsigned long long irtl)
|
2016-04-07 05:00:47 +08:00
|
|
|
{
|
2020-01-17 18:46:24 +08:00
|
|
|
static const unsigned int irtl_ns_units[] __initconst = {
|
|
|
|
1, 32, 1024, 32768, 1048576, 33554432, 0, 0
|
|
|
|
};
|
2016-04-07 05:00:47 +08:00
|
|
|
unsigned long long ns;
|
|
|
|
|
2016-06-27 14:35:12 +08:00
|
|
|
if (!irtl)
|
|
|
|
return 0;
|
|
|
|
|
2016-06-27 14:35:48 +08:00
|
|
|
ns = irtl_ns_units[(irtl >> 10) & 0x7];
|
2016-04-07 05:00:47 +08:00
|
|
|
|
2020-01-17 18:46:24 +08:00
|
|
|
return div_u64((irtl & 0x3FF) * ns, NSEC_PER_USEC);
|
2016-04-07 05:00:47 +08:00
|
|
|
}
|
2020-01-17 18:46:24 +08:00
|
|
|
|
2016-04-07 05:00:47 +08:00
|
|
|
/*
|
|
|
|
* bxt_idle_state_table_update(void)
|
|
|
|
*
|
|
|
|
* On BXT, we trust the IRTL to show the definitive maximum latency
|
|
|
|
* We use the same value for target_residency.
|
|
|
|
*/
|
2020-01-10 18:51:22 +08:00
|
|
|
static void __init bxt_idle_state_table_update(void)
|
2016-04-07 05:00:47 +08:00
|
|
|
{
|
|
|
|
unsigned long long msr;
|
2016-06-27 14:35:12 +08:00
|
|
|
unsigned int usec;
|
2016-04-07 05:00:47 +08:00
|
|
|
|
|
|
|
rdmsrl(MSR_PKGC6_IRTL, msr);
|
2016-06-27 14:35:12 +08:00
|
|
|
usec = irtl_2_usec(msr);
|
|
|
|
if (usec) {
|
2016-04-07 05:00:47 +08:00
|
|
|
bxt_cstates[2].exit_latency = usec;
|
|
|
|
bxt_cstates[2].target_residency = usec;
|
|
|
|
}
|
|
|
|
|
|
|
|
rdmsrl(MSR_PKGC7_IRTL, msr);
|
2016-06-27 14:35:12 +08:00
|
|
|
usec = irtl_2_usec(msr);
|
|
|
|
if (usec) {
|
2016-04-07 05:00:47 +08:00
|
|
|
bxt_cstates[3].exit_latency = usec;
|
|
|
|
bxt_cstates[3].target_residency = usec;
|
|
|
|
}
|
|
|
|
|
|
|
|
rdmsrl(MSR_PKGC8_IRTL, msr);
|
2016-06-27 14:35:12 +08:00
|
|
|
usec = irtl_2_usec(msr);
|
|
|
|
if (usec) {
|
2016-04-07 05:00:47 +08:00
|
|
|
bxt_cstates[4].exit_latency = usec;
|
|
|
|
bxt_cstates[4].target_residency = usec;
|
|
|
|
}
|
|
|
|
|
|
|
|
rdmsrl(MSR_PKGC9_IRTL, msr);
|
2016-06-27 14:35:12 +08:00
|
|
|
usec = irtl_2_usec(msr);
|
|
|
|
if (usec) {
|
2016-04-07 05:00:47 +08:00
|
|
|
bxt_cstates[5].exit_latency = usec;
|
|
|
|
bxt_cstates[5].target_residency = usec;
|
|
|
|
}
|
|
|
|
|
|
|
|
rdmsrl(MSR_PKGC10_IRTL, msr);
|
2016-06-27 14:35:12 +08:00
|
|
|
usec = irtl_2_usec(msr);
|
|
|
|
if (usec) {
|
2016-04-07 05:00:47 +08:00
|
|
|
bxt_cstates[6].exit_latency = usec;
|
|
|
|
bxt_cstates[6].target_residency = usec;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2016-03-13 13:33:48 +08:00
|
|
|
/*
|
|
|
|
* sklh_idle_state_table_update(void)
|
|
|
|
*
|
|
|
|
* On SKL-H (model 0x5e) disable C8 and C9 if:
|
|
|
|
* C10 is enabled and SGX disabled
|
|
|
|
*/
|
2020-01-10 18:51:22 +08:00
|
|
|
static void __init sklh_idle_state_table_update(void)
|
2016-03-13 13:33:48 +08:00
|
|
|
{
|
|
|
|
unsigned long long msr;
|
|
|
|
unsigned int eax, ebx, ecx, edx;
|
|
|
|
|
|
|
|
|
|
|
|
/* if PC10 disabled via cmdline intel_idle.max_cstate=7 or shallower */
|
|
|
|
if (max_cstate <= 7)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* if PC10 not present in CPUID.MWAIT.EDX */
|
|
|
|
if ((mwait_substates & (0xF << 28)) == 0)
|
|
|
|
return;
|
|
|
|
|
2017-01-08 12:23:25 +08:00
|
|
|
rdmsrl(MSR_PKG_CST_CONFIG_CONTROL, msr);
|
2016-03-13 13:33:48 +08:00
|
|
|
|
|
|
|
/* PC10 is not enabled in PKG C-state limit */
|
|
|
|
if ((msr & 0xF) != 8)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ecx = 0;
|
|
|
|
cpuid(7, &eax, &ebx, &ecx, &edx);
|
|
|
|
|
|
|
|
/* if SGX is present */
|
|
|
|
if (ebx & (1 << 2)) {
|
2014-04-04 13:21:07 +08:00
|
|
|
|
x86/msr-index: Clean up bit defines for IA32_FEATURE_CONTROL MSR
As pointed out by Boris, the defines for bits in IA32_FEATURE_CONTROL
are quite a mouthful, especially the VMX bits which must differentiate
between enabling VMX inside and outside SMX (TXT) operation. Rename the
MSR and its bit defines to abbreviate FEATURE_CONTROL as FEAT_CTL to
make them a little friendlier on the eyes.
Arguably, the MSR itself should keep the full IA32_FEATURE_CONTROL name
to match Intel's SDM, but a future patch will add a dedicated Kconfig,
file and functions for the MSR. Using the full name for those assets is
rather unwieldy, so bite the bullet and use IA32_FEAT_CTL so that its
nomenclature is consistent throughout the kernel.
Opportunistically, fix a few other annoyances with the defines:
- Relocate the bit defines so that they immediately follow the MSR
define, e.g. aren't mistaken as belonging to MISC_FEATURE_CONTROL.
- Add whitespace around the block of feature control defines to make
it clear they're all related.
- Use BIT() instead of manually encoding the bit shift.
- Use "VMX" instead of "VMXON" to match the SDM.
- Append "_ENABLED" to the LMCE (Local Machine Check Exception) bit to
be consistent with the kernel's verbiage used for all other feature
control bits. Note, the SDM refers to the LMCE bit as LMCE_ON,
likely to differentiate it from IA32_MCG_EXT_CTL.LMCE_EN. Ignore
the (literal) one-off usage of _ON, the SDM is simply "wrong".
Signed-off-by: Sean Christopherson <sean.j.christopherson@intel.com>
Signed-off-by: Borislav Petkov <bp@suse.de>
Link: https://lkml.kernel.org/r/20191221044513.21680-2-sean.j.christopherson@intel.com
2019-12-21 12:44:55 +08:00
|
|
|
rdmsrl(MSR_IA32_FEAT_CTL, msr);
|
2016-03-13 13:33:48 +08:00
|
|
|
|
|
|
|
/* if SGX is enabled */
|
|
|
|
if (msr & (1 << 18))
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-11-22 02:41:51 +08:00
|
|
|
skl_cstates[5].flags |= CPUIDLE_FLAG_UNUSABLE; /* C8-SKL */
|
|
|
|
skl_cstates[6].flags |= CPUIDLE_FLAG_UNUSABLE; /* C9-SKL */
|
2016-03-13 13:33:48 +08:00
|
|
|
}
|
|
|
|
|
2020-01-10 18:52:32 +08:00
|
|
|
static bool __init intel_idle_verify_cstate(unsigned int mwait_hint)
|
|
|
|
{
|
|
|
|
unsigned int mwait_cstate = MWAIT_HINT2CSTATE(mwait_hint) + 1;
|
|
|
|
unsigned int num_substates = (mwait_substates >> mwait_cstate * 4) &
|
|
|
|
MWAIT_SUBSTATE_MASK;
|
|
|
|
|
|
|
|
/* Ignore the C-state if there are NO sub-states in CPUID for it. */
|
|
|
|
if (num_substates == 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (mwait_cstate > 2 && !boot_cpu_has(X86_FEATURE_NONSTOP_TSC))
|
|
|
|
mark_tsc_unstable("TSC halts in idle states deeper than C2");
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-01-10 18:51:22 +08:00
|
|
|
static void __init intel_idle_init_cstates_icpu(struct cpuidle_driver *drv)
|
2016-03-13 13:33:48 +08:00
|
|
|
{
|
2020-01-10 18:48:25 +08:00
|
|
|
int cstate;
|
2016-03-13 13:33:48 +08:00
|
|
|
|
2020-01-10 18:48:25 +08:00
|
|
|
switch (boot_cpu_data.x86_model) {
|
2016-06-03 08:19:32 +08:00
|
|
|
case INTEL_FAM6_IVYBRIDGE_X:
|
2016-03-13 13:33:48 +08:00
|
|
|
ivt_idle_state_table_update();
|
|
|
|
break;
|
2016-06-03 08:19:32 +08:00
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT:
|
2018-08-08 01:17:27 +08:00
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
|
2016-04-07 05:00:47 +08:00
|
|
|
bxt_idle_state_table_update();
|
|
|
|
break;
|
2019-08-28 03:48:21 +08:00
|
|
|
case INTEL_FAM6_SKYLAKE:
|
2016-03-13 13:33:48 +08:00
|
|
|
sklh_idle_state_table_update();
|
|
|
|
break;
|
2014-04-04 13:21:07 +08:00
|
|
|
}
|
2011-10-28 18:50:42 +08:00
|
|
|
|
2013-02-02 12:37:30 +08:00
|
|
|
for (cstate = 0; cstate < CPUIDLE_STATE_MAX; ++cstate) {
|
2019-12-13 16:55:52 +08:00
|
|
|
unsigned int mwait_hint;
|
2011-10-28 18:50:42 +08:00
|
|
|
|
2019-12-13 16:56:01 +08:00
|
|
|
if (intel_idle_max_cstate_reached(cstate))
|
2013-02-02 12:37:30 +08:00
|
|
|
break;
|
|
|
|
|
2019-12-13 16:56:01 +08:00
|
|
|
if (!cpuidle_state_table[cstate].enter &&
|
|
|
|
!cpuidle_state_table[cstate].enter_s2idle)
|
2011-10-28 18:50:42 +08:00
|
|
|
break;
|
|
|
|
|
2019-12-13 16:55:52 +08:00
|
|
|
/* If marked as unusable, skip this state. */
|
2019-11-22 02:41:51 +08:00
|
|
|
if (cpuidle_state_table[cstate].flags & CPUIDLE_FLAG_UNUSABLE) {
|
2017-06-10 03:29:20 +08:00
|
|
|
pr_debug("state %s is disabled\n",
|
|
|
|
cpuidle_state_table[cstate].name);
|
2016-03-13 13:33:48 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2019-12-13 16:55:52 +08:00
|
|
|
mwait_hint = flg2MWAIT(cpuidle_state_table[cstate].flags);
|
|
|
|
if (!intel_idle_verify_cstate(mwait_hint))
|
|
|
|
continue;
|
2016-03-13 13:33:48 +08:00
|
|
|
|
2019-12-13 16:55:52 +08:00
|
|
|
/* Structure copy. */
|
2019-12-13 16:56:21 +08:00
|
|
|
drv->states[drv->state_count] = cpuidle_state_table[cstate];
|
|
|
|
|
|
|
|
if (icpu->use_acpi && intel_idle_off_by_default(mwait_hint) &&
|
|
|
|
!(cpuidle_state_table[cstate].flags & CPUIDLE_FLAG_ALWAYS_ENABLE))
|
|
|
|
drv->states[drv->state_count].flags |= CPUIDLE_FLAG_OFF;
|
|
|
|
|
|
|
|
drv->state_count++;
|
2011-10-28 18:50:42 +08:00
|
|
|
}
|
|
|
|
|
2014-08-01 03:21:24 +08:00
|
|
|
if (icpu->byt_auto_demotion_disable_flag) {
|
|
|
|
wrmsrl(MSR_CC6_DEMOTION_POLICY_CONFIG, 0);
|
|
|
|
wrmsrl(MSR_MC6_DEMOTION_POLICY_CONFIG, 0);
|
|
|
|
}
|
2011-10-28 18:50:42 +08:00
|
|
|
}
|
|
|
|
|
2019-12-13 16:56:01 +08:00
|
|
|
/*
|
|
|
|
* intel_idle_cpuidle_driver_init()
|
|
|
|
* allocate, initialize cpuidle_states
|
|
|
|
*/
|
2020-01-10 18:48:25 +08:00
|
|
|
static void __init intel_idle_cpuidle_driver_init(struct cpuidle_driver *drv)
|
2019-12-13 16:56:01 +08:00
|
|
|
{
|
|
|
|
cpuidle_poll_state_init(drv);
|
|
|
|
drv->state_count = 1;
|
|
|
|
|
|
|
|
if (icpu)
|
|
|
|
intel_idle_init_cstates_icpu(drv);
|
|
|
|
else
|
|
|
|
intel_idle_init_cstates_acpi(drv);
|
|
|
|
}
|
2011-10-28 18:50:42 +08:00
|
|
|
|
2020-01-10 18:52:32 +08:00
|
|
|
static void auto_demotion_disable(void)
|
|
|
|
{
|
|
|
|
unsigned long long msr_bits;
|
|
|
|
|
|
|
|
rdmsrl(MSR_PKG_CST_CONFIG_CONTROL, msr_bits);
|
|
|
|
msr_bits &= ~(icpu->auto_demotion_disable_flags);
|
|
|
|
wrmsrl(MSR_PKG_CST_CONFIG_CONTROL, msr_bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void c1e_promotion_disable(void)
|
|
|
|
{
|
|
|
|
unsigned long long msr_bits;
|
|
|
|
|
|
|
|
rdmsrl(MSR_IA32_POWER_CTL, msr_bits);
|
|
|
|
msr_bits &= ~0x2;
|
|
|
|
wrmsrl(MSR_IA32_POWER_CTL, msr_bits);
|
|
|
|
}
|
|
|
|
|
2010-03-09 03:07:30 +08:00
|
|
|
/*
|
2012-01-18 05:40:08 +08:00
|
|
|
* intel_idle_cpu_init()
|
2010-03-09 03:07:30 +08:00
|
|
|
* allocate, initialize, register cpuidle_devices
|
2012-01-18 05:40:08 +08:00
|
|
|
* @cpu: cpu/core to initialize
|
2010-03-09 03:07:30 +08:00
|
|
|
*/
|
2016-11-29 17:51:43 +08:00
|
|
|
static int intel_idle_cpu_init(unsigned int cpu)
|
2010-03-09 03:07:30 +08:00
|
|
|
{
|
|
|
|
struct cpuidle_device *dev;
|
|
|
|
|
2012-01-18 05:40:08 +08:00
|
|
|
dev = per_cpu_ptr(intel_idle_cpuidle_devices, cpu);
|
|
|
|
dev->cpu = cpu;
|
2010-03-09 03:07:30 +08:00
|
|
|
|
2012-01-18 05:40:08 +08:00
|
|
|
if (cpuidle_register_device(dev)) {
|
2017-06-10 03:29:20 +08:00
|
|
|
pr_debug("cpuidle_register_device %d failed!\n", cpu);
|
2012-01-18 05:40:08 +08:00
|
|
|
return -EIO;
|
2010-03-09 03:07:30 +08:00
|
|
|
}
|
|
|
|
|
2019-12-13 16:56:01 +08:00
|
|
|
if (!icpu)
|
|
|
|
return 0;
|
|
|
|
|
2012-01-26 07:09:07 +08:00
|
|
|
if (icpu->auto_demotion_disable_flags)
|
2016-11-29 17:51:43 +08:00
|
|
|
auto_demotion_disable();
|
2012-01-18 05:40:08 +08:00
|
|
|
|
2013-12-21 02:47:28 +08:00
|
|
|
if (icpu->disable_promotion_to_c1e)
|
2016-11-29 17:51:43 +08:00
|
|
|
c1e_promotion_disable();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int intel_idle_cpu_online(unsigned int cpu)
|
|
|
|
{
|
|
|
|
struct cpuidle_device *dev;
|
|
|
|
|
|
|
|
if (lapic_timer_reliable_states != LAPIC_TIMER_ALWAYS_RELIABLE)
|
2020-01-10 18:43:23 +08:00
|
|
|
tick_broadcast_enable();
|
2016-11-29 17:51:43 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Some systems can hotplug a cpu at runtime after
|
|
|
|
* the kernel has booted, we have to initialize the
|
|
|
|
* driver in this case
|
|
|
|
*/
|
|
|
|
dev = per_cpu_ptr(intel_idle_cpuidle_devices, cpu);
|
|
|
|
if (!dev->registered)
|
|
|
|
return intel_idle_cpu_init(cpu);
|
2013-12-21 02:47:28 +08:00
|
|
|
|
2010-03-09 03:07:30 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-01-10 18:49:58 +08:00
|
|
|
/**
|
|
|
|
* intel_idle_cpuidle_devices_uninit - Unregister all cpuidle devices.
|
|
|
|
*/
|
|
|
|
static void __init intel_idle_cpuidle_devices_uninit(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for_each_online_cpu(i)
|
|
|
|
cpuidle_unregister_device(per_cpu_ptr(intel_idle_cpuidle_devices, i));
|
|
|
|
}
|
|
|
|
|
2010-03-09 03:07:30 +08:00
|
|
|
static int __init intel_idle_init(void)
|
|
|
|
{
|
2020-01-10 18:44:58 +08:00
|
|
|
const struct x86_cpu_id *id;
|
|
|
|
unsigned int eax, ebx, ecx;
|
2016-11-29 17:51:43 +08:00
|
|
|
int retval;
|
2010-03-09 03:07:30 +08:00
|
|
|
|
2010-11-04 00:06:14 +08:00
|
|
|
/* Do not load intel_idle at all for now if idle= is passed */
|
|
|
|
if (boot_option_idle_override != IDLE_NO_OVERRIDE)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2020-01-10 18:44:58 +08:00
|
|
|
if (max_cstate == 0) {
|
|
|
|
pr_debug("disabled\n");
|
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
|
|
|
|
id = x86_match_cpu(intel_idle_ids);
|
|
|
|
if (id) {
|
|
|
|
if (!boot_cpu_has(X86_FEATURE_MWAIT)) {
|
|
|
|
pr_debug("Please enable MWAIT in BIOS SETUP\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
id = x86_match_cpu(intel_mwait_ids);
|
|
|
|
if (!id)
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (boot_cpu_data.cpuid_level < CPUID_MWAIT_LEAF)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
cpuid(CPUID_MWAIT_LEAF, &eax, &ebx, &ecx, &mwait_substates);
|
|
|
|
|
|
|
|
if (!(ecx & CPUID5_ECX_EXTENSIONS_SUPPORTED) ||
|
|
|
|
!(ecx & CPUID5_ECX_INTERRUPT_BREAK) ||
|
|
|
|
!mwait_substates)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
pr_debug("MWAIT substates: 0x%x\n", mwait_substates);
|
|
|
|
|
|
|
|
icpu = (const struct idle_cpu *)id->driver_data;
|
|
|
|
if (icpu) {
|
|
|
|
cpuidle_state_table = icpu->state_table;
|
|
|
|
if (icpu->use_acpi)
|
|
|
|
intel_idle_acpi_cst_extract();
|
|
|
|
} else if (!intel_idle_acpi_cst_extract()) {
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
pr_debug("v" INTEL_IDLE_VERSION " model 0x%X\n",
|
|
|
|
boot_cpu_data.x86_model);
|
2010-03-09 03:07:30 +08:00
|
|
|
|
2016-04-07 05:00:52 +08:00
|
|
|
intel_idle_cpuidle_devices = alloc_percpu(struct cpuidle_device);
|
2020-01-10 18:45:49 +08:00
|
|
|
if (!intel_idle_cpuidle_devices)
|
2016-04-07 05:00:52 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2020-01-10 18:48:25 +08:00
|
|
|
intel_idle_cpuidle_driver_init(&intel_idle_driver);
|
|
|
|
|
2010-03-09 03:07:30 +08:00
|
|
|
retval = cpuidle_register_driver(&intel_idle_driver);
|
|
|
|
if (retval) {
|
2012-08-17 04:06:55 +08:00
|
|
|
struct cpuidle_driver *drv = cpuidle_get_driver();
|
2017-06-10 03:29:20 +08:00
|
|
|
printk(KERN_DEBUG pr_fmt("intel_idle yielding to %s\n"),
|
|
|
|
drv ? drv->name : "none");
|
2016-11-29 17:51:43 +08:00
|
|
|
goto init_driver_fail;
|
2010-03-09 03:07:30 +08:00
|
|
|
}
|
|
|
|
|
2016-04-07 05:00:54 +08:00
|
|
|
if (boot_cpu_has(X86_FEATURE_ARAT)) /* Always Reliable APIC Timer */
|
|
|
|
lapic_timer_reliable_states = LAPIC_TIMER_ALWAYS_RELIABLE;
|
|
|
|
|
2016-11-29 17:51:43 +08:00
|
|
|
retval = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "idle/intel:online",
|
|
|
|
intel_idle_cpu_online, NULL);
|
|
|
|
if (retval < 0)
|
|
|
|
goto hp_setup_fail;
|
2010-03-09 03:07:30 +08:00
|
|
|
|
2017-06-10 03:29:20 +08:00
|
|
|
pr_debug("lapic_timer_reliable_states 0x%x\n",
|
|
|
|
lapic_timer_reliable_states);
|
2016-04-07 05:00:54 +08:00
|
|
|
|
2010-03-09 03:07:30 +08:00
|
|
|
return 0;
|
2016-11-29 17:51:43 +08:00
|
|
|
|
|
|
|
hp_setup_fail:
|
|
|
|
intel_idle_cpuidle_devices_uninit();
|
|
|
|
cpuidle_unregister_driver(&intel_idle_driver);
|
|
|
|
init_driver_fail:
|
|
|
|
free_percpu(intel_idle_cpuidle_devices);
|
|
|
|
return retval;
|
|
|
|
|
2010-03-09 03:07:30 +08:00
|
|
|
}
|
2016-06-17 13:28:33 +08:00
|
|
|
device_initcall(intel_idle_init);
|
2010-03-09 03:07:30 +08:00
|
|
|
|
2016-06-17 13:28:33 +08:00
|
|
|
/*
|
|
|
|
* We are not really modular, but we used to support that. Meaning we also
|
|
|
|
* support "intel_idle.max_cstate=..." at boot and also a read-only export of
|
|
|
|
* it at /sys/module/intel_idle/parameters/max_cstate -- so using module_param
|
|
|
|
* is the easiest way (currently) to continue doing that.
|
|
|
|
*/
|
2010-03-09 03:07:30 +08:00
|
|
|
module_param(max_cstate, int, 0444);
|