1 /* 2 * Copyright 2011 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: Alex Deucher 23 */ 24 25 #include "amdgpu.h" 26 #include "amdgpu_atombios.h" 27 #include "amdgpu_i2c.h" 28 #include "amdgpu_dpm.h" 29 #include "atom.h" 30 #include "amd_pcie.h" 31 #include "amdgpu_display.h" 32 #include "hwmgr.h" 33 #include <linux/power_supply.h> 34 #include "amdgpu_smu.h" 35 36 #define amdgpu_dpm_notify_ac_dc(adev) \ 37 ((adev)->powerplay.pp_funcs->notify_ac_dc((adev)->powerplay.pp_handle)) 38 39 #define amdgpu_dpm_is_legacy_dpm(adev) ((adev)->powerplay.pp_handle == (adev)) 40 41 int amdgpu_dpm_get_sclk(struct amdgpu_device *adev, bool low) 42 { 43 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 44 int ret = 0; 45 46 if (!pp_funcs->get_sclk) 47 return 0; 48 49 mutex_lock(&adev->pm.mutex); 50 ret = pp_funcs->get_sclk((adev)->powerplay.pp_handle, 51 low); 52 mutex_unlock(&adev->pm.mutex); 53 54 return ret; 55 } 56 57 int amdgpu_dpm_get_mclk(struct amdgpu_device *adev, bool low) 58 { 59 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 60 int ret = 0; 61 62 if (!pp_funcs->get_mclk) 63 return 0; 64 65 mutex_lock(&adev->pm.mutex); 66 ret = pp_funcs->get_mclk((adev)->powerplay.pp_handle, 67 low); 68 mutex_unlock(&adev->pm.mutex); 69 70 return ret; 71 } 72 73 int amdgpu_dpm_set_powergating_by_smu(struct amdgpu_device *adev, 74 uint32_t block_type, 75 bool gate, 76 int inst) 77 { 78 int ret = 0; 79 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 80 enum ip_power_state pwr_state = gate ? POWER_STATE_OFF : POWER_STATE_ON; 81 bool is_vcn = block_type == AMD_IP_BLOCK_TYPE_VCN; 82 83 mutex_lock(&adev->pm.mutex); 84 85 if (atomic_read(&adev->pm.pwr_state[block_type]) == pwr_state && 86 (!is_vcn || adev->vcn.num_vcn_inst == 1)) { 87 dev_dbg(adev->dev, "IP block%d already in the target %s state!", 88 block_type, gate ? "gate" : "ungate"); 89 goto out_unlock; 90 } 91 92 switch (block_type) { 93 case AMD_IP_BLOCK_TYPE_UVD: 94 case AMD_IP_BLOCK_TYPE_VCE: 95 case AMD_IP_BLOCK_TYPE_GFX: 96 case AMD_IP_BLOCK_TYPE_SDMA: 97 case AMD_IP_BLOCK_TYPE_JPEG: 98 case AMD_IP_BLOCK_TYPE_GMC: 99 case AMD_IP_BLOCK_TYPE_ACP: 100 case AMD_IP_BLOCK_TYPE_VPE: 101 case AMD_IP_BLOCK_TYPE_ISP: 102 if (pp_funcs && pp_funcs->set_powergating_by_smu) 103 ret = (pp_funcs->set_powergating_by_smu( 104 (adev)->powerplay.pp_handle, block_type, gate, 0)); 105 break; 106 case AMD_IP_BLOCK_TYPE_VCN: 107 if (pp_funcs && pp_funcs->set_powergating_by_smu) 108 ret = (pp_funcs->set_powergating_by_smu( 109 (adev)->powerplay.pp_handle, block_type, gate, inst)); 110 break; 111 default: 112 break; 113 } 114 115 if (!ret) 116 atomic_set(&adev->pm.pwr_state[block_type], pwr_state); 117 118 out_unlock: 119 mutex_unlock(&adev->pm.mutex); 120 121 return ret; 122 } 123 124 int amdgpu_dpm_set_gfx_power_up_by_imu(struct amdgpu_device *adev) 125 { 126 struct smu_context *smu = adev->powerplay.pp_handle; 127 int ret = -EOPNOTSUPP; 128 129 mutex_lock(&adev->pm.mutex); 130 ret = smu_set_gfx_power_up_by_imu(smu); 131 mutex_unlock(&adev->pm.mutex); 132 133 msleep(10); 134 135 return ret; 136 } 137 138 int amdgpu_dpm_baco_enter(struct amdgpu_device *adev) 139 { 140 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 141 void *pp_handle = adev->powerplay.pp_handle; 142 int ret = 0; 143 144 if (!pp_funcs || !pp_funcs->set_asic_baco_state) 145 return -ENOENT; 146 147 mutex_lock(&adev->pm.mutex); 148 149 /* enter BACO state */ 150 ret = pp_funcs->set_asic_baco_state(pp_handle, 1); 151 152 mutex_unlock(&adev->pm.mutex); 153 154 return ret; 155 } 156 157 int amdgpu_dpm_baco_exit(struct amdgpu_device *adev) 158 { 159 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 160 void *pp_handle = adev->powerplay.pp_handle; 161 int ret = 0; 162 163 if (!pp_funcs || !pp_funcs->set_asic_baco_state) 164 return -ENOENT; 165 166 mutex_lock(&adev->pm.mutex); 167 168 /* exit BACO state */ 169 ret = pp_funcs->set_asic_baco_state(pp_handle, 0); 170 171 mutex_unlock(&adev->pm.mutex); 172 173 return ret; 174 } 175 176 int amdgpu_dpm_set_mp1_state(struct amdgpu_device *adev, 177 enum pp_mp1_state mp1_state) 178 { 179 int ret = 0; 180 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 181 182 if (mp1_state == PP_MP1_STATE_FLR) { 183 /* VF lost access to SMU */ 184 if (amdgpu_sriov_vf(adev)) 185 adev->pm.dpm_enabled = false; 186 } else if (pp_funcs && pp_funcs->set_mp1_state) { 187 mutex_lock(&adev->pm.mutex); 188 189 ret = pp_funcs->set_mp1_state( 190 adev->powerplay.pp_handle, 191 mp1_state); 192 193 mutex_unlock(&adev->pm.mutex); 194 } 195 196 return ret; 197 } 198 199 int amdgpu_dpm_is_baco_supported(struct amdgpu_device *adev) 200 { 201 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 202 void *pp_handle = adev->powerplay.pp_handle; 203 int ret; 204 205 if (!pp_funcs || !pp_funcs->get_asic_baco_capability) 206 return 0; 207 /* Don't use baco for reset in S3. 208 * This is a workaround for some platforms 209 * where entering BACO during suspend 210 * seems to cause reboots or hangs. 211 * This might be related to the fact that BACO controls 212 * power to the whole GPU including devices like audio and USB. 213 * Powering down/up everything may adversely affect these other 214 * devices. Needs more investigation. 215 */ 216 if (adev->in_s3) 217 return 0; 218 219 mutex_lock(&adev->pm.mutex); 220 221 ret = pp_funcs->get_asic_baco_capability(pp_handle); 222 223 mutex_unlock(&adev->pm.mutex); 224 225 return ret; 226 } 227 228 int amdgpu_dpm_mode2_reset(struct amdgpu_device *adev) 229 { 230 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 231 void *pp_handle = adev->powerplay.pp_handle; 232 int ret = 0; 233 234 if (!pp_funcs || !pp_funcs->asic_reset_mode_2) 235 return -ENOENT; 236 237 mutex_lock(&adev->pm.mutex); 238 239 ret = pp_funcs->asic_reset_mode_2(pp_handle); 240 241 mutex_unlock(&adev->pm.mutex); 242 243 return ret; 244 } 245 246 int amdgpu_dpm_enable_gfx_features(struct amdgpu_device *adev) 247 { 248 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 249 void *pp_handle = adev->powerplay.pp_handle; 250 int ret = 0; 251 252 if (!pp_funcs || !pp_funcs->asic_reset_enable_gfx_features) 253 return -ENOENT; 254 255 mutex_lock(&adev->pm.mutex); 256 257 ret = pp_funcs->asic_reset_enable_gfx_features(pp_handle); 258 259 mutex_unlock(&adev->pm.mutex); 260 261 return ret; 262 } 263 264 int amdgpu_dpm_baco_reset(struct amdgpu_device *adev) 265 { 266 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 267 void *pp_handle = adev->powerplay.pp_handle; 268 int ret = 0; 269 270 if (!pp_funcs || !pp_funcs->set_asic_baco_state) 271 return -ENOENT; 272 273 mutex_lock(&adev->pm.mutex); 274 275 /* enter BACO state */ 276 ret = pp_funcs->set_asic_baco_state(pp_handle, 1); 277 if (ret) 278 goto out; 279 280 /* exit BACO state */ 281 ret = pp_funcs->set_asic_baco_state(pp_handle, 0); 282 283 out: 284 mutex_unlock(&adev->pm.mutex); 285 return ret; 286 } 287 288 bool amdgpu_dpm_is_mode1_reset_supported(struct amdgpu_device *adev) 289 { 290 struct smu_context *smu = adev->powerplay.pp_handle; 291 bool support_mode1_reset = false; 292 293 if (is_support_sw_smu(adev)) { 294 mutex_lock(&adev->pm.mutex); 295 support_mode1_reset = smu_mode1_reset_is_support(smu); 296 mutex_unlock(&adev->pm.mutex); 297 } 298 299 return support_mode1_reset; 300 } 301 302 int amdgpu_dpm_mode1_reset(struct amdgpu_device *adev) 303 { 304 struct smu_context *smu = adev->powerplay.pp_handle; 305 int ret = -EOPNOTSUPP; 306 307 if (is_support_sw_smu(adev)) { 308 mutex_lock(&adev->pm.mutex); 309 ret = smu_mode1_reset(smu); 310 mutex_unlock(&adev->pm.mutex); 311 } 312 313 return ret; 314 } 315 316 bool amdgpu_dpm_is_link_reset_supported(struct amdgpu_device *adev) 317 { 318 struct smu_context *smu = adev->powerplay.pp_handle; 319 bool support_link_reset = false; 320 321 if (is_support_sw_smu(adev)) { 322 mutex_lock(&adev->pm.mutex); 323 support_link_reset = smu_link_reset_is_support(smu); 324 mutex_unlock(&adev->pm.mutex); 325 } 326 327 return support_link_reset; 328 } 329 330 int amdgpu_dpm_link_reset(struct amdgpu_device *adev) 331 { 332 struct smu_context *smu = adev->powerplay.pp_handle; 333 int ret = -EOPNOTSUPP; 334 335 if (is_support_sw_smu(adev)) { 336 mutex_lock(&adev->pm.mutex); 337 ret = smu_link_reset(smu); 338 mutex_unlock(&adev->pm.mutex); 339 } 340 341 return ret; 342 } 343 344 int amdgpu_dpm_switch_power_profile(struct amdgpu_device *adev, 345 enum PP_SMC_POWER_PROFILE type, 346 bool en) 347 { 348 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 349 int ret = 0; 350 351 if (amdgpu_sriov_vf(adev) || 352 amdgpu_in_reset(adev)) 353 return 0; 354 355 if (pp_funcs && pp_funcs->switch_power_profile) { 356 mutex_lock(&adev->pm.mutex); 357 ret = pp_funcs->switch_power_profile( 358 adev->powerplay.pp_handle, type, en); 359 mutex_unlock(&adev->pm.mutex); 360 } 361 362 return ret; 363 } 364 365 int amdgpu_dpm_pause_power_profile(struct amdgpu_device *adev, 366 bool pause) 367 { 368 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 369 int ret = 0; 370 371 if (amdgpu_sriov_vf(adev) || 372 amdgpu_in_reset(adev)) 373 return 0; 374 375 if (pp_funcs && pp_funcs->pause_power_profile) { 376 mutex_lock(&adev->pm.mutex); 377 ret = pp_funcs->pause_power_profile( 378 adev->powerplay.pp_handle, pause); 379 mutex_unlock(&adev->pm.mutex); 380 } 381 382 return ret; 383 } 384 385 int amdgpu_dpm_set_xgmi_pstate(struct amdgpu_device *adev, 386 uint32_t pstate) 387 { 388 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 389 int ret = 0; 390 391 if (pp_funcs && pp_funcs->set_xgmi_pstate) { 392 mutex_lock(&adev->pm.mutex); 393 ret = pp_funcs->set_xgmi_pstate(adev->powerplay.pp_handle, 394 pstate); 395 mutex_unlock(&adev->pm.mutex); 396 } 397 398 return ret; 399 } 400 401 int amdgpu_dpm_set_df_cstate(struct amdgpu_device *adev, 402 uint32_t cstate) 403 { 404 int ret = 0; 405 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 406 void *pp_handle = adev->powerplay.pp_handle; 407 408 if (pp_funcs && pp_funcs->set_df_cstate) { 409 mutex_lock(&adev->pm.mutex); 410 ret = pp_funcs->set_df_cstate(pp_handle, cstate); 411 mutex_unlock(&adev->pm.mutex); 412 } 413 414 return ret; 415 } 416 417 ssize_t amdgpu_dpm_get_pm_policy_info(struct amdgpu_device *adev, 418 enum pp_pm_policy p_type, char *buf) 419 { 420 struct smu_context *smu = adev->powerplay.pp_handle; 421 int ret = -EOPNOTSUPP; 422 423 if (is_support_sw_smu(adev)) { 424 mutex_lock(&adev->pm.mutex); 425 ret = smu_get_pm_policy_info(smu, p_type, buf); 426 mutex_unlock(&adev->pm.mutex); 427 } 428 429 return ret; 430 } 431 432 int amdgpu_dpm_set_pm_policy(struct amdgpu_device *adev, int policy_type, 433 int policy_level) 434 { 435 struct smu_context *smu = adev->powerplay.pp_handle; 436 int ret = -EOPNOTSUPP; 437 438 if (is_support_sw_smu(adev)) { 439 mutex_lock(&adev->pm.mutex); 440 ret = smu_set_pm_policy(smu, policy_type, policy_level); 441 mutex_unlock(&adev->pm.mutex); 442 } 443 444 return ret; 445 } 446 447 int amdgpu_dpm_enable_mgpu_fan_boost(struct amdgpu_device *adev) 448 { 449 void *pp_handle = adev->powerplay.pp_handle; 450 const struct amd_pm_funcs *pp_funcs = 451 adev->powerplay.pp_funcs; 452 int ret = 0; 453 454 if (pp_funcs && pp_funcs->enable_mgpu_fan_boost) { 455 mutex_lock(&adev->pm.mutex); 456 ret = pp_funcs->enable_mgpu_fan_boost(pp_handle); 457 mutex_unlock(&adev->pm.mutex); 458 } 459 460 return ret; 461 } 462 463 int amdgpu_dpm_set_clockgating_by_smu(struct amdgpu_device *adev, 464 uint32_t msg_id) 465 { 466 void *pp_handle = adev->powerplay.pp_handle; 467 const struct amd_pm_funcs *pp_funcs = 468 adev->powerplay.pp_funcs; 469 int ret = 0; 470 471 if (pp_funcs && pp_funcs->set_clockgating_by_smu) { 472 mutex_lock(&adev->pm.mutex); 473 ret = pp_funcs->set_clockgating_by_smu(pp_handle, 474 msg_id); 475 mutex_unlock(&adev->pm.mutex); 476 } 477 478 return ret; 479 } 480 481 int amdgpu_dpm_smu_i2c_bus_access(struct amdgpu_device *adev, 482 bool acquire) 483 { 484 void *pp_handle = adev->powerplay.pp_handle; 485 const struct amd_pm_funcs *pp_funcs = 486 adev->powerplay.pp_funcs; 487 int ret = -EOPNOTSUPP; 488 489 if (pp_funcs && pp_funcs->smu_i2c_bus_access) { 490 mutex_lock(&adev->pm.mutex); 491 ret = pp_funcs->smu_i2c_bus_access(pp_handle, 492 acquire); 493 mutex_unlock(&adev->pm.mutex); 494 } 495 496 return ret; 497 } 498 499 void amdgpu_pm_acpi_event_handler(struct amdgpu_device *adev) 500 { 501 if (adev->pm.dpm_enabled) { 502 mutex_lock(&adev->pm.mutex); 503 if (power_supply_is_system_supplied() > 0) 504 adev->pm.ac_power = true; 505 else 506 adev->pm.ac_power = false; 507 508 if (adev->powerplay.pp_funcs && 509 adev->powerplay.pp_funcs->notify_ac_dc) 510 amdgpu_dpm_notify_ac_dc(adev); 511 512 mutex_unlock(&adev->pm.mutex); 513 } 514 } 515 516 int amdgpu_dpm_read_sensor(struct amdgpu_device *adev, enum amd_pp_sensors sensor, 517 void *data, uint32_t *size) 518 { 519 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 520 int ret = -EINVAL; 521 522 if (!data || !size) 523 return -EINVAL; 524 525 if (pp_funcs && pp_funcs->read_sensor) { 526 mutex_lock(&adev->pm.mutex); 527 ret = pp_funcs->read_sensor(adev->powerplay.pp_handle, 528 sensor, 529 data, 530 size); 531 mutex_unlock(&adev->pm.mutex); 532 } 533 534 return ret; 535 } 536 537 int amdgpu_dpm_get_apu_thermal_limit(struct amdgpu_device *adev, uint32_t *limit) 538 { 539 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 540 int ret = -EOPNOTSUPP; 541 542 if (pp_funcs && pp_funcs->get_apu_thermal_limit) { 543 mutex_lock(&adev->pm.mutex); 544 ret = pp_funcs->get_apu_thermal_limit(adev->powerplay.pp_handle, limit); 545 mutex_unlock(&adev->pm.mutex); 546 } 547 548 return ret; 549 } 550 551 int amdgpu_dpm_set_apu_thermal_limit(struct amdgpu_device *adev, uint32_t limit) 552 { 553 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 554 int ret = -EOPNOTSUPP; 555 556 if (pp_funcs && pp_funcs->set_apu_thermal_limit) { 557 mutex_lock(&adev->pm.mutex); 558 ret = pp_funcs->set_apu_thermal_limit(adev->powerplay.pp_handle, limit); 559 mutex_unlock(&adev->pm.mutex); 560 } 561 562 return ret; 563 } 564 565 void amdgpu_dpm_compute_clocks(struct amdgpu_device *adev) 566 { 567 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 568 int i; 569 570 if (!adev->pm.dpm_enabled) 571 return; 572 573 if (!pp_funcs->pm_compute_clocks) 574 return; 575 576 if (adev->mode_info.num_crtc) 577 amdgpu_display_bandwidth_update(adev); 578 579 for (i = 0; i < AMDGPU_MAX_RINGS; i++) { 580 struct amdgpu_ring *ring = adev->rings[i]; 581 if (ring && ring->sched.ready) 582 amdgpu_fence_wait_empty(ring); 583 } 584 585 mutex_lock(&adev->pm.mutex); 586 pp_funcs->pm_compute_clocks(adev->powerplay.pp_handle); 587 mutex_unlock(&adev->pm.mutex); 588 } 589 590 void amdgpu_dpm_enable_uvd(struct amdgpu_device *adev, bool enable) 591 { 592 int ret = 0; 593 594 if (adev->family == AMDGPU_FAMILY_SI) { 595 mutex_lock(&adev->pm.mutex); 596 if (enable) { 597 adev->pm.dpm.uvd_active = true; 598 adev->pm.dpm.state = POWER_STATE_TYPE_INTERNAL_UVD; 599 } else { 600 adev->pm.dpm.uvd_active = false; 601 } 602 mutex_unlock(&adev->pm.mutex); 603 604 amdgpu_dpm_compute_clocks(adev); 605 return; 606 } 607 608 ret = amdgpu_dpm_set_powergating_by_smu(adev, AMD_IP_BLOCK_TYPE_UVD, !enable, 0); 609 if (ret) 610 drm_err(adev_to_drm(adev), "DPM %s uvd failed, ret = %d.\n", 611 enable ? "enable" : "disable", ret); 612 } 613 614 void amdgpu_dpm_enable_vcn(struct amdgpu_device *adev, bool enable, int inst) 615 { 616 int ret = 0; 617 618 ret = amdgpu_dpm_set_powergating_by_smu(adev, AMD_IP_BLOCK_TYPE_VCN, !enable, inst); 619 if (ret) 620 drm_err(adev_to_drm(adev), "DPM %s vcn failed, ret = %d.\n", 621 enable ? "enable" : "disable", ret); 622 } 623 624 void amdgpu_dpm_enable_vce(struct amdgpu_device *adev, bool enable) 625 { 626 int ret = 0; 627 628 if (adev->family == AMDGPU_FAMILY_SI) { 629 mutex_lock(&adev->pm.mutex); 630 if (enable) { 631 adev->pm.dpm.vce_active = true; 632 /* XXX select vce level based on ring/task */ 633 adev->pm.dpm.vce_level = AMD_VCE_LEVEL_AC_ALL; 634 } else { 635 adev->pm.dpm.vce_active = false; 636 } 637 mutex_unlock(&adev->pm.mutex); 638 639 amdgpu_dpm_compute_clocks(adev); 640 return; 641 } 642 643 ret = amdgpu_dpm_set_powergating_by_smu(adev, AMD_IP_BLOCK_TYPE_VCE, !enable, 0); 644 if (ret) 645 drm_err(adev_to_drm(adev), "DPM %s vce failed, ret = %d.\n", 646 enable ? "enable" : "disable", ret); 647 } 648 649 void amdgpu_dpm_enable_jpeg(struct amdgpu_device *adev, bool enable) 650 { 651 int ret = 0; 652 653 ret = amdgpu_dpm_set_powergating_by_smu(adev, AMD_IP_BLOCK_TYPE_JPEG, !enable, 0); 654 if (ret) 655 drm_err(adev_to_drm(adev), "Dpm %s jpeg failed, ret = %d.\n", 656 enable ? "enable" : "disable", ret); 657 } 658 659 void amdgpu_dpm_enable_vpe(struct amdgpu_device *adev, bool enable) 660 { 661 int ret = 0; 662 663 ret = amdgpu_dpm_set_powergating_by_smu(adev, AMD_IP_BLOCK_TYPE_VPE, !enable, 0); 664 if (ret) 665 drm_err(adev_to_drm(adev), "DPM %s vpe failed, ret = %d.\n", 666 enable ? "enable" : "disable", ret); 667 } 668 669 int amdgpu_pm_load_smu_firmware(struct amdgpu_device *adev, uint32_t *smu_version) 670 { 671 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 672 int r = 0; 673 674 if (!pp_funcs || !pp_funcs->load_firmware || 675 (is_support_sw_smu(adev) && (adev->flags & AMD_IS_APU))) 676 return 0; 677 678 mutex_lock(&adev->pm.mutex); 679 r = pp_funcs->load_firmware(adev->powerplay.pp_handle); 680 if (r) { 681 pr_err("smu firmware loading failed\n"); 682 goto out; 683 } 684 685 if (smu_version) 686 *smu_version = adev->pm.fw_version; 687 688 out: 689 mutex_unlock(&adev->pm.mutex); 690 return r; 691 } 692 693 int amdgpu_dpm_handle_passthrough_sbr(struct amdgpu_device *adev, bool enable) 694 { 695 int ret = 0; 696 697 if (is_support_sw_smu(adev)) { 698 mutex_lock(&adev->pm.mutex); 699 ret = smu_handle_passthrough_sbr(adev->powerplay.pp_handle, 700 enable); 701 mutex_unlock(&adev->pm.mutex); 702 } 703 704 return ret; 705 } 706 707 int amdgpu_dpm_send_hbm_bad_pages_num(struct amdgpu_device *adev, uint32_t size) 708 { 709 struct smu_context *smu = adev->powerplay.pp_handle; 710 int ret = 0; 711 712 if (!is_support_sw_smu(adev)) 713 return -EOPNOTSUPP; 714 715 mutex_lock(&adev->pm.mutex); 716 ret = smu_send_hbm_bad_pages_num(smu, size); 717 mutex_unlock(&adev->pm.mutex); 718 719 return ret; 720 } 721 722 int amdgpu_dpm_send_hbm_bad_channel_flag(struct amdgpu_device *adev, uint32_t size) 723 { 724 struct smu_context *smu = adev->powerplay.pp_handle; 725 int ret = 0; 726 727 if (!is_support_sw_smu(adev)) 728 return -EOPNOTSUPP; 729 730 mutex_lock(&adev->pm.mutex); 731 ret = smu_send_hbm_bad_channel_flag(smu, size); 732 mutex_unlock(&adev->pm.mutex); 733 734 return ret; 735 } 736 737 int amdgpu_dpm_send_rma_reason(struct amdgpu_device *adev) 738 { 739 struct smu_context *smu = adev->powerplay.pp_handle; 740 int ret; 741 742 if (!is_support_sw_smu(adev)) 743 return -EOPNOTSUPP; 744 745 mutex_lock(&adev->pm.mutex); 746 ret = smu_send_rma_reason(smu); 747 mutex_unlock(&adev->pm.mutex); 748 749 return ret; 750 } 751 752 /** 753 * amdgpu_dpm_reset_sdma_is_supported - Check if SDMA reset is supported 754 * @adev: amdgpu_device pointer 755 * 756 * This function checks if the SMU supports resetting the SDMA engine. 757 * It returns false if the hardware does not support software SMU or 758 * if the feature is not supported. 759 */ 760 bool amdgpu_dpm_reset_sdma_is_supported(struct amdgpu_device *adev) 761 { 762 struct smu_context *smu = adev->powerplay.pp_handle; 763 bool ret; 764 765 if (!is_support_sw_smu(adev)) 766 return false; 767 768 mutex_lock(&adev->pm.mutex); 769 ret = smu_reset_sdma_is_supported(smu); 770 mutex_unlock(&adev->pm.mutex); 771 772 return ret; 773 } 774 775 int amdgpu_dpm_reset_sdma(struct amdgpu_device *adev, uint32_t inst_mask) 776 { 777 struct smu_context *smu = adev->powerplay.pp_handle; 778 int ret; 779 780 if (!is_support_sw_smu(adev)) 781 return -EOPNOTSUPP; 782 783 mutex_lock(&adev->pm.mutex); 784 ret = smu_reset_sdma(smu, inst_mask); 785 mutex_unlock(&adev->pm.mutex); 786 787 return ret; 788 } 789 790 int amdgpu_dpm_reset_vcn(struct amdgpu_device *adev, uint32_t inst_mask) 791 { 792 struct smu_context *smu = adev->powerplay.pp_handle; 793 int ret; 794 795 if (!is_support_sw_smu(adev)) 796 return -EOPNOTSUPP; 797 798 mutex_lock(&adev->pm.mutex); 799 ret = smu_reset_vcn(smu, inst_mask); 800 mutex_unlock(&adev->pm.mutex); 801 802 return ret; 803 } 804 805 bool amdgpu_dpm_reset_vcn_is_supported(struct amdgpu_device *adev) 806 { 807 struct smu_context *smu = adev->powerplay.pp_handle; 808 bool ret; 809 810 if (!is_support_sw_smu(adev)) 811 return false; 812 813 mutex_lock(&adev->pm.mutex); 814 ret = smu_reset_vcn_is_supported(smu); 815 mutex_unlock(&adev->pm.mutex); 816 817 return ret; 818 } 819 820 int amdgpu_dpm_get_dpm_freq_range(struct amdgpu_device *adev, 821 enum pp_clock_type type, 822 uint32_t *min, 823 uint32_t *max) 824 { 825 int ret = 0; 826 827 if (type != PP_SCLK) 828 return -EINVAL; 829 830 if (!is_support_sw_smu(adev)) 831 return -EOPNOTSUPP; 832 833 mutex_lock(&adev->pm.mutex); 834 ret = smu_get_dpm_freq_range(adev->powerplay.pp_handle, 835 SMU_SCLK, 836 min, 837 max); 838 mutex_unlock(&adev->pm.mutex); 839 840 return ret; 841 } 842 843 int amdgpu_dpm_set_soft_freq_range(struct amdgpu_device *adev, 844 enum pp_clock_type type, 845 uint32_t min, 846 uint32_t max) 847 { 848 struct smu_context *smu = adev->powerplay.pp_handle; 849 850 if (!is_support_sw_smu(adev)) 851 return -EOPNOTSUPP; 852 853 guard(mutex)(&adev->pm.mutex); 854 855 return smu_set_soft_freq_range(smu, 856 type, 857 min, 858 max); 859 } 860 861 int amdgpu_dpm_write_watermarks_table(struct amdgpu_device *adev) 862 { 863 struct smu_context *smu = adev->powerplay.pp_handle; 864 int ret = 0; 865 866 if (!is_support_sw_smu(adev)) 867 return 0; 868 869 mutex_lock(&adev->pm.mutex); 870 ret = smu_write_watermarks_table(smu); 871 mutex_unlock(&adev->pm.mutex); 872 873 return ret; 874 } 875 876 int amdgpu_dpm_wait_for_event(struct amdgpu_device *adev, 877 enum smu_event_type event, 878 uint64_t event_arg) 879 { 880 struct smu_context *smu = adev->powerplay.pp_handle; 881 int ret = 0; 882 883 if (!is_support_sw_smu(adev)) 884 return -EOPNOTSUPP; 885 886 mutex_lock(&adev->pm.mutex); 887 ret = smu_wait_for_event(smu, event, event_arg); 888 mutex_unlock(&adev->pm.mutex); 889 890 return ret; 891 } 892 893 int amdgpu_dpm_set_residency_gfxoff(struct amdgpu_device *adev, bool value) 894 { 895 struct smu_context *smu = adev->powerplay.pp_handle; 896 int ret = 0; 897 898 if (!is_support_sw_smu(adev)) 899 return -EOPNOTSUPP; 900 901 mutex_lock(&adev->pm.mutex); 902 ret = smu_set_residency_gfxoff(smu, value); 903 mutex_unlock(&adev->pm.mutex); 904 905 return ret; 906 } 907 908 int amdgpu_dpm_get_residency_gfxoff(struct amdgpu_device *adev, u32 *value) 909 { 910 struct smu_context *smu = adev->powerplay.pp_handle; 911 int ret = 0; 912 913 if (!is_support_sw_smu(adev)) 914 return -EOPNOTSUPP; 915 916 mutex_lock(&adev->pm.mutex); 917 ret = smu_get_residency_gfxoff(smu, value); 918 mutex_unlock(&adev->pm.mutex); 919 920 return ret; 921 } 922 923 int amdgpu_dpm_get_entrycount_gfxoff(struct amdgpu_device *adev, u64 *value) 924 { 925 struct smu_context *smu = adev->powerplay.pp_handle; 926 int ret = 0; 927 928 if (!is_support_sw_smu(adev)) 929 return -EOPNOTSUPP; 930 931 mutex_lock(&adev->pm.mutex); 932 ret = smu_get_entrycount_gfxoff(smu, value); 933 mutex_unlock(&adev->pm.mutex); 934 935 return ret; 936 } 937 938 int amdgpu_dpm_get_status_gfxoff(struct amdgpu_device *adev, uint32_t *value) 939 { 940 struct smu_context *smu = adev->powerplay.pp_handle; 941 int ret = 0; 942 943 if (!is_support_sw_smu(adev)) 944 return -EOPNOTSUPP; 945 946 mutex_lock(&adev->pm.mutex); 947 ret = smu_get_status_gfxoff(smu, value); 948 mutex_unlock(&adev->pm.mutex); 949 950 return ret; 951 } 952 953 uint64_t amdgpu_dpm_get_thermal_throttling_counter(struct amdgpu_device *adev) 954 { 955 struct smu_context *smu = adev->powerplay.pp_handle; 956 957 if (!is_support_sw_smu(adev)) 958 return 0; 959 960 return atomic64_read(&smu->throttle_int_counter); 961 } 962 963 /* amdgpu_dpm_gfx_state_change - Handle gfx power state change set 964 * @adev: amdgpu_device pointer 965 * @state: gfx power state(1 -sGpuChangeState_D0Entry and 2 -sGpuChangeState_D3Entry) 966 * 967 */ 968 void amdgpu_dpm_gfx_state_change(struct amdgpu_device *adev, 969 enum gfx_change_state state) 970 { 971 mutex_lock(&adev->pm.mutex); 972 if (adev->powerplay.pp_funcs && 973 adev->powerplay.pp_funcs->gfx_state_change_set) 974 ((adev)->powerplay.pp_funcs->gfx_state_change_set( 975 (adev)->powerplay.pp_handle, state)); 976 mutex_unlock(&adev->pm.mutex); 977 } 978 979 int amdgpu_dpm_get_ecc_info(struct amdgpu_device *adev, 980 void *umc_ecc) 981 { 982 struct smu_context *smu = adev->powerplay.pp_handle; 983 int ret = 0; 984 985 if (!is_support_sw_smu(adev)) 986 return -EOPNOTSUPP; 987 988 mutex_lock(&adev->pm.mutex); 989 ret = smu_get_ecc_info(smu, umc_ecc); 990 mutex_unlock(&adev->pm.mutex); 991 992 return ret; 993 } 994 995 struct amd_vce_state *amdgpu_dpm_get_vce_clock_state(struct amdgpu_device *adev, 996 uint32_t idx) 997 { 998 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 999 struct amd_vce_state *vstate = NULL; 1000 1001 if (!pp_funcs->get_vce_clock_state) 1002 return NULL; 1003 1004 mutex_lock(&adev->pm.mutex); 1005 vstate = pp_funcs->get_vce_clock_state(adev->powerplay.pp_handle, 1006 idx); 1007 mutex_unlock(&adev->pm.mutex); 1008 1009 return vstate; 1010 } 1011 1012 void amdgpu_dpm_get_current_power_state(struct amdgpu_device *adev, 1013 enum amd_pm_state_type *state) 1014 { 1015 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1016 1017 mutex_lock(&adev->pm.mutex); 1018 1019 if (!pp_funcs->get_current_power_state) { 1020 *state = adev->pm.dpm.user_state; 1021 goto out; 1022 } 1023 1024 *state = pp_funcs->get_current_power_state(adev->powerplay.pp_handle); 1025 if (*state < POWER_STATE_TYPE_DEFAULT || 1026 *state > POWER_STATE_TYPE_INTERNAL_3DPERF) 1027 *state = adev->pm.dpm.user_state; 1028 1029 out: 1030 mutex_unlock(&adev->pm.mutex); 1031 } 1032 1033 void amdgpu_dpm_set_power_state(struct amdgpu_device *adev, 1034 enum amd_pm_state_type state) 1035 { 1036 mutex_lock(&adev->pm.mutex); 1037 adev->pm.dpm.user_state = state; 1038 mutex_unlock(&adev->pm.mutex); 1039 1040 if (is_support_sw_smu(adev)) 1041 return; 1042 1043 if (amdgpu_dpm_dispatch_task(adev, 1044 AMD_PP_TASK_ENABLE_USER_STATE, 1045 &state) == -EOPNOTSUPP) 1046 amdgpu_dpm_compute_clocks(adev); 1047 } 1048 1049 enum amd_dpm_forced_level amdgpu_dpm_get_performance_level(struct amdgpu_device *adev) 1050 { 1051 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1052 enum amd_dpm_forced_level level; 1053 1054 if (!pp_funcs) 1055 return AMD_DPM_FORCED_LEVEL_AUTO; 1056 1057 mutex_lock(&adev->pm.mutex); 1058 if (pp_funcs->get_performance_level) 1059 level = pp_funcs->get_performance_level(adev->powerplay.pp_handle); 1060 else 1061 level = adev->pm.dpm.forced_level; 1062 mutex_unlock(&adev->pm.mutex); 1063 1064 return level; 1065 } 1066 1067 static void amdgpu_dpm_enter_umd_state(struct amdgpu_device *adev) 1068 { 1069 /* enter UMD Pstate */ 1070 amdgpu_device_ip_set_powergating_state(adev, AMD_IP_BLOCK_TYPE_GFX, 1071 AMD_PG_STATE_UNGATE); 1072 amdgpu_device_ip_set_clockgating_state(adev, AMD_IP_BLOCK_TYPE_GFX, 1073 AMD_CG_STATE_UNGATE); 1074 } 1075 1076 static void amdgpu_dpm_exit_umd_state(struct amdgpu_device *adev) 1077 { 1078 /* exit UMD Pstate */ 1079 amdgpu_device_ip_set_clockgating_state(adev, AMD_IP_BLOCK_TYPE_GFX, 1080 AMD_CG_STATE_GATE); 1081 amdgpu_device_ip_set_powergating_state(adev, AMD_IP_BLOCK_TYPE_GFX, 1082 AMD_PG_STATE_GATE); 1083 } 1084 1085 /** 1086 * amdgpu_dpm_reapply_umd_profile - Restore the active UMD profile 1087 * @adev: amdgpu device 1088 * 1089 * Resume and reset retain the selected DPM level in software, but the 1090 * underlying GFX and PMFW state is lost. Reapply a retained UMD profile 1091 * after the common resume path has restored its default CG and PG state. 1092 */ 1093 int amdgpu_dpm_reapply_umd_profile(struct amdgpu_device *adev) 1094 { 1095 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1096 enum amd_dpm_forced_level level; 1097 int ret, fallback_ret; 1098 1099 if (!pp_funcs || !pp_funcs->reapply_performance_level || 1100 !pp_funcs->force_performance_level) 1101 return 0; 1102 1103 /* Serialize the retained level with the GFX and PMFW reprogramming. */ 1104 mutex_lock(&adev->pm.mutex); 1105 if (adev->pm.dpm.thermal_active) { 1106 dev_warn(adev->dev, 1107 "Cannot restore UMD profile while thermal control is active\n"); 1108 ret = 0; 1109 goto unlock; 1110 } 1111 1112 if (pp_funcs->get_performance_level) 1113 level = pp_funcs->get_performance_level(adev->powerplay.pp_handle); 1114 else 1115 level = adev->pm.dpm.forced_level; 1116 1117 switch (level) { 1118 case AMD_DPM_FORCED_LEVEL_PROFILE_STANDARD: 1119 case AMD_DPM_FORCED_LEVEL_PROFILE_MIN_SCLK: 1120 case AMD_DPM_FORCED_LEVEL_PROFILE_MIN_MCLK: 1121 case AMD_DPM_FORCED_LEVEL_PROFILE_PEAK: 1122 break; 1123 default: 1124 ret = 0; 1125 goto unlock; 1126 } 1127 1128 /* The active profile already owns the GFX PG reference. */ 1129 ret = amdgpu_device_ip_set_clockgating_state(adev, AMD_IP_BLOCK_TYPE_GFX, 1130 AMD_CG_STATE_UNGATE); 1131 if (ret) 1132 goto fallback_auto; 1133 1134 ret = amdgpu_asic_update_umd_stable_pstate(adev, true); 1135 if (ret) 1136 goto fallback_auto; 1137 1138 ret = pp_funcs->reapply_performance_level(adev->powerplay.pp_handle, 1139 level); 1140 if (ret) 1141 goto fallback_auto; 1142 1143 unlock: 1144 mutex_unlock(&adev->pm.mutex); 1145 1146 return ret; 1147 1148 fallback_auto: 1149 dev_warn(adev->dev, "Failed to restore UMD profile state: %d\n", ret); 1150 1151 /* Restore normal CG before releasing the profile's PG reference. */ 1152 amdgpu_asic_update_umd_stable_pstate(adev, false); 1153 amdgpu_device_ip_set_clockgating_state(adev, AMD_IP_BLOCK_TYPE_GFX, 1154 AMD_CG_STATE_GATE); 1155 mutex_unlock(&adev->pm.mutex); 1156 1157 mutex_lock(&adev->pm.stable_pstate_ctx_lock); 1158 fallback_ret = amdgpu_dpm_force_performance_level(adev, 1159 AMD_DPM_FORCED_LEVEL_AUTO); 1160 if (fallback_ret) 1161 dev_warn(adev->dev, "Failed to fall back to AUTO performance level: %d\n", 1162 fallback_ret); 1163 else 1164 adev->pm.stable_pstate_ctx = NULL; 1165 mutex_unlock(&adev->pm.stable_pstate_ctx_lock); 1166 1167 return 0; 1168 } 1169 1170 int amdgpu_dpm_force_performance_level(struct amdgpu_device *adev, 1171 enum amd_dpm_forced_level level) 1172 { 1173 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1174 enum amd_dpm_forced_level current_level; 1175 uint32_t profile_mode_mask = AMD_DPM_FORCED_LEVEL_PROFILE_STANDARD | 1176 AMD_DPM_FORCED_LEVEL_PROFILE_MIN_SCLK | 1177 AMD_DPM_FORCED_LEVEL_PROFILE_MIN_MCLK | 1178 AMD_DPM_FORCED_LEVEL_PROFILE_PEAK; 1179 1180 if (!pp_funcs || !pp_funcs->force_performance_level) 1181 return 0; 1182 1183 if (adev->pm.dpm.thermal_active) 1184 return -EINVAL; 1185 1186 current_level = amdgpu_dpm_get_performance_level(adev); 1187 if (current_level == level) 1188 return 0; 1189 1190 if (!(current_level & profile_mode_mask) && 1191 (level == AMD_DPM_FORCED_LEVEL_PROFILE_EXIT)) 1192 return -EINVAL; 1193 1194 if (adev->asic_type == CHIP_RAVEN) { 1195 if (!(adev->apu_flags & AMD_APU_IS_RAVEN2)) { 1196 if (current_level != AMD_DPM_FORCED_LEVEL_MANUAL && 1197 level == AMD_DPM_FORCED_LEVEL_MANUAL) 1198 amdgpu_gfx_off_ctrl(adev, false); 1199 else if (current_level == AMD_DPM_FORCED_LEVEL_MANUAL && 1200 level != AMD_DPM_FORCED_LEVEL_MANUAL) 1201 amdgpu_gfx_off_ctrl(adev, true); 1202 } 1203 } 1204 1205 if (!(current_level & profile_mode_mask) && (level & profile_mode_mask)) 1206 amdgpu_dpm_enter_umd_state(adev); 1207 else if ((current_level & profile_mode_mask) && 1208 !(level & profile_mode_mask)) 1209 amdgpu_dpm_exit_umd_state(adev); 1210 1211 mutex_lock(&adev->pm.mutex); 1212 1213 if (pp_funcs->force_performance_level(adev->powerplay.pp_handle, 1214 level)) { 1215 mutex_unlock(&adev->pm.mutex); 1216 /* If new level failed, retain the umd state as before */ 1217 if (!(current_level & profile_mode_mask) && 1218 (level & profile_mode_mask)) 1219 amdgpu_dpm_exit_umd_state(adev); 1220 else if ((current_level & profile_mode_mask) && 1221 !(level & profile_mode_mask)) 1222 amdgpu_dpm_enter_umd_state(adev); 1223 1224 return -EINVAL; 1225 } 1226 1227 adev->pm.dpm.forced_level = level; 1228 1229 mutex_unlock(&adev->pm.mutex); 1230 1231 return 0; 1232 } 1233 1234 int amdgpu_dpm_get_pp_num_states(struct amdgpu_device *adev, 1235 struct pp_states_info *states) 1236 { 1237 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1238 int ret = 0; 1239 1240 if (!pp_funcs->get_pp_num_states) 1241 return -EOPNOTSUPP; 1242 1243 mutex_lock(&adev->pm.mutex); 1244 ret = pp_funcs->get_pp_num_states(adev->powerplay.pp_handle, 1245 states); 1246 mutex_unlock(&adev->pm.mutex); 1247 1248 return ret; 1249 } 1250 1251 int amdgpu_dpm_dispatch_task(struct amdgpu_device *adev, 1252 enum amd_pp_task task_id, 1253 enum amd_pm_state_type *user_state) 1254 { 1255 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1256 int ret = 0; 1257 1258 if (!pp_funcs->dispatch_tasks) 1259 return -EOPNOTSUPP; 1260 1261 mutex_lock(&adev->pm.mutex); 1262 ret = pp_funcs->dispatch_tasks(adev->powerplay.pp_handle, 1263 task_id, 1264 user_state); 1265 mutex_unlock(&adev->pm.mutex); 1266 1267 return ret; 1268 } 1269 1270 static bool amdgpu_dpm_is_pp_table_allowed(struct amdgpu_device *adev) 1271 { 1272 return !amdgpu_sriov_vf(adev) && 1273 !(adev->flags & AMD_IS_APU) && 1274 !adev->scpm_enabled; 1275 } 1276 1277 int amdgpu_dpm_get_pp_table(struct amdgpu_device *adev, char *table, 1278 size_t size) 1279 { 1280 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1281 char *pptable = NULL; 1282 int ret = 0; 1283 1284 if ((!table && size) || (table && !size)) 1285 return -EINVAL; 1286 1287 if (!amdgpu_dpm_is_pp_table_allowed(adev) || 1288 !pp_funcs->get_pp_table) 1289 return -EOPNOTSUPP; 1290 1291 mutex_lock(&adev->pm.mutex); 1292 ret = pp_funcs->get_pp_table(adev->powerplay.pp_handle, 1293 &pptable); 1294 if (ret > 0 && !pptable) { 1295 ret = -EINVAL; 1296 } else if (ret > 0 && table) { 1297 ret = min_t(size_t, ret, size); 1298 memcpy(table, pptable, ret); 1299 } 1300 mutex_unlock(&adev->pm.mutex); 1301 1302 return ret; 1303 } 1304 1305 int amdgpu_dpm_set_fine_grain_clk_vol(struct amdgpu_device *adev, 1306 uint32_t type, 1307 long *input, 1308 uint32_t size) 1309 { 1310 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1311 int ret = 0; 1312 1313 if (!pp_funcs->set_fine_grain_clk_vol) 1314 return 0; 1315 1316 mutex_lock(&adev->pm.mutex); 1317 ret = pp_funcs->set_fine_grain_clk_vol(adev->powerplay.pp_handle, 1318 type, 1319 input, 1320 size); 1321 mutex_unlock(&adev->pm.mutex); 1322 1323 return ret; 1324 } 1325 1326 int amdgpu_dpm_odn_edit_dpm_table(struct amdgpu_device *adev, 1327 uint32_t type, 1328 long *input, 1329 uint32_t size) 1330 { 1331 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1332 int ret = 0; 1333 1334 if (!pp_funcs->odn_edit_dpm_table) 1335 return 0; 1336 1337 mutex_lock(&adev->pm.mutex); 1338 ret = pp_funcs->odn_edit_dpm_table(adev->powerplay.pp_handle, 1339 type, 1340 input, 1341 size); 1342 mutex_unlock(&adev->pm.mutex); 1343 1344 return ret; 1345 } 1346 1347 int amdgpu_dpm_emit_clock_levels(struct amdgpu_device *adev, 1348 enum pp_clock_type type, 1349 char *buf, 1350 int *offset) 1351 { 1352 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1353 int ret = 0; 1354 1355 if (!pp_funcs->emit_clock_levels) 1356 return -ENOENT; 1357 1358 mutex_lock(&adev->pm.mutex); 1359 ret = pp_funcs->emit_clock_levels(adev->powerplay.pp_handle, 1360 type, 1361 buf, 1362 offset); 1363 mutex_unlock(&adev->pm.mutex); 1364 1365 return ret; 1366 } 1367 1368 int amdgpu_dpm_set_ppfeature_status(struct amdgpu_device *adev, 1369 uint64_t ppfeature_masks) 1370 { 1371 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1372 int ret = 0; 1373 1374 if (!pp_funcs->set_ppfeature_status) 1375 return 0; 1376 1377 mutex_lock(&adev->pm.mutex); 1378 ret = pp_funcs->set_ppfeature_status(adev->powerplay.pp_handle, 1379 ppfeature_masks); 1380 mutex_unlock(&adev->pm.mutex); 1381 1382 return ret; 1383 } 1384 1385 int amdgpu_dpm_get_ppfeature_status(struct amdgpu_device *adev, char *buf) 1386 { 1387 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1388 int ret = 0; 1389 1390 if (!pp_funcs->get_ppfeature_status) 1391 return 0; 1392 1393 mutex_lock(&adev->pm.mutex); 1394 ret = pp_funcs->get_ppfeature_status(adev->powerplay.pp_handle, 1395 buf); 1396 mutex_unlock(&adev->pm.mutex); 1397 1398 return ret; 1399 } 1400 1401 int amdgpu_dpm_force_clock_level(struct amdgpu_device *adev, 1402 enum pp_clock_type type, 1403 uint32_t mask) 1404 { 1405 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1406 int ret = 0; 1407 1408 if (!pp_funcs->force_clock_level) 1409 return 0; 1410 1411 mutex_lock(&adev->pm.mutex); 1412 ret = pp_funcs->force_clock_level(adev->powerplay.pp_handle, 1413 type, 1414 mask); 1415 mutex_unlock(&adev->pm.mutex); 1416 1417 return ret; 1418 } 1419 1420 int amdgpu_dpm_get_sclk_od(struct amdgpu_device *adev) 1421 { 1422 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1423 int ret = 0; 1424 1425 if (!pp_funcs->get_sclk_od) 1426 return -EOPNOTSUPP; 1427 1428 mutex_lock(&adev->pm.mutex); 1429 ret = pp_funcs->get_sclk_od(adev->powerplay.pp_handle); 1430 mutex_unlock(&adev->pm.mutex); 1431 1432 return ret; 1433 } 1434 1435 int amdgpu_dpm_set_sclk_od(struct amdgpu_device *adev, uint32_t value) 1436 { 1437 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1438 1439 if (is_support_sw_smu(adev)) 1440 return -EOPNOTSUPP; 1441 1442 mutex_lock(&adev->pm.mutex); 1443 if (pp_funcs->set_sclk_od) 1444 pp_funcs->set_sclk_od(adev->powerplay.pp_handle, value); 1445 mutex_unlock(&adev->pm.mutex); 1446 1447 if (amdgpu_dpm_dispatch_task(adev, 1448 AMD_PP_TASK_READJUST_POWER_STATE, 1449 NULL) == -EOPNOTSUPP) { 1450 adev->pm.dpm.current_ps = adev->pm.dpm.boot_ps; 1451 amdgpu_dpm_compute_clocks(adev); 1452 } 1453 1454 return 0; 1455 } 1456 1457 int amdgpu_dpm_get_mclk_od(struct amdgpu_device *adev) 1458 { 1459 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1460 int ret = 0; 1461 1462 if (!pp_funcs->get_mclk_od) 1463 return -EOPNOTSUPP; 1464 1465 mutex_lock(&adev->pm.mutex); 1466 ret = pp_funcs->get_mclk_od(adev->powerplay.pp_handle); 1467 mutex_unlock(&adev->pm.mutex); 1468 1469 return ret; 1470 } 1471 1472 int amdgpu_dpm_set_mclk_od(struct amdgpu_device *adev, uint32_t value) 1473 { 1474 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1475 1476 if (is_support_sw_smu(adev)) 1477 return -EOPNOTSUPP; 1478 1479 mutex_lock(&adev->pm.mutex); 1480 if (pp_funcs->set_mclk_od) 1481 pp_funcs->set_mclk_od(adev->powerplay.pp_handle, value); 1482 mutex_unlock(&adev->pm.mutex); 1483 1484 if (amdgpu_dpm_dispatch_task(adev, 1485 AMD_PP_TASK_READJUST_POWER_STATE, 1486 NULL) == -EOPNOTSUPP) { 1487 adev->pm.dpm.current_ps = adev->pm.dpm.boot_ps; 1488 amdgpu_dpm_compute_clocks(adev); 1489 } 1490 1491 return 0; 1492 } 1493 1494 int amdgpu_dpm_get_power_profile_mode(struct amdgpu_device *adev, 1495 char *buf) 1496 { 1497 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1498 int ret = 0; 1499 1500 if (!pp_funcs->get_power_profile_mode) 1501 return -EOPNOTSUPP; 1502 1503 mutex_lock(&adev->pm.mutex); 1504 ret = pp_funcs->get_power_profile_mode(adev->powerplay.pp_handle, 1505 buf); 1506 mutex_unlock(&adev->pm.mutex); 1507 1508 return ret; 1509 } 1510 1511 int amdgpu_dpm_set_power_profile_mode(struct amdgpu_device *adev, 1512 long *input, uint32_t size) 1513 { 1514 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1515 int ret = 0; 1516 1517 if (!pp_funcs->set_power_profile_mode) 1518 return 0; 1519 1520 mutex_lock(&adev->pm.mutex); 1521 ret = pp_funcs->set_power_profile_mode(adev->powerplay.pp_handle, 1522 input, 1523 size); 1524 mutex_unlock(&adev->pm.mutex); 1525 1526 return ret; 1527 } 1528 1529 ssize_t amdgpu_dpm_get_gpu_metrics(struct amdgpu_device *adev, void *buf, 1530 size_t size) 1531 { 1532 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1533 void *table; 1534 ssize_t ret; 1535 1536 if (!pp_funcs->get_gpu_metrics) 1537 return 0; 1538 1539 mutex_lock(&adev->pm.mutex); 1540 ret = pp_funcs->get_gpu_metrics(adev->powerplay.pp_handle, 1541 &table); 1542 if (ret > 0) { 1543 ret = min_t(ssize_t, ret, size); 1544 memcpy(buf, table, ret); 1545 } 1546 mutex_unlock(&adev->pm.mutex); 1547 1548 return ret; 1549 } 1550 1551 ssize_t amdgpu_dpm_get_pm_metrics(struct amdgpu_device *adev, void *pm_metrics, 1552 size_t size) 1553 { 1554 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1555 int ret = 0; 1556 1557 if (!pp_funcs->get_pm_metrics) 1558 return -EOPNOTSUPP; 1559 1560 mutex_lock(&adev->pm.mutex); 1561 ret = pp_funcs->get_pm_metrics(adev->powerplay.pp_handle, pm_metrics, 1562 size); 1563 mutex_unlock(&adev->pm.mutex); 1564 1565 return ret; 1566 } 1567 1568 int amdgpu_dpm_get_fan_control_mode(struct amdgpu_device *adev, 1569 uint32_t *fan_mode) 1570 { 1571 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1572 int ret = 0; 1573 1574 if (!pp_funcs->get_fan_control_mode) 1575 return -EOPNOTSUPP; 1576 1577 mutex_lock(&adev->pm.mutex); 1578 ret = pp_funcs->get_fan_control_mode(adev->powerplay.pp_handle, 1579 fan_mode); 1580 mutex_unlock(&adev->pm.mutex); 1581 1582 return ret; 1583 } 1584 1585 int amdgpu_dpm_set_fan_speed_pwm(struct amdgpu_device *adev, 1586 uint32_t speed) 1587 { 1588 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1589 int ret = 0; 1590 1591 if (!pp_funcs->set_fan_speed_pwm) 1592 return -EOPNOTSUPP; 1593 1594 mutex_lock(&adev->pm.mutex); 1595 ret = pp_funcs->set_fan_speed_pwm(adev->powerplay.pp_handle, 1596 speed); 1597 mutex_unlock(&adev->pm.mutex); 1598 1599 return ret; 1600 } 1601 1602 int amdgpu_dpm_get_fan_speed_pwm(struct amdgpu_device *adev, 1603 uint32_t *speed) 1604 { 1605 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1606 int ret = 0; 1607 1608 if (!pp_funcs->get_fan_speed_pwm) 1609 return -EOPNOTSUPP; 1610 1611 mutex_lock(&adev->pm.mutex); 1612 ret = pp_funcs->get_fan_speed_pwm(adev->powerplay.pp_handle, 1613 speed); 1614 mutex_unlock(&adev->pm.mutex); 1615 1616 return ret; 1617 } 1618 1619 int amdgpu_dpm_get_fan_speed_rpm(struct amdgpu_device *adev, 1620 uint32_t *speed) 1621 { 1622 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1623 int ret = 0; 1624 1625 if (!pp_funcs->get_fan_speed_rpm) 1626 return -EOPNOTSUPP; 1627 1628 mutex_lock(&adev->pm.mutex); 1629 ret = pp_funcs->get_fan_speed_rpm(adev->powerplay.pp_handle, 1630 speed); 1631 mutex_unlock(&adev->pm.mutex); 1632 1633 return ret; 1634 } 1635 1636 int amdgpu_dpm_set_fan_speed_rpm(struct amdgpu_device *adev, 1637 uint32_t speed) 1638 { 1639 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1640 int ret = 0; 1641 1642 if (!pp_funcs->set_fan_speed_rpm) 1643 return -EOPNOTSUPP; 1644 1645 mutex_lock(&adev->pm.mutex); 1646 ret = pp_funcs->set_fan_speed_rpm(adev->powerplay.pp_handle, 1647 speed); 1648 mutex_unlock(&adev->pm.mutex); 1649 1650 return ret; 1651 } 1652 1653 int amdgpu_dpm_set_fan_control_mode(struct amdgpu_device *adev, 1654 uint32_t mode) 1655 { 1656 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1657 int ret = 0; 1658 1659 if (!pp_funcs->set_fan_control_mode) 1660 return -EOPNOTSUPP; 1661 1662 mutex_lock(&adev->pm.mutex); 1663 ret = pp_funcs->set_fan_control_mode(adev->powerplay.pp_handle, 1664 mode); 1665 mutex_unlock(&adev->pm.mutex); 1666 1667 return ret; 1668 } 1669 1670 int amdgpu_dpm_get_power_limit(struct amdgpu_device *adev, 1671 uint32_t *limit, 1672 enum pp_power_limit_level pp_limit_level, 1673 enum pp_power_type power_type) 1674 { 1675 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1676 int ret = 0; 1677 1678 if (!pp_funcs->get_power_limit) 1679 return -EOPNOTSUPP; 1680 1681 mutex_lock(&adev->pm.mutex); 1682 ret = pp_funcs->get_power_limit(adev->powerplay.pp_handle, 1683 limit, 1684 pp_limit_level, 1685 power_type); 1686 mutex_unlock(&adev->pm.mutex); 1687 1688 return ret; 1689 } 1690 1691 int amdgpu_dpm_set_power_limit(struct amdgpu_device *adev, 1692 uint32_t limit_type, 1693 uint32_t limit) 1694 { 1695 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1696 int ret = 0; 1697 1698 if (!pp_funcs->set_power_limit) 1699 return -EINVAL; 1700 1701 mutex_lock(&adev->pm.mutex); 1702 ret = pp_funcs->set_power_limit(adev->powerplay.pp_handle, 1703 limit_type, limit); 1704 mutex_unlock(&adev->pm.mutex); 1705 1706 return ret; 1707 } 1708 1709 int amdgpu_dpm_is_cclk_dpm_supported(struct amdgpu_device *adev) 1710 { 1711 bool cclk_dpm_supported = false; 1712 1713 if (!is_support_sw_smu(adev)) 1714 return false; 1715 1716 mutex_lock(&adev->pm.mutex); 1717 cclk_dpm_supported = is_support_cclk_dpm(adev); 1718 mutex_unlock(&adev->pm.mutex); 1719 1720 return (int)cclk_dpm_supported; 1721 } 1722 1723 int amdgpu_dpm_debugfs_print_current_performance_level(struct amdgpu_device *adev, 1724 struct seq_file *m) 1725 { 1726 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1727 1728 if (!pp_funcs->debugfs_print_current_performance_level) 1729 return -EOPNOTSUPP; 1730 1731 mutex_lock(&adev->pm.mutex); 1732 pp_funcs->debugfs_print_current_performance_level(adev->powerplay.pp_handle, 1733 m); 1734 mutex_unlock(&adev->pm.mutex); 1735 1736 return 0; 1737 } 1738 1739 int amdgpu_dpm_get_smu_prv_buf_details(struct amdgpu_device *adev, 1740 void **addr, 1741 size_t *size) 1742 { 1743 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1744 int ret = 0; 1745 1746 if (!pp_funcs->get_smu_prv_buf_details) 1747 return -ENOSYS; 1748 1749 mutex_lock(&adev->pm.mutex); 1750 ret = pp_funcs->get_smu_prv_buf_details(adev->powerplay.pp_handle, 1751 addr, 1752 size); 1753 mutex_unlock(&adev->pm.mutex); 1754 1755 return ret; 1756 } 1757 1758 int amdgpu_dpm_is_overdrive_supported(struct amdgpu_device *adev) 1759 { 1760 if (is_support_sw_smu(adev)) { 1761 struct smu_context *smu = adev->powerplay.pp_handle; 1762 1763 return (smu->od_enabled || smu->is_apu); 1764 } else { 1765 struct pp_hwmgr *hwmgr; 1766 1767 /* 1768 * dpm on some legacy asics don't carry od_enabled member 1769 * as its pp_handle is casted directly from adev. 1770 */ 1771 if (amdgpu_dpm_is_legacy_dpm(adev)) 1772 return false; 1773 1774 hwmgr = (struct pp_hwmgr *)adev->powerplay.pp_handle; 1775 1776 return hwmgr->od_enabled; 1777 } 1778 } 1779 1780 int amdgpu_dpm_is_overdrive_enabled(struct amdgpu_device *adev) 1781 { 1782 if (is_support_sw_smu(adev)) { 1783 struct smu_context *smu = adev->powerplay.pp_handle; 1784 1785 return smu->od_enabled; 1786 } else { 1787 struct pp_hwmgr *hwmgr; 1788 1789 /* 1790 * dpm on some legacy asics don't carry od_enabled member 1791 * as its pp_handle is casted directly from adev. 1792 */ 1793 if (amdgpu_dpm_is_legacy_dpm(adev)) 1794 return false; 1795 1796 hwmgr = (struct pp_hwmgr *)adev->powerplay.pp_handle; 1797 1798 return hwmgr->od_enabled; 1799 } 1800 } 1801 1802 int amdgpu_dpm_set_pp_table(struct amdgpu_device *adev, 1803 const char *buf, 1804 size_t size) 1805 { 1806 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1807 int ret = 0; 1808 1809 if (!buf || !size) 1810 return -EINVAL; 1811 1812 if (!amdgpu_dpm_is_pp_table_allowed(adev) || 1813 !pp_funcs->set_pp_table) 1814 return -EOPNOTSUPP; 1815 1816 mutex_lock(&adev->pm.mutex); 1817 ret = pp_funcs->set_pp_table(adev->powerplay.pp_handle, 1818 buf, 1819 size); 1820 mutex_unlock(&adev->pm.mutex); 1821 1822 return ret; 1823 } 1824 1825 int amdgpu_dpm_get_num_cpu_cores(struct amdgpu_device *adev) 1826 { 1827 struct smu_context *smu = adev->powerplay.pp_handle; 1828 1829 if (!is_support_sw_smu(adev)) 1830 return INT_MAX; 1831 1832 return smu->cpu_core_num; 1833 } 1834 1835 void amdgpu_dpm_stb_debug_fs_init(struct amdgpu_device *adev) 1836 { 1837 if (!is_support_sw_smu(adev)) 1838 return; 1839 1840 amdgpu_smu_stb_debug_fs_init(adev); 1841 } 1842 1843 int amdgpu_dpm_display_configuration_change(struct amdgpu_device *adev, 1844 const struct amd_pp_display_configuration *input) 1845 { 1846 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1847 int ret = 0; 1848 1849 if (!pp_funcs->display_configuration_change) 1850 return 0; 1851 1852 mutex_lock(&adev->pm.mutex); 1853 ret = pp_funcs->display_configuration_change(adev->powerplay.pp_handle, 1854 input); 1855 mutex_unlock(&adev->pm.mutex); 1856 1857 return ret; 1858 } 1859 1860 int amdgpu_dpm_get_clock_by_type(struct amdgpu_device *adev, 1861 enum amd_pp_clock_type type, 1862 struct amd_pp_clocks *clocks) 1863 { 1864 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1865 int ret = 0; 1866 1867 if (!pp_funcs->get_clock_by_type) 1868 return 0; 1869 1870 mutex_lock(&adev->pm.mutex); 1871 ret = pp_funcs->get_clock_by_type(adev->powerplay.pp_handle, 1872 type, 1873 clocks); 1874 mutex_unlock(&adev->pm.mutex); 1875 1876 return ret; 1877 } 1878 1879 int amdgpu_dpm_get_display_mode_validation_clks(struct amdgpu_device *adev, 1880 struct amd_pp_simple_clock_info *clocks) 1881 { 1882 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1883 int ret = 0; 1884 1885 if (!pp_funcs->get_display_mode_validation_clocks) 1886 return 0; 1887 1888 mutex_lock(&adev->pm.mutex); 1889 ret = pp_funcs->get_display_mode_validation_clocks(adev->powerplay.pp_handle, 1890 clocks); 1891 mutex_unlock(&adev->pm.mutex); 1892 1893 return ret; 1894 } 1895 1896 int amdgpu_dpm_get_clock_by_type_with_latency(struct amdgpu_device *adev, 1897 enum amd_pp_clock_type type, 1898 struct pp_clock_levels_with_latency *clocks) 1899 { 1900 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1901 int ret = 0; 1902 1903 if (!pp_funcs->get_clock_by_type_with_latency) 1904 return 0; 1905 1906 mutex_lock(&adev->pm.mutex); 1907 ret = pp_funcs->get_clock_by_type_with_latency(adev->powerplay.pp_handle, 1908 type, 1909 clocks); 1910 mutex_unlock(&adev->pm.mutex); 1911 1912 return ret; 1913 } 1914 1915 int amdgpu_dpm_get_clock_by_type_with_voltage(struct amdgpu_device *adev, 1916 enum amd_pp_clock_type type, 1917 struct pp_clock_levels_with_voltage *clocks) 1918 { 1919 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1920 int ret = 0; 1921 1922 if (!pp_funcs->get_clock_by_type_with_voltage) 1923 return 0; 1924 1925 mutex_lock(&adev->pm.mutex); 1926 ret = pp_funcs->get_clock_by_type_with_voltage(adev->powerplay.pp_handle, 1927 type, 1928 clocks); 1929 mutex_unlock(&adev->pm.mutex); 1930 1931 return ret; 1932 } 1933 1934 int amdgpu_dpm_set_watermarks_for_clocks_ranges(struct amdgpu_device *adev, 1935 void *clock_ranges) 1936 { 1937 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1938 int ret = 0; 1939 1940 if (!pp_funcs->set_watermarks_for_clocks_ranges) 1941 return -EOPNOTSUPP; 1942 1943 mutex_lock(&adev->pm.mutex); 1944 ret = pp_funcs->set_watermarks_for_clocks_ranges(adev->powerplay.pp_handle, 1945 clock_ranges); 1946 mutex_unlock(&adev->pm.mutex); 1947 1948 return ret; 1949 } 1950 1951 int amdgpu_dpm_display_clock_voltage_request(struct amdgpu_device *adev, 1952 struct pp_display_clock_request *clock) 1953 { 1954 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1955 int ret = 0; 1956 1957 if (!pp_funcs->display_clock_voltage_request) 1958 return -EOPNOTSUPP; 1959 1960 mutex_lock(&adev->pm.mutex); 1961 ret = pp_funcs->display_clock_voltage_request(adev->powerplay.pp_handle, 1962 clock); 1963 mutex_unlock(&adev->pm.mutex); 1964 1965 return ret; 1966 } 1967 1968 int amdgpu_dpm_get_current_clocks(struct amdgpu_device *adev, 1969 struct amd_pp_clock_info *clocks) 1970 { 1971 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1972 int ret = 0; 1973 1974 if (!pp_funcs->get_current_clocks) 1975 return -EOPNOTSUPP; 1976 1977 mutex_lock(&adev->pm.mutex); 1978 ret = pp_funcs->get_current_clocks(adev->powerplay.pp_handle, 1979 clocks); 1980 mutex_unlock(&adev->pm.mutex); 1981 1982 return ret; 1983 } 1984 1985 void amdgpu_dpm_notify_smu_enable_pwe(struct amdgpu_device *adev) 1986 { 1987 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1988 1989 if (!pp_funcs->notify_smu_enable_pwe) 1990 return; 1991 1992 mutex_lock(&adev->pm.mutex); 1993 pp_funcs->notify_smu_enable_pwe(adev->powerplay.pp_handle); 1994 mutex_unlock(&adev->pm.mutex); 1995 } 1996 1997 int amdgpu_dpm_set_active_display_count(struct amdgpu_device *adev, 1998 uint32_t count) 1999 { 2000 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 2001 int ret = 0; 2002 2003 if (!pp_funcs->set_active_display_count) 2004 return -EOPNOTSUPP; 2005 2006 mutex_lock(&adev->pm.mutex); 2007 ret = pp_funcs->set_active_display_count(adev->powerplay.pp_handle, 2008 count); 2009 mutex_unlock(&adev->pm.mutex); 2010 2011 return ret; 2012 } 2013 2014 int amdgpu_dpm_set_min_deep_sleep_dcefclk(struct amdgpu_device *adev, 2015 uint32_t clock) 2016 { 2017 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 2018 int ret = 0; 2019 2020 if (!pp_funcs->set_min_deep_sleep_dcefclk) 2021 return -EOPNOTSUPP; 2022 2023 mutex_lock(&adev->pm.mutex); 2024 ret = pp_funcs->set_min_deep_sleep_dcefclk(adev->powerplay.pp_handle, 2025 clock); 2026 mutex_unlock(&adev->pm.mutex); 2027 2028 return ret; 2029 } 2030 2031 void amdgpu_dpm_set_hard_min_dcefclk_by_freq(struct amdgpu_device *adev, 2032 uint32_t clock) 2033 { 2034 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 2035 2036 if (!pp_funcs->set_hard_min_dcefclk_by_freq) 2037 return; 2038 2039 mutex_lock(&adev->pm.mutex); 2040 pp_funcs->set_hard_min_dcefclk_by_freq(adev->powerplay.pp_handle, 2041 clock); 2042 mutex_unlock(&adev->pm.mutex); 2043 } 2044 2045 void amdgpu_dpm_set_hard_min_fclk_by_freq(struct amdgpu_device *adev, 2046 uint32_t clock) 2047 { 2048 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 2049 2050 if (!pp_funcs->set_hard_min_fclk_by_freq) 2051 return; 2052 2053 mutex_lock(&adev->pm.mutex); 2054 pp_funcs->set_hard_min_fclk_by_freq(adev->powerplay.pp_handle, 2055 clock); 2056 mutex_unlock(&adev->pm.mutex); 2057 } 2058 2059 int amdgpu_dpm_display_disable_memory_clock_switch(struct amdgpu_device *adev, 2060 bool disable_memory_clock_switch) 2061 { 2062 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 2063 int ret = 0; 2064 2065 if (!pp_funcs->display_disable_memory_clock_switch) 2066 return 0; 2067 2068 mutex_lock(&adev->pm.mutex); 2069 ret = pp_funcs->display_disable_memory_clock_switch(adev->powerplay.pp_handle, 2070 disable_memory_clock_switch); 2071 mutex_unlock(&adev->pm.mutex); 2072 2073 return ret; 2074 } 2075 2076 int amdgpu_dpm_get_max_sustainable_clocks_by_dc(struct amdgpu_device *adev, 2077 struct pp_smu_nv_clock_table *max_clocks) 2078 { 2079 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 2080 int ret = 0; 2081 2082 if (!pp_funcs->get_max_sustainable_clocks_by_dc) 2083 return -EOPNOTSUPP; 2084 2085 mutex_lock(&adev->pm.mutex); 2086 ret = pp_funcs->get_max_sustainable_clocks_by_dc(adev->powerplay.pp_handle, 2087 max_clocks); 2088 mutex_unlock(&adev->pm.mutex); 2089 2090 return ret; 2091 } 2092 2093 enum pp_smu_status amdgpu_dpm_get_uclk_dpm_states(struct amdgpu_device *adev, 2094 unsigned int *clock_values_in_khz, 2095 unsigned int *num_states) 2096 { 2097 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 2098 int ret = 0; 2099 2100 if (!pp_funcs->get_uclk_dpm_states) 2101 return -EOPNOTSUPP; 2102 2103 mutex_lock(&adev->pm.mutex); 2104 ret = pp_funcs->get_uclk_dpm_states(adev->powerplay.pp_handle, 2105 clock_values_in_khz, 2106 num_states); 2107 mutex_unlock(&adev->pm.mutex); 2108 2109 return ret; 2110 } 2111 2112 int amdgpu_dpm_get_dpm_clock_table(struct amdgpu_device *adev, 2113 struct dpm_clocks *clock_table) 2114 { 2115 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 2116 int ret = 0; 2117 2118 if (!pp_funcs->get_dpm_clock_table) 2119 return -EOPNOTSUPP; 2120 2121 mutex_lock(&adev->pm.mutex); 2122 ret = pp_funcs->get_dpm_clock_table(adev->powerplay.pp_handle, 2123 clock_table); 2124 mutex_unlock(&adev->pm.mutex); 2125 2126 return ret; 2127 } 2128 2129 /** 2130 * amdgpu_dpm_get_temp_metrics - Retrieve metrics for a specific compute 2131 * partition 2132 * @adev: Pointer to the device. 2133 * @type: Identifier for the temperature type metrics to be fetched. 2134 * @table: Pointer to a buffer where the metrics will be stored. If NULL, the 2135 * function returns the size of the metrics structure. 2136 * 2137 * This function retrieves metrics for a specific temperature type, If the 2138 * table parameter is NULL, the function returns the size of the metrics 2139 * structure without populating it. 2140 * 2141 * Return: Size of the metrics structure on success, or a negative error code on failure. 2142 */ 2143 ssize_t amdgpu_dpm_get_temp_metrics(struct amdgpu_device *adev, 2144 enum smu_temp_metric_type type, void *table) 2145 { 2146 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 2147 int ret; 2148 2149 if (!pp_funcs->get_temp_metrics || 2150 !amdgpu_dpm_is_temp_metrics_supported(adev, type)) 2151 return -EOPNOTSUPP; 2152 2153 mutex_lock(&adev->pm.mutex); 2154 ret = pp_funcs->get_temp_metrics(adev->powerplay.pp_handle, type, table); 2155 mutex_unlock(&adev->pm.mutex); 2156 2157 return ret; 2158 } 2159 2160 /** 2161 * amdgpu_dpm_is_temp_metrics_supported - Return if specific temperature metrics support 2162 * is available 2163 * @adev: Pointer to the device. 2164 * @type: Identifier for the temperature type metrics to be fetched. 2165 * 2166 * This function returns metrics if specific temperature metrics type is supported or not. 2167 * 2168 * Return: True in case of metrics type supported else false. 2169 */ 2170 bool amdgpu_dpm_is_temp_metrics_supported(struct amdgpu_device *adev, 2171 enum smu_temp_metric_type type) 2172 { 2173 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 2174 bool support_temp_metrics = false; 2175 2176 if (!pp_funcs->temp_metrics_is_supported) 2177 return support_temp_metrics; 2178 2179 if (is_support_sw_smu(adev)) { 2180 mutex_lock(&adev->pm.mutex); 2181 support_temp_metrics = 2182 pp_funcs->temp_metrics_is_supported(adev->powerplay.pp_handle, type); 2183 mutex_unlock(&adev->pm.mutex); 2184 } 2185 2186 return support_temp_metrics; 2187 } 2188 2189 /** 2190 * amdgpu_dpm_get_npm_cap - Return NPM sysfs capability bitmap 2191 * @adev: Pointer to the device. 2192 * 2193 * Two bits per field (R then W). Both 0 means the field is unsupported. 2194 * 2195 * Return: Capability bitmap, or 0 if NPM is not supported. 2196 */ 2197 u64 amdgpu_dpm_get_npm_cap(struct amdgpu_device *adev) 2198 { 2199 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 2200 u64 cap = 0; 2201 2202 if (!pp_funcs || !pp_funcs->get_npm_cap) 2203 return 0; 2204 2205 mutex_lock(&adev->pm.mutex); 2206 cap = pp_funcs->get_npm_cap(adev->powerplay.pp_handle); 2207 mutex_unlock(&adev->pm.mutex); 2208 2209 return cap; 2210 } 2211 2212 int amdgpu_dpm_set_npm_limit(struct amdgpu_device *adev, uint32_t limit) 2213 { 2214 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 2215 int ret; 2216 2217 if (!pp_funcs || !pp_funcs->set_npm_limit) 2218 return -EOPNOTSUPP; 2219 2220 if (amdgpu_sriov_vf(adev)) 2221 return -EPERM; 2222 2223 mutex_lock(&adev->pm.mutex); 2224 ret = pp_funcs->set_npm_limit(adev->powerplay.pp_handle, limit); 2225 mutex_unlock(&adev->pm.mutex); 2226 2227 return ret; 2228 } 2229 2230 /** 2231 * amdgpu_dpm_get_xcp_metrics - Retrieve metrics for a specific compute 2232 * partition 2233 * @adev: Pointer to the device. 2234 * @xcp_id: Identifier of the XCP for which metrics are to be retrieved. 2235 * @table: Pointer to a buffer where the metrics will be stored. If NULL, the 2236 * function returns the size of the metrics structure. 2237 * 2238 * This function retrieves metrics for a specific XCP, including details such as 2239 * VCN/JPEG activity, clock frequencies, and other performance metrics. If the 2240 * table parameter is NULL, the function returns the size of the metrics 2241 * structure without populating it. 2242 * 2243 * Return: Size of the metrics structure on success, or a negative error code on failure. 2244 */ 2245 ssize_t amdgpu_dpm_get_xcp_metrics(struct amdgpu_device *adev, int xcp_id, 2246 void *table) 2247 { 2248 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 2249 int ret = 0; 2250 2251 if (!pp_funcs->get_xcp_metrics) 2252 return 0; 2253 2254 mutex_lock(&adev->pm.mutex); 2255 ret = pp_funcs->get_xcp_metrics(adev->powerplay.pp_handle, xcp_id, 2256 table); 2257 mutex_unlock(&adev->pm.mutex); 2258 2259 return ret; 2260 } 2261