30 files changed, 1037 insertions, 154 deletions

diff --git a/Documentation/admin-guide/pm/cpuidle.rst b/Documentation/admin-guide/pm/cpuidle.rst
index 106379e2619f..9c58b35a81cb 100644
--- a/Documentation/admin-guide/pm/cpuidle.rst
+++ b/Documentation/admin-guide/pm/cpuidle.rst
@@ -155,14 +155,14 @@ governor uses that information depends on what algorithm is implemented by it
 and that is the primary reason for having more than one governor in the
 ``CPUIdle`` subsystem.
 
-There are two ``CPUIdle`` governors available, ``menu`` and ``ladder``.  Which
-of them is used depends on the configuration of the kernel and in particular on
-whether or not the scheduler tick can be `stopped by the idle
-loop <idle-cpus-and-tick_>`_.  It is possible to change the governor at run time
-if the ``cpuidle_sysfs_switch`` command line parameter has been passed to the
-kernel, but that is not safe in general, so it should not be done on production
-systems (that may change in the future, though).  The name of the ``CPUIdle``
-governor currently used by the kernel can be read from the
+There are three ``CPUIdle`` governors available, ``menu``, `TEO <teo-gov_>`_
+and ``ladder``.  Which of them is used by default depends on the configuration
+of the kernel and in particular on whether or not the scheduler tick can be
+`stopped by the idle loop <idle-cpus-and-tick_>`_.  It is possible to change the
+governor at run time if the ``cpuidle_sysfs_switch`` command line parameter has
+been passed to the kernel, but that is not safe in general, so it should not be
+done on production systems (that may change in the future, though).  The name of
+the ``CPUIdle`` governor currently used by the kernel can be read from the
 :file:`current_governor_ro` (or :file:`current_governor` if
 ``cpuidle_sysfs_switch`` is present in the kernel command line) file under
 :file:`/sys/devices/system/cpu/cpuidle/` in ``sysfs``.
@@ -256,6 +256,8 @@ the ``menu`` governor by default and if it is not tickless, the default
 ``CPUIdle`` governor on it will be ``ladder``.
 
 
+.. _menu-gov:
+
 The ``menu`` Governor
 =====================
 
@@ -333,6 +335,92 @@ that time, the governor may need to select a shallower state with a suitable
 target residency.
 
 
+.. _teo-gov:
+
+The Timer Events Oriented (TEO) Governor
+========================================
+
+The timer events oriented (TEO) governor is an alternative ``CPUIdle`` governor
+for tickless systems.  It follows the same basic strategy as the ``menu`` `one
+<menu-gov_>`_: it always tries to find the deepest idle state suitable for the
+given conditions.  However, it applies a different approach to that problem.
+
+First, it does not use sleep length correction factors, but instead it attempts
+to correlate the observed idle duration values with the available idle states
+and use that information to pick up the idle state that is most likely to
+"match" the upcoming CPU idle interval.   Second, it does not take the tasks
+that were running on the given CPU in the past and are waiting on some I/O
+operations to complete now at all (there is no guarantee that they will run on
+the same CPU when they become runnable again) and the pattern detection code in
+it avoids taking timer wakeups into account.  It also only uses idle duration
+values less than the current time till the closest timer (with the scheduler
+tick excluded) for that purpose.
+
+Like in the ``menu`` governor `case <menu-gov_>`_, the first step is to obtain
+the *sleep length*, which is the time until the closest timer event with the
+assumption that the scheduler tick will be stopped (that also is the upper bound
+on the time until the next CPU wakeup).  That value is then used to preselect an
+idle state on the basis of three metrics maintained for each idle state provided
+by the ``CPUIdle`` driver: ``hits``, ``misses`` and ``early_hits``.
+
+The ``hits`` and ``misses`` metrics measure the likelihood that a given idle
+state will "match" the observed (post-wakeup) idle duration if it "matches" the
+sleep length.  They both are subject to decay (after a CPU wakeup) every time
+the target residency of the idle state corresponding to them is less than or
+equal to the sleep length and the target residency of the next idle state is
+greater than the sleep length (that is, when the idle state corresponding to
+them "matches" the sleep length).  The ``hits`` metric is increased if the
+former condition is satisfied and the target residency of the given idle state
+is less than or equal to the observed idle duration and the target residency of
+the next idle state is greater than the observed idle duration at the same time
+(that is, it is increased when the given idle state "matches" both the sleep
+length and the observed idle duration).  In turn, the ``misses`` metric is
+increased when the given idle state "matches" the sleep length only and the
+observed idle duration is too short for its target residency.
+
+The ``early_hits`` metric measures the likelihood that a given idle state will
+"match" the observed (post-wakeup) idle duration if it does not "match" the
+sleep length.  It is subject to decay on every CPU wakeup and it is increased
+when the idle state corresponding to it "matches" the observed (post-wakeup)
+idle duration and the target residency of the next idle state is less than or
+equal to the sleep length (i.e. the idle state "matching" the sleep length is
+deeper than the given one).
+
+The governor walks the list of idle states provided by the ``CPUIdle`` driver
+and finds the last (deepest) one with the target residency less than or equal
+to the sleep length.  Then, the ``hits`` and ``misses`` metrics of that idle
+state are compared with each other and it is preselected if the ``hits`` one is
+greater (which means that that idle state is likely to "match" the observed idle
+duration after CPU wakeup).  If the ``misses`` one is greater, the governor
+preselects the shallower idle state with the maximum ``early_hits`` metric
+(or if there are multiple shallower idle states with equal ``early_hits``
+metric which also is the maximum, the shallowest of them will be preselected).
+[If there is a wakeup latency constraint coming from the `PM QoS framework
+<cpu-pm-qos_>`_ which is hit before reaching the deepest idle state with the
+target residency within the sleep length, the deepest idle state with the exit
+latency within the constraint is preselected without consulting the ``hits``,
+``misses`` and ``early_hits`` metrics.]
+
+Next, the governor takes several idle duration values observed most recently
+into consideration and if at least a half of them are greater than or equal to
+the target residency of the preselected idle state, that idle state becomes the
+final candidate to ask for.  Otherwise, the average of the most recent idle
+duration values below the target residency of the preselected idle state is
+computed and the governor walks the idle states shallower than the preselected
+one and finds the deepest of them with the target residency within that average.
+That idle state is then taken as the final candidate to ask for.
+
+Still, at this point the governor may need to refine the idle state selection if
+it has not decided to `stop the scheduler tick <idle-cpus-and-tick_>`_.  That
+generally happens if the target residency of the idle state selected so far is
+less than the tick period and the tick has not been stopped already (in a
+previous iteration of the idle loop).  Then, like in the ``menu`` governor
+`case <menu-gov_>`_, the sleep length used in the previous computations may not
+reflect the real time until the closest timer event and if it really is greater
+than that time, a shallower state with a suitable target residency may need to
+be selected.
+
+
 .. _idle-states-representation:
 
 Representation of Idle States
