drm/msm/gpu: System suspend fixes
Subsystems (4)
v2 cover drm/msm/gpu: System suspend fixes
From: Rob Clark <[email protected]>
Because system suspend uses pm_runtime_force_suspend() we can't rely runpm refcnt's to protect us if the GPU is active, etc. Fortunately *usually* the GPU is idle when system suspend is triggered. But that isn't quite good enough.
The first patch attempts to block for a modest amount of time until GPU is idle (and failing that, returns -EBUSY). We could have taken a slightly easier approach and just returned -EBUSY if GPU is not idle, but that would cause system suspend to fail. And no one likes pulling a hot laptop out of their backpack.
The second patch avoids getting devfreq callbacks after suspend, since pm_runtime_force_suspend() breaks the pm_runtime_get_if_in_use() tricks used to deal with devfreq callbacks while suspended.
Rob Clark (2):
drm/msm/gpu: Wait for idle before suspending
drm/msm/gpu: Cancel idle/boost work on suspend
drivers/gpu/drm/msm/adreno/adreno_device.c | 18 ++++++++++++++++++ drivers/gpu/drm/msm/msm_gpu.c | 3 +++ drivers/gpu/drm/msm/msm_gpu.h | 3 +++ drivers/gpu/drm/msm/msm_gpu_devfreq.c | 21 +++++++++++++++++++-- 4 files changed, 43 insertions(+), 2 deletions(-)
Signature · 1 line
2.33.1
PATCH v2 1/2 drm/msm/gpu: Wait for idle before suspending
From: Rob Clark <[email protected]>
System suspend uses pm_runtime_force_suspend(), which cheekily bypasses the runpm reference counts. This doesn't actually work so well when the GPU is active. So add a reasonable delay waiting for the GPU to become idle.
Alternatively we could just return -EBUSY in this case, but that has the disadvantage of causing system suspend to fail.
--- drivers/gpu/drm/msm/adreno/adreno_device.c | 18 ++++++++++++++++++ drivers/gpu/drm/msm/msm_gpu.c | 3 +++ drivers/gpu/drm/msm/msm_gpu.h | 3 +++ 3 files changed, 24 insertions(+)
drivers/gpu/drm/msm/adreno/adreno_device.c +18 -0
@@ -608,9 +608,27 @@ static int adreno_resume(struct device *dev)return gpu->funcs->pm_resume (gpu); } +static int active_submits (struct msm_gpu *gpu) +{ +int active_submits; +mutex_lock (&gpu->active_lock); + active_submits = gpu->active_submits; +mutex_unlock (&gpu->active_lock); +return active_submits; +} +static int adreno_suspend (struct device *dev) {struct msm_gpu *gpu =dev_to_gpu (dev); +int remaining; + + remaining =wait_event_timeout (gpu->retire_event, +active_submits (gpu) >0 , +msecs_to_jiffies (1000 )); +if (remaining ==0 ) { +dev_err (dev,"Timeout waiting for GPU to suspend\n" ); +return -EBUSY ; + }return gpu->funcs->pm_suspend (gpu); }
drivers/gpu/drm/msm/msm_gpu.c +3 -0
@@ -703,6 +703,8 @@ static void retire_submits(struct msm_gpu *gpu) } } } + +wake_up_all (&gpu->retire_event); }static void retire_worker (struct kthread_work *work)
@@ -848,6 +850,7 @@ int msm_gpu_init(struct drm_device *drm, struct platform_device *pdev,INIT_LIST_HEAD (&gpu->active_list);mutex_init (&gpu->active_lock);mutex_init (&gpu->lock); +init_waitqueue_head (&gpu->retire_event);kthread_init_work (&gpu->retire_work, retire_worker);kthread_init_work (&gpu->recover_work, recover_worker);kthread_init_work (&gpu->fault_work, fault_worker);
drivers/gpu/drm/msm/msm_gpu.h +3 -0
@@ -230,6 +230,9 @@ struct msm_gpu {/* work for handling GPU recovery: */ struct kthread_work recover_work; +/** retire_event: notified when submits are retired: */ +wait_queue_head_t retire_event; +/* work for handling active-list retiring: */ struct kthread_work retire_work;
Signature · 1 line
2.33.1
PATCH v2 2/2 drm/msm/gpu: Cancel idle/boost work on suspend
In reply to Rob ClarkFrom: Rob Clark <[email protected]>
With system suspend using pm_runtime_force_suspend() we can't rely on the pm_runtime_get_if_in_use() trick to deal with devfreq callbacks after (or racing with) suspend. So flush any pending idle or boost work in the suspend path.
v2: s/ret/remaining [sboyd], and switch to using active_submits count
to ensure we aren't racing with submit cleanup (and devfreq idle work getting scheduled, etc)
--- drivers/gpu/drm/msm/msm_gpu_devfreq.c | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-)
drivers/gpu/drm/msm/msm_gpu_devfreq.c +19 -2
@@ -133,6 +133,18 @@ void msm_devfreq_init(struct msm_gpu *gpu) CLOCK_MONOTONIC, HRTIMER_MODE_REL); } +static void cancel_idle_work (struct msm_gpu_devfreq *df) +{ +hrtimer_cancel (&df->idle_work.timer); +kthread_cancel_work_sync (&df->idle_work.work); +} + +static void cancel_boost_work (struct msm_gpu_devfreq *df) +{ +hrtimer_cancel (&df->boost_work.timer); +kthread_cancel_work_sync (&df->boost_work.work); +} +void msm_devfreq_cleanup (struct msm_gpu *gpu) {struct msm_gpu_devfreq *df = &gpu->devfreq;
@@ -152,7 +164,12 @@ void msm_devfreq_resume(struct msm_gpu *gpu)void msm_devfreq_suspend (struct msm_gpu *gpu) { -devfreq_suspend_device (gpu->devfreq.devfreq); +struct msm_gpu_devfreq *df = &gpu->devfreq; + +devfreq_suspend_device (df->devfreq); + +cancel_idle_work (df); +cancel_boost_work (df); }static void msm_devfreq_boost_work (struct kthread_work *work)
@@ -196,7 +213,7 @@ void msm_devfreq_active(struct msm_gpu *gpu)/* * Cancel any pending transition to idle frequency: */ -hrtimer_cancel (&df->idle_work.timer); +cancel_idle_work (df); idle_time =ktime_to_ms (ktime_sub (ktime_get (), df->idle_time));
Signature · 1 line
2.33.1