drivers/gpu/drm/amd/amdgpu/amdgpu_powerplay.c

   1 /*
   2  * Copyright 2015 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  * Authors: AMD
  23  *
  24  */
  25 #include "atom.h"
  26 #include "amdgpu.h"
  27 #include "amd_shared.h"
  28 #include <linux/module.h>
  29 #include <linux/moduleparam.h>
  30 #include "amdgpu_pm.h"
  31 #include <drm/amdgpu_drm.h>
  32 #include "amdgpu_powerplay.h"
  33 #include "si_dpm.h"
  34 #include "cik_dpm.h"
  35 #include "vi_dpm.h"
  36
  37 static int amdgpu_create_pp_handle(struct amdgpu_device *adev)
  38 {
  39         struct amd_pp_init pp_init;
  40         struct amd_powerplay *amd_pp;
  41         int ret;
  42
  43         amd_pp = &(adev->powerplay);
  44         pp_init.chip_family = adev->family;
  45         pp_init.chip_id = adev->asic_type;
  46         pp_init.pm_en = (amdgpu_dpm != 0 && !amdgpu_sriov_vf(adev)) ? true : false;
  47         pp_init.feature_mask = amdgpu_pp_feature_mask;
  48         pp_init.device = amd_pp->cgs_device;
  49         ret = amd_powerplay_create(&pp_init, &(amd_pp->pp_handle));
  50         if (ret)
  51                 return -EINVAL;
  52         return 0;
  53 }
  54
  55 static int amdgpu_pp_early_init(void *handle)
  56 {
  57         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
  58         struct amd_powerplay *amd_pp;
  59         int ret = 0;
  60
  61         amd_pp = &(adev->powerplay);
  62         amd_pp->pp_handle = (void *)adev;
  63
  64         switch (adev->asic_type) {
  65         case CHIP_POLARIS11:
  66         case CHIP_POLARIS10:
  67         case CHIP_POLARIS12:
  68         case CHIP_TONGA:
  69         case CHIP_FIJI:
  70         case CHIP_TOPAZ:
  71         case CHIP_CARRIZO:
  72         case CHIP_STONEY:
  73         case CHIP_VEGA10:
  74         case CHIP_RAVEN:
  75                 amd_pp->cgs_device = amdgpu_cgs_create_device(adev);
  76                 if (amdgpu_create_pp_handle(adev))
  77                         return -EINVAL;
  78                 amd_pp->ip_funcs = &pp_ip_funcs;
  79                 amd_pp->pp_funcs = &pp_dpm_funcs;
  80                 break;
  81         /* These chips don't have powerplay implemenations */
  82 #ifdef CONFIG_DRM_AMDGPU_SI
  83         case CHIP_TAHITI:
  84         case CHIP_PITCAIRN:
  85         case CHIP_VERDE:
  86         case CHIP_OLAND:
  87         case CHIP_HAINAN:
  88                 amd_pp->ip_funcs = &si_dpm_ip_funcs;
  89                 amd_pp->pp_funcs = &si_dpm_funcs;
  90         break;
  91 #endif
  92 #ifdef CONFIG_DRM_AMDGPU_CIK
  93         case CHIP_BONAIRE:
  94         case CHIP_HAWAII:
  95                 if (amdgpu_dpm == -1) {
  96                         amd_pp->ip_funcs = &ci_dpm_ip_funcs;
  97                         amd_pp->pp_funcs = &ci_dpm_funcs;
  98                 } else {
  99                         amd_pp->cgs_device = amdgpu_cgs_create_device(adev);
 100                         if (amdgpu_create_pp_handle(adev))
 101                                 return -EINVAL;
 102                         amd_pp->ip_funcs = &pp_ip_funcs;
 103                         amd_pp->pp_funcs = &pp_dpm_funcs;
 104                 }
 105                 break;
 106         case CHIP_KABINI:
 107         case CHIP_MULLINS:
 108         case CHIP_KAVERI:
 109                 amd_pp->ip_funcs = &kv_dpm_ip_funcs;
 110                 amd_pp->pp_funcs = &kv_dpm_funcs;
 111                 break;
 112 #endif
 113         default:
 114                 ret = -EINVAL;
 115                 break;
 116         }
 117
 118         if (adev->powerplay.ip_funcs->early_init)
 119                 ret = adev->powerplay.ip_funcs->early_init(
 120                                         adev->powerplay.pp_handle);
 121
 122         if (ret == PP_DPM_DISABLED) {
 123                 adev->pm.dpm_enabled = false;
 124                 return 0;
 125         }
 126         return ret;
 127 }
 128
 129
 130 static int amdgpu_pp_late_init(void *handle)
 131 {
 132         int ret = 0;
 133         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 134
 135         if (adev->powerplay.ip_funcs->late_init)
 136                 ret = adev->powerplay.ip_funcs->late_init(
 137                                         adev->powerplay.pp_handle);
 138
 139         return ret;
 140 }
 141
 142 static int amdgpu_pp_sw_init(void *handle)
 143 {
 144         int ret = 0;
 145         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 146
 147         if (adev->powerplay.ip_funcs->sw_init)
 148                 ret = adev->powerplay.ip_funcs->sw_init(
 149                                         adev->powerplay.pp_handle);
 150
 151         return ret;
 152 }
 153
 154 static int amdgpu_pp_sw_fini(void *handle)
 155 {
 156         int ret = 0;
 157         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 158
 159         if (adev->powerplay.ip_funcs->sw_fini)
 160                 ret = adev->powerplay.ip_funcs->sw_fini(
 161                                         adev->powerplay.pp_handle);
 162         if (ret)
 163                 return ret;
 164
 165         return ret;
 166 }
 167
 168 static int amdgpu_pp_hw_init(void *handle)
 169 {
 170         int ret = 0;
 171         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 172
 173
 174         if (adev->powerplay.ip_funcs->hw_init)
 175                 ret = adev->powerplay.ip_funcs->hw_init(
 176                                         adev->powerplay.pp_handle);
 177
 178         if (ret == PP_DPM_DISABLED) {
 179                 adev->pm.dpm_enabled = false;
 180                 return 0;
 181         }
 182
 183         if ((amdgpu_dpm != 0) && !amdgpu_sriov_vf(adev))
 184                 adev->pm.dpm_enabled = true;
 185
 186         return ret;
 187 }
 188
 189 static int amdgpu_pp_hw_fini(void *handle)
 190 {
 191         int ret = 0;
 192         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 193
 194         if (adev->powerplay.ip_funcs->hw_fini)
 195                 ret = adev->powerplay.ip_funcs->hw_fini(
 196                                         adev->powerplay.pp_handle);
 197
 198         return ret;
 199 }
 200
 201 static void amdgpu_pp_late_fini(void *handle)
 202 {
 203         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 204
 205         if (adev->powerplay.ip_funcs->late_fini)
 206                 adev->powerplay.ip_funcs->late_fini(
 207                           adev->powerplay.pp_handle);
 208
 209
 210         if (adev->powerplay.cgs_device) {
 211                 amd_powerplay_destroy(adev->powerplay.pp_handle);
 212                 amdgpu_cgs_destroy_device(adev->powerplay.cgs_device);
 213         }
 214 }
 215
 216 static int amdgpu_pp_suspend(void *handle)
 217 {
 218         int ret = 0;
 219         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 220
 221         if (adev->powerplay.ip_funcs->suspend)
 222                 ret = adev->powerplay.ip_funcs->suspend(
 223                                          adev->powerplay.pp_handle);
 224         return ret;
 225 }
 226
 227 static int amdgpu_pp_resume(void *handle)
 228 {
 229         int ret = 0;
 230         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 231
 232         if (adev->powerplay.ip_funcs->resume)
 233                 ret = adev->powerplay.ip_funcs->resume(
 234                                         adev->powerplay.pp_handle);
 235         return ret;
 236 }
 237
 238 static int amdgpu_pp_set_clockgating_state(void *handle,
 239                                         enum amd_clockgating_state state)
 240 {
 241         int ret = 0;
 242         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 243
 244         if (adev->powerplay.ip_funcs->set_clockgating_state)
 245                 ret = adev->powerplay.ip_funcs->set_clockgating_state(
 246                                 adev->powerplay.pp_handle, state);
 247         return ret;
 248 }
 249
 250 static int amdgpu_pp_set_powergating_state(void *handle,
 251                                         enum amd_powergating_state state)
 252 {
 253         int ret = 0;
 254         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 255
 256         if (adev->powerplay.ip_funcs->set_powergating_state)
 257                 ret = adev->powerplay.ip_funcs->set_powergating_state(
 258                                  adev->powerplay.pp_handle, state);
 259         return ret;
 260 }
 261
 262
 263 static bool amdgpu_pp_is_idle(void *handle)
 264 {
 265         bool ret = true;
 266         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 267
 268         if (adev->powerplay.ip_funcs->is_idle)
 269                 ret = adev->powerplay.ip_funcs->is_idle(
 270                                         adev->powerplay.pp_handle);
 271         return ret;
 272 }
 273
 274 static int amdgpu_pp_wait_for_idle(void *handle)
 275 {
 276         int ret = 0;
 277         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 278
 279         if (adev->powerplay.ip_funcs->wait_for_idle)
 280                 ret = adev->powerplay.ip_funcs->wait_for_idle(
 281                                         adev->powerplay.pp_handle);
 282         return ret;
 283 }
 284
 285 static int amdgpu_pp_soft_reset(void *handle)
 286 {
 287         int ret = 0;
 288         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 289
 290         if (adev->powerplay.ip_funcs->soft_reset)
 291                 ret = adev->powerplay.ip_funcs->soft_reset(
 292                                         adev->powerplay.pp_handle);
 293         return ret;
 294 }
 295
 296 static const struct amd_ip_funcs amdgpu_pp_ip_funcs = {
 297         .name = "amdgpu_powerplay",
 298         .early_init = amdgpu_pp_early_init,
 299         .late_init = amdgpu_pp_late_init,
 300         .sw_init = amdgpu_pp_sw_init,
 301         .sw_fini = amdgpu_pp_sw_fini,
 302         .hw_init = amdgpu_pp_hw_init,
 303         .hw_fini = amdgpu_pp_hw_fini,
 304         .late_fini = amdgpu_pp_late_fini,
 305         .suspend = amdgpu_pp_suspend,
 306         .resume = amdgpu_pp_resume,
 307         .is_idle = amdgpu_pp_is_idle,
 308         .wait_for_idle = amdgpu_pp_wait_for_idle,
 309         .soft_reset = amdgpu_pp_soft_reset,
 310         .set_clockgating_state = amdgpu_pp_set_clockgating_state,
 311         .set_powergating_state = amdgpu_pp_set_powergating_state,
 312 };
 313
 314 const struct amdgpu_ip_block_version amdgpu_pp_ip_block =
 315 {
 316         .type = AMD_IP_BLOCK_TYPE_SMC,
 317         .major = 1,
 318         .minor = 0,
 319         .rev = 0,
 320         .funcs = &amdgpu_pp_ip_funcs,
 321 };