MALI: rockchip: upgrade midgard DDK to r13p0-00rel0

[firefly-linux-kernel-4.4.55.git] / drivers / gpu / arm / midgard / backend / gpu / mali_kbase_pm_policy.c

diff --git a/drivers/gpu/arm/midgard/backend/gpu/mali_kbase_pm_policy.c b/drivers/gpu/arm/midgard/backend/gpu/mali_kbase_pm_policy.c
index ad0e98be4571a71041c12d269ad03fcb072a7ec3..4d006028089a13b5994f90755a51a9dfe45c7c52 100644 (file)
--- a/drivers/gpu/arm/midgard/backend/gpu/mali_kbase_pm_policy.c
+++ b/drivers/gpu/arm/midgard/backend/gpu/mali_kbase_pm_policy.c
@@ -21,7 +21,6 @@
 
 #include <mali_kbase.h>
 #include <mali_midg_regmap.h>
-#include <mali_kbase_gator.h>
 #include <mali_kbase_pm.h>
 #include <mali_kbase_config_defaults.h>
 #include <backend/gpu/mali_kbase_pm_internal.h>
@@ -155,16 +154,22 @@ static inline void kbase_timeline_pm_cores_func(struct kbase_device *kbdev,
 static void kbasep_pm_do_poweroff_cores(struct kbase_device *kbdev)
 {
        u64 prev_shader_state = kbdev->pm.backend.desired_shader_state;
+       u64 prev_tiler_state = kbdev->pm.backend.desired_tiler_state;
 
        lockdep_assert_held(&kbdev->pm.power_change_lock);
 
        kbdev->pm.backend.desired_shader_state &=
                        ~kbdev->pm.backend.shader_poweroff_pending;
+       kbdev->pm.backend.desired_tiler_state &=
+                       ~kbdev->pm.backend.tiler_poweroff_pending;
 
        kbdev->pm.backend.shader_poweroff_pending = 0;
+       kbdev->pm.backend.tiler_poweroff_pending = 0;
 
-       if (prev_shader_state != kbdev->pm.backend.desired_shader_state
-                       || kbdev->pm.backend.ca_in_transition) {
+       if (prev_shader_state != kbdev->pm.backend.desired_shader_state ||
+                       prev_tiler_state !=
+                               kbdev->pm.backend.desired_tiler_state ||
+                       kbdev->pm.backend.ca_in_transition) {
                bool cores_are_available;
 
                KBASE_TIMELINE_PM_CHECKTRANS(kbdev,
@@ -202,7 +207,8 @@ kbasep_pm_do_gpu_poweroff_callback(struct hrtimer *timer)
                queue_work(kbdev->pm.backend.gpu_poweroff_wq,
                                        &kbdev->pm.backend.gpu_poweroff_work);
 
-       if (kbdev->pm.backend.shader_poweroff_pending) {
+       if (kbdev->pm.backend.shader_poweroff_pending ||
+                       kbdev->pm.backend.tiler_poweroff_pending) {
                kbdev->pm.backend.shader_poweroff_pending_time--;
 
                KBASE_DEBUG_ASSERT(
@@ -327,6 +333,7 @@ void kbase_pm_cancel_deferred_poweroff(struct kbase_device *kbdev)
        kbdev->pm.backend.gpu_poweroff_pending = 0;
 
        kbdev->pm.backend.shader_poweroff_pending = 0;
+       kbdev->pm.backend.tiler_poweroff_pending = 0;
        kbdev->pm.backend.shader_poweroff_pending_time = 0;
 
        spin_unlock_irqrestore(&kbdev->pm.power_change_lock, flags);
@@ -381,8 +388,10 @@ void kbase_pm_update_active(struct kbase_device *kbdev)
                 * when there are contexts active */
                KBASE_DEBUG_ASSERT(pm->active_count == 0);
 
-               if (backend->shader_poweroff_pending) {
+               if (backend->shader_poweroff_pending ||
+                               backend->tiler_poweroff_pending) {
                        backend->shader_poweroff_pending = 0;
+                       backend->tiler_poweroff_pending = 0;
                        backend->shader_poweroff_pending_time = 0;
                }
 
@@ -441,6 +450,7 @@ void kbase_pm_update_active(struct kbase_device *kbdev)
 void kbase_pm_update_cores_state_nolock(struct kbase_device *kbdev)
 {
        u64 desired_bitmap;
+       u64 desired_tiler_bitmap;
        bool cores_are_available;
        bool do_poweroff = false;
 
@@ -453,23 +463,37 @@ void kbase_pm_update_cores_state_nolock(struct kbase_device *kbdev)
                kbdev->pm.backend.pm_current_policy->get_core_mask(kbdev);
        desired_bitmap &= kbase_pm_ca_get_core_mask(kbdev);
 
-       /* Enable core 0 if tiler required, regardless of core availability */
        if (kbdev->tiler_needed_cnt > 0 || kbdev->tiler_inuse_cnt > 0)
-               desired_bitmap |= 1;
+               desired_tiler_bitmap = 1;
+       else
+               desired_tiler_bitmap = 0;
+
+       if (!kbase_hw_has_feature(kbdev, BASE_HW_FEATURE_XAFFINITY)) {
+               /* Unless XAFFINITY is supported, enable core 0 if tiler
+                * required, regardless of core availability */
+               if (kbdev->tiler_needed_cnt > 0 || kbdev->tiler_inuse_cnt > 0)
+                       desired_bitmap |= 1;
+       }
 
        if (kbdev->pm.backend.desired_shader_state != desired_bitmap)
                KBASE_TRACE_ADD(kbdev, PM_CORES_CHANGE_DESIRED, NULL, NULL, 0u,
                                                        (u32)desired_bitmap);
        /* Are any cores being powered on? */
        if (~kbdev->pm.backend.desired_shader_state & desired_bitmap ||
+           ~kbdev->pm.backend.desired_tiler_state & desired_tiler_bitmap ||
            kbdev->pm.backend.ca_in_transition) {
                /* Check if we are powering off any cores before updating shader
                 * state */
-               if (kbdev->pm.backend.desired_shader_state & ~desired_bitmap) {
+               if (kbdev->pm.backend.desired_shader_state & ~desired_bitmap ||
+                               kbdev->pm.backend.desired_tiler_state &
+                               ~desired_tiler_bitmap) {
                        /* Start timer to power off cores */
                        kbdev->pm.backend.shader_poweroff_pending |=
                                (kbdev->pm.backend.desired_shader_state &
                                                        ~desired_bitmap);
+                       kbdev->pm.backend.tiler_poweroff_pending |=
+                               (kbdev->pm.backend.desired_tiler_state &
+                                                       ~desired_tiler_bitmap);
 
                        if (kbdev->pm.poweroff_shader_ticks)
                                kbdev->pm.backend.shader_poweroff_pending_time =
@@ -479,21 +503,28 @@ void kbase_pm_update_cores_state_nolock(struct kbase_device *kbdev)
                }
 
                kbdev->pm.backend.desired_shader_state = desired_bitmap;
+               kbdev->pm.backend.desired_tiler_state = desired_tiler_bitmap;
 
                /* If any cores are being powered on, transition immediately */
                cores_are_available = kbase_pm_check_transitions_nolock(kbdev);
-       } else if (kbdev->pm.backend.desired_shader_state & ~desired_bitmap) {
+       } else if (kbdev->pm.backend.desired_shader_state & ~desired_bitmap ||
+                               kbdev->pm.backend.desired_tiler_state &
+                               ~desired_tiler_bitmap) {
                /* Start timer to power off cores */
                kbdev->pm.backend.shader_poweroff_pending |=
                                (kbdev->pm.backend.desired_shader_state &
                                                        ~desired_bitmap);
+               kbdev->pm.backend.tiler_poweroff_pending |=
+                               (kbdev->pm.backend.desired_tiler_state &
+                                                       ~desired_tiler_bitmap);
                if (kbdev->pm.poweroff_shader_ticks)
                        kbdev->pm.backend.shader_poweroff_pending_time =
                                        kbdev->pm.poweroff_shader_ticks;
                else
                        kbasep_pm_do_poweroff_cores(kbdev);
        } else if (kbdev->pm.active_count == 0 && desired_bitmap != 0 &&
-                               kbdev->pm.backend.poweroff_timer_needed) {
+                       desired_tiler_bitmap != 0 &&
+                       kbdev->pm.backend.poweroff_timer_needed) {
                /* If power policy is keeping cores on despite there being no
                 * active contexts then disable poweroff timer as it isn't
                 * required.
@@ -504,11 +535,17 @@ void kbase_pm_update_cores_state_nolock(struct kbase_device *kbdev)
 
        /* Ensure timer does not power off wanted cores and make sure to power
         * off unwanted cores */
-       if (kbdev->pm.backend.shader_poweroff_pending != 0) {
+       if (kbdev->pm.backend.shader_poweroff_pending ||
+                       kbdev->pm.backend.tiler_poweroff_pending) {
                kbdev->pm.backend.shader_poweroff_pending &=
                                ~(kbdev->pm.backend.desired_shader_state &
                                                                desired_bitmap);
-               if (kbdev->pm.backend.shader_poweroff_pending == 0)
+               kbdev->pm.backend.tiler_poweroff_pending &=
+                               ~(kbdev->pm.backend.desired_tiler_state &
+                               desired_tiler_bitmap);
+
+               if (!kbdev->pm.backend.shader_poweroff_pending &&
+                               !kbdev->pm.backend.tiler_poweroff_pending)
                        kbdev->pm.backend.shader_poweroff_pending_time = 0;
        }