Chris Wilson <chris@xxxxxxxxxxxxxxxxxx> writes:
> Everytime we take a wakeref, record the stack trace of where it was
> taken; clearing the set if we ever drop back to no owners. For debugging
> a rpm leak, we can look at all the current wakerefs and check if they
> have a matching rpm_put.
>
> Signed-off-by: Chris Wilson <chris@xxxxxxxxxxxxxxxxxx>
> Cc: Jani Nikula <jani.nikula@xxxxxxxxx>
> ---
> drivers/gpu/drm/i915/Kconfig.debug | 2 +-
> drivers/gpu/drm/i915/i915_debugfs.c | 6 +
> drivers/gpu/drm/i915/i915_drv.c | 8 +-
> drivers/gpu/drm/i915/i915_drv.h | 7 +
> drivers/gpu/drm/i915/intel_drv.h | 44 ++-
> drivers/gpu/drm/i915/intel_runtime_pm.c | 267 ++++++++++++++++--
> .../gpu/drm/i915/selftests/mock_gem_device.c | 8 +-
> 7 files changed, 292 insertions(+), 50 deletions(-)
>
> diff --git a/drivers/gpu/drm/i915/Kconfig.debug b/drivers/gpu/drm/i915/Kconfig.debug
> index 9e36ffb5eb7c..a97929c47466 100644
> --- a/drivers/gpu/drm/i915/Kconfig.debug
> +++ b/drivers/gpu/drm/i915/Kconfig.debug
> @@ -21,11 +21,11 @@ config DRM_I915_DEBUG
> select DEBUG_FS
> select PREEMPT_COUNT
> select I2C_CHARDEV
> + select STACKDEPOT
> select DRM_DP_AUX_CHARDEV
> select X86_MSR # used by igt/pm_rpm
> select DRM_VGEM # used by igt/prime_vgem (dmabuf interop checks)
> select DRM_DEBUG_MM if DRM=y
> - select STACKDEPOT if DRM=y # for DRM_DEBUG_MM
> select DRM_DEBUG_SELFTEST
> select SW_SYNC # signaling validation framework (igt/syncobj*)
> select DRM_I915_SW_FENCE_DEBUG_OBJECTS
> diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
> index c77326a7d058..3a369245d7e6 100644
> --- a/drivers/gpu/drm/i915/i915_debugfs.c
> +++ b/drivers/gpu/drm/i915/i915_debugfs.c
> @@ -2702,6 +2702,12 @@ static int i915_runtime_pm_status(struct seq_file *m, void *unused)
> pci_power_name(pdev->current_state),
> pdev->current_state);
>
> + if (IS_ENABLED(CONFIG_DRM_I915_DEBUG_RUNTIME_PM)) {
> + struct drm_printer p = drm_seq_file_printer(m);
> +
> + print_intel_runtime_pm_wakeref(dev_priv, &p);
> + }
> +
> return 0;
> }
>
> diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c
> index 17fca3ba343e..e2f4753ca21f 100644
> --- a/drivers/gpu/drm/i915/i915_drv.c
> +++ b/drivers/gpu/drm/i915/i915_drv.c
> @@ -906,6 +906,7 @@ static int i915_driver_init_early(struct drm_i915_private *dev_priv)
> mutex_init(&dev_priv->pps_mutex);
>
> i915_memcpy_init_early(dev_priv);
> + intel_runtime_pm_init_early(dev_priv);
>
> ret = i915_workqueues_init(dev_priv);
> if (ret < 0)
> @@ -1808,8 +1809,7 @@ void i915_driver_unload(struct drm_device *dev)
> i915_driver_cleanup_mmio(dev_priv);
>
> enable_rpm_wakeref_asserts(dev_priv);
> -
> - WARN_ON(atomic_read(&dev_priv->runtime_pm.wakeref_count));
> + intel_runtime_pm_cleanup(dev_priv);
> }
>
> static void i915_driver_release(struct drm_device *dev)
> @@ -2011,6 +2011,8 @@ static int i915_drm_suspend_late(struct drm_device *dev, bool hibernation)
>
> out:
> enable_rpm_wakeref_asserts(dev_priv);
> + if (!dev_priv->uncore.user_forcewake.count)
> + intel_runtime_pm_cleanup(dev_priv);
>
Why would we have forcewake active in here?
Are you planning on extending the intel_runtime_pm_cleanup?
Atleast in the callsite 'intel_runtime_assert_no_wakerefs' would
make more sense.
> return ret;
> }
> @@ -2966,7 +2968,7 @@ static int intel_runtime_suspend(struct device *kdev)
> }
>
> enable_rpm_wakeref_asserts(dev_priv);
> - WARN_ON_ONCE(atomic_read(&dev_priv->runtime_pm.wakeref_count));
> + intel_runtime_pm_cleanup(dev_priv);
>
> if (intel_uncore_arm_unclaimed_mmio_detection(dev_priv))
> DRM_ERROR("Unclaimed access detected prior to suspending\n");
> diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
> index 17a017645c5d..60b98103aba3 100644
> --- a/drivers/gpu/drm/i915/i915_drv.h
> +++ b/drivers/gpu/drm/i915/i915_drv.h
> @@ -45,6 +45,7 @@
> #include <linux/pm_qos.h>
> #include <linux/reservation.h>
> #include <linux/shmem_fs.h>
> +#include <linux/stackdepot.h>
>
> #include <drm/drmP.h>
> #include <drm/intel-gtt.h>
> @@ -1156,6 +1157,12 @@ struct i915_runtime_pm {
> atomic_t wakeref_count;
> bool suspended;
> bool irqs_enabled;
> +
> +#if IS_ENABLED(CONFIG_DRM_I915_DEBUG_RUNTIME_PM)
> + spinlock_t debug_lock;
> + depot_stack_handle_t *debug_owners;
> + unsigned long debug_count;
> +#endif
> };
>
> enum intel_pipe_crc_source {
> diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h
> index 1a11c2beb7f3..ac513fd70315 100644
> --- a/drivers/gpu/drm/i915/intel_drv.h
> +++ b/drivers/gpu/drm/i915/intel_drv.h
> @@ -41,6 +41,8 @@
> #include <drm/drm_atomic.h>
> #include <media/cec-notifier.h>
>
> +struct drm_printer;
> +
> /**
> * __wait_for - magic wait macro
> *
> @@ -2084,6 +2086,7 @@ bool intel_psr_enabled(struct intel_dp *intel_dp);
> void intel_init_quirks(struct drm_i915_private *dev_priv);
>
> /* intel_runtime_pm.c */
> +void intel_runtime_pm_init_early(struct drm_i915_private *dev_priv);
> int intel_power_domains_init(struct drm_i915_private *);
> void intel_power_domains_cleanup(struct drm_i915_private *dev_priv);
> void intel_power_domains_init_hw(struct drm_i915_private *dev_priv, bool resume);
> @@ -2106,6 +2109,7 @@ void bxt_display_core_init(struct drm_i915_private *dev_priv, bool resume);
> void bxt_display_core_uninit(struct drm_i915_private *dev_priv);
> void intel_runtime_pm_enable(struct drm_i915_private *dev_priv);
> void intel_runtime_pm_disable(struct drm_i915_private *dev_priv);
> +void intel_runtime_pm_cleanup(struct drm_i915_private *dev_priv);
> const char *
> intel_display_power_domain_str(enum intel_display_power_domain domain);
>
> @@ -2123,23 +2127,23 @@ void icl_dbuf_slices_update(struct drm_i915_private *dev_priv,
> u8 req_slices);
>
> static inline void
> -assert_rpm_device_not_suspended(struct drm_i915_private *dev_priv)
> +assert_rpm_device_not_suspended(struct drm_i915_private *i915)
> {
> - WARN_ONCE(dev_priv->runtime_pm.suspended,
> + WARN_ONCE(i915->runtime_pm.suspended,
> "Device suspended during HW access\n");
> }
>
> static inline void
> -assert_rpm_wakelock_held(struct drm_i915_private *dev_priv)
> +assert_rpm_wakelock_held(struct drm_i915_private *i915)
> {
> - assert_rpm_device_not_suspended(dev_priv);
> - WARN_ONCE(!atomic_read(&dev_priv->runtime_pm.wakeref_count),
> + assert_rpm_device_not_suspended(i915);
> + WARN_ONCE(!atomic_read(&i915->runtime_pm.wakeref_count),
> "RPM wakelock ref not held during HW access");
> }
>
> /**
> * disable_rpm_wakeref_asserts - disable the RPM assert checks
> - * @dev_priv: i915 device instance
> + * @i915: i915 device instance
> *
> * This function disable asserts that check if we hold an RPM wakelock
> * reference, while keeping the device-not-suspended checks still enabled.
> @@ -2156,14 +2160,14 @@ assert_rpm_wakelock_held(struct drm_i915_private *dev_priv)
> * enable_rpm_wakeref_asserts().
> */
> static inline void
> -disable_rpm_wakeref_asserts(struct drm_i915_private *dev_priv)
> +disable_rpm_wakeref_asserts(struct drm_i915_private *i915)
> {
> - atomic_inc(&dev_priv->runtime_pm.wakeref_count);
> + atomic_inc(&i915->runtime_pm.wakeref_count);
> }
>
> /**
> * enable_rpm_wakeref_asserts - re-enable the RPM assert checks
> - * @dev_priv: i915 device instance
> + * @i915: i915 device instance
> *
> * This function re-enables the RPM assert checks after disabling them with
> * disable_rpm_wakeref_asserts. It's meant to be used only in special
> @@ -2173,15 +2177,25 @@ disable_rpm_wakeref_asserts(struct drm_i915_private *dev_priv)
> * disable_rpm_wakeref_asserts().
> */
> static inline void
> -enable_rpm_wakeref_asserts(struct drm_i915_private *dev_priv)
> +enable_rpm_wakeref_asserts(struct drm_i915_private *i915)
> {
> - atomic_dec(&dev_priv->runtime_pm.wakeref_count);
> + atomic_dec(&i915->runtime_pm.wakeref_count);
> }
>
> -void intel_runtime_pm_get(struct drm_i915_private *dev_priv);
> -bool intel_runtime_pm_get_if_in_use(struct drm_i915_private *dev_priv);
> -void intel_runtime_pm_get_noresume(struct drm_i915_private *dev_priv);
> -void intel_runtime_pm_put(struct drm_i915_private *dev_priv);
> +void intel_runtime_pm_get(struct drm_i915_private *i915);
> +bool intel_runtime_pm_get_if_in_use(struct drm_i915_private *i915);
> +void intel_runtime_pm_get_noresume(struct drm_i915_private *i915);
> +void intel_runtime_pm_put(struct drm_i915_private *i915);
> +
> +#if IS_ENABLED(CONFIG_DRM_I915_DEBUG_RUNTIME_PM)
> +void print_intel_runtime_pm_wakeref(struct drm_i915_private *i915,
> + struct drm_printer *p);
> +#else
> +static inline void print_intel_runtime_pm_wakeref(struct drm_i915_private *i915,
> + struct drm_printer *p)
> +{
> +}
> +#endif
Plural 'wakerefs' would read better for me.
>
> void chv_phy_powergate_lanes(struct intel_encoder *encoder,
> bool override, unsigned int mask);
> diff --git a/drivers/gpu/drm/i915/intel_runtime_pm.c b/drivers/gpu/drm/i915/intel_runtime_pm.c
> index 9e9501f82f06..67d71cc604f1 100644
> --- a/drivers/gpu/drm/i915/intel_runtime_pm.c
> +++ b/drivers/gpu/drm/i915/intel_runtime_pm.c
> @@ -29,6 +29,8 @@
> #include <linux/pm_runtime.h>
> #include <linux/vgaarb.h>
>
> +#include <drm/drm_print.h>
> +
> #include "i915_drv.h"
> #include "intel_drv.h"
>
> @@ -49,6 +51,189 @@
> * present for a given platform.
> */
>
> +#if IS_ENABLED(CONFIG_DRM_I915_DEBUG_RUNTIME_PM)
> +
> +#include <linux/sort.h>
> +
> +#define STACKDEPTH 8
> +
> +static void init_intel_runtime_pm_wakeref(struct drm_i915_private *i915)
> +{
> + spin_lock_init(&i915->runtime_pm.debug_lock);
> +}
> +
> +static noinline void
> +track_intel_runtime_pm_wakeref(struct drm_i915_private *i915)
> +{
> + struct i915_runtime_pm *rpm = &i915->runtime_pm;
> + unsigned long entries[STACKDEPTH];
> + struct stack_trace trace = {
> + .entries = entries,
> + .max_entries = ARRAY_SIZE(entries),
> + .skip = 1
> + };
> + unsigned long flags;
> + depot_stack_handle_t stack, *stacks;
> +
> + if (!HAS_RUNTIME_PM(i915))
> + return;
> +
> + save_stack_trace(&trace);
> + if (trace.nr_entries &&
> + trace.entries[trace.nr_entries - 1] == ULONG_MAX)
> + trace.nr_entries--;
> +
What is this special handling for?
> + stack = depot_save_stack(&trace, GFP_NOWAIT | __GFP_NOWARN);
> + if (!stack)
> + return;
> +
> + spin_lock_irqsave(&rpm->debug_lock, flags);
> + stacks = krealloc(rpm->debug_owners,
> + (rpm->debug_count + 1) * sizeof(*stacks),
> + GFP_NOWAIT | __GFP_NOWARN);
> + if (stacks) {
> + stacks[rpm->debug_count++] = stack;
> + rpm->debug_owners = stacks;
> + }
> + spin_unlock_irqrestore(&rpm->debug_lock, flags);
> +}
> +
> +static void untrack_intel_runtime_pm_wakeref(struct drm_i915_private *i915)
> +{
> + struct i915_runtime_pm *rpm = &i915->runtime_pm;
> + depot_stack_handle_t *stacks;
> + unsigned long flags;
> +
> + spin_lock_irqsave(&rpm->debug_lock, flags);
> + stacks = fetch_and_zero(&rpm->debug_owners);
> + rpm->debug_count = 0;
> + spin_unlock_irqrestore(&rpm->debug_lock, flags);
> +
> + kfree(stacks);
> +}
> +
> +static int cmphandle(const void *_a, const void *_b)
> +{
> + const depot_stack_handle_t * const a = _a, * const b = _b;
> +
> + if (*a < *b)
> + return -1;
> + else if (*a > *b)
> + return 1;
> + else
> + return 0;
> +}
> +
> +static void __print_intel_runtime_pm_wakeref(struct drm_printer *p,
> + depot_stack_handle_t *stacks,
> + unsigned long count)
> +{
> + unsigned long entries[STACKDEPTH];
> + unsigned long i;
> + char *buf;
> +
> + drm_printf(p, "Wakeref count: %lu\n", count);
> +
> + buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
> + if (!buf)
> + return;
> +
> + sort(stacks, count, sizeof(*stacks), cmphandle, NULL);
Is the sorting only for nicer output?
> +
> + for (i = 0; i < count; i++) {
> + struct stack_trace trace = {
> + .entries = entries,
> + .max_entries = ARRAY_SIZE(entries),
> + };
> + depot_stack_handle_t stack = stacks[i];
> + unsigned long rep;
> +
> + rep = 1;
> + while (i + 1 < count && stacks[i + 1] == stack)
> + rep++, i++;
> + depot_fetch_stack(stack, &trace);
> + snprint_stack_trace(buf, PAGE_SIZE, &trace, 2);
> + drm_printf(p, "Wakeref x%lu taken at:\n%s", rep, buf);
> + }
> +
> + kfree(buf);
> +}
> +
> +static void show_intel_runtime_pm_wakeref(struct drm_i915_private *i915)
> +{
s/wakeref/wakerefs?
-Mika
> + struct i915_runtime_pm *rpm = &i915->runtime_pm;
> + depot_stack_handle_t *stacks;
> + unsigned long flags, count;
> + struct drm_printer p;
> +
> + spin_lock_irqsave(&rpm->debug_lock, flags);
> + stacks = fetch_and_zero(&rpm->debug_owners);
> + count = fetch_and_zero(&rpm->debug_count);
> + spin_unlock_irqrestore(&rpm->debug_lock, flags);
> + if (!count)
> + return;
> +
> + p = drm_debug_printer("i915");
> + __print_intel_runtime_pm_wakeref(&p, stacks, count);
> +
> + kfree(stacks);
> +}
> +
> +void print_intel_runtime_pm_wakeref(struct drm_i915_private *i915,
> + struct drm_printer *p)
> +{
> + depot_stack_handle_t *stacks = NULL;
> + unsigned long count = 0;
> +
> + do {
> + struct i915_runtime_pm *rpm = &i915->runtime_pm;
> + unsigned long alloc = count;
> + depot_stack_handle_t *s;
> +
> + spin_lock_irq(&rpm->debug_lock);
> + count = rpm->debug_count;
> + if (count == alloc) {
> + memcpy(stacks,
> + rpm->debug_owners,
> + count * sizeof(*stacks));
> + }
> + spin_unlock_irq(&rpm->debug_lock);
> + if (count == alloc)
> + break;
> +
> + s = krealloc(stacks, count * sizeof(*stacks), GFP_KERNEL);
> + if (!s)
> + goto out;
> +
> + stacks = s;
> + } while (1);
> +
> + __print_intel_runtime_pm_wakeref(p, stacks, count);
> +
> +out:
> + kfree(stacks);
> +}
> +
> +#else
> +
> +static void init_intel_runtime_pm_wakeref(struct drm_i915_private *i915)
> +{
> +}
> +
> +static void track_intel_runtime_pm_wakeref(struct drm_i915_private *i915)
> +{
> +}
> +
> +static void untrack_intel_runtime_pm_wakeref(struct drm_i915_private *i915)
> +{
> +}
> +
> +static void show_intel_runtime_pm_wakeref(struct drm_i915_private *i915)
> +{
> +}
> +
> +#endif
> +
> bool intel_display_power_well_is_enabled(struct drm_i915_private *dev_priv,
> enum i915_power_well_id power_well_id);
>
> @@ -3986,7 +4171,7 @@ static void intel_power_domains_verify_state(struct drm_i915_private *dev_priv)
>
> /**
> * intel_runtime_pm_get - grab a runtime pm reference
> - * @dev_priv: i915 device instance
> + * @i915: i915 device instance
> *
> * This function grabs a device-level runtime pm reference (mostly used for GEM
> * code to ensure the GTT or GT is on) and ensures that it is powered up.
> @@ -3994,22 +4179,24 @@ static void intel_power_domains_verify_state(struct drm_i915_private *dev_priv)
> * Any runtime pm reference obtained by this function must have a symmetric
> * call to intel_runtime_pm_put() to release the reference again.
> */
> -void intel_runtime_pm_get(struct drm_i915_private *dev_priv)
> +void intel_runtime_pm_get(struct drm_i915_private *i915)
> {
> - struct pci_dev *pdev = dev_priv->drm.pdev;
> + struct pci_dev *pdev = i915->drm.pdev;
> struct device *kdev = &pdev->dev;
> int ret;
>
> ret = pm_runtime_get_sync(kdev);
> WARN_ONCE(ret < 0, "pm_runtime_get_sync() failed: %d\n", ret);
>
> - atomic_inc(&dev_priv->runtime_pm.wakeref_count);
> - assert_rpm_wakelock_held(dev_priv);
> + atomic_inc(&i915->runtime_pm.wakeref_count);
> + assert_rpm_wakelock_held(i915);
> +
> + track_intel_runtime_pm_wakeref(i915);
> }
>
> /**
> * intel_runtime_pm_get_if_in_use - grab a runtime pm reference if device in use
> - * @dev_priv: i915 device instance
> + * @i915: i915 device instance
> *
> * This function grabs a device-level runtime pm reference if the device is
> * already in use and ensures that it is powered up. It is illegal to try
> @@ -4020,10 +4207,10 @@ void intel_runtime_pm_get(struct drm_i915_private *dev_priv)
> *
> * Returns: True if the wakeref was acquired, or False otherwise.
> */
> -bool intel_runtime_pm_get_if_in_use(struct drm_i915_private *dev_priv)
> +bool intel_runtime_pm_get_if_in_use(struct drm_i915_private *i915)
> {
> if (IS_ENABLED(CONFIG_PM)) {
> - struct pci_dev *pdev = dev_priv->drm.pdev;
> + struct pci_dev *pdev = i915->drm.pdev;
> struct device *kdev = &pdev->dev;
>
> /*
> @@ -4036,15 +4223,17 @@ bool intel_runtime_pm_get_if_in_use(struct drm_i915_private *dev_priv)
> return false;
> }
>
> - atomic_inc(&dev_priv->runtime_pm.wakeref_count);
> - assert_rpm_wakelock_held(dev_priv);
> + atomic_inc(&i915->runtime_pm.wakeref_count);
> + assert_rpm_wakelock_held(i915);
> +
> + track_intel_runtime_pm_wakeref(i915);
>
> return true;
> }
>
> /**
> * intel_runtime_pm_get_noresume - grab a runtime pm reference
> - * @dev_priv: i915 device instance
> + * @i915: i915 device instance
> *
> * This function grabs a device-level runtime pm reference (mostly used for GEM
> * code to ensure the GTT or GT is on).
> @@ -4059,32 +4248,35 @@ bool intel_runtime_pm_get_if_in_use(struct drm_i915_private *dev_priv)
> * Any runtime pm reference obtained by this function must have a symmetric
> * call to intel_runtime_pm_put() to release the reference again.
> */
> -void intel_runtime_pm_get_noresume(struct drm_i915_private *dev_priv)
> +void intel_runtime_pm_get_noresume(struct drm_i915_private *i915)
> {
> - struct pci_dev *pdev = dev_priv->drm.pdev;
> + struct pci_dev *pdev = i915->drm.pdev;
> struct device *kdev = &pdev->dev;
>
> - assert_rpm_wakelock_held(dev_priv);
> + assert_rpm_wakelock_held(i915);
> pm_runtime_get_noresume(kdev);
>
> - atomic_inc(&dev_priv->runtime_pm.wakeref_count);
> + atomic_inc(&i915->runtime_pm.wakeref_count);
> +
> + track_intel_runtime_pm_wakeref(i915);
> }
>
> /**
> * intel_runtime_pm_put - release a runtime pm reference
> - * @dev_priv: i915 device instance
> + * @i915: i915 device instance
> *
> * This function drops the device-level runtime pm reference obtained by
> * intel_runtime_pm_get() and might power down the corresponding
> * hardware block right away if this is the last reference.
> */
> -void intel_runtime_pm_put(struct drm_i915_private *dev_priv)
> +void intel_runtime_pm_put(struct drm_i915_private *i915)
> {
> - struct pci_dev *pdev = dev_priv->drm.pdev;
> + struct pci_dev *pdev = i915->drm.pdev;
> struct device *kdev = &pdev->dev;
>
> - assert_rpm_wakelock_held(dev_priv);
> - atomic_dec(&dev_priv->runtime_pm.wakeref_count);
> + assert_rpm_wakelock_held(i915);
> + if (atomic_dec_and_test(&i915->runtime_pm.wakeref_count))
> + untrack_intel_runtime_pm_wakeref(i915);
>
> pm_runtime_mark_last_busy(kdev);
> pm_runtime_put_autosuspend(kdev);
> @@ -4092,7 +4284,7 @@ void intel_runtime_pm_put(struct drm_i915_private *dev_priv)
>
> /**
> * intel_runtime_pm_enable - enable runtime pm
> - * @dev_priv: i915 device instance
> + * @i915: i915 device instance
> *
> * This function enables runtime pm at the end of the driver load sequence.
> *
> @@ -4100,9 +4292,9 @@ void intel_runtime_pm_put(struct drm_i915_private *dev_priv)
> * subordinate display power domains. That is done by
> * intel_power_domains_enable().
> */
> -void intel_runtime_pm_enable(struct drm_i915_private *dev_priv)
> +void intel_runtime_pm_enable(struct drm_i915_private *i915)
> {
> - struct pci_dev *pdev = dev_priv->drm.pdev;
> + struct pci_dev *pdev = i915->drm.pdev;
> struct device *kdev = &pdev->dev;
>
> /*
> @@ -4124,7 +4316,7 @@ void intel_runtime_pm_enable(struct drm_i915_private *dev_priv)
> * so the driver's own RPM reference tracking asserts also work on
> * platforms without RPM support.
> */
> - if (!HAS_RUNTIME_PM(dev_priv)) {
> + if (!HAS_RUNTIME_PM(i915)) {
> int ret;
>
> pm_runtime_dont_use_autosuspend(kdev);
> @@ -4142,17 +4334,36 @@ void intel_runtime_pm_enable(struct drm_i915_private *dev_priv)
> pm_runtime_put_autosuspend(kdev);
> }
>
> -void intel_runtime_pm_disable(struct drm_i915_private *dev_priv)
> +void intel_runtime_pm_disable(struct drm_i915_private *i915)
> {
> - struct pci_dev *pdev = dev_priv->drm.pdev;
> + struct pci_dev *pdev = i915->drm.pdev;
> struct device *kdev = &pdev->dev;
>
> /* Transfer rpm ownership back to core */
> - WARN(pm_runtime_get_sync(&dev_priv->drm.pdev->dev) < 0,
> + WARN(pm_runtime_get_sync(kdev) < 0,
> "Failed to pass rpm ownership back to core\n");
>
> pm_runtime_dont_use_autosuspend(kdev);
>
> - if (!HAS_RUNTIME_PM(dev_priv))
> + if (!HAS_RUNTIME_PM(i915))
> pm_runtime_put(kdev);
> }
> +
> +void intel_runtime_pm_cleanup(struct drm_i915_private *i915)
> +{
> + struct i915_runtime_pm *rpm = &i915->runtime_pm;
> +
> + if (WARN(atomic_read(&rpm->wakeref_count),
> + "i915->runtime_pm.wakeref_count=%d on cleanup\n",
> + atomic_read(&rpm->wakeref_count))) {
> + show_intel_runtime_pm_wakeref(i915);
> + atomic_set(&rpm->wakeref_count, 0);
> + }
> +
> + untrack_intel_runtime_pm_wakeref(i915);
> +}
> +
> +void intel_runtime_pm_init_early(struct drm_i915_private *i915)
> +{
> + init_intel_runtime_pm_wakeref(i915);
> +}
> diff --git a/drivers/gpu/drm/i915/selftests/mock_gem_device.c b/drivers/gpu/drm/i915/selftests/mock_gem_device.c
> index 43ed8b28aeaa..0eb283e7fc96 100644
> --- a/drivers/gpu/drm/i915/selftests/mock_gem_device.c
> +++ b/drivers/gpu/drm/i915/selftests/mock_gem_device.c
> @@ -154,15 +154,17 @@ struct drm_i915_private *mock_gem_device(void)
> pdev->dev.archdata.iommu = (void *)-1;
> #endif
>
> + i915 = (struct drm_i915_private *)(pdev + 1);
> + pci_set_drvdata(pdev, i915);
> +
> + intel_runtime_pm_init_early(i915);
> +
> dev_pm_domain_set(&pdev->dev, &pm_domain);
> pm_runtime_enable(&pdev->dev);
> pm_runtime_dont_use_autosuspend(&pdev->dev);
> if (pm_runtime_enabled(&pdev->dev))
> WARN_ON(pm_runtime_get_sync(&pdev->dev));
>
> - i915 = (struct drm_i915_private *)(pdev + 1);
> - pci_set_drvdata(pdev, i915);
> -
> err = drm_dev_init(&i915->drm, &mock_driver, &pdev->dev);
> if (err) {
> pr_err("Failed to initialise mock GEM device: err=%d\n", err);
> --
> 2.20.1
>
> _______________________________________________
> Intel-gfx mailing list
> Intel-gfx@xxxxxxxxxxxxxxxxxxxxx
> https://lists.freedesktop.org/mailman/listinfo/intel-gfx
_______________________________________________
Intel-gfx mailing list
Intel-gfx@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
