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 int amdgpu_dpm_force_performance_level(struct amdgpu_device *adev, 1086 enum amd_dpm_forced_level level) 1087 { 1088 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1089 enum amd_dpm_forced_level current_level; 1090 uint32_t profile_mode_mask = AMD_DPM_FORCED_LEVEL_PROFILE_STANDARD | 1091 AMD_DPM_FORCED_LEVEL_PROFILE_MIN_SCLK | 1092 AMD_DPM_FORCED_LEVEL_PROFILE_MIN_MCLK | 1093 AMD_DPM_FORCED_LEVEL_PROFILE_PEAK; 1094 1095 if (!pp_funcs || !pp_funcs->force_performance_level) 1096 return 0; 1097 1098 if (adev->pm.dpm.thermal_active) 1099 return -EINVAL; 1100 1101 current_level = amdgpu_dpm_get_performance_level(adev); 1102 if (current_level == level) 1103 return 0; 1104 1105 if (!(current_level & profile_mode_mask) && 1106 (level == AMD_DPM_FORCED_LEVEL_PROFILE_EXIT)) 1107 return -EINVAL; 1108 1109 if (adev->asic_type == CHIP_RAVEN) { 1110 if (!(adev->apu_flags & AMD_APU_IS_RAVEN2)) { 1111 if (current_level != AMD_DPM_FORCED_LEVEL_MANUAL && 1112 level == AMD_DPM_FORCED_LEVEL_MANUAL) 1113 amdgpu_gfx_off_ctrl(adev, false); 1114 else if (current_level == AMD_DPM_FORCED_LEVEL_MANUAL && 1115 level != AMD_DPM_FORCED_LEVEL_MANUAL) 1116 amdgpu_gfx_off_ctrl(adev, true); 1117 } 1118 } 1119 1120 if (!(current_level & profile_mode_mask) && (level & profile_mode_mask)) 1121 amdgpu_dpm_enter_umd_state(adev); 1122 else if ((current_level & profile_mode_mask) && 1123 !(level & profile_mode_mask)) 1124 amdgpu_dpm_exit_umd_state(adev); 1125 1126 mutex_lock(&adev->pm.mutex); 1127 1128 if (pp_funcs->force_performance_level(adev->powerplay.pp_handle, 1129 level)) { 1130 mutex_unlock(&adev->pm.mutex); 1131 /* If new level failed, retain the umd state as before */ 1132 if (!(current_level & profile_mode_mask) && 1133 (level & profile_mode_mask)) 1134 amdgpu_dpm_exit_umd_state(adev); 1135 else if ((current_level & profile_mode_mask) && 1136 !(level & profile_mode_mask)) 1137 amdgpu_dpm_enter_umd_state(adev); 1138 1139 return -EINVAL; 1140 } 1141 1142 adev->pm.dpm.forced_level = level; 1143 1144 mutex_unlock(&adev->pm.mutex); 1145 1146 return 0; 1147 } 1148 1149 int amdgpu_dpm_get_pp_num_states(struct amdgpu_device *adev, 1150 struct pp_states_info *states) 1151 { 1152 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1153 int ret = 0; 1154 1155 if (!pp_funcs->get_pp_num_states) 1156 return -EOPNOTSUPP; 1157 1158 mutex_lock(&adev->pm.mutex); 1159 ret = pp_funcs->get_pp_num_states(adev->powerplay.pp_handle, 1160 states); 1161 mutex_unlock(&adev->pm.mutex); 1162 1163 return ret; 1164 } 1165 1166 int amdgpu_dpm_dispatch_task(struct amdgpu_device *adev, 1167 enum amd_pp_task task_id, 1168 enum amd_pm_state_type *user_state) 1169 { 1170 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1171 int ret = 0; 1172 1173 if (!pp_funcs->dispatch_tasks) 1174 return -EOPNOTSUPP; 1175 1176 mutex_lock(&adev->pm.mutex); 1177 ret = pp_funcs->dispatch_tasks(adev->powerplay.pp_handle, 1178 task_id, 1179 user_state); 1180 mutex_unlock(&adev->pm.mutex); 1181 1182 return ret; 1183 } 1184 1185 static bool amdgpu_dpm_is_pp_table_allowed(struct amdgpu_device *adev) 1186 { 1187 return !amdgpu_sriov_vf(adev) && 1188 !(adev->flags & AMD_IS_APU) && 1189 !adev->scpm_enabled; 1190 } 1191 1192 int amdgpu_dpm_get_pp_table(struct amdgpu_device *adev, char *table, 1193 size_t size) 1194 { 1195 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1196 char *pptable = NULL; 1197 int ret = 0; 1198 1199 if ((!table && size) || (table && !size)) 1200 return -EINVAL; 1201 1202 if (!amdgpu_dpm_is_pp_table_allowed(adev) || 1203 !pp_funcs->get_pp_table) 1204 return -EOPNOTSUPP; 1205 1206 mutex_lock(&adev->pm.mutex); 1207 ret = pp_funcs->get_pp_table(adev->powerplay.pp_handle, 1208 &pptable); 1209 if (ret > 0 && !pptable) { 1210 ret = -EINVAL; 1211 } else if (ret > 0 && table) { 1212 ret = min_t(size_t, ret, size); 1213 memcpy(table, pptable, ret); 1214 } 1215 mutex_unlock(&adev->pm.mutex); 1216 1217 return ret; 1218 } 1219 1220 int amdgpu_dpm_set_fine_grain_clk_vol(struct amdgpu_device *adev, 1221 uint32_t type, 1222 long *input, 1223 uint32_t size) 1224 { 1225 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1226 int ret = 0; 1227 1228 if (!pp_funcs->set_fine_grain_clk_vol) 1229 return 0; 1230 1231 mutex_lock(&adev->pm.mutex); 1232 ret = pp_funcs->set_fine_grain_clk_vol(adev->powerplay.pp_handle, 1233 type, 1234 input, 1235 size); 1236 mutex_unlock(&adev->pm.mutex); 1237 1238 return ret; 1239 } 1240 1241 int amdgpu_dpm_odn_edit_dpm_table(struct amdgpu_device *adev, 1242 uint32_t type, 1243 long *input, 1244 uint32_t size) 1245 { 1246 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1247 int ret = 0; 1248 1249 if (!pp_funcs->odn_edit_dpm_table) 1250 return 0; 1251 1252 mutex_lock(&adev->pm.mutex); 1253 ret = pp_funcs->odn_edit_dpm_table(adev->powerplay.pp_handle, 1254 type, 1255 input, 1256 size); 1257 mutex_unlock(&adev->pm.mutex); 1258 1259 return ret; 1260 } 1261 1262 int amdgpu_dpm_emit_clock_levels(struct amdgpu_device *adev, 1263 enum pp_clock_type type, 1264 char *buf, 1265 int *offset) 1266 { 1267 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1268 int ret = 0; 1269 1270 if (!pp_funcs->emit_clock_levels) 1271 return -ENOENT; 1272 1273 mutex_lock(&adev->pm.mutex); 1274 ret = pp_funcs->emit_clock_levels(adev->powerplay.pp_handle, 1275 type, 1276 buf, 1277 offset); 1278 mutex_unlock(&adev->pm.mutex); 1279 1280 return ret; 1281 } 1282 1283 int amdgpu_dpm_set_ppfeature_status(struct amdgpu_device *adev, 1284 uint64_t ppfeature_masks) 1285 { 1286 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1287 int ret = 0; 1288 1289 if (!pp_funcs->set_ppfeature_status) 1290 return 0; 1291 1292 mutex_lock(&adev->pm.mutex); 1293 ret = pp_funcs->set_ppfeature_status(adev->powerplay.pp_handle, 1294 ppfeature_masks); 1295 mutex_unlock(&adev->pm.mutex); 1296 1297 return ret; 1298 } 1299 1300 int amdgpu_dpm_get_ppfeature_status(struct amdgpu_device *adev, char *buf) 1301 { 1302 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1303 int ret = 0; 1304 1305 if (!pp_funcs->get_ppfeature_status) 1306 return 0; 1307 1308 mutex_lock(&adev->pm.mutex); 1309 ret = pp_funcs->get_ppfeature_status(adev->powerplay.pp_handle, 1310 buf); 1311 mutex_unlock(&adev->pm.mutex); 1312 1313 return ret; 1314 } 1315 1316 int amdgpu_dpm_force_clock_level(struct amdgpu_device *adev, 1317 enum pp_clock_type type, 1318 uint32_t mask) 1319 { 1320 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1321 int ret = 0; 1322 1323 if (!pp_funcs->force_clock_level) 1324 return 0; 1325 1326 mutex_lock(&adev->pm.mutex); 1327 ret = pp_funcs->force_clock_level(adev->powerplay.pp_handle, 1328 type, 1329 mask); 1330 mutex_unlock(&adev->pm.mutex); 1331 1332 return ret; 1333 } 1334 1335 int amdgpu_dpm_get_sclk_od(struct amdgpu_device *adev) 1336 { 1337 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1338 int ret = 0; 1339 1340 if (!pp_funcs->get_sclk_od) 1341 return -EOPNOTSUPP; 1342 1343 mutex_lock(&adev->pm.mutex); 1344 ret = pp_funcs->get_sclk_od(adev->powerplay.pp_handle); 1345 mutex_unlock(&adev->pm.mutex); 1346 1347 return ret; 1348 } 1349 1350 int amdgpu_dpm_set_sclk_od(struct amdgpu_device *adev, uint32_t value) 1351 { 1352 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1353 1354 if (is_support_sw_smu(adev)) 1355 return -EOPNOTSUPP; 1356 1357 mutex_lock(&adev->pm.mutex); 1358 if (pp_funcs->set_sclk_od) 1359 pp_funcs->set_sclk_od(adev->powerplay.pp_handle, value); 1360 mutex_unlock(&adev->pm.mutex); 1361 1362 if (amdgpu_dpm_dispatch_task(adev, 1363 AMD_PP_TASK_READJUST_POWER_STATE, 1364 NULL) == -EOPNOTSUPP) { 1365 adev->pm.dpm.current_ps = adev->pm.dpm.boot_ps; 1366 amdgpu_dpm_compute_clocks(adev); 1367 } 1368 1369 return 0; 1370 } 1371 1372 int amdgpu_dpm_get_mclk_od(struct amdgpu_device *adev) 1373 { 1374 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1375 int ret = 0; 1376 1377 if (!pp_funcs->get_mclk_od) 1378 return -EOPNOTSUPP; 1379 1380 mutex_lock(&adev->pm.mutex); 1381 ret = pp_funcs->get_mclk_od(adev->powerplay.pp_handle); 1382 mutex_unlock(&adev->pm.mutex); 1383 1384 return ret; 1385 } 1386 1387 int amdgpu_dpm_set_mclk_od(struct amdgpu_device *adev, uint32_t value) 1388 { 1389 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1390 1391 if (is_support_sw_smu(adev)) 1392 return -EOPNOTSUPP; 1393 1394 mutex_lock(&adev->pm.mutex); 1395 if (pp_funcs->set_mclk_od) 1396 pp_funcs->set_mclk_od(adev->powerplay.pp_handle, value); 1397 mutex_unlock(&adev->pm.mutex); 1398 1399 if (amdgpu_dpm_dispatch_task(adev, 1400 AMD_PP_TASK_READJUST_POWER_STATE, 1401 NULL) == -EOPNOTSUPP) { 1402 adev->pm.dpm.current_ps = adev->pm.dpm.boot_ps; 1403 amdgpu_dpm_compute_clocks(adev); 1404 } 1405 1406 return 0; 1407 } 1408 1409 int amdgpu_dpm_get_power_profile_mode(struct amdgpu_device *adev, 1410 char *buf) 1411 { 1412 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1413 int ret = 0; 1414 1415 if (!pp_funcs->get_power_profile_mode) 1416 return -EOPNOTSUPP; 1417 1418 mutex_lock(&adev->pm.mutex); 1419 ret = pp_funcs->get_power_profile_mode(adev->powerplay.pp_handle, 1420 buf); 1421 mutex_unlock(&adev->pm.mutex); 1422 1423 return ret; 1424 } 1425 1426 int amdgpu_dpm_set_power_profile_mode(struct amdgpu_device *adev, 1427 long *input, uint32_t size) 1428 { 1429 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1430 int ret = 0; 1431 1432 if (!pp_funcs->set_power_profile_mode) 1433 return 0; 1434 1435 mutex_lock(&adev->pm.mutex); 1436 ret = pp_funcs->set_power_profile_mode(adev->powerplay.pp_handle, 1437 input, 1438 size); 1439 mutex_unlock(&adev->pm.mutex); 1440 1441 return ret; 1442 } 1443 1444 ssize_t amdgpu_dpm_get_gpu_metrics(struct amdgpu_device *adev, void *buf, 1445 size_t size) 1446 { 1447 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1448 void *table; 1449 ssize_t ret; 1450 1451 if (!pp_funcs->get_gpu_metrics) 1452 return 0; 1453 1454 mutex_lock(&adev->pm.mutex); 1455 ret = pp_funcs->get_gpu_metrics(adev->powerplay.pp_handle, 1456 &table); 1457 if (ret > 0) { 1458 ret = min_t(ssize_t, ret, size); 1459 memcpy(buf, table, ret); 1460 } 1461 mutex_unlock(&adev->pm.mutex); 1462 1463 return ret; 1464 } 1465 1466 ssize_t amdgpu_dpm_get_pm_metrics(struct amdgpu_device *adev, void *pm_metrics, 1467 size_t size) 1468 { 1469 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1470 int ret = 0; 1471 1472 if (!pp_funcs->get_pm_metrics) 1473 return -EOPNOTSUPP; 1474 1475 mutex_lock(&adev->pm.mutex); 1476 ret = pp_funcs->get_pm_metrics(adev->powerplay.pp_handle, pm_metrics, 1477 size); 1478 mutex_unlock(&adev->pm.mutex); 1479 1480 return ret; 1481 } 1482 1483 int amdgpu_dpm_get_fan_control_mode(struct amdgpu_device *adev, 1484 uint32_t *fan_mode) 1485 { 1486 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1487 int ret = 0; 1488 1489 if (!pp_funcs->get_fan_control_mode) 1490 return -EOPNOTSUPP; 1491 1492 mutex_lock(&adev->pm.mutex); 1493 ret = pp_funcs->get_fan_control_mode(adev->powerplay.pp_handle, 1494 fan_mode); 1495 mutex_unlock(&adev->pm.mutex); 1496 1497 return ret; 1498 } 1499 1500 int amdgpu_dpm_set_fan_speed_pwm(struct amdgpu_device *adev, 1501 uint32_t speed) 1502 { 1503 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1504 int ret = 0; 1505 1506 if (!pp_funcs->set_fan_speed_pwm) 1507 return -EOPNOTSUPP; 1508 1509 mutex_lock(&adev->pm.mutex); 1510 ret = pp_funcs->set_fan_speed_pwm(adev->powerplay.pp_handle, 1511 speed); 1512 mutex_unlock(&adev->pm.mutex); 1513 1514 return ret; 1515 } 1516 1517 int amdgpu_dpm_get_fan_speed_pwm(struct amdgpu_device *adev, 1518 uint32_t *speed) 1519 { 1520 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1521 int ret = 0; 1522 1523 if (!pp_funcs->get_fan_speed_pwm) 1524 return -EOPNOTSUPP; 1525 1526 mutex_lock(&adev->pm.mutex); 1527 ret = pp_funcs->get_fan_speed_pwm(adev->powerplay.pp_handle, 1528 speed); 1529 mutex_unlock(&adev->pm.mutex); 1530 1531 return ret; 1532 } 1533 1534 int amdgpu_dpm_get_fan_speed_rpm(struct amdgpu_device *adev, 1535 uint32_t *speed) 1536 { 1537 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1538 int ret = 0; 1539 1540 if (!pp_funcs->get_fan_speed_rpm) 1541 return -EOPNOTSUPP; 1542 1543 mutex_lock(&adev->pm.mutex); 1544 ret = pp_funcs->get_fan_speed_rpm(adev->powerplay.pp_handle, 1545 speed); 1546 mutex_unlock(&adev->pm.mutex); 1547 1548 return ret; 1549 } 1550 1551 int amdgpu_dpm_set_fan_speed_rpm(struct amdgpu_device *adev, 1552 uint32_t speed) 1553 { 1554 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1555 int ret = 0; 1556 1557 if (!pp_funcs->set_fan_speed_rpm) 1558 return -EOPNOTSUPP; 1559 1560 mutex_lock(&adev->pm.mutex); 1561 ret = pp_funcs->set_fan_speed_rpm(adev->powerplay.pp_handle, 1562 speed); 1563 mutex_unlock(&adev->pm.mutex); 1564 1565 return ret; 1566 } 1567 1568 int amdgpu_dpm_set_fan_control_mode(struct amdgpu_device *adev, 1569 uint32_t mode) 1570 { 1571 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1572 int ret = 0; 1573 1574 if (!pp_funcs->set_fan_control_mode) 1575 return -EOPNOTSUPP; 1576 1577 mutex_lock(&adev->pm.mutex); 1578 ret = pp_funcs->set_fan_control_mode(adev->powerplay.pp_handle, 1579 mode); 1580 mutex_unlock(&adev->pm.mutex); 1581 1582 return ret; 1583 } 1584 1585 int amdgpu_dpm_get_power_limit(struct amdgpu_device *adev, 1586 uint32_t *limit, 1587 enum pp_power_limit_level pp_limit_level, 1588 enum pp_power_type power_type) 1589 { 1590 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1591 int ret = 0; 1592 1593 if (!pp_funcs->get_power_limit) 1594 return -EOPNOTSUPP; 1595 1596 mutex_lock(&adev->pm.mutex); 1597 ret = pp_funcs->get_power_limit(adev->powerplay.pp_handle, 1598 limit, 1599 pp_limit_level, 1600 power_type); 1601 mutex_unlock(&adev->pm.mutex); 1602 1603 return ret; 1604 } 1605 1606 int amdgpu_dpm_set_power_limit(struct amdgpu_device *adev, 1607 uint32_t limit_type, 1608 uint32_t limit) 1609 { 1610 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1611 int ret = 0; 1612 1613 if (!pp_funcs->set_power_limit) 1614 return -EINVAL; 1615 1616 mutex_lock(&adev->pm.mutex); 1617 ret = pp_funcs->set_power_limit(adev->powerplay.pp_handle, 1618 limit_type, limit); 1619 mutex_unlock(&adev->pm.mutex); 1620 1621 return ret; 1622 } 1623 1624 int amdgpu_dpm_is_cclk_dpm_supported(struct amdgpu_device *adev) 1625 { 1626 bool cclk_dpm_supported = false; 1627 1628 if (!is_support_sw_smu(adev)) 1629 return false; 1630 1631 mutex_lock(&adev->pm.mutex); 1632 cclk_dpm_supported = is_support_cclk_dpm(adev); 1633 mutex_unlock(&adev->pm.mutex); 1634 1635 return (int)cclk_dpm_supported; 1636 } 1637 1638 int amdgpu_dpm_debugfs_print_current_performance_level(struct amdgpu_device *adev, 1639 struct seq_file *m) 1640 { 1641 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1642 1643 if (!pp_funcs->debugfs_print_current_performance_level) 1644 return -EOPNOTSUPP; 1645 1646 mutex_lock(&adev->pm.mutex); 1647 pp_funcs->debugfs_print_current_performance_level(adev->powerplay.pp_handle, 1648 m); 1649 mutex_unlock(&adev->pm.mutex); 1650 1651 return 0; 1652 } 1653 1654 int amdgpu_dpm_get_smu_prv_buf_details(struct amdgpu_device *adev, 1655 void **addr, 1656 size_t *size) 1657 { 1658 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1659 int ret = 0; 1660 1661 if (!pp_funcs->get_smu_prv_buf_details) 1662 return -ENOSYS; 1663 1664 mutex_lock(&adev->pm.mutex); 1665 ret = pp_funcs->get_smu_prv_buf_details(adev->powerplay.pp_handle, 1666 addr, 1667 size); 1668 mutex_unlock(&adev->pm.mutex); 1669 1670 return ret; 1671 } 1672 1673 int amdgpu_dpm_is_overdrive_supported(struct amdgpu_device *adev) 1674 { 1675 if (is_support_sw_smu(adev)) { 1676 struct smu_context *smu = adev->powerplay.pp_handle; 1677 1678 return (smu->od_enabled || smu->is_apu); 1679 } else { 1680 struct pp_hwmgr *hwmgr; 1681 1682 /* 1683 * dpm on some legacy asics don't carry od_enabled member 1684 * as its pp_handle is casted directly from adev. 1685 */ 1686 if (amdgpu_dpm_is_legacy_dpm(adev)) 1687 return false; 1688 1689 hwmgr = (struct pp_hwmgr *)adev->powerplay.pp_handle; 1690 1691 return hwmgr->od_enabled; 1692 } 1693 } 1694 1695 int amdgpu_dpm_is_overdrive_enabled(struct amdgpu_device *adev) 1696 { 1697 if (is_support_sw_smu(adev)) { 1698 struct smu_context *smu = adev->powerplay.pp_handle; 1699 1700 return smu->od_enabled; 1701 } else { 1702 struct pp_hwmgr *hwmgr; 1703 1704 /* 1705 * dpm on some legacy asics don't carry od_enabled member 1706 * as its pp_handle is casted directly from adev. 1707 */ 1708 if (amdgpu_dpm_is_legacy_dpm(adev)) 1709 return false; 1710 1711 hwmgr = (struct pp_hwmgr *)adev->powerplay.pp_handle; 1712 1713 return hwmgr->od_enabled; 1714 } 1715 } 1716 1717 int amdgpu_dpm_set_pp_table(struct amdgpu_device *adev, 1718 const char *buf, 1719 size_t size) 1720 { 1721 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1722 int ret = 0; 1723 1724 if (!buf || !size) 1725 return -EINVAL; 1726 1727 if (!amdgpu_dpm_is_pp_table_allowed(adev) || 1728 !pp_funcs->set_pp_table) 1729 return -EOPNOTSUPP; 1730 1731 mutex_lock(&adev->pm.mutex); 1732 ret = pp_funcs->set_pp_table(adev->powerplay.pp_handle, 1733 buf, 1734 size); 1735 mutex_unlock(&adev->pm.mutex); 1736 1737 return ret; 1738 } 1739 1740 int amdgpu_dpm_get_num_cpu_cores(struct amdgpu_device *adev) 1741 { 1742 struct smu_context *smu = adev->powerplay.pp_handle; 1743 1744 if (!is_support_sw_smu(adev)) 1745 return INT_MAX; 1746 1747 return smu->cpu_core_num; 1748 } 1749 1750 void amdgpu_dpm_stb_debug_fs_init(struct amdgpu_device *adev) 1751 { 1752 if (!is_support_sw_smu(adev)) 1753 return; 1754 1755 amdgpu_smu_stb_debug_fs_init(adev); 1756 } 1757 1758 int amdgpu_dpm_display_configuration_change(struct amdgpu_device *adev, 1759 const struct amd_pp_display_configuration *input) 1760 { 1761 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1762 int ret = 0; 1763 1764 if (!pp_funcs->display_configuration_change) 1765 return 0; 1766 1767 mutex_lock(&adev->pm.mutex); 1768 ret = pp_funcs->display_configuration_change(adev->powerplay.pp_handle, 1769 input); 1770 mutex_unlock(&adev->pm.mutex); 1771 1772 return ret; 1773 } 1774 1775 int amdgpu_dpm_get_clock_by_type(struct amdgpu_device *adev, 1776 enum amd_pp_clock_type type, 1777 struct amd_pp_clocks *clocks) 1778 { 1779 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1780 int ret = 0; 1781 1782 if (!pp_funcs->get_clock_by_type) 1783 return 0; 1784 1785 mutex_lock(&adev->pm.mutex); 1786 ret = pp_funcs->get_clock_by_type(adev->powerplay.pp_handle, 1787 type, 1788 clocks); 1789 mutex_unlock(&adev->pm.mutex); 1790 1791 return ret; 1792 } 1793 1794 int amdgpu_dpm_get_display_mode_validation_clks(struct amdgpu_device *adev, 1795 struct amd_pp_simple_clock_info *clocks) 1796 { 1797 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1798 int ret = 0; 1799 1800 if (!pp_funcs->get_display_mode_validation_clocks) 1801 return 0; 1802 1803 mutex_lock(&adev->pm.mutex); 1804 ret = pp_funcs->get_display_mode_validation_clocks(adev->powerplay.pp_handle, 1805 clocks); 1806 mutex_unlock(&adev->pm.mutex); 1807 1808 return ret; 1809 } 1810 1811 int amdgpu_dpm_get_clock_by_type_with_latency(struct amdgpu_device *adev, 1812 enum amd_pp_clock_type type, 1813 struct pp_clock_levels_with_latency *clocks) 1814 { 1815 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1816 int ret = 0; 1817 1818 if (!pp_funcs->get_clock_by_type_with_latency) 1819 return 0; 1820 1821 mutex_lock(&adev->pm.mutex); 1822 ret = pp_funcs->get_clock_by_type_with_latency(adev->powerplay.pp_handle, 1823 type, 1824 clocks); 1825 mutex_unlock(&adev->pm.mutex); 1826 1827 return ret; 1828 } 1829 1830 int amdgpu_dpm_get_clock_by_type_with_voltage(struct amdgpu_device *adev, 1831 enum amd_pp_clock_type type, 1832 struct pp_clock_levels_with_voltage *clocks) 1833 { 1834 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1835 int ret = 0; 1836 1837 if (!pp_funcs->get_clock_by_type_with_voltage) 1838 return 0; 1839 1840 mutex_lock(&adev->pm.mutex); 1841 ret = pp_funcs->get_clock_by_type_with_voltage(adev->powerplay.pp_handle, 1842 type, 1843 clocks); 1844 mutex_unlock(&adev->pm.mutex); 1845 1846 return ret; 1847 } 1848 1849 int amdgpu_dpm_set_watermarks_for_clocks_ranges(struct amdgpu_device *adev, 1850 void *clock_ranges) 1851 { 1852 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1853 int ret = 0; 1854 1855 if (!pp_funcs->set_watermarks_for_clocks_ranges) 1856 return -EOPNOTSUPP; 1857 1858 mutex_lock(&adev->pm.mutex); 1859 ret = pp_funcs->set_watermarks_for_clocks_ranges(adev->powerplay.pp_handle, 1860 clock_ranges); 1861 mutex_unlock(&adev->pm.mutex); 1862 1863 return ret; 1864 } 1865 1866 int amdgpu_dpm_display_clock_voltage_request(struct amdgpu_device *adev, 1867 struct pp_display_clock_request *clock) 1868 { 1869 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1870 int ret = 0; 1871 1872 if (!pp_funcs->display_clock_voltage_request) 1873 return -EOPNOTSUPP; 1874 1875 mutex_lock(&adev->pm.mutex); 1876 ret = pp_funcs->display_clock_voltage_request(adev->powerplay.pp_handle, 1877 clock); 1878 mutex_unlock(&adev->pm.mutex); 1879 1880 return ret; 1881 } 1882 1883 int amdgpu_dpm_get_current_clocks(struct amdgpu_device *adev, 1884 struct amd_pp_clock_info *clocks) 1885 { 1886 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1887 int ret = 0; 1888 1889 if (!pp_funcs->get_current_clocks) 1890 return -EOPNOTSUPP; 1891 1892 mutex_lock(&adev->pm.mutex); 1893 ret = pp_funcs->get_current_clocks(adev->powerplay.pp_handle, 1894 clocks); 1895 mutex_unlock(&adev->pm.mutex); 1896 1897 return ret; 1898 } 1899 1900 void amdgpu_dpm_notify_smu_enable_pwe(struct amdgpu_device *adev) 1901 { 1902 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1903 1904 if (!pp_funcs->notify_smu_enable_pwe) 1905 return; 1906 1907 mutex_lock(&adev->pm.mutex); 1908 pp_funcs->notify_smu_enable_pwe(adev->powerplay.pp_handle); 1909 mutex_unlock(&adev->pm.mutex); 1910 } 1911 1912 int amdgpu_dpm_set_active_display_count(struct amdgpu_device *adev, 1913 uint32_t count) 1914 { 1915 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1916 int ret = 0; 1917 1918 if (!pp_funcs->set_active_display_count) 1919 return -EOPNOTSUPP; 1920 1921 mutex_lock(&adev->pm.mutex); 1922 ret = pp_funcs->set_active_display_count(adev->powerplay.pp_handle, 1923 count); 1924 mutex_unlock(&adev->pm.mutex); 1925 1926 return ret; 1927 } 1928 1929 int amdgpu_dpm_set_min_deep_sleep_dcefclk(struct amdgpu_device *adev, 1930 uint32_t clock) 1931 { 1932 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1933 int ret = 0; 1934 1935 if (!pp_funcs->set_min_deep_sleep_dcefclk) 1936 return -EOPNOTSUPP; 1937 1938 mutex_lock(&adev->pm.mutex); 1939 ret = pp_funcs->set_min_deep_sleep_dcefclk(adev->powerplay.pp_handle, 1940 clock); 1941 mutex_unlock(&adev->pm.mutex); 1942 1943 return ret; 1944 } 1945 1946 void amdgpu_dpm_set_hard_min_dcefclk_by_freq(struct amdgpu_device *adev, 1947 uint32_t clock) 1948 { 1949 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1950 1951 if (!pp_funcs->set_hard_min_dcefclk_by_freq) 1952 return; 1953 1954 mutex_lock(&adev->pm.mutex); 1955 pp_funcs->set_hard_min_dcefclk_by_freq(adev->powerplay.pp_handle, 1956 clock); 1957 mutex_unlock(&adev->pm.mutex); 1958 } 1959 1960 void amdgpu_dpm_set_hard_min_fclk_by_freq(struct amdgpu_device *adev, 1961 uint32_t clock) 1962 { 1963 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1964 1965 if (!pp_funcs->set_hard_min_fclk_by_freq) 1966 return; 1967 1968 mutex_lock(&adev->pm.mutex); 1969 pp_funcs->set_hard_min_fclk_by_freq(adev->powerplay.pp_handle, 1970 clock); 1971 mutex_unlock(&adev->pm.mutex); 1972 } 1973 1974 int amdgpu_dpm_display_disable_memory_clock_switch(struct amdgpu_device *adev, 1975 bool disable_memory_clock_switch) 1976 { 1977 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1978 int ret = 0; 1979 1980 if (!pp_funcs->display_disable_memory_clock_switch) 1981 return 0; 1982 1983 mutex_lock(&adev->pm.mutex); 1984 ret = pp_funcs->display_disable_memory_clock_switch(adev->powerplay.pp_handle, 1985 disable_memory_clock_switch); 1986 mutex_unlock(&adev->pm.mutex); 1987 1988 return ret; 1989 } 1990 1991 int amdgpu_dpm_get_max_sustainable_clocks_by_dc(struct amdgpu_device *adev, 1992 struct pp_smu_nv_clock_table *max_clocks) 1993 { 1994 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 1995 int ret = 0; 1996 1997 if (!pp_funcs->get_max_sustainable_clocks_by_dc) 1998 return -EOPNOTSUPP; 1999 2000 mutex_lock(&adev->pm.mutex); 2001 ret = pp_funcs->get_max_sustainable_clocks_by_dc(adev->powerplay.pp_handle, 2002 max_clocks); 2003 mutex_unlock(&adev->pm.mutex); 2004 2005 return ret; 2006 } 2007 2008 enum pp_smu_status amdgpu_dpm_get_uclk_dpm_states(struct amdgpu_device *adev, 2009 unsigned int *clock_values_in_khz, 2010 unsigned int *num_states) 2011 { 2012 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 2013 int ret = 0; 2014 2015 if (!pp_funcs->get_uclk_dpm_states) 2016 return -EOPNOTSUPP; 2017 2018 mutex_lock(&adev->pm.mutex); 2019 ret = pp_funcs->get_uclk_dpm_states(adev->powerplay.pp_handle, 2020 clock_values_in_khz, 2021 num_states); 2022 mutex_unlock(&adev->pm.mutex); 2023 2024 return ret; 2025 } 2026 2027 int amdgpu_dpm_get_dpm_clock_table(struct amdgpu_device *adev, 2028 struct dpm_clocks *clock_table) 2029 { 2030 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 2031 int ret = 0; 2032 2033 if (!pp_funcs->get_dpm_clock_table) 2034 return -EOPNOTSUPP; 2035 2036 mutex_lock(&adev->pm.mutex); 2037 ret = pp_funcs->get_dpm_clock_table(adev->powerplay.pp_handle, 2038 clock_table); 2039 mutex_unlock(&adev->pm.mutex); 2040 2041 return ret; 2042 } 2043 2044 /** 2045 * amdgpu_dpm_get_temp_metrics - Retrieve metrics for a specific compute 2046 * partition 2047 * @adev: Pointer to the device. 2048 * @type: Identifier for the temperature type metrics to be fetched. 2049 * @table: Pointer to a buffer where the metrics will be stored. If NULL, the 2050 * function returns the size of the metrics structure. 2051 * 2052 * This function retrieves metrics for a specific temperature type, If the 2053 * table parameter is NULL, the function returns the size of the metrics 2054 * structure without populating it. 2055 * 2056 * Return: Size of the metrics structure on success, or a negative error code on failure. 2057 */ 2058 ssize_t amdgpu_dpm_get_temp_metrics(struct amdgpu_device *adev, 2059 enum smu_temp_metric_type type, void *table) 2060 { 2061 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 2062 int ret; 2063 2064 if (!pp_funcs->get_temp_metrics || 2065 !amdgpu_dpm_is_temp_metrics_supported(adev, type)) 2066 return -EOPNOTSUPP; 2067 2068 mutex_lock(&adev->pm.mutex); 2069 ret = pp_funcs->get_temp_metrics(adev->powerplay.pp_handle, type, table); 2070 mutex_unlock(&adev->pm.mutex); 2071 2072 return ret; 2073 } 2074 2075 /** 2076 * amdgpu_dpm_is_temp_metrics_supported - Return if specific temperature metrics support 2077 * is available 2078 * @adev: Pointer to the device. 2079 * @type: Identifier for the temperature type metrics to be fetched. 2080 * 2081 * This function returns metrics if specific temperature metrics type is supported or not. 2082 * 2083 * Return: True in case of metrics type supported else false. 2084 */ 2085 bool amdgpu_dpm_is_temp_metrics_supported(struct amdgpu_device *adev, 2086 enum smu_temp_metric_type type) 2087 { 2088 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 2089 bool support_temp_metrics = false; 2090 2091 if (!pp_funcs->temp_metrics_is_supported) 2092 return support_temp_metrics; 2093 2094 if (is_support_sw_smu(adev)) { 2095 mutex_lock(&adev->pm.mutex); 2096 support_temp_metrics = 2097 pp_funcs->temp_metrics_is_supported(adev->powerplay.pp_handle, type); 2098 mutex_unlock(&adev->pm.mutex); 2099 } 2100 2101 return support_temp_metrics; 2102 } 2103 2104 /** 2105 * amdgpu_dpm_get_npm_cap - Return NPM sysfs capability bitmap 2106 * @adev: Pointer to the device. 2107 * 2108 * Two bits per field (R then W). Both 0 means the field is unsupported. 2109 * 2110 * Return: Capability bitmap, or 0 if NPM is not supported. 2111 */ 2112 u64 amdgpu_dpm_get_npm_cap(struct amdgpu_device *adev) 2113 { 2114 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 2115 u64 cap = 0; 2116 2117 if (!pp_funcs || !pp_funcs->get_npm_cap) 2118 return 0; 2119 2120 mutex_lock(&adev->pm.mutex); 2121 cap = pp_funcs->get_npm_cap(adev->powerplay.pp_handle); 2122 mutex_unlock(&adev->pm.mutex); 2123 2124 return cap; 2125 } 2126 2127 /** 2128 * amdgpu_dpm_get_xcp_metrics - Retrieve metrics for a specific compute 2129 * partition 2130 * @adev: Pointer to the device. 2131 * @xcp_id: Identifier of the XCP for which metrics are to be retrieved. 2132 * @table: Pointer to a buffer where the metrics will be stored. If NULL, the 2133 * function returns the size of the metrics structure. 2134 * 2135 * This function retrieves metrics for a specific XCP, including details such as 2136 * VCN/JPEG activity, clock frequencies, and other performance metrics. If the 2137 * table parameter is NULL, the function returns the size of the metrics 2138 * structure without populating it. 2139 * 2140 * Return: Size of the metrics structure on success, or a negative error code on failure. 2141 */ 2142 ssize_t amdgpu_dpm_get_xcp_metrics(struct amdgpu_device *adev, int xcp_id, 2143 void *table) 2144 { 2145 const struct amd_pm_funcs *pp_funcs = adev->powerplay.pp_funcs; 2146 int ret = 0; 2147 2148 if (!pp_funcs->get_xcp_metrics) 2149 return 0; 2150 2151 mutex_lock(&adev->pm.mutex); 2152 ret = pp_funcs->get_xcp_metrics(adev->powerplay.pp_handle, xcp_id, 2153 table); 2154 mutex_unlock(&adev->pm.mutex); 2155 2156 return ret; 2157 } 2158