LXR linux/drivers/gpu/drm/radeon/trinity

   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
  29static 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
  55int 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
  63int 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
  73int 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
  80int 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
  87int trinity_uvd_dpm_config(struct radeon_device *rdev)
  88{
  89        return trinity_notify_message_to_smu(rdev, PPSMC_MSG_UVD_DPM_Config);
  90}
  91
  92int trinity_dpm_no_forced_level(struct radeon_device *rdev)
  93{
  94        return trinity_notify_message_to_smu(rdev, PPSMC_MSG_NoForcedLevel);
  95}
  96
  97int 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
 106int 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
 111void 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
 123void trinity_release_mutex(struct radeon_device *rdev)
 124{
 125        WREG32(SMC_INT_REQ, 0);
 126}
 127