diff --git a/Documentation/cpuidle/driver.txt b/Documentation/cpuidle/driver.txt
deleted file mode 100644
index 1b0d81d92583..000000000000
--- a/Documentation/cpuidle/driver.txt
+++ /dev/null
@@ -1,37 +0,0 @@
-
-
-                Supporting multiple CPU idle levels in kernel
-
-                                cpuidle drivers
-
-
-
-
-cpuidle driver hooks into the cpuidle infrastructure and handles the
-architecture/platform dependent part of CPU idle states. Driver
-provides the platform idle state detection capability and also
-has mechanisms in place to support actual entry-exit into CPU idle states.
-
-cpuidle driver initializes the cpuidle_device structure for each CPU device
-and registers with cpuidle using cpuidle_register_device.
-
-If all the idle states are the same, the wrapper function cpuidle_register
-could be used instead.
-
-It can also support the dynamic changes (like battery <-> AC), by using
-cpuidle_pause_and_lock, cpuidle_disable_device and cpuidle_enable_device,
-cpuidle_resume_and_unlock.
-
-Interfaces:
-extern int cpuidle_register(struct cpuidle_driver *drv,
-                            const struct cpumask *const coupled_cpus);
-extern int cpuidle_unregister(struct cpuidle_driver *drv);
-extern int cpuidle_register_driver(struct cpuidle_driver *drv);
-extern void cpuidle_unregister_driver(struct cpuidle_driver *drv);
-extern int cpuidle_register_device(struct cpuidle_device *dev);
-extern void cpuidle_unregister_device(struct cpuidle_device *dev);
-
-extern void cpuidle_pause_and_lock(void);
-extern void cpuidle_resume_and_unlock(void);
-extern int cpuidle_enable_device(struct cpuidle_device *dev);
-extern void cpuidle_disable_device(struct cpuidle_device *dev);
diff --git a/Documentation/cpuidle/governor.txt b/Documentation/cpuidle/governor.txt
deleted file mode 100644
index d9020f5e847b..000000000000
--- a/Documentation/cpuidle/governor.txt
+++ /dev/null
@@ -1,28 +0,0 @@
-
-
-
-                Supporting multiple CPU idle levels in kernel
-
-                                cpuidle governors
-
-
-
-
-cpuidle governor is policy routine that decides what idle state to enter at
-any given time. cpuidle core uses different callbacks to the governor.
-
-* enable() to enable governor for a particular device
-* disable() to disable governor for a particular device
-* select() to select an idle state to enter
-* reflect() called after returning from the idle state, which can be used
-  by the governor for some record keeping.
-
-More than one governor can be registered at the same time and
-users can switch between drivers using /sysfs interface (when enabled).
-More than one governor part is supported for developers to easily experiment
-with different governors. By default, most optimal governor based on your
-kernel configuration and platform will be selected by cpuidle.
-
-Interfaces:
-extern int cpuidle_register_governor(struct cpuidle_governor *gov);
-struct cpuidle_governor
diff --git a/Documentation/driver-api/pm/cpuidle.rst b/Documentation/driver-api/pm/cpuidle.rst
new file mode 100644
index 000000000000..5842ab621a58
--- /dev/null
+++ b/Documentation/driver-api/pm/cpuidle.rst
@@ -0,0 +1,282 @@
+.. |struct cpuidle_governor| replace:: :c:type:`struct cpuidle_governor <cpuidle_governor>`
+.. |struct cpuidle_device| replace:: :c:type:`struct cpuidle_device <cpuidle_device>`
+.. |struct cpuidle_driver| replace:: :c:type:`struct cpuidle_driver <cpuidle_driver>`
+.. |struct cpuidle_state| replace:: :c:type:`struct cpuidle_state <cpuidle_state>`
+
+========================
+CPU Idle Time Management
+========================
+
+::
+
+ Copyright (c) 2019 Intel Corp., Rafael J. Wysocki <rafael.j.wysocki@intel.com>
+
+
+CPU Idle Time Management Subsystem
+==================================
+
+Every time one of the logical CPUs in the system (the entities that appear to
+fetch and execute instructions: hardware threads, if present, or processor
+cores) is idle after an interrupt or equivalent wakeup event, which means that
+there are no tasks to run on it except for the special "idle" task associated
+with it, there is an opportunity to save energy for the processor that it
+belongs to.  That can be done by making the idle logical CPU stop fetching
+instructions from memory and putting some of the processor's functional units
+depended on by it into an idle state in which they will draw less power.
+
+However, there may be multiple different idle states that can be used in such a
+situation in principle, so it may be necessary to find the most suitable one
+(from the kernel perspective) and ask the processor to use (or "enter") that
+particular idle state.  That is the role of the CPU idle time management
+subsystem in the kernel, called ``CPUIdle``.
+
+The design of ``CPUIdle`` is modular and based on the code duplication avoidance
+principle, so the generic code that in principle need not depend on the hardware
+or platform design details in it is separate from the code that interacts with
+the hardware.  It generally is divided into three categories of functional
+units: *governors* responsible for selecting idle states to ask the processor
+to enter, *drivers* that pass the governors' decisions on to the hardware and
+the *core* providing a common framework for them.
+
+
+CPU Idle Time Governors
+=======================
+
+A CPU idle time (``CPUIdle``) governor is a bundle of policy code invoked when
+one of the logical CPUs in the system turns out to be idle.  Its role is to
+select an idle state to ask the processor to enter in order to save some energy.
+
+``CPUIdle`` governors are generic and each of them can be used on any hardware
+platform that the Linux kernel can run on.  For this reason, data structures
+operated on by them cannot depend on any hardware architecture or platform
+design details as well.
+
+The governor itself is represented by a |struct cpuidle_governor| object
+containing four callback pointers, :c:member:`enable`, :c:member:`disable`,
+:c:member:`select`, :c:member:`reflect`, a :c:member:`rating` field described
+below, and a name (string) used for identifying it.
+
+For the governor to be available at all, that object needs to be registered
+with the ``CPUIdle`` core by calling :c:func:`cpuidle_register_governor()` with
+a pointer to it passed as the argument.  If successful, that causes the core to
+add the governor to the global list of available governors and, if it is the
+only one in the list (that is, the list was empty before) or the value of its
+:c:member:`rating` field is greater than the value of that field for the
+governor currently in use, or the name of the new governor was passed to the
+kernel as the value of the ``cpuidle.governor=`` command line parameter, the new
+governor will be used from that point on (there can be only one ``CPUIdle``
+governor in use at a time).  Also, if ``cpuidle_sysfs_switch`` is passed to the
+kernel in the command line, user space can choose the ``CPUIdle`` governor to
+use at run time via ``sysfs``.
+
+Once registered, ``CPUIdle`` governors cannot be unregistered, so it is not
+practical to put them into loadable kernel modules.
+
+The interface between ``CPUIdle`` governors and the core consists of four
+callbacks:
+
+:c:member:`enable`
+        ::
+
+          int (*enable) (struct cpuidle_driver *drv, struct cpuidle_device *dev);
+
+        The role of this callback is to prepare the governor for handling the
+        (logical) CPU represented by the |struct cpuidle_device| object pointed
+        to by the ``dev`` argument.  The |struct cpuidle_driver| object pointed
+        to by the ``drv`` argument represents the ``CPUIdle`` driver to be used
+        with that CPU (among other things, it should contain the list of
+        |struct cpuidle_state| objects representing idle states that the
+        processor holding the given CPU can be asked to enter).
+
+        It may fail, in which case it is expected to return a negative error
+        code, and that causes the kernel to run the architecture-specific
+        default code for idle CPUs on the CPU in question instead of ``CPUIdle``
+        until the ``->enable()`` governor callback is invoked for that CPU
+        again.
+
+:c:member:`disable`
+        ::
+
+          void (*disable) (struct cpuidle_driver *drv, struct cpuidle_device *dev);
+
+        Called to make the governor stop handling the (logical) CPU represented
+        by the |struct cpuidle_device| object pointed to by the ``dev``
+        argument.
+
+        It is expected to reverse any changes made by the ``->enable()``
+        callback when it was last invoked for the target CPU, free all memory
+        allocated by that callback and so on.
+
+:c:member:`select`
+        ::
+
+          int (*select) (struct cpuidle_driver *drv, struct cpuidle_device *dev,
+                         bool *stop_tick);
+
+        Called to select an idle state for the processor holding the (logical)
+        CPU represented by the |struct cpuidle_device| object pointed to by the
+        ``dev`` argument.
+
+        The list of idle states to take into consideration is represented by the
+        :c:member:`states` array of |struct cpuidle_state| objects held by the
+        |struct cpuidle_driver| object pointed to by the ``drv`` argument (which
+        represents the ``CPUIdle`` driver to be used with the CPU at hand).  The
+        value returned by this callback is interpreted as an index into that
+        array (unless it is a negative error code).
+
+        The ``stop_tick`` argument is used to indicate whether or not to stop
+        the scheduler tick before asking the processor to enter the selected
+        idle state.  When the ``bool`` variable pointed to by it (which is set
+        to ``true`` before invoking this callback) is cleared to ``false``, the
+        processor will be asked to enter the selected idle state without
+        stopping the scheduler tick on the given CPU (if the tick has been
+        stopped on that CPU already, however, it will not be restarted before
+        asking the processor to enter the idle state).
+
+        This callback is mandatory (i.e. the :c:member:`select` callback pointer
+        in |struct cpuidle_governor| must not be ``NULL`` for the registration
+        of the governor to succeed).
+
+:c:member:`reflect`
+        ::
+
+          void (*reflect) (struct cpuidle_device *dev, int index);
+
+        Called to allow the governor to evaluate the accuracy of the idle state
+        selection made by the ``->select()`` callback (when it was invoked last
+        time) and possibly use the result of that to improve the accuracy of
+        idle state selections in the future.
+
+In addition, ``CPUIdle`` governors are required to take power management
+quality of service (PM QoS) constraints on the processor wakeup latency into
+account when selecting idle states.  In order to obtain the current effective
+PM QoS wakeup latency constraint for a given CPU, a ``CPUIdle`` governor is
+expected to pass the number of the CPU to
+:c:func:`cpuidle_governor_latency_req()`.  Then, the governor's ``->select()``
+callback must not return the index of an indle state whose
+:c:member:`exit_latency` value is greater than the number returned by that
+function.
+
+
+CPU Idle Time Management Drivers
+================================
+
+CPU idle time management (``CPUIdle``) drivers provide an interface between the
+other parts of ``CPUIdle`` and the hardware.
+
+First of all, a ``CPUIdle`` driver has to populate the :c:member:`states` array
+of |struct cpuidle_state| objects included in the |struct cpuidle_driver| object
+representing it.  Going forward this array will represent the list of available
+idle states that the processor hardware can be asked to enter shared by all of
+the logical CPUs handled by the given driver.
+
+The entries in the :c:member:`states` array are expected to be sorted by the
+value of the :c:member:`target_residency` field in |struct cpuidle_state| in
+the ascending order (that is, index 0 should correspond to the idle state with
+the minimum value of :c:member:`target_residency`).  [Since the
+:c:member:`target_residency` value is expected to reflect the "depth" of the
+idle state represented by the |struct cpuidle_state| object holding it, this
+sorting order should be the same as the ascending sorting order by the idle
+state "depth".]
+
+Three fields in |struct cpuidle_state| are used by the existing ``CPUIdle``
+governors for computations related to idle state selection:
+
+:c:member:`target_residency`
+        Minimum time to spend in this idle state including the time needed to
+        enter it (which may be substantial) to save more energy than could
+        be saved by staying in a shallower idle state for the same amount of
+        time, in microseconds.
+
+:c:member:`exit_latency`
+        Maximum time it will take a CPU asking the processor to enter this idle
+        state to start executing the first instruction after a wakeup from it,
+        in microseconds.
+
+:c:member:`flags`
+        Flags representing idle state properties.  Currently, governors only use
+        the ``CPUIDLE_FLAG_POLLING`` flag which is set if the given object
+        does not represent a real idle state, but an interface to a software
+        "loop" that can be used in order to avoid asking the processor to enter
+        any idle state at all.  [There are other flags used by the ``CPUIdle``
+        core in special situations.]
+
+The :c:member:`enter` callback pointer in |struct cpuidle_state|, which must not
+be ``NULL``, points to the routine to execute in order to ask the processor to
+enter this particular idle state:
+
+::
+
+  void (*enter) (struct cpuidle_device *dev, struct cpuidle_driver *drv,
+                 int index);
+
+The first two arguments of it point to the |struct cpuidle_device| object
+representing the logical CPU running this callback and the
+|struct cpuidle_driver| object representing the driver itself, respectively,
+and the last one is an index of the |struct cpuidle_state| entry in the driver's
+:c:member:`states` array representing the idle state to ask the processor to
+enter.
+
+The analogous ``->enter_s2idle()`` callback in |struct cpuidle_state| is used
+only for implementing the suspend-to-idle system-wide power management feature.
+The difference between in and ``->enter()`` is that it must not re-enable
+interrupts at any point (even temporarily) or attempt to change the states of
+clock event devices, which the ``->enter()`` callback may do sometimes.
+
+Once the :c:member:`states` array has been populated, the number of valid
+entries in it has to be stored in the :c:member:`state_count` field of the
+|struct cpuidle_driver| object representing the driver.  Moreover, if any
+entries in the :c:member:`states` array represent "coupled" idle states (that
+is, idle states that can only be asked for if multiple related logical CPUs are
+idle), the :c:member:`safe_state_index` field in |struct cpuidle_driver| needs
+to be the index of an idle state that is not "coupled" (that is, one that can be
+asked for if only one logical CPU is idle).
+
+In addition to that, if the given ``CPUIdle`` driver is only going to handle a
+subset of logical CPUs in the system, the :c:member:`cpumask` field in its
+|struct cpuidle_driver| object must point to the set (mask) of CPUs that will be
+handled by it.
+
+A ``CPUIdle`` driver can only be used after it has been registered.  If there
+are no "coupled" idle state entries in the driver's :c:member:`states` array,
+that can be accomplished by passing the driver's |struct cpuidle_driver| object
+to :c:func:`cpuidle_register_driver()`.  Otherwise, :c:func:`cpuidle_register()`
+should be used for this purpose.
+
+However, it also is necessary to register |struct cpuidle_device| objects for
+all of the logical CPUs to be handled by the given ``CPUIdle`` driver with the
+help of :c:func:`cpuidle_register_device()` after the driver has been registered
+and :c:func:`cpuidle_register_driver()`, unlike :c:func:`cpuidle_register()`,
+does not do that automatically.  For this reason, the drivers that use
+:c:func:`cpuidle_register_driver()` to register themselves must also take care
+of registering the |struct cpuidle_device| objects as needed, so it is generally
+recommended to use :c:func:`cpuidle_register()` for ``CPUIdle`` driver
+registration in all cases.
+
+The registration of a |struct cpuidle_device| object causes the ``CPUIdle``
+``sysfs`` interface to be created and the governor's ``->enable()`` callback to
+be invoked for the logical CPU represented by it, so it must take place after
+registering the driver that will handle the CPU in question.
+
+``CPUIdle`` drivers and |struct cpuidle_device| objects can be unregistered
+when they are not necessary any more which allows some resources associated with
+them to be released.  Due to dependencies between them, all of the
+|struct cpuidle_device| objects representing CPUs handled by the given
+``CPUIdle`` driver must be unregistered, with the help of
+:c:func:`cpuidle_unregister_device()`, before calling
+:c:func:`cpuidle_unregister_driver()` to unregister the driver.  Alternatively,
+:c:func:`cpuidle_unregister()` can be called to unregister a ``CPUIdle`` driver
+along with all of the |struct cpuidle_device| objects representing CPUs handled
+by it.
+
+``CPUIdle`` drivers can respond to runtime system configuration changes that
+lead to modifications of the list of available processor idle states (which can
+happen, for example, when the system's power source is switched from AC to
+battery or the other way around).  Upon a notification of such a change,
+a ``CPUIdle`` driver is expected to call :c:func:`cpuidle_pause_and_lock()` to
+turn ``CPUIdle`` off temporarily and then :c:func:`cpuidle_disable_device()` for
+all of the |struct cpuidle_device| objects representing CPUs affected by that
+change.  Next, it can update its :c:member:`states` array in accordance with
+the new configuration of the system, call :c:func:`cpuidle_enable_device()` for
+all of the relevant |struct cpuidle_device| objects and invoke
+:c:func:`cpuidle_resume_and_unlock()` to allow ``CPUIdle`` to be used again.
diff --git a/Documentation/driver-api/pm/index.rst b/Documentation/driver-api/pm/index.rst
index 2f6d0e9cf6b7..56975c6bc789 100644
--- a/Documentation/driver-api/pm/index.rst
+++ b/Documentation/driver-api/pm/index.rst
@@ -1,9 +1,10 @@
-=======================
-Device Power Management
-=======================
+===============================
+CPU and Device Power Management
+===============================
 
 .. toctree::
 
