drivers/gpu/arm/mali400/mali/common/mali_pmu.c

   1 /*
   2  * Copyright (C) 2010-2014 ARM Limited. All rights reserved.
   3  *
   4  * This program is free software and is provided to you under the terms of the GNU General Public License version 2
   5  * as published by the Free Software Foundation, and any use by you of this program is subject to the terms of such GNU licence.
   6  *
   7  * A copy of the licence is included with the program, and can also be obtained from Free Software
   8  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   9  */
  10
  11 /**
  12  * @file mali_pmu.c
  13  * Mali driver functions for Mali 400 PMU hardware
  14  */
  15 #include "mali_hw_core.h"
  16 #include "mali_pmu.h"
  17 #include "mali_pp.h"
  18 #include "mali_kernel_common.h"
  19 #include "mali_osk.h"
  20 #include "mali_pm.h"
  21 #include "mali_osk_mali.h"
  22
  23 struct mali_pmu_core *mali_global_pmu_core = NULL;
  24
  25 static _mali_osk_errcode_t mali_pmu_wait_for_command_finish(
  26         struct mali_pmu_core *pmu);
  27
  28 struct mali_pmu_core *mali_pmu_create(_mali_osk_resource_t *resource)
  29 {
  30         struct mali_pmu_core *pmu;
  31
  32         MALI_DEBUG_ASSERT(NULL == mali_global_pmu_core);
  33         MALI_DEBUG_PRINT(2, ("Mali PMU: Creating Mali PMU core\n"));
  34
  35         pmu = (struct mali_pmu_core *)_mali_osk_malloc(
  36                       sizeof(struct mali_pmu_core));
  37         if (NULL != pmu) {
  38                 pmu->registered_cores_mask = 0; /* to be set later */
  39
  40                 if (_MALI_OSK_ERR_OK == mali_hw_core_create(&pmu->hw_core,
  41                                 resource, PMU_REGISTER_ADDRESS_SPACE_SIZE)) {
  42
  43                         pmu->switch_delay = _mali_osk_get_pmu_switch_delay();
  44
  45                         mali_global_pmu_core = pmu;
  46
  47                         return pmu;
  48                 }
  49                 _mali_osk_free(pmu);
  50         }
  51
  52         return NULL;
  53 }
  54
  55 void mali_pmu_delete(struct mali_pmu_core *pmu)
  56 {
  57         MALI_DEBUG_ASSERT_POINTER(pmu);
  58         MALI_DEBUG_ASSERT(pmu == mali_global_pmu_core);
  59
  60         MALI_DEBUG_PRINT(2, ("Mali PMU: Deleting Mali PMU core\n"));
  61
  62         mali_global_pmu_core = NULL;
  63
  64         mali_hw_core_delete(&pmu->hw_core);
  65         _mali_osk_free(pmu);
  66 }
  67
  68 void mali_pmu_set_registered_cores_mask(struct mali_pmu_core *pmu, u32 mask)
  69 {
  70         pmu->registered_cores_mask = mask;
  71 }
  72
  73 void mali_pmu_reset(struct mali_pmu_core *pmu)
  74 {
  75         MALI_DEBUG_ASSERT_POINTER(pmu);
  76         MALI_DEBUG_ASSERT(pmu->registered_cores_mask != 0);
  77
  78         /* Setup the desired defaults */
  79         mali_hw_core_register_write_relaxed(&pmu->hw_core,
  80                                             PMU_REG_ADDR_MGMT_INT_MASK, 0);
  81         mali_hw_core_register_write_relaxed(&pmu->hw_core,
  82                                             PMU_REG_ADDR_MGMT_SW_DELAY, pmu->switch_delay);
  83 }
  84
  85 void mali_pmu_power_up_all(struct mali_pmu_core *pmu)
  86 {
  87         u32 stat;
  88
  89         MALI_DEBUG_ASSERT_POINTER(pmu);
  90         MALI_DEBUG_ASSERT(pmu->registered_cores_mask != 0);
  91
  92         mali_pm_exec_lock();
  93
  94         mali_pmu_reset(pmu);
  95
  96         /* Now simply power up the domains which are marked as powered down */
  97         stat = mali_hw_core_register_read(&pmu->hw_core,
  98                                           PMU_REG_ADDR_MGMT_STATUS);
  99         mali_pmu_power_up(pmu, stat);
 100
 101         mali_pm_exec_unlock();
 102 }
 103
 104 void mali_pmu_power_down_all(struct mali_pmu_core *pmu)
 105 {
 106         u32 stat;
 107
 108         MALI_DEBUG_ASSERT_POINTER(pmu);
 109         MALI_DEBUG_ASSERT(pmu->registered_cores_mask != 0);
 110
 111         mali_pm_exec_lock();
 112
 113         /* Now simply power down the domains which are marked as powered up */
 114         stat = mali_hw_core_register_read(&pmu->hw_core,
 115                                           PMU_REG_ADDR_MGMT_STATUS);
 116         mali_pmu_power_down(pmu, (~stat) & pmu->registered_cores_mask);
 117
 118         mali_pm_exec_unlock();
 119 }
 120
 121 _mali_osk_errcode_t mali_pmu_power_down(struct mali_pmu_core *pmu, u32 mask)
 122 {
 123         u32 stat;
 124         _mali_osk_errcode_t err;
 125
 126         MALI_DEBUG_ASSERT_POINTER(pmu);
 127         MALI_DEBUG_ASSERT(pmu->registered_cores_mask != 0);
 128         MALI_DEBUG_ASSERT(mask <= pmu->registered_cores_mask);
 129         MALI_DEBUG_ASSERT(0 == (mali_hw_core_register_read(&pmu->hw_core,
 130                                 PMU_REG_ADDR_MGMT_INT_RAWSTAT) &
 131                                 PMU_REG_VAL_IRQ));
 132
 133         MALI_DEBUG_PRINT(3,
 134                          ("PMU power down: ...................... [%s]\n",
 135                           mali_pm_mask_to_string(mask)));
 136
 137         stat = mali_hw_core_register_read(&pmu->hw_core,
 138                                           PMU_REG_ADDR_MGMT_STATUS);
 139
 140         /*
 141          * Assert that we are not powering down domains which are already
 142          * powered down.
 143          */
 144         MALI_DEBUG_ASSERT(0 == (stat & mask));
 145
 146         if (0 == mask || 0 == ((~stat) & mask)) return _MALI_OSK_ERR_OK;
 147
 148         mali_hw_core_register_write(&pmu->hw_core,
 149                                     PMU_REG_ADDR_MGMT_POWER_DOWN, mask);
 150
 151         /*
 152          * Do not wait for interrupt on Mali-300/400 if all domains are
 153          * powered off by our power down command, because the HW will simply
 154          * not generate an interrupt in this case.
 155          */
 156         if (mali_is_mali450() || pmu->registered_cores_mask != (mask | stat)) {
 157                 err = mali_pmu_wait_for_command_finish(pmu);
 158                 if (_MALI_OSK_ERR_OK != err) {
 159                         return err;
 160                 }
 161         } else {
 162                 mali_hw_core_register_write(&pmu->hw_core,
 163                                             PMU_REG_ADDR_MGMT_INT_CLEAR, PMU_REG_VAL_IRQ);
 164         }
 165
 166 #if defined(DEBUG)
 167         /* Verify power status of domains after power down */
 168         stat = mali_hw_core_register_read(&pmu->hw_core,
 169                                           PMU_REG_ADDR_MGMT_STATUS);
 170         MALI_DEBUG_ASSERT(mask == (stat & mask));
 171 #endif
 172
 173         return _MALI_OSK_ERR_OK;
 174 }
 175
 176 _mali_osk_errcode_t mali_pmu_power_up(struct mali_pmu_core *pmu, u32 mask)
 177 {
 178         u32 stat;
 179         _mali_osk_errcode_t err;
 180 #if !defined(CONFIG_MALI_PMU_PARALLEL_POWER_UP)
 181         u32 current_domain;
 182 #endif
 183
 184         MALI_DEBUG_ASSERT_POINTER(pmu);
 185         MALI_DEBUG_ASSERT(pmu->registered_cores_mask != 0);
 186         MALI_DEBUG_ASSERT(mask <= pmu->registered_cores_mask);
 187         MALI_DEBUG_ASSERT(0 == (mali_hw_core_register_read(&pmu->hw_core,
 188                                 PMU_REG_ADDR_MGMT_INT_RAWSTAT) &
 189                                 PMU_REG_VAL_IRQ));
 190
 191         MALI_DEBUG_PRINT(3,
 192                          ("PMU power up: ........................ [%s]\n",
 193                           mali_pm_mask_to_string(mask)));
 194
 195         stat = mali_hw_core_register_read(&pmu->hw_core,
 196                                           PMU_REG_ADDR_MGMT_STATUS);
 197         stat &= pmu->registered_cores_mask;
 198         if (0 == mask || 0 == (stat & mask)) return _MALI_OSK_ERR_OK;
 199
 200         /*
 201          * Assert that we are only powering up domains which are currently
 202          * powered down.
 203          */
 204         MALI_DEBUG_ASSERT(mask == (stat & mask));
 205
 206 #if defined(CONFIG_MALI_PMU_PARALLEL_POWER_UP)
 207         mali_hw_core_register_write(&pmu->hw_core,
 208                                     PMU_REG_ADDR_MGMT_POWER_UP, mask);
 209
 210         err = mali_pmu_wait_for_command_finish(pmu);
 211         if (_MALI_OSK_ERR_OK != err) {
 212                 return err;
 213         }
 214 #else
 215         for (current_domain = 1;
 216              current_domain <= pmu->registered_cores_mask;
 217              current_domain <<= 1) {
 218                 if (current_domain & mask & stat) {
 219                         mali_hw_core_register_write(&pmu->hw_core,
 220                                                     PMU_REG_ADDR_MGMT_POWER_UP,
 221                                                     current_domain);
 222
 223                         err = mali_pmu_wait_for_command_finish(pmu);
 224                         if (_MALI_OSK_ERR_OK != err) {
 225                                 return err;
 226                         }
 227                 }
 228         }
 229 #endif
 230
 231 #if defined(DEBUG)
 232         /* Verify power status of domains after power up */
 233         stat = mali_hw_core_register_read(&pmu->hw_core,
 234                                           PMU_REG_ADDR_MGMT_STATUS);
 235         MALI_DEBUG_ASSERT(0 == (stat & mask));
 236 #endif /* defined(DEBUG) */
 237
 238         return _MALI_OSK_ERR_OK;
 239 }
 240
 241 static _mali_osk_errcode_t mali_pmu_wait_for_command_finish(
 242         struct mali_pmu_core *pmu)
 243 {
 244         u32 rawstat;
 245         u32 timeout = MALI_REG_POLL_COUNT_SLOW;
 246
 247         MALI_DEBUG_ASSERT(pmu);
 248
 249         /* Wait for the command to complete */
 250         do {
 251                 rawstat = mali_hw_core_register_read(&pmu->hw_core,
 252                                                      PMU_REG_ADDR_MGMT_INT_RAWSTAT);
 253                 --timeout;
 254         } while (0 == (rawstat & PMU_REG_VAL_IRQ) && 0 < timeout);
 255
 256         MALI_DEBUG_ASSERT(0 < timeout);
 257
 258         if (0 == timeout) {
 259                 return _MALI_OSK_ERR_TIMEOUT;
 260         }
 261
 262         mali_hw_core_register_write(&pmu->hw_core,
 263                                     PMU_REG_ADDR_MGMT_INT_CLEAR, PMU_REG_VAL_IRQ);
 264
 265         return _MALI_OSK_ERR_OK;
 266 }