drivers/gpu/drm/radeon/trinity_smc.c

   1 /*
   2  * Copyright 2012 Advanced Micro Devices, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  */
  23
  24 #include "radeon.h"
  25 #include "trinityd.h"
  26 #include "trinity_dpm.h"
  27 #include "ppsmc.h"
  28
  29 static int trinity_notify_message_to_smu(struct radeon_device *rdev, u32 id)
  30 {
  31         int i;
  32         u32 v = 0;
  33
  34         WREG32(SMC_MESSAGE_0, id);
  35         for (i = 0; i < rdev->usec_timeout; i++) {
  36                 if (RREG32(SMC_RESP_0) != 0)
  37                         break;
  38                 udelay(1);
  39         }
  40         v = RREG32(SMC_RESP_0);
  41
  42         if (v != 1) {
  43                 if (v == 0xFF) {
  44                         DRM_ERROR("SMC failed to handle the message!\n");
  45                         return -EINVAL;
  46                 } else if (v == 0xFE) {
  47                         DRM_ERROR("Unknown SMC message!\n");
  48                         return -EINVAL;
  49                 }
  50         }
  51
  52         return 0;
  53 }
  54
  55 int trinity_dpm_bapm_enable(struct radeon_device *rdev, bool enable)
  56 {
  57         if (enable)
  58                 return trinity_notify_message_to_smu(rdev, PPSMC_MSG_EnableBAPM);
  59         else
  60                 return trinity_notify_message_to_smu(rdev, PPSMC_MSG_DisableBAPM);
  61 }
  62
  63 int trinity_dpm_config(struct radeon_device *rdev, bool enable)
  64 {
  65         if (enable)
  66                 WREG32_SMC(SMU_SCRATCH0, 1);
  67         else
  68                 WREG32_SMC(SMU_SCRATCH0, 0);
  69
  70         return trinity_notify_message_to_smu(rdev, PPSMC_MSG_DPM_Config);
  71 }
  72
  73 int trinity_dpm_force_state(struct radeon_device *rdev, u32 n)
  74 {
  75         WREG32_SMC(SMU_SCRATCH0, n);
  76
  77         return trinity_notify_message_to_smu(rdev, PPSMC_MSG_DPM_ForceState);
  78 }
  79
  80 int trinity_dpm_n_levels_disabled(struct radeon_device *rdev, u32 n)
  81 {
  82         WREG32_SMC(SMU_SCRATCH0, n);
  83
  84         return trinity_notify_message_to_smu(rdev, PPSMC_MSG_DPM_N_LevelsDisabled);
  85 }
  86
  87 int trinity_uvd_dpm_config(struct radeon_device *rdev)
  88 {
  89         return trinity_notify_message_to_smu(rdev, PPSMC_MSG_UVD_DPM_Config);
  90 }
  91
  92 int trinity_dpm_no_forced_level(struct radeon_device *rdev)
  93 {
  94         return trinity_notify_message_to_smu(rdev, PPSMC_MSG_NoForcedLevel);
  95 }
  96
  97 int trinity_dce_enable_voltage_adjustment(struct radeon_device *rdev,
  98                                           bool enable)
  99 {
 100         if (enable)
 101                 return trinity_notify_message_to_smu(rdev, PPSMC_MSG_DCE_AllowVoltageAdjustment);
 102         else
 103                 return trinity_notify_message_to_smu(rdev, PPSMC_MSG_DCE_RemoveVoltageAdjustment);
 104 }
 105
 106 int trinity_gfx_dynamic_mgpg_config(struct radeon_device *rdev)
 107 {
 108         return trinity_notify_message_to_smu(rdev, PPSMC_MSG_PG_SIMD_Config);
 109 }
 110
 111 void trinity_acquire_mutex(struct radeon_device *rdev)
 112 {
 113         int i;
 114
 115         WREG32(SMC_INT_REQ, 1);
 116         for (i = 0; i < rdev->usec_timeout; i++) {
 117                 if ((RREG32(SMC_INT_REQ) & 0xffff) == 1)
 118                         break;
 119                 udelay(1);
 120         }
 121 }
 122
 123 void trinity_release_mutex(struct radeon_device *rdev)
 124 {
 125         WREG32(SMC_INT_REQ, 0);
 126 }