+   cpuidle
    devices
    notifiers
    types
diff --git a/MAINTAINERS b/MAINTAINERS
index 3f2c6d697cab..d8db9ad441c3 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -4022,6 +4022,7 @@ S:	Maintained
 T:      git git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm.git
 B:      https://bugzilla.kernel.org
 F:      Documentation/admin-guide/pm/cpuidle.rst
+F:      Documentation/driver-api/pm/cpuidle.rst
 F:      drivers/cpuidle/*
 F:      include/linux/cpuidle.h
 
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index b2131c4ea124..98d4ec5bf450 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -282,6 +282,13 @@ static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr)
                           pr->power.states[ACPI_STATE_C2].address,
                           pr->power.states[ACPI_STATE_C3].address));
 
+        snprintf(pr->power.states[ACPI_STATE_C2].desc,
+                         ACPI_CX_DESC_LEN, "ACPI P_LVL2 IOPORT 0x%x",
+                         pr->power.states[ACPI_STATE_C2].address);
+        snprintf(pr->power.states[ACPI_STATE_C3].desc,
+                         ACPI_CX_DESC_LEN, "ACPI P_LVL3 IOPORT 0x%x",
+                         pr->power.states[ACPI_STATE_C3].address);
+
         return 0;
 }
 
diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c
index eb9443d5bae1..6ce93a52bf3f 100644
--- a/drivers/base/cpu.c
+++ b/drivers/base/cpu.c
@@ -427,6 +427,7 @@ __cpu_device_create(struct device *parent, void *drvdata,
         dev->parent = parent;
         dev->groups = groups;
         dev->release = device_create_release;
+        device_set_pm_not_required(dev);
         dev_set_drvdata(dev, drvdata);
 
         retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
diff --git a/drivers/base/power/clock_ops.c b/drivers/base/power/clock_ops.c
index 5a42ae4078c2..365ad751ce0f 100644
--- a/drivers/base/power/clock_ops.c
+++ b/drivers/base/power/clock_ops.c
@@ -65,10 +65,15 @@ static void pm_clk_acquire(struct device *dev, struct pm_clock_entry *ce)
         if (IS_ERR(ce->clk)) {
                 ce->status = PCE_STATUS_ERROR;
         } else {
-                clk_prepare(ce->clk);
-                ce->status = PCE_STATUS_ACQUIRED;
-                dev_dbg(dev, "Clock %pC con_id %s managed by runtime PM.\n",
-                        ce->clk, ce->con_id);
+                if (clk_prepare(ce->clk)) {
+                        ce->status = PCE_STATUS_ERROR;
+                        dev_err(dev, "clk_prepare() failed\n");
+                } else {
+                        ce->status = PCE_STATUS_ACQUIRED;
+                        dev_dbg(dev,
+                                "Clock %pC con_id %s managed by runtime PM.\n",
+                                ce->clk, ce->con_id);
+                }
         }
 }
 
diff --git a/drivers/base/power/common.c b/drivers/base/power/common.c
index b413951c6abc..22aedb28aad7 100644
--- a/drivers/base/power/common.c
+++ b/drivers/base/power/common.c
@@ -160,7 +160,7 @@ EXPORT_SYMBOL_GPL(dev_pm_domain_attach_by_id);
  * For a detailed function description, see dev_pm_domain_attach_by_id().
  */
 struct device *dev_pm_domain_attach_by_name(struct device *dev,
-                                            char *name)
+                                            const char *name)
 {
         if (dev->pm_domain)
                 return ERR_PTR(-EEXIST);
diff --git a/drivers/base/power/domain.c b/drivers/base/power/domain.c
index 500de1dee967..2c334c01fc43 100644
--- a/drivers/base/power/domain.c
+++ b/drivers/base/power/domain.c
@@ -2483,7 +2483,7 @@ EXPORT_SYMBOL_GPL(genpd_dev_pm_attach_by_id);
  * power-domain-names DT property. For further description see
  * genpd_dev_pm_attach_by_id().
  */
-struct device *genpd_dev_pm_attach_by_name(struct device *dev, char *name)
+struct device *genpd_dev_pm_attach_by_name(struct device *dev, const char *name)
 {
         int index;
 
@@ -2948,18 +2948,11 @@ static int __init genpd_debug_init(void)
 
         genpd_debugfs_dir = debugfs_create_dir("pm_genpd", NULL);
 
-        if (!genpd_debugfs_dir)
-                return -ENOMEM;
-
-        d = debugfs_create_file("pm_genpd_summary", S_IRUGO,
-                        genpd_debugfs_dir, NULL, &summary_fops);
-        if (!d)
-                return -ENOMEM;
+        debugfs_create_file("pm_genpd_summary", S_IRUGO, genpd_debugfs_dir,
+                            NULL, &summary_fops);
 
         list_for_each_entry(genpd, &gpd_list, gpd_list_node) {
                 d = debugfs_create_dir(genpd->name, genpd_debugfs_dir);
-                if (!d)
-                        return -ENOMEM;
 
                 debugfs_create_file("current_state", 0444,
                                 d, genpd, &status_fops);
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 0992e67e862b..893ae464bfd6 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -124,6 +124,10 @@ void device_pm_unlock(void)
  */
 void device_pm_add(struct device *dev)
 {
+        /* Skip PM setup/initialization. */
+        if (device_pm_not_required(dev))
+                return;
+
         pr_debug("PM: Adding info for %s:%s\n",
                  dev->bus ? dev->bus->name : "No Bus", dev_name(dev));
         device_pm_check_callbacks(dev);
@@ -142,6 +146,9 @@ void device_pm_add(struct device *dev)
  */
 void device_pm_remove(struct device *dev)
 {
+        if (device_pm_not_required(dev))
+                return;
+
         pr_debug("PM: Removing info for %s:%s\n",
                  dev->bus ? dev->bus->name : "No Bus", dev_name(dev));
         complete_all(&dev->power.completion);
@@ -1741,8 +1748,10 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
         if (dev->power.direct_complete) {
                 if (pm_runtime_status_suspended(dev)) {
                         pm_runtime_disable(dev);
-                        if (pm_runtime_status_suspended(dev))
+                        if (pm_runtime_status_suspended(dev)) {
+                                pm_dev_dbg(dev, state, "direct-complete ");
                                 goto Complete;
+                        }
 
                         pm_runtime_enable(dev);
                 }
diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
index 0ea2139c50d8..78937c45278c 100644
--- a/drivers/base/power/runtime.c
+++ b/drivers/base/power/runtime.c
@@ -66,20 +66,30 @@ static int rpm_suspend(struct device *dev, int rpmflags);
  */
 void update_pm_runtime_accounting(struct device *dev)
 {
-        unsigned long now = jiffies;
-        unsigned long delta;
+        u64 now, last, delta;
 
-        delta = now - dev->power.accounting_timestamp;
+        if (dev->power.disable_depth > 0)
+                return;
+
+        last = dev->power.accounting_timestamp;
 
+        now = ktime_get_mono_fast_ns();
         dev->power.accounting_timestamp = now;
 
-        if (dev->power.disable_depth > 0)
+        /*
+         * Because ktime_get_mono_fast_ns() is not monotonic during
+         * timekeeping updates, ensure that 'now' is after the last saved
+         * timesptamp.
+         */
+        if (now < last)
                 return;
 
+        delta = now - last;
+
         if (dev->power.runtime_status == RPM_SUSPENDED)
-                dev->power.suspended_jiffies += delta;
+                dev->power.suspended_time += delta;
         else
-                dev->power.active_jiffies += delta;
+                dev->power.active_time += delta;
 }
 
 static void __update_runtime_status(struct device *dev, enum rpm_status status)
@@ -88,6 +98,22 @@ static void __update_runtime_status(struct device *dev, enum rpm_status status)
         dev->power.runtime_status = status;
 }
 
+u64 pm_runtime_suspended_time(struct device *dev)
+{
+        u64 time;
+        unsigned long flags;
+
+        spin_lock_irqsave(&dev->power.lock, flags);
+
+        update_pm_runtime_accounting(dev);
+        time = dev->power.suspended_time;
+
+        spin_unlock_irqrestore(&dev->power.lock, flags);
+
+        return time;
+}
+EXPORT_SYMBOL_GPL(pm_runtime_suspended_time);
+
 /**
  * pm_runtime_deactivate_timer - Deactivate given device's suspend timer.
  * @dev: Device to handle.
@@ -95,7 +121,7 @@ static void __update_runtime_status(struct device *dev, enum rpm_status status)
 static void pm_runtime_deactivate_timer(struct device *dev)
 {
         if (dev->power.timer_expires > 0) {
-                hrtimer_cancel(&dev->power.suspend_timer);
+                hrtimer_try_to_cancel(&dev->power.suspend_timer);
                 dev->power.timer_expires = 0;
         }
 }
@@ -129,24 +155,21 @@ static void pm_runtime_cancel_pending(struct device *dev)
 u64 pm_runtime_autosuspend_expiration(struct device *dev)
 {
         int autosuspend_delay;
-        u64 last_busy, expires = 0;
-        u64 now = ktime_get_mono_fast_ns();
+        u64 expires;
 
         if (!dev->power.use_autosuspend)
-                goto out;
+                return 0;
 
         autosuspend_delay = READ_ONCE(dev->power.autosuspend_delay);
         if (autosuspend_delay < 0)
-                goto out;
-
-        last_busy = READ_ONCE(dev->power.last_busy);
+                return 0;
 
-        expires = last_busy + (u64)autosuspend_delay * NSEC_PER_MSEC;
-        if (expires <= now)
-                expires = 0;    /* Already expired. */
+        expires  = READ_ONCE(dev->power.last_busy);
+        expires += (u64)autosuspend_delay * NSEC_PER_MSEC;
+        if (expires > ktime_get_mono_fast_ns())
+                return expires; /* Expires in the future */
 
- out:
-        return expires;
+        return 0;
 }
 EXPORT_SYMBOL_GPL(pm_runtime_autosuspend_expiration);
 
@@ -1276,6 +1299,9 @@ void __pm_runtime_disable(struct device *dev, bool check_resume)
                 pm_runtime_put_noidle(dev);
         }
 
+        /* Update time accounting before disabling PM-runtime. */
+        update_pm_runtime_accounting(dev);
+
         if (!dev->power.disable_depth++)
                 __pm_runtime_barrier(dev);
 
@@ -1294,10 +1320,15 @@ void pm_runtime_enable(struct device *dev)
 
         spin_lock_irqsave(&dev->power.lock, flags);
 
-        if (dev->power.disable_depth > 0)
+        if (dev->power.disable_depth > 0) {
                 dev->power.disable_depth--;
-        else
+
+                /* About to enable runtime pm, set accounting_timestamp to now */
+                if (!dev->power.disable_depth)
+                        dev->power.accounting_timestamp = ktime_get_mono_fast_ns();
+        } else {
                 dev_warn(dev, "Unbalanced %s!\n", __func__);
+        }
 
         WARN(!dev->power.disable_depth &&
              dev->power.runtime_status == RPM_SUSPENDED &&
@@ -1494,7 +1525,6 @@ void pm_runtime_init(struct device *dev)
         dev->power.request_pending = false;
         dev->power.request = RPM_REQ_NONE;
         dev->power.deferred_resume = false;
-        dev->power.accounting_timestamp = jiffies;
         INIT_WORK(&dev->power.work, pm_runtime_work);
 
         dev->power.timer_expires = 0;
diff --git a/drivers/base/power/sysfs.c b/drivers/base/power/sysfs.c
index d713738ce796..c6bf76124184 100644
--- a/drivers/base/power/sysfs.c
+++ b/drivers/base/power/sysfs.c
@@ -125,9 +125,12 @@ static ssize_t runtime_active_time_show(struct device *dev,
                                 struct device_attribute *attr, char *buf)
 {
         int ret;
+        u64 tmp;
         spin_lock_irq(&dev->power.lock);
         update_pm_runtime_accounting(dev);
-        ret = sprintf(buf, "%i\n", jiffies_to_msecs(dev->power.active_jiffies));
+        tmp = dev->power.active_time;
+        do_div(tmp, NSEC_PER_MSEC);
+        ret = sprintf(buf, "%llu\n", tmp);
         spin_unlock_irq(&dev->power.lock);
         return ret;
 }
@@ -138,10 +141,12 @@ static ssize_t runtime_suspended_time_show(struct device *dev,
                                 struct device_attribute *attr, char *buf)
 {
         int ret;
+        u64 tmp;
         spin_lock_irq(&dev->power.lock);
         update_pm_runtime_accounting(dev);
-        ret = sprintf(buf, "%i\n",
-                jiffies_to_msecs(dev->power.suspended_jiffies));
+        tmp = dev->power.suspended_time;
+        do_div(tmp, NSEC_PER_MSEC);
+        ret = sprintf(buf, "%llu\n", tmp);
         spin_unlock_irq(&dev->power.lock);
         return ret;
 }
@@ -648,6 +653,10 @@ int dpm_sysfs_add(struct device *dev)
 {
         int rc;
 
+        /* No need to create PM sysfs if explicitly disabled. */
+        if (device_pm_not_required(dev))
+                return 0;
+
         rc = sysfs_create_group(&dev->kobj, &pm_attr_group);
         if (rc)
                 return rc;
@@ -727,6 +736,8 @@ void rpm_sysfs_remove(struct device *dev)
 
 void dpm_sysfs_remove(struct device *dev)
 {
+        if (device_pm_not_required(dev))
+                return;
         sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
         dev_pm_qos_constraints_destroy(dev);
         rpm_sysfs_remove(dev);
diff --git a/drivers/base/power/wakeup.c b/drivers/base/power/wakeup.c
index 5fa1898755a3..f1fee72ed970 100644
--- a/drivers/base/power/wakeup.c
+++ b/drivers/base/power/wakeup.c
@@ -783,7 +783,7 @@ void pm_wakeup_ws_event(struct wakeup_source *ws, unsigned int msec, bool hard)
 EXPORT_SYMBOL_GPL(pm_wakeup_ws_event);
 
 /**
- * pm_wakeup_event - Notify the PM core of a wakeup event.
+ * pm_wakeup_dev_event - Notify the PM core of a wakeup event.
  * @dev: Device the wakeup event is related to.
  * @msec: Anticipated event processing time (in milliseconds).
  * @hard: If set, abort suspends in progress and wake up from suspend-to-idle.
diff --git a/drivers/cpuidle/Kconfig b/drivers/cpuidle/Kconfig
index 7e48eb5bf0a7..8caccbbd7353 100644
--- a/drivers/cpuidle/Kconfig
+++ b/drivers/cpuidle/Kconfig
@@ -4,7 +4,7 @@ config CPU_IDLE
         bool "CPU idle PM support"
         default y if ACPI || PPC_PSERIES
         select CPU_IDLE_GOV_LADDER if (!NO_HZ && !NO_HZ_IDLE)
-        select CPU_IDLE_GOV_MENU if (NO_HZ || NO_HZ_IDLE)
+        select CPU_IDLE_GOV_MENU if (NO_HZ || NO_HZ_IDLE) && !CPU_IDLE_GOV_TEO
         help
           CPU idle is a generic framework for supporting software-controlled
           idle processor power management.  It includes modular cross-platform
@@ -23,6 +23,15 @@ config CPU_IDLE_GOV_LADDER
 config CPU_IDLE_GOV_MENU
         bool "Menu governor (for tickless system)"
 
+config CPU_IDLE_GOV_TEO
+        bool "Timer events oriented (TEO) governor (for tickless systems)"
+        help
+          This governor implements a simplified idle state selection method
+          focused on timer events and does not do any interactivity boosting.
+
+          Some workloads benefit from using it and it generally should be safe
+          to use.  Say Y here if you are not happy with the alternatives.
+
 config DT_IDLE_STATES
         bool
 
diff --git a/drivers/cpuidle/dt_idle_states.c b/drivers/cpuidle/dt_idle_states.c
index 53342b7f1010..add9569636b5 100644
--- a/drivers/cpuidle/dt_idle_states.c
+++ b/drivers/cpuidle/dt_idle_states.c
@@ -22,16 +22,12 @@
 #include "dt_idle_states.h"
 
 static int init_state_node(struct cpuidle_state *idle_state,
-                           const struct of_device_id *matches,
+                           const struct of_device_id *match_id,
                            struct device_node *state_node)
 {
         int err;
-        const struct of_device_id *match_id;
         const char *desc;
 
-        match_id = of_match_node(matches, state_node);
-        if (!match_id)
-                return -ENODEV;
         /*
          * CPUidle drivers are expected to initialize the const void *data
          * pointer of the passed in struct of_device_id array to the idle
@@ -160,6 +156,7 @@ int dt_init_idle_driver(struct cpuidle_driver *drv,
 {
         struct cpuidle_state *idle_state;
         struct device_node *state_node, *cpu_node;
+        const struct of_device_id *match_id;
         int i, err = 0;
         const cpumask_t *cpumask;
         unsigned int state_idx = start_idx;
@@ -180,6 +177,12 @@ int dt_init_idle_driver(struct cpuidle_driver *drv,
                 if (!state_node)
                         break;
 
+                match_id = of_match_node(matches, state_node);
+                if (!match_id) {
+                        err = -ENODEV;
+                        break;
+                }
+
                 if (!of_device_is_available(state_node)) {
                         of_node_put(state_node);
                         continue;
@@ -198,7 +201,7 @@ int dt_init_idle_driver(struct cpuidle_driver *drv,
                 }
 
                 idle_state = &drv->states[state_idx++];
-                err = init_state_node(idle_state, matches, state_node);
+                err = init_state_node(idle_state, match_id, state_node);
                 if (err) {
                         pr_err("Parsing idle state node %pOF failed with err %d\n",
                                state_node, err);
diff --git a/drivers/cpuidle/governors/Makefile b/drivers/cpuidle/governors/Makefile
index 1b512722689f..4d8aff5248a8 100644
--- a/drivers/cpuidle/governors/Makefile
+++ b/drivers/cpuidle/governors/Makefile
@@ -4,3 +4,4 @@
 
 obj-$(CONFIG_CPU_IDLE_GOV_LADDER) += ladder.o
 obj-$(CONFIG_CPU_IDLE_GOV_MENU) += menu.o
+obj-$(CONFIG_CPU_IDLE_GOV_TEO) += teo.o
diff --git a/drivers/cpuidle/governors/teo.c b/drivers/cpuidle/governors/teo.c
new file mode 100644
index 000000000000..7d05efdbd3c6
--- /dev/null
+++ b/drivers/cpuidle/governors/teo.c
@@ -0,0 +1,444 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Timer events oriented CPU idle governor
+ *
+ * Copyright (C) 2018 Intel Corporation
+ * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
+ *
+ * The idea of this governor is based on the observation that on many systems
+ * timer events are two or more orders of magnitude more frequent than any
+ * other interrupts, so they are likely to be the most significant source of CPU
+ * wakeups from idle states.  Moreover, information about what happened in the
+ * (relatively recent) past can be used to estimate whether or not the deepest
+ * idle state with target residency within the time to the closest timer is
+ * likely to be suitable for the upcoming idle time of the CPU and, if not, then
+ * which of the shallower idle states to choose.
+ *
+ * Of course, non-timer wakeup sources are more important in some use cases and
+ * they can be covered by taking a few most recent idle time intervals of the
+ * CPU into account.  However, even in that case it is not necessary to consider
+ * idle duration values greater than the time till the closest timer, as the
+ * patterns that they may belong to produce average values close enough to
+ * the time till the closest timer (sleep length) anyway.
+ *
+ * Thus this governor estimates whether or not the upcoming idle time of the CPU
+ * is likely to be significantly shorter than the sleep length and selects an
+ * idle state for it in accordance with that, as follows:
+ *
+ * - Find an idle state on the basis of the sleep length and state statistics
+ *   collected over time:
+ *
+ *   o Find the deepest idle state whose target residency is less than or equal
+ *     to the sleep length.
+ *
+ *   o Select it if it matched both the sleep length and the observed idle
+ *     duration in the past more often than it matched the sleep length alone
+ *     (i.e. the observed idle duration was significantly shorter than the sleep
+ *     length matched by it).
+ *
+ *   o Otherwise, select the shallower state with the greatest matched "early"
+ *     wakeups metric.
+ *
+ * - If the majority of the most recent idle duration values are below the
+ *   target residency of the idle state selected so far, use those values to
+ *   compute the new expected idle duration and find an idle state matching it
+ *   (which has to be shallower than the one selected so far).
+ */
+
+#include <linux/cpuidle.h>
+#include <linux/jiffies.h>
+#include <linux/kernel.h>
+#include <linux/sched/clock.h>
+#include <linux/tick.h>
+
+/*
+ * The PULSE value is added to metrics when they grow and the DECAY_SHIFT value
+ * is used for decreasing metrics on a regular basis.
+ */
+#define PULSE           1024
+#define DECAY_SHIFT     3
+
+/*
+ * Number of the most recent idle duration values to take into consideration for
+ * the detection of wakeup patterns.
+ */
+#define INTERVALS       8
+
+/**
+ * struct teo_idle_state - Idle state data used by the TEO cpuidle governor.
+ * @early_hits: "Early" CPU wakeups "matching" this state.
+ * @hits: "On time" CPU wakeups "matching" this state.
+ * @misses: CPU wakeups "missing" this state.
+ *
+ * A CPU wakeup is "matched" by a given idle state if the idle duration measured
+ * after the wakeup is between the target residency of that state and the target
+ * residency of the next one (or if this is the deepest available idle state, it
+ * "matches" a CPU wakeup when the measured idle duration is at least equal to
+ * its target residency).
+ *
+ * Also, from the TEO governor perspective, a CPU wakeup from idle is "early" if
+ * it occurs significantly earlier than the closest expected timer event (that
+ * is, early enough to match an idle state shallower than the one matching the
+ * time till the closest timer event).  Otherwise, the wakeup is "on time", or
+ * it is a "hit".
+ *
+ * A "miss" occurs when the given state doesn't match the wakeup, but it matches
+ * the time till the closest timer event used for idle state selection.
+ */
+struct teo_idle_state {
+        unsigned int early_hits;
+        unsigned int hits;
+        unsigned int misses;
+};
+
+/**
+ * struct teo_cpu - CPU data used by the TEO cpuidle governor.
+ * @time_span_ns: Time between idle state selection and post-wakeup update.
+ * @sleep_length_ns: Time till the closest timer event (at the selection time).
+ * @states: Idle states data corresponding to this CPU.
+ * @last_state: Idle state entered by the CPU last time.
+ * @interval_idx: Index of the most recent saved idle interval.
+ * @intervals: Saved idle duration values.
+ */
+struct teo_cpu {
+        u64 time_span_ns;
+        u64 sleep_length_ns;
+        struct teo_idle_state states[CPUIDLE_STATE_MAX];
+        int last_state;
+        int interval_idx;
+        unsigned int intervals[INTERVALS];
+};
+
+static DEFINE_PER_CPU(struct teo_cpu, teo_cpus);
+
+/**
+ * teo_update - Update CPU data after wakeup.
+ * @drv: cpuidle driver containing state data.
+ * @dev: Target CPU.
+ */
+static void teo_update(struct cpuidle_driver *drv, struct cpuidle_device *dev)
+{
+        struct teo_cpu *cpu_data = per_cpu_ptr(&teo_cpus, dev->cpu);
+        unsigned int sleep_length_us = ktime_to_us(cpu_data->sleep_length_ns);
+        int i, idx_hit = -1, idx_timer = -1;
+        unsigned int measured_us;
+
+        if (cpu_data->time_span_ns >= cpu_data->sleep_length_ns) {
+                /*
+                 * One of the safety nets has triggered or this was a timer
+                 * wakeup (or equivalent).
+                 */
+                measured_us = sleep_length_us;
+        } else {
+                unsigned int lat = drv->states[cpu_data->last_state].exit_latency;
+
+                measured_us = ktime_to_us(cpu_data->time_span_ns);
+                /*
+                 * The delay between the wakeup and the first instruction
+                 * executed by the CPU is not likely to be worst-case every
+                 * time, so take 1/2 of the exit latency as a very rough
+                 * approximation of the average of it.
+                 */
+                if (measured_us >= lat)
+                        measured_us -= lat / 2;
+                else
+                        measured_us /= 2;
+        }
+
+        /*
+         * Decay the "early hits" metric for all of the states and find the
+         * states matching the sleep length and the measured idle duration.
+         */
+        for (i = 0; i < drv->state_count; i++) {
+                unsigned int early_hits = cpu_data->states[i].early_hits;
+
+                cpu_data->states[i].early_hits -= early_hits >> DECAY_SHIFT;
+
+                if (drv->states[i].target_residency <= sleep_length_us) {
+                        idx_timer = i;
+                        if (drv->states[i].target_residency <= measured_us)
+                                idx_hit = i;
+                }
+        }
+
+        /*
+         * Update the "hits" and "misses" data for the state matching the sleep
+         * length.  If it matches the measured idle duration too, this is a hit,
+         * so increase the "hits" metric for it then.  Otherwise, this is a
+         * miss, so increase the "misses" metric for it.  In the latter case
+         * also increase the "early hits" metric for the state that actually
+         * matches the measured idle duration.
+         */
+        if (idx_timer >= 0) {
+                unsigned int hits = cpu_data->states[idx_timer].hits;
+                unsigned int misses = cpu_data->states[idx_timer].misses;
+
+                hits -= hits >> DECAY_SHIFT;
+                misses -= misses >> DECAY_SHIFT;
+
+                if (idx_timer > idx_hit) {
+                        misses += PULSE;
+                        if (idx_hit >= 0)
+                                cpu_data->states[idx_hit].early_hits += PULSE;
+                } else {
+                        hits += PULSE;
+                }
+
+                cpu_data->states[idx_timer].misses = misses;
+                cpu_data->states[idx_timer].hits = hits;
+        }
+
+        /*
+         * If the total time span between idle state selection and the "reflect"
+         * callback is greater than or equal to the sleep length determined at
+         * the idle state selection time, the wakeup is likely to be due to a
+         * timer event.
+         */
+        if (cpu_data->time_span_ns >= cpu_data->sleep_length_ns)
+                measured_us = UINT_MAX;
+
+        /*
+         * Save idle duration values corresponding to non-timer wakeups for
+         * pattern detection.
+         */
+        cpu_data->intervals[cpu_data->interval_idx++] = measured_us;
+        if (cpu_data->interval_idx > INTERVALS)
+                cpu_data->interval_idx = 0;
+}
+
+/**
+ * teo_find_shallower_state - Find shallower idle state matching given duration.
+ * @drv: cpuidle driver containing state data.
+ * @dev: Target CPU.
+ * @state_idx: Index of the capping idle state.
+ * @duration_us: Idle duration value to match.
+ */
+static int teo_find_shallower_state(struct cpuidle_driver *drv,
+                                    struct cpuidle_device *dev, int state_idx,
+                                    unsigned int duration_us)
+{
+        int i;
+
+        for (i = state_idx - 1; i >= 0; i--) {
+                if (drv->states[i].disabled || dev->states_usage[i].disable)
+                        continue;
+
+                state_idx = i;
+                if (drv->states[i].target_residency <= duration_us)
+                        break;
+        }
+        return state_idx;
+}
+
+/**
+ * teo_select - Selects the next idle state to enter.
+ * @drv: cpuidle driver containing state data.
+ * @dev: Target CPU.
+ * @stop_tick: Indication on whether or not to stop the scheduler tick.
+ */
+static int teo_select(struct cpuidle_driver *drv, struct cpuidle_device *dev,
+                      bool *stop_tick)
+{
+        struct teo_cpu *cpu_data = per_cpu_ptr(&teo_cpus, dev->cpu);
+        int latency_req = cpuidle_governor_latency_req(dev->cpu);
+        unsigned int duration_us, count;
+        int max_early_idx, idx, i;
+        ktime_t delta_tick;
+
+        if (cpu_data->last_state >= 0) {
+                teo_update(drv, dev);
+                cpu_data->last_state = -1;
+        }
+
+        cpu_data->time_span_ns = local_clock();
+
+        cpu_data->sleep_length_ns = tick_nohz_get_sleep_length(&delta_tick);
+        duration_us = ktime_to_us(cpu_data->sleep_length_ns);
+
+        count = 0;
+        max_early_idx = -1;
+        idx = -1;
+
+        for (i = 0; i < drv->state_count; i++) {
+                struct cpuidle_state *s = &drv->states[i];
+                struct cpuidle_state_usage *su = &dev->states_usage[i];
+
+                if (s->disabled || su->disable) {
+                        /*
+                         * If the "early hits" metric of a disabled state is
+                         * greater than the current maximum, it should be taken
+                         * into account, because it would be a mistake to select
+                         * a deeper state with lower "early hits" metric.  The
+                         * index cannot be changed to point to it, however, so
+                         * just increase the max count alone and let the index
+                         * still point to a shallower idle state.
+                         */
+                        if (max_early_idx >= 0 &&
+                            count < cpu_data->states[i].early_hits)
+                                count = cpu_data->states[i].early_hits;
+
+                        continue;
+                }
+
+                if (idx < 0)
+                        idx = i; /* first enabled state */
+
+                if (s->target_residency > duration_us)
+                        break;
+
+                if (s->exit_latency > latency_req) {
+                        /*
+                         * If we break out of the loop for latency reasons, use
+                         * the target residency of the selected state as the
+                         * expected idle duration to avoid stopping the tick
+                         * as long as that target residency is low enough.
+                         */
+                        duration_us = drv->states[idx].target_residency;
+                        goto refine;
+                }
+
+                idx = i;
+
+                if (count < cpu_data->states[i].early_hits &&
+                    !(tick_nohz_tick_stopped() &&
+                      drv->states[i].target_residency < TICK_USEC)) {
+                        count = cpu_data->states[i].early_hits;
+                        max_early_idx = i;
+                }
+        }
+
+        /*
+         * If the "hits" metric of the idle state matching the sleep length is
+         * greater than its "misses" metric, that is the one to use.  Otherwise,
+         * it is more likely that one of the shallower states will match the
+         * idle duration observed after wakeup, so take the one with the maximum
+         * "early hits" metric, but if that cannot be determined, just use the
+         * state selected so far.
+         */
+        if (cpu_data->states[idx].hits <= cpu_data->states[idx].misses &&
+            max_early_idx >= 0) {
+                idx = max_early_idx;
+                duration_us = drv->states[idx].target_residency;
+        }
+
+refine:
+        if (idx < 0) {
+                idx = 0; /* No states enabled. Must use 0. */
+        } else if (idx > 0) {
+                u64 sum = 0;
+
+                count = 0;
+
+                /*
+                 * Count and sum the most recent idle duration values less than
+                 * the target residency of the state selected so far, find the
+                 * max.
+                 */
+                for (i = 0; i < INTERVALS; i++) {
+                        unsigned int val = cpu_data->intervals[i];
+
+                        if (val >= drv->states[idx].target_residency)
+                                continue;
+
+                        count++;
+                        sum += val;
+                }
+
+                /*
+                 * Give up unless the majority of the most recent idle duration
+                 * values are in the interesting range.
+                 */
+                if (count > INTERVALS / 2) {
+                        unsigned int avg_us = div64_u64(sum, count);
+
+                        /*
+                         * Avoid spending too much time in an idle state that
+                         * would be too shallow.
+                         */
+                        if (!(tick_nohz_tick_stopped() && avg_us < TICK_USEC)) {
+                                idx = teo_find_shallower_state(drv, dev, idx, avg_us);
+                                duration_us = avg_us;
+                        }
+                }
+        }
+
+        /*
+         * Don't stop the tick if the selected state is a polling one or if the
+         * expected idle duration is shorter than the tick period length.
+         */
+        if (((drv->states[idx].flags & CPUIDLE_FLAG_POLLING) ||
+            duration_us < TICK_USEC) && !tick_nohz_tick_stopped()) {
+                unsigned int delta_tick_us = ktime_to_us(delta_tick);
+
+                *stop_tick = false;
+
+                /*
+                 * The tick is not going to be stopped, so if the target
+                 * residency of the state to be returned is not within the time
+                 * till the closest timer including the tick, try to correct
+                 * that.
+                 */
+                if (idx > 0 && drv->states[idx].target_residency > delta_tick_us)
+                        idx = teo_find_shallower_state(drv, dev, idx, delta_tick_us);
+        }
+
+        return idx;
+}
+
+/**
+ * teo_reflect - Note that governor data for the CPU need to be updated.
+ * @dev: Target CPU.
+ * @state: Entered state.
+ */
+static void teo_reflect(struct cpuidle_device *dev, int state)
+{
+        struct teo_cpu *cpu_data = per_cpu_ptr(&teo_cpus, dev->cpu);
+
+        cpu_data->last_state = state;
+        /*
+         * If the wakeup was not "natural", but triggered by one of the safety
+         * nets, assume that the CPU might have been idle for the entire sleep
+         * length time.
+         */
+        if (dev->poll_time_limit ||
+            (tick_nohz_idle_got_tick() && cpu_data->sleep_length_ns > TICK_NSEC)) {
+                dev->poll_time_limit = false;
+                cpu_data->time_span_ns = cpu_data->sleep_length_ns;
+        } else {
+                cpu_data->time_span_ns = local_clock() - cpu_data->time_span_ns;
+        }
+}
+
+/**
+ * teo_enable_device - Initialize the governor's data for the target CPU.
+ * @drv: cpuidle driver (not used).
+ * @dev: Target CPU.
+ */
+static int teo_enable_device(struct cpuidle_driver *drv,
+                             struct cpuidle_device *dev)
+{
+        struct teo_cpu *cpu_data = per_cpu_ptr(&teo_cpus, dev->cpu);
+        int i;
+
+        memset(cpu_data, 0, sizeof(*cpu_data));
+
+        for (i = 0; i < INTERVALS; i++)
+                cpu_data->intervals[i] = UINT_MAX;
+
+        return 0;
+}
+
+static struct cpuidle_governor teo_governor = {
+        .name =         "teo",
+        .rating =       19,
+        .enable =       teo_enable_device,
+        .select =       teo_select,
+        .reflect =      teo_reflect,
+};
+
+static int __init teo_governor_init(void)
+{
+        return cpuidle_register_governor(&teo_governor);
+}
+
+postcore_initcall(teo_governor_init);
diff --git a/drivers/gpu/drm/i915/i915_pmu.c b/drivers/gpu/drm/i915/i915_pmu.c
index 017fc602a10e..cf7c66bb3ed9 100644
--- a/drivers/gpu/drm/i915/i915_pmu.c
+++ b/drivers/gpu/drm/i915/i915_pmu.c
@@ -5,6 +5,7 @@
  */
 
 #include <linux/irq.h>
+#include <linux/pm_runtime.h>
 #include "i915_pmu.h"
 #include "intel_ringbuffer.h"
 #include "i915_drv.h"
@@ -478,7 +479,6 @@ static u64 get_rc6(struct drm_i915_private *i915)
                  * counter value.
                  */
                 spin_lock_irqsave(&i915->pmu.lock, flags);
-                spin_lock(&kdev->power.lock);
 
                 /*
                  * After the above branch intel_runtime_pm_get_if_in_use failed
@@ -491,16 +491,13 @@ static u64 get_rc6(struct drm_i915_private *i915)
                  * suspended and if not we cannot do better than report the last
                  * known RC6 value.
                  */
-                if (kdev->power.runtime_status == RPM_SUSPENDED) {
-                        if (!i915->pmu.sample[__I915_SAMPLE_RC6_ESTIMATED].cur)
-                                i915->pmu.suspended_jiffies_last =
-                                                  kdev->power.suspended_jiffies;
+                if (pm_runtime_status_suspended(kdev)) {
+                        val = pm_runtime_suspended_time(kdev);
 
-                        val = kdev->power.suspended_jiffies -
-                              i915->pmu.suspended_jiffies_last;
-                        val += jiffies - kdev->power.accounting_timestamp;
+                        if (!i915->pmu.sample[__I915_SAMPLE_RC6_ESTIMATED].cur)
+                                i915->pmu.suspended_time_last = val;
 
-                        val = jiffies_to_nsecs(val);
+                        val -= i915->pmu.suspended_time_last;
                         val += i915->pmu.sample[__I915_SAMPLE_RC6].cur;
 
                         i915->pmu.sample[__I915_SAMPLE_RC6_ESTIMATED].cur = val;
@@ -510,7 +507,6 @@ static u64 get_rc6(struct drm_i915_private *i915)
                         val = i915->pmu.sample[__I915_SAMPLE_RC6].cur;
                 }
 
-                spin_unlock(&kdev->power.lock);
                 spin_unlock_irqrestore(&i915->pmu.lock, flags);
         }
 
diff --git a/drivers/gpu/drm/i915/i915_pmu.h b/drivers/gpu/drm/i915/i915_pmu.h
index b3728c5f13e7..4fc4f2478301 100644
--- a/drivers/gpu/drm/i915/i915_pmu.h
+++ b/drivers/gpu/drm/i915/i915_pmu.h
@@ -97,9 +97,9 @@ struct i915_pmu {
          */
         struct i915_pmu_sample sample[__I915_NUM_PMU_SAMPLERS];
         /**
-         * @suspended_jiffies_last: Cached suspend time from PM core.
+         * @suspended_time_last: Cached suspend time from PM core.
          */
-        unsigned long suspended_jiffies_last;
+        u64 suspended_time_last;
         /**
          * @i915_attr: Memory block holding device attributes.
          */
diff --git a/drivers/idle/intel_idle.c b/drivers/idle/intel_idle.c
index 8b5d85c91e9d..b8647b5c3d4d 100644
--- a/drivers/idle/intel_idle.c
+++ b/drivers/idle/intel_idle.c
@@ -1103,6 +1103,7 @@ static const struct x86_cpu_id intel_idle_ids[] __initconst = {
         INTEL_CPU_FAM6(ATOM_GOLDMONT,           idle_cpu_bxt),
         INTEL_CPU_FAM6(ATOM_GOLDMONT_PLUS,      idle_cpu_bxt),
         INTEL_CPU_FAM6(ATOM_GOLDMONT_X,         idle_cpu_dnv),
+        INTEL_CPU_FAM6(ATOM_TREMONT_X,          idle_cpu_dnv),
         {}
 };
 
diff --git a/drivers/powercap/intel_rapl.c b/drivers/powercap/intel_rapl.c
index 6cdb2c14eee4..4347f15165f8 100644
--- a/drivers/powercap/intel_rapl.c
+++ b/drivers/powercap/intel_rapl.c
@@ -1156,6 +1156,7 @@ static const struct x86_cpu_id rapl_ids[] __initconst = {
         INTEL_CPU_FAM6(KABYLAKE_MOBILE,         rapl_defaults_core),
         INTEL_CPU_FAM6(KABYLAKE_DESKTOP,        rapl_defaults_core),
         INTEL_CPU_FAM6(CANNONLAKE_MOBILE,       rapl_defaults_core),
+        INTEL_CPU_FAM6(ICELAKE_MOBILE,          rapl_defaults_core),
 
         INTEL_CPU_FAM6(ATOM_SILVERMONT,         rapl_defaults_byt),
         INTEL_CPU_FAM6(ATOM_AIRMONT,            rapl_defaults_cht),
@@ -1164,6 +1165,7 @@ static const struct x86_cpu_id rapl_ids[] __initconst = {
         INTEL_CPU_FAM6(ATOM_GOLDMONT,           rapl_defaults_core),
         INTEL_CPU_FAM6(ATOM_GOLDMONT_PLUS,      rapl_defaults_core),
         INTEL_CPU_FAM6(ATOM_GOLDMONT_X,         rapl_defaults_core),
+        INTEL_CPU_FAM6(ATOM_TREMONT_X,          rapl_defaults_core),
 
         INTEL_CPU_FAM6(XEON_PHI_KNL,            rapl_defaults_hsw_server),
         INTEL_CPU_FAM6(XEON_PHI_KNM,            rapl_defaults_hsw_server),
diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h
index 4dff74f48d4b..3b39472324a3 100644
--- a/include/linux/cpuidle.h
+++ b/include/linux/cpuidle.h
@@ -69,11 +69,9 @@ struct cpuidle_state {
 
 /* Idle State Flags */
 #define CPUIDLE_FLAG_NONE       (0x00)
-#define CPUIDLE_FLAG_POLLING    (0x01) /* polling state */
-#define CPUIDLE_FLAG_COUPLED    (0x02) /* state applies to multiple cpus */
-#define CPUIDLE_FLAG_TIMER_STOP (0x04)  /* timer is stopped on this state */
-
-#define CPUIDLE_DRIVER_FLAGS_MASK (0xFFFF0000)
+#define CPUIDLE_FLAG_POLLING    BIT(0) /* polling state */
+#define CPUIDLE_FLAG_COUPLED    BIT(1) /* state applies to multiple cpus */
+#define CPUIDLE_FLAG_TIMER_STOP BIT(2) /* timer is stopped on this state */
 
 struct cpuidle_device_kobj;
 struct cpuidle_state_kobj;
diff --git a/include/linux/device.h b/include/linux/device.h
index 6cb4640b6160..53028636fe39 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -1165,6 +1165,16 @@ static inline bool device_async_suspend_enabled(struct device *dev)
         return !!dev->power.async_suspend;
 }
 
+static inline bool device_pm_not_required(struct device *dev)
+{
+        return dev->power.no_pm;
+}
+
+static inline void device_set_pm_not_required(struct device *dev)
+{
+        dev->power.no_pm = true;
+}
+
 static inline void dev_pm_syscore_device(struct device *dev, bool val)
 {
 #ifdef CONFIG_PM_SLEEP
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 0bd9de116826..06f7ed893928 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -592,6 +592,7 @@ struct dev_pm_info {
         bool                    is_suspended:1; /* Ditto */
         bool                    is_noirq_suspended:1;
         bool                    is_late_suspended:1;
+        bool                    no_pm:1;
         bool                    early_init:1;   /* Owned by the PM core */
         bool                    direct_complete:1;      /* Owned by the PM core */
         u32                     driver_flags;
@@ -633,9 +634,9 @@ struct dev_pm_info {
         int                     runtime_error;
         int                     autosuspend_delay;
         u64                     last_busy;
-        unsigned long           active_jiffies;
-        unsigned long           suspended_jiffies;
-        unsigned long           accounting_timestamp;
+        u64                     active_time;
+        u64                     suspended_time;
+        u64                     accounting_timestamp;
 #endif
         struct pm_subsys_data   *subsys_data;  /* Owned by the subsystem. */
         void (*set_latency_tolerance)(struct device *, s32);
diff --git a/include/linux/pm_domain.h b/include/linux/pm_domain.h
index dd364abb649a..1ed5874bcee0 100644
--- a/include/linux/pm_domain.h
+++ b/include/linux/pm_domain.h
@@ -271,7 +271,7 @@ int genpd_dev_pm_attach(struct device *dev);
 struct device *genpd_dev_pm_attach_by_id(struct device *dev,
                                          unsigned int index);
 struct device *genpd_dev_pm_attach_by_name(struct device *dev,
-                                           char *name);
+                                           const char *name);
 #else /* !CONFIG_PM_GENERIC_DOMAINS_OF */
 static inline int of_genpd_add_provider_simple(struct device_node *np,
                                         struct generic_pm_domain *genpd)
@@ -324,7 +324,7 @@ static inline struct device *genpd_dev_pm_attach_by_id(struct device *dev,
 }
 
 static inline struct device *genpd_dev_pm_attach_by_name(struct device *dev,
-                                                         char *name)
+                                                         const char *name)
 {
         return NULL;
 }
@@ -341,7 +341,7 @@ int dev_pm_domain_attach(struct device *dev, bool power_on);
 struct device *dev_pm_domain_attach_by_id(struct device *dev,
                                           unsigned int index);
 struct device *dev_pm_domain_attach_by_name(struct device *dev,
-                                            char *name);
+                                            const char *name);
 void dev_pm_domain_detach(struct device *dev, bool power_off);
 void dev_pm_domain_set(struct device *dev, struct dev_pm_domain *pd);
 #else
@@ -355,7 +355,7 @@ static inline struct device *dev_pm_domain_attach_by_id(struct device *dev,
         return NULL;
 }
 static inline struct device *dev_pm_domain_attach_by_name(struct device *dev,
-                                                          char *name)
+                                                          const char *name)
 {
         return NULL;
 }
diff --git a/include/linux/pm_runtime.h b/include/linux/pm_runtime.h
index fed5be706bc9..9dc6eebf62d2 100644
--- a/include/linux/pm_runtime.h
+++ b/include/linux/pm_runtime.h
@@ -113,6 +113,8 @@ static inline bool pm_runtime_is_irq_safe(struct device *dev)
         return dev->power.irq_safe;
 }
 
+extern u64 pm_runtime_suspended_time(struct device *dev);
+
 #else /* !CONFIG_PM */
 
 static inline bool queue_pm_work(struct work_struct *work) { return false; }
diff --git a/kernel/power/energy_model.c b/kernel/power/energy_model.c
index d9dc2c38764a..7d66ee68aaaf 100644
--- a/kernel/power/energy_model.c
+++ b/kernel/power/energy_model.c
@@ -10,6 +10,7 @@
 
 #include <linux/cpu.h>
 #include <linux/cpumask.h>
+#include <linux/debugfs.h>
 #include <linux/energy_model.h>
 #include <linux/sched/topology.h>
 #include <linux/slab.h>
@@ -23,6 +24,60 @@ static DEFINE_PER_CPU(struct em_perf_domain *, em_data);
  */
 static DEFINE_MUTEX(em_pd_mutex);
 
+#ifdef CONFIG_DEBUG_FS
+static struct dentry *rootdir;
+
+static void em_debug_create_cs(struct em_cap_state *cs, struct dentry *pd)
+{
+        struct dentry *d;
+        char name[24];
+
+        snprintf(name, sizeof(name), "cs:%lu", cs->frequency);
+
+        /* Create per-cs directory */
+        d = debugfs_create_dir(name, pd);
+        debugfs_create_ulong("frequency", 0444, d, &cs->frequency);
+        debugfs_create_ulong("power", 0444, d, &cs->power);
+        debugfs_create_ulong("cost", 0444, d, &cs->cost);
+}
+
+static int em_debug_cpus_show(struct seq_file *s, void *unused)
+{
+        seq_printf(s, "%*pbl\n", cpumask_pr_args(to_cpumask(s->private)));
+
+        return 0;
+}
+DEFINE_SHOW_ATTRIBUTE(em_debug_cpus);
+
+static void em_debug_create_pd(struct em_perf_domain *pd, int cpu)
+{
+        struct dentry *d;
+        char name[8];
+        int i;
+
+        snprintf(name, sizeof(name), "pd%d", cpu);
+
+        /* Create the directory of the performance domain */
+        d = debugfs_create_dir(name, rootdir);
+
+        debugfs_create_file("cpus", 0444, d, pd->cpus, &em_debug_cpus_fops);
+
+        /* Create a sub-directory for each capacity state */
+        for (i = 0; i < pd->nr_cap_states; i++)
+                em_debug_create_cs(&pd->table[i], d);
+}
+
+static int __init em_debug_init(void)
+{
+        /* Create /sys/kernel/debug/energy_model directory */
+        rootdir = debugfs_create_dir("energy_model", NULL);
+
+        return 0;
+}
+core_initcall(em_debug_init);
+#else /* CONFIG_DEBUG_FS */
+static void em_debug_create_pd(struct em_perf_domain *pd, int cpu) {}
+#endif
 static struct em_perf_domain *em_create_pd(cpumask_t *span, int nr_states,
                                                 struct em_data_callback *cb)
 {
@@ -102,6 +157,8 @@ static struct em_perf_domain *em_create_pd(cpumask_t *span, int nr_states,
         pd->nr_cap_states = nr_states;
         cpumask_copy(to_cpumask(pd->cpus), span);
 
+        em_debug_create_pd(pd, cpu);
+
         return pd;
 
 free_cs_table:
diff --git a/kernel/power/qos.c b/kernel/power/qos.c
index b7a82502857a..9d22131afc1e 100644
--- a/kernel/power/qos.c
+++ b/kernel/power/qos.c
@@ -582,10 +582,8 @@ static int register_pm_qos_misc(struct pm_qos_object *qos, struct dentry *d)
         qos->pm_qos_power_miscdev.name = qos->name;
         qos->pm_qos_power_miscdev.fops = &pm_qos_power_fops;
 
-        if (d) {
-                (void)debugfs_create_file(qos->name, S_IRUGO, d,
-                                          (void *)qos, &pm_qos_debug_fops);
-        }
+        debugfs_create_file(qos->name, S_IRUGO, d, (void *)qos,
+                            &pm_qos_debug_fops);
 
         return misc_register(&qos->pm_qos_power_miscdev);
 }
@@ -685,8 +683,6 @@ static int __init pm_qos_power_init(void)
         BUILD_BUG_ON(ARRAY_SIZE(pm_qos_array) != PM_QOS_NUM_CLASSES);
 
         d = debugfs_create_dir("pm_qos", NULL);
-        if (IS_ERR_OR_NULL(d))
-                d = NULL;
 
         for (i = PM_QOS_CPU_DMA_LATENCY; i < PM_QOS_NUM_CLASSES; i++) {
                 ret = register_pm_qos_misc(pm_qos_array[i], d);