1 /* 2 * Copyright 2015 Advanced Micro Devices, Inc. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included in 12 * all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 * 22 */ 23 #include "pp_debug.h" 24 #include <linux/types.h> 25 #include <linux/kernel.h> 26 #include <linux/slab.h> 27 #include <linux/pci.h> 28 29 #include <drm/amdgpu_drm.h> 30 #include "processpptables.h" 31 #include <atom-types.h> 32 #include <atombios.h> 33 #include "pptable.h" 34 #include "power_state.h" 35 #include "hwmgr.h" 36 #include "hardwaremanager.h" 37 38 39 #define SIZE_OF_ATOM_PPLIB_EXTENDEDHEADER_V2 12 40 #define SIZE_OF_ATOM_PPLIB_EXTENDEDHEADER_V3 14 41 #define SIZE_OF_ATOM_PPLIB_EXTENDEDHEADER_V4 16 42 #define SIZE_OF_ATOM_PPLIB_EXTENDEDHEADER_V5 18 43 #define SIZE_OF_ATOM_PPLIB_EXTENDEDHEADER_V6 20 44 #define SIZE_OF_ATOM_PPLIB_EXTENDEDHEADER_V7 22 45 #define SIZE_OF_ATOM_PPLIB_EXTENDEDHEADER_V8 24 46 #define SIZE_OF_ATOM_PPLIB_EXTENDEDHEADER_V9 26 47 48 #define NUM_BITS_CLOCK_INFO_ARRAY_INDEX 6 49 50 static uint16_t get_vce_table_offset(struct pp_hwmgr *hwmgr, 51 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 52 { 53 uint16_t vce_table_offset = 0; 54 55 if (le16_to_cpu(powerplay_table->usTableSize) >= 56 sizeof(ATOM_PPLIB_POWERPLAYTABLE3)) { 57 const ATOM_PPLIB_POWERPLAYTABLE3 *powerplay_table3 = 58 (const ATOM_PPLIB_POWERPLAYTABLE3 *)powerplay_table; 59 60 if (powerplay_table3->usExtendendedHeaderOffset > 0) { 61 const ATOM_PPLIB_EXTENDEDHEADER *extended_header = 62 (const ATOM_PPLIB_EXTENDEDHEADER *) 63 (((unsigned long)powerplay_table3) + 64 le16_to_cpu(powerplay_table3->usExtendendedHeaderOffset)); 65 if (le16_to_cpu(extended_header->usSize) >= 66 SIZE_OF_ATOM_PPLIB_EXTENDEDHEADER_V2) 67 vce_table_offset = le16_to_cpu(extended_header->usVCETableOffset); 68 } 69 } 70 71 return vce_table_offset; 72 } 73 74 static uint16_t get_vce_clock_info_array_offset(struct pp_hwmgr *hwmgr, 75 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 76 { 77 uint16_t table_offset = get_vce_table_offset(hwmgr, 78 powerplay_table); 79 80 if (table_offset > 0) 81 return table_offset + 1; 82 83 return 0; 84 } 85 86 static uint16_t get_vce_clock_info_array_size(struct pp_hwmgr *hwmgr, 87 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 88 { 89 uint16_t table_offset = get_vce_clock_info_array_offset(hwmgr, 90 powerplay_table); 91 uint16_t table_size = 0; 92 93 if (table_offset > 0) { 94 const VCEClockInfoArray *p = (const VCEClockInfoArray *) 95 (((unsigned long) powerplay_table) + table_offset); 96 table_size = sizeof(uint8_t) + p->ucNumEntries * sizeof(VCEClockInfo); 97 } 98 99 return table_size; 100 } 101 102 static uint16_t get_vce_clock_voltage_limit_table_offset(struct pp_hwmgr *hwmgr, 103 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 104 { 105 uint16_t table_offset = get_vce_clock_info_array_offset(hwmgr, 106 powerplay_table); 107 108 if (table_offset > 0) 109 return table_offset + get_vce_clock_info_array_size(hwmgr, 110 powerplay_table); 111 112 return 0; 113 } 114 115 static uint16_t get_vce_clock_voltage_limit_table_size(struct pp_hwmgr *hwmgr, 116 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 117 { 118 uint16_t table_offset = get_vce_clock_voltage_limit_table_offset(hwmgr, powerplay_table); 119 uint16_t table_size = 0; 120 121 if (table_offset > 0) { 122 const ATOM_PPLIB_VCE_Clock_Voltage_Limit_Table *ptable = 123 (const ATOM_PPLIB_VCE_Clock_Voltage_Limit_Table *)(((unsigned long) powerplay_table) + table_offset); 124 125 table_size = sizeof(uint8_t) + ptable->numEntries * sizeof(ATOM_PPLIB_VCE_Clock_Voltage_Limit_Record); 126 } 127 return table_size; 128 } 129 130 static uint16_t get_vce_state_table_offset(struct pp_hwmgr *hwmgr, const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 131 { 132 uint16_t table_offset = get_vce_clock_voltage_limit_table_offset(hwmgr, powerplay_table); 133 134 if (table_offset > 0) 135 return table_offset + get_vce_clock_voltage_limit_table_size(hwmgr, powerplay_table); 136 137 return 0; 138 } 139 140 static const ATOM_PPLIB_VCE_State_Table *get_vce_state_table( 141 struct pp_hwmgr *hwmgr, 142 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 143 { 144 uint16_t table_offset = get_vce_state_table_offset(hwmgr, powerplay_table); 145 146 if (table_offset > 0) 147 return (const ATOM_PPLIB_VCE_State_Table *)(((unsigned long) powerplay_table) + table_offset); 148 149 return NULL; 150 } 151 152 static uint16_t get_uvd_table_offset(struct pp_hwmgr *hwmgr, 153 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 154 { 155 uint16_t uvd_table_offset = 0; 156 157 if (le16_to_cpu(powerplay_table->usTableSize) >= 158 sizeof(ATOM_PPLIB_POWERPLAYTABLE3)) { 159 const ATOM_PPLIB_POWERPLAYTABLE3 *powerplay_table3 = 160 (const ATOM_PPLIB_POWERPLAYTABLE3 *)powerplay_table; 161 if (powerplay_table3->usExtendendedHeaderOffset > 0) { 162 const ATOM_PPLIB_EXTENDEDHEADER *extended_header = 163 (const ATOM_PPLIB_EXTENDEDHEADER *) 164 (((unsigned long)powerplay_table3) + 165 le16_to_cpu(powerplay_table3->usExtendendedHeaderOffset)); 166 if (le16_to_cpu(extended_header->usSize) >= 167 SIZE_OF_ATOM_PPLIB_EXTENDEDHEADER_V3) 168 uvd_table_offset = le16_to_cpu(extended_header->usUVDTableOffset); 169 } 170 } 171 return uvd_table_offset; 172 } 173 174 static uint16_t get_uvd_clock_info_array_offset(struct pp_hwmgr *hwmgr, 175 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 176 { 177 uint16_t table_offset = get_uvd_table_offset(hwmgr, 178 powerplay_table); 179 180 if (table_offset > 0) 181 return table_offset + 1; 182 return 0; 183 } 184 185 static uint16_t get_uvd_clock_info_array_size(struct pp_hwmgr *hwmgr, 186 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 187 { 188 uint16_t table_offset = get_uvd_clock_info_array_offset(hwmgr, 189 powerplay_table); 190 uint16_t table_size = 0; 191 192 if (table_offset > 0) { 193 const UVDClockInfoArray *p = (const UVDClockInfoArray *) 194 (((unsigned long) powerplay_table) 195 + table_offset); 196 table_size = sizeof(UCHAR) + 197 p->ucNumEntries * sizeof(UVDClockInfo); 198 } 199 200 return table_size; 201 } 202 203 static uint16_t get_uvd_clock_voltage_limit_table_offset( 204 struct pp_hwmgr *hwmgr, 205 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 206 { 207 uint16_t table_offset = get_uvd_clock_info_array_offset(hwmgr, 208 powerplay_table); 209 210 if (table_offset > 0) 211 return table_offset + 212 get_uvd_clock_info_array_size(hwmgr, powerplay_table); 213 214 return 0; 215 } 216 217 static uint16_t get_samu_table_offset(struct pp_hwmgr *hwmgr, 218 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 219 { 220 uint16_t samu_table_offset = 0; 221 222 if (le16_to_cpu(powerplay_table->usTableSize) >= 223 sizeof(ATOM_PPLIB_POWERPLAYTABLE3)) { 224 const ATOM_PPLIB_POWERPLAYTABLE3 *powerplay_table3 = 225 (const ATOM_PPLIB_POWERPLAYTABLE3 *)powerplay_table; 226 if (powerplay_table3->usExtendendedHeaderOffset > 0) { 227 const ATOM_PPLIB_EXTENDEDHEADER *extended_header = 228 (const ATOM_PPLIB_EXTENDEDHEADER *) 229 (((unsigned long)powerplay_table3) + 230 le16_to_cpu(powerplay_table3->usExtendendedHeaderOffset)); 231 if (le16_to_cpu(extended_header->usSize) >= 232 SIZE_OF_ATOM_PPLIB_EXTENDEDHEADER_V4) 233 samu_table_offset = le16_to_cpu(extended_header->usSAMUTableOffset); 234 } 235 } 236 237 return samu_table_offset; 238 } 239 240 static uint16_t get_samu_clock_voltage_limit_table_offset( 241 struct pp_hwmgr *hwmgr, 242 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 243 { 244 uint16_t table_offset = get_samu_table_offset(hwmgr, 245 powerplay_table); 246 247 if (table_offset > 0) 248 return table_offset + 1; 249 250 return 0; 251 } 252 253 static uint16_t get_acp_table_offset(struct pp_hwmgr *hwmgr, 254 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 255 { 256 uint16_t acp_table_offset = 0; 257 258 if (le16_to_cpu(powerplay_table->usTableSize) >= 259 sizeof(ATOM_PPLIB_POWERPLAYTABLE3)) { 260 const ATOM_PPLIB_POWERPLAYTABLE3 *powerplay_table3 = 261 (const ATOM_PPLIB_POWERPLAYTABLE3 *)powerplay_table; 262 if (powerplay_table3->usExtendendedHeaderOffset > 0) { 263 const ATOM_PPLIB_EXTENDEDHEADER *pExtendedHeader = 264 (const ATOM_PPLIB_EXTENDEDHEADER *) 265 (((unsigned long)powerplay_table3) + 266 le16_to_cpu(powerplay_table3->usExtendendedHeaderOffset)); 267 if (le16_to_cpu(pExtendedHeader->usSize) >= 268 SIZE_OF_ATOM_PPLIB_EXTENDEDHEADER_V6) 269 acp_table_offset = le16_to_cpu(pExtendedHeader->usACPTableOffset); 270 } 271 } 272 273 return acp_table_offset; 274 } 275 276 static uint16_t get_acp_clock_voltage_limit_table_offset( 277 struct pp_hwmgr *hwmgr, 278 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 279 { 280 uint16_t tableOffset = get_acp_table_offset(hwmgr, powerplay_table); 281 282 if (tableOffset > 0) 283 return tableOffset + 1; 284 285 return 0; 286 } 287 288 static uint16_t get_cacp_tdp_table_offset( 289 struct pp_hwmgr *hwmgr, 290 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 291 { 292 uint16_t cacTdpTableOffset = 0; 293 294 if (le16_to_cpu(powerplay_table->usTableSize) >= 295 sizeof(ATOM_PPLIB_POWERPLAYTABLE3)) { 296 const ATOM_PPLIB_POWERPLAYTABLE3 *powerplay_table3 = 297 (const ATOM_PPLIB_POWERPLAYTABLE3 *)powerplay_table; 298 if (powerplay_table3->usExtendendedHeaderOffset > 0) { 299 const ATOM_PPLIB_EXTENDEDHEADER *pExtendedHeader = 300 (const ATOM_PPLIB_EXTENDEDHEADER *) 301 (((unsigned long)powerplay_table3) + 302 le16_to_cpu(powerplay_table3->usExtendendedHeaderOffset)); 303 if (le16_to_cpu(pExtendedHeader->usSize) >= 304 SIZE_OF_ATOM_PPLIB_EXTENDEDHEADER_V7) 305 cacTdpTableOffset = le16_to_cpu(pExtendedHeader->usPowerTuneTableOffset); 306 } 307 } 308 309 return cacTdpTableOffset; 310 } 311 312 static int get_cac_tdp_table(struct pp_hwmgr *hwmgr, 313 struct phm_cac_tdp_table **ptable, 314 const ATOM_PowerTune_Table *table, 315 uint16_t us_maximum_power_delivery_limit) 316 { 317 unsigned long table_size; 318 struct phm_cac_tdp_table *tdp_table; 319 320 table_size = sizeof(unsigned long) + sizeof(struct phm_cac_tdp_table); 321 322 tdp_table = kzalloc(table_size, GFP_KERNEL); 323 if (NULL == tdp_table) 324 return -ENOMEM; 325 326 tdp_table->usTDP = le16_to_cpu(table->usTDP); 327 tdp_table->usConfigurableTDP = le16_to_cpu(table->usConfigurableTDP); 328 tdp_table->usTDC = le16_to_cpu(table->usTDC); 329 tdp_table->usBatteryPowerLimit = le16_to_cpu(table->usBatteryPowerLimit); 330 tdp_table->usSmallPowerLimit = le16_to_cpu(table->usSmallPowerLimit); 331 tdp_table->usLowCACLeakage = le16_to_cpu(table->usLowCACLeakage); 332 tdp_table->usHighCACLeakage = le16_to_cpu(table->usHighCACLeakage); 333 tdp_table->usMaximumPowerDeliveryLimit = us_maximum_power_delivery_limit; 334 335 *ptable = tdp_table; 336 337 return 0; 338 } 339 340 static uint16_t get_sclk_vdd_gfx_table_offset(struct pp_hwmgr *hwmgr, 341 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 342 { 343 uint16_t sclk_vdd_gfx_table_offset = 0; 344 345 if (le16_to_cpu(powerplay_table->usTableSize) >= 346 sizeof(ATOM_PPLIB_POWERPLAYTABLE3)) { 347 const ATOM_PPLIB_POWERPLAYTABLE3 *powerplay_table3 = 348 (const ATOM_PPLIB_POWERPLAYTABLE3 *)powerplay_table; 349 if (powerplay_table3->usExtendendedHeaderOffset > 0) { 350 const ATOM_PPLIB_EXTENDEDHEADER *pExtendedHeader = 351 (const ATOM_PPLIB_EXTENDEDHEADER *) 352 (((unsigned long)powerplay_table3) + 353 le16_to_cpu(powerplay_table3->usExtendendedHeaderOffset)); 354 if (le16_to_cpu(pExtendedHeader->usSize) >= 355 SIZE_OF_ATOM_PPLIB_EXTENDEDHEADER_V8) 356 sclk_vdd_gfx_table_offset = 357 le16_to_cpu(pExtendedHeader->usSclkVddgfxTableOffset); 358 } 359 } 360 361 return sclk_vdd_gfx_table_offset; 362 } 363 364 static uint16_t get_sclk_vdd_gfx_clock_voltage_dependency_table_offset( 365 struct pp_hwmgr *hwmgr, 366 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 367 { 368 uint16_t tableOffset = get_sclk_vdd_gfx_table_offset(hwmgr, powerplay_table); 369 370 if (tableOffset > 0) 371 return tableOffset; 372 373 return 0; 374 } 375 376 377 static int get_clock_voltage_dependency_table(struct pp_hwmgr *hwmgr, 378 struct phm_clock_voltage_dependency_table **ptable, 379 const ATOM_PPLIB_Clock_Voltage_Dependency_Table *table) 380 { 381 382 unsigned long i; 383 struct phm_clock_voltage_dependency_table *dep_table; 384 385 dep_table = kzalloc(struct_size(dep_table, entries, table->ucNumEntries), 386 GFP_KERNEL); 387 if (NULL == dep_table) 388 return -ENOMEM; 389 390 dep_table->count = (unsigned long)table->ucNumEntries; 391 392 for (i = 0; i < dep_table->count; i++) { 393 dep_table->entries[i].clk = 394 ((unsigned long)table->entries[i].ucClockHigh << 16) | 395 le16_to_cpu(table->entries[i].usClockLow); 396 dep_table->entries[i].v = 397 (unsigned long)le16_to_cpu(table->entries[i].usVoltage); 398 } 399 400 *ptable = dep_table; 401 402 return 0; 403 } 404 405 static int get_valid_clk(struct pp_hwmgr *hwmgr, 406 struct phm_clock_array **ptable, 407 const struct phm_clock_voltage_dependency_table *table) 408 { 409 unsigned long i; 410 struct phm_clock_array *clock_table; 411 412 clock_table = kzalloc(struct_size(clock_table, values, table->count), GFP_KERNEL); 413 if (!clock_table) 414 return -ENOMEM; 415 416 clock_table->count = (unsigned long)table->count; 417 418 for (i = 0; i < clock_table->count; i++) 419 clock_table->values[i] = (unsigned long)table->entries[i].clk; 420 421 *ptable = clock_table; 422 423 return 0; 424 } 425 426 static int get_clock_voltage_limit(struct pp_hwmgr *hwmgr, 427 struct phm_clock_and_voltage_limits *limits, 428 const ATOM_PPLIB_Clock_Voltage_Limit_Table *table) 429 { 430 limits->sclk = ((unsigned long)table->entries[0].ucSclkHigh << 16) | 431 le16_to_cpu(table->entries[0].usSclkLow); 432 limits->mclk = ((unsigned long)table->entries[0].ucMclkHigh << 16) | 433 le16_to_cpu(table->entries[0].usMclkLow); 434 limits->vddc = (unsigned long)le16_to_cpu(table->entries[0].usVddc); 435 limits->vddci = (unsigned long)le16_to_cpu(table->entries[0].usVddci); 436 437 return 0; 438 } 439 440 441 static void set_hw_cap(struct pp_hwmgr *hwmgr, bool enable, 442 enum phm_platform_caps cap) 443 { 444 if (enable) 445 phm_cap_set(hwmgr->platform_descriptor.platformCaps, cap); 446 else 447 phm_cap_unset(hwmgr->platform_descriptor.platformCaps, cap); 448 } 449 450 static int set_platform_caps(struct pp_hwmgr *hwmgr, 451 unsigned long powerplay_caps) 452 { 453 set_hw_cap( 454 hwmgr, 455 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_POWERPLAY), 456 PHM_PlatformCaps_PowerPlaySupport 457 ); 458 459 set_hw_cap( 460 hwmgr, 461 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_SBIOSPOWERSOURCE), 462 PHM_PlatformCaps_BiosPowerSourceControl 463 ); 464 465 set_hw_cap( 466 hwmgr, 467 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_ASPM_L0s), 468 PHM_PlatformCaps_EnableASPML0s 469 ); 470 471 set_hw_cap( 472 hwmgr, 473 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_ASPM_L1), 474 PHM_PlatformCaps_EnableASPML1 475 ); 476 477 set_hw_cap( 478 hwmgr, 479 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_BACKBIAS), 480 PHM_PlatformCaps_EnableBackbias 481 ); 482 483 set_hw_cap( 484 hwmgr, 485 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_HARDWAREDC), 486 PHM_PlatformCaps_AutomaticDCTransition 487 ); 488 489 set_hw_cap( 490 hwmgr, 491 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_GEMINIPRIMARY), 492 PHM_PlatformCaps_GeminiPrimary 493 ); 494 495 set_hw_cap( 496 hwmgr, 497 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_STEPVDDC), 498 PHM_PlatformCaps_StepVddc 499 ); 500 501 set_hw_cap( 502 hwmgr, 503 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_VOLTAGECONTROL), 504 PHM_PlatformCaps_EnableVoltageControl 505 ); 506 507 set_hw_cap( 508 hwmgr, 509 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_SIDEPORTCONTROL), 510 PHM_PlatformCaps_EnableSideportControl 511 ); 512 513 set_hw_cap( 514 hwmgr, 515 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_TURNOFFPLL_ASPML1), 516 PHM_PlatformCaps_TurnOffPll_ASPML1 517 ); 518 519 set_hw_cap( 520 hwmgr, 521 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_HTLINKCONTROL), 522 PHM_PlatformCaps_EnableHTLinkControl 523 ); 524 525 set_hw_cap( 526 hwmgr, 527 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_MVDDCONTROL), 528 PHM_PlatformCaps_EnableMVDDControl 529 ); 530 531 set_hw_cap( 532 hwmgr, 533 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_VDDCI_CONTROL), 534 PHM_PlatformCaps_ControlVDDCI 535 ); 536 537 set_hw_cap( 538 hwmgr, 539 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_REGULATOR_HOT), 540 PHM_PlatformCaps_RegulatorHot 541 ); 542 543 set_hw_cap( 544 hwmgr, 545 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_GOTO_BOOT_ON_ALERT), 546 PHM_PlatformCaps_BootStateOnAlert 547 ); 548 549 set_hw_cap( 550 hwmgr, 551 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_DONT_WAIT_FOR_VBLANK_ON_ALERT), 552 PHM_PlatformCaps_DontWaitForVBlankOnAlert 553 ); 554 555 set_hw_cap( 556 hwmgr, 557 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_BACO), 558 PHM_PlatformCaps_BACO 559 ); 560 561 set_hw_cap( 562 hwmgr, 563 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_NEW_CAC_VOLTAGE), 564 PHM_PlatformCaps_NewCACVoltage 565 ); 566 567 set_hw_cap( 568 hwmgr, 569 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_REVERT_GPIO5_POLARITY), 570 PHM_PlatformCaps_RevertGPIO5Polarity 571 ); 572 573 set_hw_cap( 574 hwmgr, 575 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_OUTPUT_THERMAL2GPIO17), 576 PHM_PlatformCaps_Thermal2GPIO17 577 ); 578 579 set_hw_cap( 580 hwmgr, 581 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_VRHOT_GPIO_CONFIGURABLE), 582 PHM_PlatformCaps_VRHotGPIOConfigurable 583 ); 584 585 set_hw_cap( 586 hwmgr, 587 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_TEMP_INVERSION), 588 PHM_PlatformCaps_TempInversion 589 ); 590 591 set_hw_cap( 592 hwmgr, 593 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_EVV), 594 PHM_PlatformCaps_EVV 595 ); 596 597 set_hw_cap( 598 hwmgr, 599 0 != (powerplay_caps & ATOM_PP_PLATFORM_COMBINE_PCC_WITH_THERMAL_SIGNAL), 600 PHM_PlatformCaps_CombinePCCWithThermalSignal 601 ); 602 603 set_hw_cap( 604 hwmgr, 605 0 != (powerplay_caps & ATOM_PP_PLATFORM_LOAD_POST_PRODUCTION_FIRMWARE), 606 PHM_PlatformCaps_LoadPostProductionFirmware 607 ); 608 609 set_hw_cap( 610 hwmgr, 611 0 != (powerplay_caps & ATOM_PP_PLATFORM_CAP_DISABLE_USING_ACTUAL_TEMPERATURE_FOR_POWER_CALC), 612 PHM_PlatformCaps_DisableUsingActualTemperatureForPowerCalc 613 ); 614 615 return 0; 616 } 617 618 static PP_StateClassificationFlags make_classification_flags( 619 struct pp_hwmgr *hwmgr, 620 USHORT classification, 621 USHORT classification2) 622 { 623 PP_StateClassificationFlags result = 0; 624 625 if (classification & ATOM_PPLIB_CLASSIFICATION_BOOT) 626 result |= PP_StateClassificationFlag_Boot; 627 628 if (classification & ATOM_PPLIB_CLASSIFICATION_THERMAL) 629 result |= PP_StateClassificationFlag_Thermal; 630 631 if (classification & 632 ATOM_PPLIB_CLASSIFICATION_LIMITEDPOWERSOURCE) 633 result |= PP_StateClassificationFlag_LimitedPowerSource; 634 635 if (classification & ATOM_PPLIB_CLASSIFICATION_REST) 636 result |= PP_StateClassificationFlag_Rest; 637 638 if (classification & ATOM_PPLIB_CLASSIFICATION_FORCED) 639 result |= PP_StateClassificationFlag_Forced; 640 641 if (classification & ATOM_PPLIB_CLASSIFICATION_3DPERFORMANCE) 642 result |= PP_StateClassificationFlag_3DPerformance; 643 644 645 if (classification & ATOM_PPLIB_CLASSIFICATION_OVERDRIVETEMPLATE) 646 result |= PP_StateClassificationFlag_ACOverdriveTemplate; 647 648 if (classification & ATOM_PPLIB_CLASSIFICATION_UVDSTATE) 649 result |= PP_StateClassificationFlag_Uvd; 650 651 if (classification & ATOM_PPLIB_CLASSIFICATION_HDSTATE) 652 result |= PP_StateClassificationFlag_UvdHD; 653 654 if (classification & ATOM_PPLIB_CLASSIFICATION_SDSTATE) 655 result |= PP_StateClassificationFlag_UvdSD; 656 657 if (classification & ATOM_PPLIB_CLASSIFICATION_HD2STATE) 658 result |= PP_StateClassificationFlag_HD2; 659 660 if (classification & ATOM_PPLIB_CLASSIFICATION_ACPI) 661 result |= PP_StateClassificationFlag_ACPI; 662 663 if (classification2 & ATOM_PPLIB_CLASSIFICATION2_LIMITEDPOWERSOURCE_2) 664 result |= PP_StateClassificationFlag_LimitedPowerSource_2; 665 666 667 if (classification2 & ATOM_PPLIB_CLASSIFICATION2_ULV) 668 result |= PP_StateClassificationFlag_ULV; 669 670 if (classification2 & ATOM_PPLIB_CLASSIFICATION2_MVC) 671 result |= PP_StateClassificationFlag_UvdMVC; 672 673 return result; 674 } 675 676 static int init_non_clock_fields(struct pp_hwmgr *hwmgr, 677 struct pp_power_state *ps, 678 uint8_t version, 679 const ATOM_PPLIB_NONCLOCK_INFO *pnon_clock_info) { 680 unsigned long rrr_index; 681 unsigned long tmp; 682 683 ps->classification.ui_label = (le16_to_cpu(pnon_clock_info->usClassification) & 684 ATOM_PPLIB_CLASSIFICATION_UI_MASK) >> ATOM_PPLIB_CLASSIFICATION_UI_SHIFT; 685 ps->classification.flags = make_classification_flags(hwmgr, 686 le16_to_cpu(pnon_clock_info->usClassification), 687 le16_to_cpu(pnon_clock_info->usClassification2)); 688 689 ps->classification.temporary_state = false; 690 ps->classification.to_be_deleted = false; 691 tmp = le32_to_cpu(pnon_clock_info->ulCapsAndSettings) & 692 ATOM_PPLIB_SINGLE_DISPLAY_ONLY; 693 694 ps->validation.singleDisplayOnly = (0 != tmp); 695 696 tmp = le32_to_cpu(pnon_clock_info->ulCapsAndSettings) & 697 ATOM_PPLIB_DISALLOW_ON_DC; 698 699 ps->validation.disallowOnDC = (0 != tmp); 700 701 ps->pcie.lanes = ((le32_to_cpu(pnon_clock_info->ulCapsAndSettings) & 702 ATOM_PPLIB_PCIE_LINK_WIDTH_MASK) >> 703 ATOM_PPLIB_PCIE_LINK_WIDTH_SHIFT) + 1; 704 705 ps->pcie.lanes = 0; 706 707 ps->display.disableFrameModulation = false; 708 709 rrr_index = (le32_to_cpu(pnon_clock_info->ulCapsAndSettings) & 710 ATOM_PPLIB_LIMITED_REFRESHRATE_VALUE_MASK) >> 711 ATOM_PPLIB_LIMITED_REFRESHRATE_VALUE_SHIFT; 712 713 if (rrr_index != ATOM_PPLIB_LIMITED_REFRESHRATE_UNLIMITED) { 714 static const uint8_t look_up[(ATOM_PPLIB_LIMITED_REFRESHRATE_VALUE_MASK >> ATOM_PPLIB_LIMITED_REFRESHRATE_VALUE_SHIFT) + 1] = \ 715 { 0, 50, 0 }; 716 717 ps->display.refreshrateSource = PP_RefreshrateSource_Explicit; 718 ps->display.explicitRefreshrate = look_up[rrr_index]; 719 ps->display.limitRefreshrate = true; 720 721 if (ps->display.explicitRefreshrate == 0) 722 ps->display.limitRefreshrate = false; 723 } else 724 ps->display.limitRefreshrate = false; 725 726 tmp = le32_to_cpu(pnon_clock_info->ulCapsAndSettings) & 727 ATOM_PPLIB_ENABLE_VARIBRIGHT; 728 729 ps->display.enableVariBright = (0 != tmp); 730 731 tmp = le32_to_cpu(pnon_clock_info->ulCapsAndSettings) & 732 ATOM_PPLIB_SWSTATE_MEMORY_DLL_OFF; 733 734 ps->memory.dllOff = (0 != tmp); 735 736 ps->memory.m3arb = (le32_to_cpu(pnon_clock_info->ulCapsAndSettings) & 737 ATOM_PPLIB_M3ARB_MASK) >> ATOM_PPLIB_M3ARB_SHIFT; 738 739 ps->temperatures.min = PP_TEMPERATURE_UNITS_PER_CENTIGRADES * 740 pnon_clock_info->ucMinTemperature; 741 742 ps->temperatures.max = PP_TEMPERATURE_UNITS_PER_CENTIGRADES * 743 pnon_clock_info->ucMaxTemperature; 744 745 tmp = le32_to_cpu(pnon_clock_info->ulCapsAndSettings) & 746 ATOM_PPLIB_SOFTWARE_DISABLE_LOADBALANCING; 747 748 ps->software.disableLoadBalancing = tmp; 749 750 tmp = le32_to_cpu(pnon_clock_info->ulCapsAndSettings) & 751 ATOM_PPLIB_SOFTWARE_ENABLE_SLEEP_FOR_TIMESTAMPS; 752 753 ps->software.enableSleepForTimestamps = (0 != tmp); 754 755 ps->validation.supportedPowerLevels = pnon_clock_info->ucRequiredPower; 756 757 if (ATOM_PPLIB_NONCLOCKINFO_VER1 < version) { 758 ps->uvd_clocks.VCLK = le32_to_cpu(pnon_clock_info->ulVCLK); 759 ps->uvd_clocks.DCLK = le32_to_cpu(pnon_clock_info->ulDCLK); 760 } else { 761 ps->uvd_clocks.VCLK = 0; 762 ps->uvd_clocks.DCLK = 0; 763 } 764 765 return 0; 766 } 767 768 static ULONG size_of_entry_v2(ULONG num_dpm_levels) 769 { 770 return (sizeof(UCHAR) + sizeof(UCHAR) + 771 (num_dpm_levels * sizeof(UCHAR))); 772 } 773 774 static const ATOM_PPLIB_STATE_V2 *get_state_entry_v2( 775 const StateArray * pstate_arrays, 776 ULONG entry_index) 777 { 778 ULONG i; 779 const ATOM_PPLIB_STATE_V2 *pstate; 780 781 pstate = pstate_arrays->states; 782 if (entry_index <= pstate_arrays->ucNumEntries) { 783 for (i = 0; i < entry_index; i++) 784 pstate = (ATOM_PPLIB_STATE_V2 *)( 785 (unsigned long)pstate + 786 size_of_entry_v2(pstate->ucNumDPMLevels)); 787 } 788 return pstate; 789 } 790 791 static const unsigned char soft_dummy_pp_table[] = { 792 0xe1, 0x01, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x00, 0x4a, 0x00, 0x6c, 0x00, 0x00, 793 0x00, 0x00, 0x00, 0x42, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 794 0x00, 0x4e, 0x00, 0x88, 0x00, 0x00, 0x9e, 0x00, 0x17, 0x00, 0x00, 0x00, 0x9e, 0x00, 0x00, 0x00, 795 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 796 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 797 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 798 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x18, 0x05, 0x00, 799 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 800 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 801 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 802 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe1, 0x00, 0x43, 0x01, 0x00, 0x00, 0x00, 0x00, 803 0x8e, 0x01, 0x00, 0x00, 0xb8, 0x01, 0x00, 0x00, 0x08, 0x30, 0x75, 0x00, 0x80, 0x00, 0xa0, 0x8c, 804 0x00, 0x7e, 0x00, 0x71, 0xa5, 0x00, 0x7c, 0x00, 0xe5, 0xc8, 0x00, 0x70, 0x00, 0x91, 0xf4, 0x00, 805 0x64, 0x00, 0x40, 0x19, 0x01, 0x5a, 0x00, 0x0e, 0x28, 0x01, 0x52, 0x00, 0x80, 0x38, 0x01, 0x4a, 806 0x00, 0x00, 0x09, 0x30, 0x75, 0x00, 0x30, 0x75, 0x00, 0x40, 0x9c, 0x00, 0x40, 0x9c, 0x00, 0x59, 807 0xd8, 0x00, 0x59, 0xd8, 0x00, 0x91, 0xf4, 0x00, 0x91, 0xf4, 0x00, 0x0e, 0x28, 0x01, 0x0e, 0x28, 808 0x01, 0x90, 0x5f, 0x01, 0x90, 0x5f, 0x01, 0x00, 0x77, 0x01, 0x00, 0x77, 0x01, 0xca, 0x91, 0x01, 809 0xca, 0x91, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x80, 0x00, 0x00, 0x7e, 0x00, 0x01, 810 0x7c, 0x00, 0x02, 0x70, 0x00, 0x03, 0x64, 0x00, 0x04, 0x5a, 0x00, 0x05, 0x52, 0x00, 0x06, 0x4a, 811 0x00, 0x07, 0x08, 0x08, 0x00, 0x08, 0x00, 0x01, 0x02, 0x02, 0x02, 0x01, 0x02, 0x02, 0x02, 0x03, 812 0x02, 0x04, 0x02, 0x00, 0x08, 0x40, 0x9c, 0x00, 0x30, 0x75, 0x00, 0x74, 0xb5, 0x00, 0xa0, 0x8c, 813 0x00, 0x60, 0xea, 0x00, 0x74, 0xb5, 0x00, 0x0e, 0x28, 0x01, 0x60, 0xea, 0x00, 0x90, 0x5f, 0x01, 814 0x40, 0x19, 0x01, 0xb2, 0xb0, 0x01, 0x90, 0x5f, 0x01, 0xc0, 0xd4, 0x01, 0x00, 0x77, 0x01, 0x5e, 815 0xff, 0x01, 0xca, 0x91, 0x01, 0x08, 0x80, 0x00, 0x00, 0x7e, 0x00, 0x01, 0x7c, 0x00, 0x02, 0x70, 816 0x00, 0x03, 0x64, 0x00, 0x04, 0x5a, 0x00, 0x05, 0x52, 0x00, 0x06, 0x4a, 0x00, 0x07, 0x00, 0x08, 817 0x80, 0x00, 0x30, 0x75, 0x00, 0x7e, 0x00, 0x40, 0x9c, 0x00, 0x7c, 0x00, 0x59, 0xd8, 0x00, 0x70, 818 0x00, 0xdc, 0x0b, 0x01, 0x64, 0x00, 0x80, 0x38, 0x01, 0x5a, 0x00, 0x80, 0x38, 0x01, 0x52, 0x00, 819 0x80, 0x38, 0x01, 0x4a, 0x00, 0x80, 0x38, 0x01, 0x08, 0x30, 0x75, 0x00, 0x80, 0x00, 0xa0, 0x8c, 820 0x00, 0x7e, 0x00, 0x71, 0xa5, 0x00, 0x7c, 0x00, 0xe5, 0xc8, 0x00, 0x74, 0x00, 0x91, 0xf4, 0x00, 821 0x66, 0x00, 0x40, 0x19, 0x01, 0x58, 0x00, 0x0e, 0x28, 0x01, 0x52, 0x00, 0x80, 0x38, 0x01, 0x4a, 822 0x00 823 }; 824 825 static const ATOM_PPLIB_POWERPLAYTABLE *get_powerplay_table( 826 struct pp_hwmgr *hwmgr) 827 { 828 const void *table_addr = hwmgr->soft_pp_table; 829 uint8_t frev, crev; 830 uint16_t size; 831 832 if (!table_addr) { 833 if (hwmgr->chip_id == CHIP_RAVEN) { 834 table_addr = &soft_dummy_pp_table[0]; 835 hwmgr->soft_pp_table = &soft_dummy_pp_table[0]; 836 hwmgr->soft_pp_table_size = sizeof(soft_dummy_pp_table); 837 } else { 838 table_addr = smu_atom_get_data_table(hwmgr->adev, 839 GetIndexIntoMasterTable(DATA, PowerPlayInfo), 840 &size, &frev, &crev); 841 hwmgr->soft_pp_table = table_addr; 842 hwmgr->soft_pp_table_size = size; 843 } 844 } 845 846 return (const ATOM_PPLIB_POWERPLAYTABLE *)table_addr; 847 } 848 849 int pp_tables_get_response_times(struct pp_hwmgr *hwmgr, 850 uint32_t *vol_rep_time, uint32_t *bb_rep_time) 851 { 852 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_tab = get_powerplay_table(hwmgr); 853 854 PP_ASSERT_WITH_CODE(NULL != powerplay_tab, 855 "Missing PowerPlay Table!", return -EINVAL); 856 857 *vol_rep_time = (uint32_t)le16_to_cpu(powerplay_tab->usVoltageTime); 858 *bb_rep_time = (uint32_t)le16_to_cpu(powerplay_tab->usBackbiasTime); 859 860 return 0; 861 } 862 863 int pp_tables_get_num_of_entries(struct pp_hwmgr *hwmgr, 864 unsigned long *num_of_entries) 865 { 866 const StateArray *pstate_arrays; 867 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table = get_powerplay_table(hwmgr); 868 869 if (powerplay_table == NULL) 870 return -1; 871 872 if (powerplay_table->sHeader.ucTableFormatRevision >= 6) { 873 pstate_arrays = (StateArray *)(((unsigned long)powerplay_table) + 874 le16_to_cpu(powerplay_table->usStateArrayOffset)); 875 876 *num_of_entries = (unsigned long)(pstate_arrays->ucNumEntries); 877 } else 878 *num_of_entries = (unsigned long)(powerplay_table->ucNumStates); 879 880 return 0; 881 } 882 883 int pp_tables_get_entry(struct pp_hwmgr *hwmgr, 884 unsigned long entry_index, 885 struct pp_power_state *ps, 886 pp_tables_hw_clock_info_callback func) 887 { 888 int i; 889 const StateArray *pstate_arrays; 890 const ATOM_PPLIB_STATE_V2 *pstate_entry_v2; 891 const ATOM_PPLIB_NONCLOCK_INFO *pnon_clock_info; 892 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table = get_powerplay_table(hwmgr); 893 int result = 0; 894 int res = 0; 895 896 const ClockInfoArray *pclock_arrays; 897 898 const NonClockInfoArray *pnon_clock_arrays; 899 900 const ATOM_PPLIB_STATE *pstate_entry; 901 902 if (powerplay_table == NULL) 903 return -1; 904 905 ps->classification.bios_index = entry_index; 906 907 if (powerplay_table->sHeader.ucTableFormatRevision >= 6) { 908 pstate_arrays = (StateArray *)(((unsigned long)powerplay_table) + 909 le16_to_cpu(powerplay_table->usStateArrayOffset)); 910 911 if (entry_index > pstate_arrays->ucNumEntries) 912 return -1; 913 914 pstate_entry_v2 = get_state_entry_v2(pstate_arrays, entry_index); 915 pclock_arrays = (ClockInfoArray *)(((unsigned long)powerplay_table) + 916 le16_to_cpu(powerplay_table->usClockInfoArrayOffset)); 917 918 pnon_clock_arrays = (NonClockInfoArray *)(((unsigned long)powerplay_table) + 919 le16_to_cpu(powerplay_table->usNonClockInfoArrayOffset)); 920 921 pnon_clock_info = (ATOM_PPLIB_NONCLOCK_INFO *)((unsigned long)(pnon_clock_arrays->nonClockInfo) + 922 (pstate_entry_v2->nonClockInfoIndex * pnon_clock_arrays->ucEntrySize)); 923 924 result = init_non_clock_fields(hwmgr, ps, pnon_clock_arrays->ucEntrySize, pnon_clock_info); 925 926 for (i = 0; i < pstate_entry_v2->ucNumDPMLevels; i++) { 927 const void *pclock_info = (const void *)( 928 (unsigned long)(pclock_arrays->clockInfo) + 929 (pstate_entry_v2->clockInfoIndex[i] * pclock_arrays->ucEntrySize)); 930 res = func(hwmgr, &ps->hardware, i, pclock_info); 931 if ((0 == result) && (0 != res)) 932 result = res; 933 } 934 } else { 935 if (entry_index > powerplay_table->ucNumStates) 936 return -1; 937 938 pstate_entry = (ATOM_PPLIB_STATE *)((unsigned long)powerplay_table + 939 le16_to_cpu(powerplay_table->usStateArrayOffset) + 940 entry_index * powerplay_table->ucStateEntrySize); 941 942 pnon_clock_info = (ATOM_PPLIB_NONCLOCK_INFO *)((unsigned long)powerplay_table + 943 le16_to_cpu(powerplay_table->usNonClockInfoArrayOffset) + 944 pstate_entry->ucNonClockStateIndex * 945 powerplay_table->ucNonClockSize); 946 947 result = init_non_clock_fields(hwmgr, ps, 948 powerplay_table->ucNonClockSize, 949 pnon_clock_info); 950 951 for (i = 0; i < powerplay_table->ucStateEntrySize-1; i++) { 952 const void *pclock_info = (const void *)((unsigned long)powerplay_table + 953 le16_to_cpu(powerplay_table->usClockInfoArrayOffset) + 954 pstate_entry->ucClockStateIndices[i] * 955 powerplay_table->ucClockInfoSize); 956 957 int res = func(hwmgr, &ps->hardware, i, pclock_info); 958 959 if ((0 == result) && (0 != res)) 960 result = res; 961 } 962 } 963 964 if ((0 == result) && (0 != (ps->classification.flags & PP_StateClassificationFlag_Boot))) { 965 if (hwmgr->chip_family < AMDGPU_FAMILY_RV) 966 result = hwmgr->hwmgr_func->patch_boot_state(hwmgr, &(ps->hardware)); 967 } 968 969 return result; 970 } 971 972 static int init_powerplay_tables( 973 struct pp_hwmgr *hwmgr, 974 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table 975 ) 976 { 977 return 0; 978 } 979 980 981 static int init_thermal_controller( 982 struct pp_hwmgr *hwmgr, 983 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 984 { 985 struct amdgpu_device *adev = hwmgr->adev; 986 987 hwmgr->thermal_controller.ucType = 988 powerplay_table->sThermalController.ucType; 989 hwmgr->thermal_controller.ucI2cLine = 990 powerplay_table->sThermalController.ucI2cLine; 991 hwmgr->thermal_controller.ucI2cAddress = 992 powerplay_table->sThermalController.ucI2cAddress; 993 994 hwmgr->thermal_controller.fanInfo.bNoFan = 995 (0 != (powerplay_table->sThermalController.ucFanParameters & 996 ATOM_PP_FANPARAMETERS_NOFAN)); 997 998 hwmgr->thermal_controller.fanInfo.ucTachometerPulsesPerRevolution = 999 powerplay_table->sThermalController.ucFanParameters & 1000 ATOM_PP_FANPARAMETERS_TACHOMETER_PULSES_PER_REVOLUTION_MASK; 1001 1002 hwmgr->thermal_controller.fanInfo.ulMinRPM 1003 = powerplay_table->sThermalController.ucFanMinRPM * 100UL; 1004 hwmgr->thermal_controller.fanInfo.ulMaxRPM 1005 = powerplay_table->sThermalController.ucFanMaxRPM * 100UL; 1006 1007 set_hw_cap(hwmgr, 1008 ATOM_PP_THERMALCONTROLLER_NONE != hwmgr->thermal_controller.ucType, 1009 PHM_PlatformCaps_ThermalController); 1010 1011 if (powerplay_table->usTableSize >= sizeof(ATOM_PPLIB_POWERPLAYTABLE3)) { 1012 const ATOM_PPLIB_POWERPLAYTABLE3 *powerplay_table3 = 1013 (const ATOM_PPLIB_POWERPLAYTABLE3 *)powerplay_table; 1014 1015 if (0 == le16_to_cpu(powerplay_table3->usFanTableOffset)) { 1016 hwmgr->thermal_controller.use_hw_fan_control = 1; 1017 return 0; 1018 } else { 1019 const ATOM_PPLIB_FANTABLE *fan_table = 1020 (const ATOM_PPLIB_FANTABLE *)(((unsigned long)powerplay_table) + 1021 le16_to_cpu(powerplay_table3->usFanTableOffset)); 1022 1023 if (1 <= fan_table->ucFanTableFormat) { 1024 hwmgr->thermal_controller.advanceFanControlParameters.ucTHyst = 1025 fan_table->ucTHyst; 1026 hwmgr->thermal_controller.advanceFanControlParameters.usTMin = 1027 le16_to_cpu(fan_table->usTMin); 1028 hwmgr->thermal_controller.advanceFanControlParameters.usTMed = 1029 le16_to_cpu(fan_table->usTMed); 1030 hwmgr->thermal_controller.advanceFanControlParameters.usTHigh = 1031 le16_to_cpu(fan_table->usTHigh); 1032 hwmgr->thermal_controller.advanceFanControlParameters.usPWMMin = 1033 le16_to_cpu(fan_table->usPWMMin); 1034 hwmgr->thermal_controller.advanceFanControlParameters.usPWMMed = 1035 le16_to_cpu(fan_table->usPWMMed); 1036 hwmgr->thermal_controller.advanceFanControlParameters.usPWMHigh = 1037 le16_to_cpu(fan_table->usPWMHigh); 1038 hwmgr->thermal_controller.advanceFanControlParameters.usTMax = 10900; 1039 hwmgr->thermal_controller.advanceFanControlParameters.ulCycleDelay = 100000; 1040 1041 phm_cap_set(hwmgr->platform_descriptor.platformCaps, 1042 PHM_PlatformCaps_MicrocodeFanControl); 1043 } 1044 1045 if (2 <= fan_table->ucFanTableFormat) { 1046 const ATOM_PPLIB_FANTABLE2 *fan_table2 = 1047 (const ATOM_PPLIB_FANTABLE2 *)(((unsigned long)powerplay_table) + 1048 le16_to_cpu(powerplay_table3->usFanTableOffset)); 1049 hwmgr->thermal_controller.advanceFanControlParameters.usTMax = 1050 le16_to_cpu(fan_table2->usTMax); 1051 } 1052 1053 if (3 <= fan_table->ucFanTableFormat) { 1054 const ATOM_PPLIB_FANTABLE3 *fan_table3 = 1055 (const ATOM_PPLIB_FANTABLE3 *) (((unsigned long)powerplay_table) + 1056 le16_to_cpu(powerplay_table3->usFanTableOffset)); 1057 1058 hwmgr->thermal_controller.advanceFanControlParameters.ucFanControlMode = 1059 fan_table3->ucFanControlMode; 1060 1061 if ((3 == fan_table->ucFanTableFormat) && 1062 (0x67B1 == adev->pdev->device)) 1063 hwmgr->thermal_controller.advanceFanControlParameters.usDefaultMaxFanPWM = 1064 47; 1065 else 1066 hwmgr->thermal_controller.advanceFanControlParameters.usDefaultMaxFanPWM = 1067 le16_to_cpu(fan_table3->usFanPWMMax); 1068 1069 hwmgr->thermal_controller.advanceFanControlParameters.usDefaultFanOutputSensitivity = 1070 4836; 1071 hwmgr->thermal_controller.advanceFanControlParameters.usFanOutputSensitivity = 1072 le16_to_cpu(fan_table3->usFanOutputSensitivity); 1073 } 1074 1075 if (6 <= fan_table->ucFanTableFormat) { 1076 const ATOM_PPLIB_FANTABLE4 *fan_table4 = 1077 (const ATOM_PPLIB_FANTABLE4 *)(((unsigned long)powerplay_table) + 1078 le16_to_cpu(powerplay_table3->usFanTableOffset)); 1079 1080 phm_cap_set(hwmgr->platform_descriptor.platformCaps, 1081 PHM_PlatformCaps_FanSpeedInTableIsRPM); 1082 1083 hwmgr->thermal_controller.advanceFanControlParameters.usDefaultMaxFanRPM = 1084 le16_to_cpu(fan_table4->usFanRPMMax); 1085 } 1086 1087 if (7 <= fan_table->ucFanTableFormat) { 1088 const ATOM_PPLIB_FANTABLE5 *fan_table5 = 1089 (const ATOM_PPLIB_FANTABLE5 *)(((unsigned long)powerplay_table) + 1090 le16_to_cpu(powerplay_table3->usFanTableOffset)); 1091 1092 if (0x67A2 == adev->pdev->device || 1093 0x67A9 == adev->pdev->device || 1094 0x67B9 == adev->pdev->device) { 1095 phm_cap_set(hwmgr->platform_descriptor.platformCaps, 1096 PHM_PlatformCaps_GeminiRegulatorFanControlSupport); 1097 hwmgr->thermal_controller.advanceFanControlParameters.usFanCurrentLow = 1098 le16_to_cpu(fan_table5->usFanCurrentLow); 1099 hwmgr->thermal_controller.advanceFanControlParameters.usFanCurrentHigh = 1100 le16_to_cpu(fan_table5->usFanCurrentHigh); 1101 hwmgr->thermal_controller.advanceFanControlParameters.usFanRPMLow = 1102 le16_to_cpu(fan_table5->usFanRPMLow); 1103 hwmgr->thermal_controller.advanceFanControlParameters.usFanRPMHigh = 1104 le16_to_cpu(fan_table5->usFanRPMHigh); 1105 } 1106 } 1107 } 1108 } 1109 1110 return 0; 1111 } 1112 1113 static int init_overdrive_limits_V1_4(struct pp_hwmgr *hwmgr, 1114 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table, 1115 const ATOM_FIRMWARE_INFO_V1_4 *fw_info) 1116 { 1117 hwmgr->platform_descriptor.overdriveLimit.engineClock = 1118 le32_to_cpu(fw_info->ulASICMaxEngineClock); 1119 1120 hwmgr->platform_descriptor.overdriveLimit.memoryClock = 1121 le32_to_cpu(fw_info->ulASICMaxMemoryClock); 1122 1123 hwmgr->platform_descriptor.maxOverdriveVDDC = 1124 le32_to_cpu(fw_info->ul3DAccelerationEngineClock) & 0x7FF; 1125 1126 hwmgr->platform_descriptor.minOverdriveVDDC = 1127 le16_to_cpu(fw_info->usBootUpVDDCVoltage); 1128 1129 hwmgr->platform_descriptor.maxOverdriveVDDC = 1130 le16_to_cpu(fw_info->usBootUpVDDCVoltage); 1131 1132 hwmgr->platform_descriptor.overdriveVDDCStep = 0; 1133 return 0; 1134 } 1135 1136 static int init_overdrive_limits_V2_1(struct pp_hwmgr *hwmgr, 1137 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table, 1138 const ATOM_FIRMWARE_INFO_V2_1 *fw_info) 1139 { 1140 const ATOM_PPLIB_POWERPLAYTABLE3 *powerplay_table3; 1141 const ATOM_PPLIB_EXTENDEDHEADER *header; 1142 1143 if (le16_to_cpu(powerplay_table->usTableSize) < 1144 sizeof(ATOM_PPLIB_POWERPLAYTABLE3)) 1145 return 0; 1146 1147 powerplay_table3 = (const ATOM_PPLIB_POWERPLAYTABLE3 *)powerplay_table; 1148 1149 if (0 == powerplay_table3->usExtendendedHeaderOffset) 1150 return 0; 1151 1152 header = (ATOM_PPLIB_EXTENDEDHEADER *)(((unsigned long) powerplay_table) + 1153 le16_to_cpu(powerplay_table3->usExtendendedHeaderOffset)); 1154 1155 hwmgr->platform_descriptor.overdriveLimit.engineClock = le32_to_cpu(header->ulMaxEngineClock); 1156 hwmgr->platform_descriptor.overdriveLimit.memoryClock = le32_to_cpu(header->ulMaxMemoryClock); 1157 1158 1159 hwmgr->platform_descriptor.minOverdriveVDDC = 0; 1160 hwmgr->platform_descriptor.maxOverdriveVDDC = 0; 1161 hwmgr->platform_descriptor.overdriveVDDCStep = 0; 1162 1163 return 0; 1164 } 1165 1166 static int init_overdrive_limits(struct pp_hwmgr *hwmgr, 1167 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 1168 { 1169 int result = 0; 1170 uint8_t frev, crev; 1171 uint16_t size; 1172 1173 const ATOM_COMMON_TABLE_HEADER *fw_info = NULL; 1174 1175 hwmgr->platform_descriptor.overdriveLimit.engineClock = 0; 1176 hwmgr->platform_descriptor.overdriveLimit.memoryClock = 0; 1177 hwmgr->platform_descriptor.minOverdriveVDDC = 0; 1178 hwmgr->platform_descriptor.maxOverdriveVDDC = 0; 1179 hwmgr->platform_descriptor.overdriveVDDCStep = 0; 1180 1181 if (hwmgr->chip_id == CHIP_RAVEN) 1182 return 0; 1183 1184 /* We assume here that fw_info is unchanged if this call fails.*/ 1185 fw_info = smu_atom_get_data_table(hwmgr->adev, 1186 GetIndexIntoMasterTable(DATA, FirmwareInfo), 1187 &size, &frev, &crev); 1188 1189 if ((fw_info->ucTableFormatRevision == 1) 1190 && (le16_to_cpu(fw_info->usStructureSize) >= sizeof(ATOM_FIRMWARE_INFO_V1_4))) 1191 result = init_overdrive_limits_V1_4(hwmgr, 1192 powerplay_table, 1193 (const ATOM_FIRMWARE_INFO_V1_4 *)fw_info); 1194 1195 else if ((fw_info->ucTableFormatRevision == 2) 1196 && (le16_to_cpu(fw_info->usStructureSize) >= sizeof(ATOM_FIRMWARE_INFO_V2_1))) 1197 result = init_overdrive_limits_V2_1(hwmgr, 1198 powerplay_table, 1199 (const ATOM_FIRMWARE_INFO_V2_1 *)fw_info); 1200 1201 return result; 1202 } 1203 1204 static int get_uvd_clock_voltage_limit_table(struct pp_hwmgr *hwmgr, 1205 struct phm_uvd_clock_voltage_dependency_table **ptable, 1206 const ATOM_PPLIB_UVD_Clock_Voltage_Limit_Table *table, 1207 const UVDClockInfoArray *array) 1208 { 1209 unsigned long i; 1210 struct phm_uvd_clock_voltage_dependency_table *uvd_table; 1211 1212 uvd_table = kzalloc(struct_size(uvd_table, entries, table->numEntries), 1213 GFP_KERNEL); 1214 if (!uvd_table) 1215 return -ENOMEM; 1216 1217 uvd_table->count = table->numEntries; 1218 1219 for (i = 0; i < table->numEntries; i++) { 1220 const UVDClockInfo *entry = 1221 &array->entries[table->entries[i].ucUVDClockInfoIndex]; 1222 uvd_table->entries[i].v = (unsigned long)le16_to_cpu(table->entries[i].usVoltage); 1223 uvd_table->entries[i].vclk = ((unsigned long)entry->ucVClkHigh << 16) 1224 | le16_to_cpu(entry->usVClkLow); 1225 uvd_table->entries[i].dclk = ((unsigned long)entry->ucDClkHigh << 16) 1226 | le16_to_cpu(entry->usDClkLow); 1227 } 1228 1229 *ptable = uvd_table; 1230 1231 return 0; 1232 } 1233 1234 static int get_vce_clock_voltage_limit_table(struct pp_hwmgr *hwmgr, 1235 struct phm_vce_clock_voltage_dependency_table **ptable, 1236 const ATOM_PPLIB_VCE_Clock_Voltage_Limit_Table *table, 1237 const VCEClockInfoArray *array) 1238 { 1239 unsigned long i; 1240 struct phm_vce_clock_voltage_dependency_table *vce_table; 1241 1242 vce_table = kzalloc(struct_size(vce_table, entries, table->numEntries), 1243 GFP_KERNEL); 1244 if (!vce_table) 1245 return -ENOMEM; 1246 1247 vce_table->count = table->numEntries; 1248 for (i = 0; i < table->numEntries; i++) { 1249 const VCEClockInfo *entry = &array->entries[table->entries[i].ucVCEClockInfoIndex]; 1250 1251 vce_table->entries[i].v = (unsigned long)le16_to_cpu(table->entries[i].usVoltage); 1252 vce_table->entries[i].evclk = ((unsigned long)entry->ucEVClkHigh << 16) 1253 | le16_to_cpu(entry->usEVClkLow); 1254 vce_table->entries[i].ecclk = ((unsigned long)entry->ucECClkHigh << 16) 1255 | le16_to_cpu(entry->usECClkLow); 1256 } 1257 1258 *ptable = vce_table; 1259 1260 return 0; 1261 } 1262 1263 static int get_samu_clock_voltage_limit_table(struct pp_hwmgr *hwmgr, 1264 struct phm_samu_clock_voltage_dependency_table **ptable, 1265 const ATOM_PPLIB_SAMClk_Voltage_Limit_Table *table) 1266 { 1267 unsigned long i; 1268 struct phm_samu_clock_voltage_dependency_table *samu_table; 1269 1270 samu_table = kzalloc(struct_size(samu_table, entries, table->numEntries), 1271 GFP_KERNEL); 1272 if (!samu_table) 1273 return -ENOMEM; 1274 1275 samu_table->count = table->numEntries; 1276 1277 for (i = 0; i < table->numEntries; i++) { 1278 samu_table->entries[i].v = (unsigned long)le16_to_cpu(table->entries[i].usVoltage); 1279 samu_table->entries[i].samclk = ((unsigned long)table->entries[i].ucSAMClockHigh << 16) 1280 | le16_to_cpu(table->entries[i].usSAMClockLow); 1281 } 1282 1283 *ptable = samu_table; 1284 1285 return 0; 1286 } 1287 1288 static int get_acp_clock_voltage_limit_table(struct pp_hwmgr *hwmgr, 1289 struct phm_acp_clock_voltage_dependency_table **ptable, 1290 const ATOM_PPLIB_ACPClk_Voltage_Limit_Table *table) 1291 { 1292 unsigned long i; 1293 struct phm_acp_clock_voltage_dependency_table *acp_table; 1294 1295 acp_table = kzalloc(struct_size(acp_table, entries, table->numEntries), 1296 GFP_KERNEL); 1297 if (!acp_table) 1298 return -ENOMEM; 1299 1300 acp_table->count = (unsigned long)table->numEntries; 1301 1302 for (i = 0; i < table->numEntries; i++) { 1303 acp_table->entries[i].v = (unsigned long)le16_to_cpu(table->entries[i].usVoltage); 1304 acp_table->entries[i].acpclk = ((unsigned long)table->entries[i].ucACPClockHigh << 16) 1305 | le16_to_cpu(table->entries[i].usACPClockLow); 1306 } 1307 1308 *ptable = acp_table; 1309 1310 return 0; 1311 } 1312 1313 static int init_clock_voltage_dependency(struct pp_hwmgr *hwmgr, 1314 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 1315 { 1316 ATOM_PPLIB_Clock_Voltage_Dependency_Table *table; 1317 ATOM_PPLIB_Clock_Voltage_Limit_Table *limit_table; 1318 int result = 0; 1319 1320 uint16_t vce_clock_info_array_offset; 1321 uint16_t uvd_clock_info_array_offset; 1322 uint16_t table_offset; 1323 1324 hwmgr->dyn_state.vddc_dependency_on_sclk = NULL; 1325 hwmgr->dyn_state.vddci_dependency_on_mclk = NULL; 1326 hwmgr->dyn_state.vddc_dependency_on_mclk = NULL; 1327 hwmgr->dyn_state.vddc_dep_on_dal_pwrl = NULL; 1328 hwmgr->dyn_state.mvdd_dependency_on_mclk = NULL; 1329 hwmgr->dyn_state.vce_clock_voltage_dependency_table = NULL; 1330 hwmgr->dyn_state.uvd_clock_voltage_dependency_table = NULL; 1331 hwmgr->dyn_state.samu_clock_voltage_dependency_table = NULL; 1332 hwmgr->dyn_state.acp_clock_voltage_dependency_table = NULL; 1333 hwmgr->dyn_state.ppm_parameter_table = NULL; 1334 hwmgr->dyn_state.vdd_gfx_dependency_on_sclk = NULL; 1335 1336 vce_clock_info_array_offset = get_vce_clock_info_array_offset( 1337 hwmgr, powerplay_table); 1338 table_offset = get_vce_clock_voltage_limit_table_offset(hwmgr, 1339 powerplay_table); 1340 if (vce_clock_info_array_offset > 0 && table_offset > 0) { 1341 const VCEClockInfoArray *array = (const VCEClockInfoArray *) 1342 (((unsigned long) powerplay_table) + 1343 vce_clock_info_array_offset); 1344 const ATOM_PPLIB_VCE_Clock_Voltage_Limit_Table *table = 1345 (const ATOM_PPLIB_VCE_Clock_Voltage_Limit_Table *) 1346 (((unsigned long) powerplay_table) + table_offset); 1347 result = get_vce_clock_voltage_limit_table(hwmgr, 1348 &hwmgr->dyn_state.vce_clock_voltage_dependency_table, 1349 table, array); 1350 } 1351 1352 uvd_clock_info_array_offset = get_uvd_clock_info_array_offset(hwmgr, powerplay_table); 1353 table_offset = get_uvd_clock_voltage_limit_table_offset(hwmgr, powerplay_table); 1354 1355 if (uvd_clock_info_array_offset > 0 && table_offset > 0) { 1356 const UVDClockInfoArray *array = (const UVDClockInfoArray *) 1357 (((unsigned long) powerplay_table) + 1358 uvd_clock_info_array_offset); 1359 const ATOM_PPLIB_UVD_Clock_Voltage_Limit_Table *ptable = 1360 (const ATOM_PPLIB_UVD_Clock_Voltage_Limit_Table *) 1361 (((unsigned long) powerplay_table) + table_offset); 1362 result = get_uvd_clock_voltage_limit_table(hwmgr, 1363 &hwmgr->dyn_state.uvd_clock_voltage_dependency_table, ptable, array); 1364 } 1365 1366 table_offset = get_samu_clock_voltage_limit_table_offset(hwmgr, 1367 powerplay_table); 1368 1369 if (table_offset > 0) { 1370 const ATOM_PPLIB_SAMClk_Voltage_Limit_Table *ptable = 1371 (const ATOM_PPLIB_SAMClk_Voltage_Limit_Table *) 1372 (((unsigned long) powerplay_table) + table_offset); 1373 result = get_samu_clock_voltage_limit_table(hwmgr, 1374 &hwmgr->dyn_state.samu_clock_voltage_dependency_table, ptable); 1375 } 1376 1377 table_offset = get_acp_clock_voltage_limit_table_offset(hwmgr, 1378 powerplay_table); 1379 1380 if (table_offset > 0) { 1381 const ATOM_PPLIB_ACPClk_Voltage_Limit_Table *ptable = 1382 (const ATOM_PPLIB_ACPClk_Voltage_Limit_Table *) 1383 (((unsigned long) powerplay_table) + table_offset); 1384 result = get_acp_clock_voltage_limit_table(hwmgr, 1385 &hwmgr->dyn_state.acp_clock_voltage_dependency_table, ptable); 1386 } 1387 1388 table_offset = get_cacp_tdp_table_offset(hwmgr, powerplay_table); 1389 if (table_offset > 0) { 1390 UCHAR rev_id = *(UCHAR *)(((unsigned long)powerplay_table) + table_offset); 1391 1392 if (rev_id > 0) { 1393 const ATOM_PPLIB_POWERTUNE_Table_V1 *tune_table = 1394 (const ATOM_PPLIB_POWERTUNE_Table_V1 *) 1395 (((unsigned long) powerplay_table) + table_offset); 1396 result = get_cac_tdp_table(hwmgr, &hwmgr->dyn_state.cac_dtp_table, 1397 &tune_table->power_tune_table, 1398 le16_to_cpu(tune_table->usMaximumPowerDeliveryLimit)); 1399 hwmgr->dyn_state.cac_dtp_table->usDefaultTargetOperatingTemp = 1400 le16_to_cpu(tune_table->usTjMax); 1401 } else { 1402 const ATOM_PPLIB_POWERTUNE_Table *tune_table = 1403 (const ATOM_PPLIB_POWERTUNE_Table *) 1404 (((unsigned long) powerplay_table) + table_offset); 1405 result = get_cac_tdp_table(hwmgr, 1406 &hwmgr->dyn_state.cac_dtp_table, 1407 &tune_table->power_tune_table, 255); 1408 } 1409 } 1410 1411 if (le16_to_cpu(powerplay_table->usTableSize) >= 1412 sizeof(ATOM_PPLIB_POWERPLAYTABLE4)) { 1413 const ATOM_PPLIB_POWERPLAYTABLE4 *powerplay_table4 = 1414 (const ATOM_PPLIB_POWERPLAYTABLE4 *)powerplay_table; 1415 if (0 != powerplay_table4->usVddcDependencyOnSCLKOffset) { 1416 table = (ATOM_PPLIB_Clock_Voltage_Dependency_Table *) 1417 (((unsigned long) powerplay_table4) + 1418 le16_to_cpu(powerplay_table4->usVddcDependencyOnSCLKOffset)); 1419 result = get_clock_voltage_dependency_table(hwmgr, 1420 &hwmgr->dyn_state.vddc_dependency_on_sclk, table); 1421 } 1422 1423 if (result == 0 && (0 != powerplay_table4->usVddciDependencyOnMCLKOffset)) { 1424 table = (ATOM_PPLIB_Clock_Voltage_Dependency_Table *) 1425 (((unsigned long) powerplay_table4) + 1426 le16_to_cpu(powerplay_table4->usVddciDependencyOnMCLKOffset)); 1427 result = get_clock_voltage_dependency_table(hwmgr, 1428 &hwmgr->dyn_state.vddci_dependency_on_mclk, table); 1429 } 1430 1431 if (result == 0 && (0 != powerplay_table4->usVddcDependencyOnMCLKOffset)) { 1432 table = (ATOM_PPLIB_Clock_Voltage_Dependency_Table *) 1433 (((unsigned long) powerplay_table4) + 1434 le16_to_cpu(powerplay_table4->usVddcDependencyOnMCLKOffset)); 1435 result = get_clock_voltage_dependency_table(hwmgr, 1436 &hwmgr->dyn_state.vddc_dependency_on_mclk, table); 1437 } 1438 1439 if (result == 0 && (0 != powerplay_table4->usMaxClockVoltageOnDCOffset)) { 1440 limit_table = (ATOM_PPLIB_Clock_Voltage_Limit_Table *) 1441 (((unsigned long) powerplay_table4) + 1442 le16_to_cpu(powerplay_table4->usMaxClockVoltageOnDCOffset)); 1443 result = get_clock_voltage_limit(hwmgr, 1444 &hwmgr->dyn_state.max_clock_voltage_on_dc, limit_table); 1445 } 1446 1447 if (result == 0 && (NULL != hwmgr->dyn_state.vddc_dependency_on_mclk) && 1448 (0 != hwmgr->dyn_state.vddc_dependency_on_mclk->count)) 1449 result = get_valid_clk(hwmgr, &hwmgr->dyn_state.valid_mclk_values, 1450 hwmgr->dyn_state.vddc_dependency_on_mclk); 1451 1452 if(result == 0 && (NULL != hwmgr->dyn_state.vddc_dependency_on_sclk) && 1453 (0 != hwmgr->dyn_state.vddc_dependency_on_sclk->count)) 1454 result = get_valid_clk(hwmgr, 1455 &hwmgr->dyn_state.valid_sclk_values, 1456 hwmgr->dyn_state.vddc_dependency_on_sclk); 1457 1458 if (result == 0 && (0 != powerplay_table4->usMvddDependencyOnMCLKOffset)) { 1459 table = (ATOM_PPLIB_Clock_Voltage_Dependency_Table *) 1460 (((unsigned long) powerplay_table4) + 1461 le16_to_cpu(powerplay_table4->usMvddDependencyOnMCLKOffset)); 1462 result = get_clock_voltage_dependency_table(hwmgr, 1463 &hwmgr->dyn_state.mvdd_dependency_on_mclk, table); 1464 } 1465 } 1466 1467 table_offset = get_sclk_vdd_gfx_clock_voltage_dependency_table_offset(hwmgr, 1468 powerplay_table); 1469 1470 if (table_offset > 0) { 1471 table = (ATOM_PPLIB_Clock_Voltage_Dependency_Table *) 1472 (((unsigned long) powerplay_table) + table_offset); 1473 result = get_clock_voltage_dependency_table(hwmgr, 1474 &hwmgr->dyn_state.vdd_gfx_dependency_on_sclk, table); 1475 } 1476 1477 return result; 1478 } 1479 1480 static int get_cac_leakage_table(struct pp_hwmgr *hwmgr, 1481 struct phm_cac_leakage_table **ptable, 1482 const ATOM_PPLIB_CAC_Leakage_Table *table) 1483 { 1484 struct phm_cac_leakage_table *cac_leakage_table; 1485 unsigned long i; 1486 1487 if (!hwmgr || !table || !ptable) 1488 return -EINVAL; 1489 1490 cac_leakage_table = kzalloc(struct_size(cac_leakage_table, entries, table->ucNumEntries), 1491 GFP_KERNEL); 1492 if (!cac_leakage_table) 1493 return -ENOMEM; 1494 1495 cac_leakage_table->count = (ULONG)table->ucNumEntries; 1496 1497 for (i = 0; i < cac_leakage_table->count; i++) { 1498 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps, 1499 PHM_PlatformCaps_EVV)) { 1500 cac_leakage_table->entries[i].Vddc1 = le16_to_cpu(table->entries[i].usVddc1); 1501 cac_leakage_table->entries[i].Vddc2 = le16_to_cpu(table->entries[i].usVddc2); 1502 cac_leakage_table->entries[i].Vddc3 = le16_to_cpu(table->entries[i].usVddc3); 1503 } else { 1504 cac_leakage_table->entries[i].Vddc = le16_to_cpu(table->entries[i].usVddc); 1505 cac_leakage_table->entries[i].Leakage = le32_to_cpu(table->entries[i].ulLeakageValue); 1506 } 1507 } 1508 1509 *ptable = cac_leakage_table; 1510 1511 return 0; 1512 } 1513 1514 static int get_platform_power_management_table(struct pp_hwmgr *hwmgr, 1515 ATOM_PPLIB_PPM_Table *atom_ppm_table) 1516 { 1517 struct phm_ppm_table *ptr = kzalloc(sizeof(struct phm_ppm_table), GFP_KERNEL); 1518 1519 if (NULL == ptr) 1520 return -ENOMEM; 1521 1522 ptr->ppm_design = atom_ppm_table->ucPpmDesign; 1523 ptr->cpu_core_number = le16_to_cpu(atom_ppm_table->usCpuCoreNumber); 1524 ptr->platform_tdp = le32_to_cpu(atom_ppm_table->ulPlatformTDP); 1525 ptr->small_ac_platform_tdp = le32_to_cpu(atom_ppm_table->ulSmallACPlatformTDP); 1526 ptr->platform_tdc = le32_to_cpu(atom_ppm_table->ulPlatformTDC); 1527 ptr->small_ac_platform_tdc = le32_to_cpu(atom_ppm_table->ulSmallACPlatformTDC); 1528 ptr->apu_tdp = le32_to_cpu(atom_ppm_table->ulApuTDP); 1529 ptr->dgpu_tdp = le32_to_cpu(atom_ppm_table->ulDGpuTDP); 1530 ptr->dgpu_ulv_power = le32_to_cpu(atom_ppm_table->ulDGpuUlvPower); 1531 ptr->tj_max = le32_to_cpu(atom_ppm_table->ulTjmax); 1532 hwmgr->dyn_state.ppm_parameter_table = ptr; 1533 1534 return 0; 1535 } 1536 1537 static int init_dpm2_parameters(struct pp_hwmgr *hwmgr, 1538 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 1539 { 1540 int result = 0; 1541 1542 if (le16_to_cpu(powerplay_table->usTableSize) >= 1543 sizeof(ATOM_PPLIB_POWERPLAYTABLE5)) { 1544 const ATOM_PPLIB_POWERPLAYTABLE5 *ptable5 = 1545 (const ATOM_PPLIB_POWERPLAYTABLE5 *)powerplay_table; 1546 const ATOM_PPLIB_POWERPLAYTABLE4 *ptable4 = 1547 (const ATOM_PPLIB_POWERPLAYTABLE4 *) 1548 (&ptable5->basicTable4); 1549 const ATOM_PPLIB_POWERPLAYTABLE3 *ptable3 = 1550 (const ATOM_PPLIB_POWERPLAYTABLE3 *) 1551 (&ptable4->basicTable3); 1552 const ATOM_PPLIB_EXTENDEDHEADER *extended_header; 1553 uint16_t table_offset; 1554 ATOM_PPLIB_PPM_Table *atom_ppm_table; 1555 1556 hwmgr->platform_descriptor.TDPLimit = le32_to_cpu(ptable5->ulTDPLimit); 1557 hwmgr->platform_descriptor.nearTDPLimit = le32_to_cpu(ptable5->ulNearTDPLimit); 1558 1559 hwmgr->platform_descriptor.TDPODLimit = le16_to_cpu(ptable5->usTDPODLimit); 1560 hwmgr->platform_descriptor.TDPAdjustment = 0; 1561 1562 hwmgr->platform_descriptor.VidAdjustment = 0; 1563 hwmgr->platform_descriptor.VidAdjustmentPolarity = 0; 1564 hwmgr->platform_descriptor.VidMinLimit = 0; 1565 hwmgr->platform_descriptor.VidMaxLimit = 1500000; 1566 hwmgr->platform_descriptor.VidStep = 6250; 1567 1568 hwmgr->platform_descriptor.nearTDPLimitAdjusted = le32_to_cpu(ptable5->ulNearTDPLimit); 1569 1570 if (hwmgr->platform_descriptor.TDPODLimit != 0) 1571 phm_cap_set(hwmgr->platform_descriptor.platformCaps, 1572 PHM_PlatformCaps_PowerControl); 1573 1574 hwmgr->platform_descriptor.SQRampingThreshold = le32_to_cpu(ptable5->ulSQRampingThreshold); 1575 1576 hwmgr->platform_descriptor.CACLeakage = le32_to_cpu(ptable5->ulCACLeakage); 1577 1578 hwmgr->dyn_state.cac_leakage_table = NULL; 1579 1580 if (0 != ptable5->usCACLeakageTableOffset) { 1581 const ATOM_PPLIB_CAC_Leakage_Table *pCAC_leakage_table = 1582 (ATOM_PPLIB_CAC_Leakage_Table *)(((unsigned long)ptable5) + 1583 le16_to_cpu(ptable5->usCACLeakageTableOffset)); 1584 result = get_cac_leakage_table(hwmgr, 1585 &hwmgr->dyn_state.cac_leakage_table, pCAC_leakage_table); 1586 } 1587 1588 hwmgr->platform_descriptor.LoadLineSlope = le16_to_cpu(ptable5->usLoadLineSlope); 1589 1590 hwmgr->dyn_state.ppm_parameter_table = NULL; 1591 1592 if (0 != ptable3->usExtendendedHeaderOffset) { 1593 extended_header = (const ATOM_PPLIB_EXTENDEDHEADER *) 1594 (((unsigned long)powerplay_table) + 1595 le16_to_cpu(ptable3->usExtendendedHeaderOffset)); 1596 if ((extended_header->usPPMTableOffset > 0) && 1597 le16_to_cpu(extended_header->usSize) >= 1598 SIZE_OF_ATOM_PPLIB_EXTENDEDHEADER_V5) { 1599 table_offset = le16_to_cpu(extended_header->usPPMTableOffset); 1600 atom_ppm_table = (ATOM_PPLIB_PPM_Table *) 1601 (((unsigned long)powerplay_table) + table_offset); 1602 if (0 == get_platform_power_management_table(hwmgr, atom_ppm_table)) 1603 phm_cap_set(hwmgr->platform_descriptor.platformCaps, 1604 PHM_PlatformCaps_EnablePlatformPowerManagement); 1605 } 1606 } 1607 } 1608 return result; 1609 } 1610 1611 static int init_phase_shedding_table(struct pp_hwmgr *hwmgr, 1612 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) 1613 { 1614 if (le16_to_cpu(powerplay_table->usTableSize) >= 1615 sizeof(ATOM_PPLIB_POWERPLAYTABLE4)) { 1616 const ATOM_PPLIB_POWERPLAYTABLE4 *powerplay_table4 = 1617 (const ATOM_PPLIB_POWERPLAYTABLE4 *)powerplay_table; 1618 1619 if (0 != powerplay_table4->usVddcPhaseShedLimitsTableOffset) { 1620 const ATOM_PPLIB_PhaseSheddingLimits_Table *ptable = 1621 (ATOM_PPLIB_PhaseSheddingLimits_Table *) 1622 (((unsigned long)powerplay_table4) + 1623 le16_to_cpu(powerplay_table4->usVddcPhaseShedLimitsTableOffset)); 1624 struct phm_phase_shedding_limits_table *table; 1625 unsigned long i; 1626 1627 1628 table = kzalloc(struct_size(table, entries, ptable->ucNumEntries), 1629 GFP_KERNEL); 1630 if (!table) 1631 return -ENOMEM; 1632 1633 table->count = (unsigned long)ptable->ucNumEntries; 1634 1635 for (i = 0; i < table->count; i++) { 1636 table->entries[i].Voltage = (unsigned long)le16_to_cpu(ptable->entries[i].usVoltage); 1637 table->entries[i].Sclk = ((unsigned long)ptable->entries[i].ucSclkHigh << 16) 1638 | le16_to_cpu(ptable->entries[i].usSclkLow); 1639 table->entries[i].Mclk = ((unsigned long)ptable->entries[i].ucMclkHigh << 16) 1640 | le16_to_cpu(ptable->entries[i].usMclkLow); 1641 } 1642 hwmgr->dyn_state.vddc_phase_shed_limits_table = table; 1643 } 1644 } 1645 1646 return 0; 1647 } 1648 1649 static int get_number_of_vce_state_table_entries( 1650 struct pp_hwmgr *hwmgr) 1651 { 1652 const ATOM_PPLIB_POWERPLAYTABLE *table = 1653 get_powerplay_table(hwmgr); 1654 const ATOM_PPLIB_VCE_State_Table *vce_table = 1655 get_vce_state_table(hwmgr, table); 1656 1657 if (vce_table) 1658 return vce_table->numEntries; 1659 1660 return 0; 1661 } 1662 1663 static int get_vce_state_table_entry(struct pp_hwmgr *hwmgr, 1664 unsigned long i, 1665 struct amd_vce_state *vce_state, 1666 void **clock_info, 1667 unsigned long *flag) 1668 { 1669 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table = get_powerplay_table(hwmgr); 1670 1671 const ATOM_PPLIB_VCE_State_Table *vce_state_table = get_vce_state_table(hwmgr, powerplay_table); 1672 1673 unsigned short vce_clock_info_array_offset = get_vce_clock_info_array_offset(hwmgr, powerplay_table); 1674 1675 const VCEClockInfoArray *vce_clock_info_array = (const VCEClockInfoArray *)(((unsigned long) powerplay_table) + vce_clock_info_array_offset); 1676 1677 const ClockInfoArray *clock_arrays = (ClockInfoArray *)(((unsigned long)powerplay_table) + 1678 le16_to_cpu(powerplay_table->usClockInfoArrayOffset)); 1679 1680 const ATOM_PPLIB_VCE_State_Record *record = &vce_state_table->entries[i]; 1681 1682 const VCEClockInfo *vce_clock_info = &vce_clock_info_array->entries[record->ucVCEClockInfoIndex]; 1683 1684 unsigned long clockInfoIndex = record->ucClockInfoIndex & 0x3F; 1685 1686 *flag = (record->ucClockInfoIndex >> NUM_BITS_CLOCK_INFO_ARRAY_INDEX); 1687 1688 vce_state->evclk = ((uint32_t)vce_clock_info->ucEVClkHigh << 16) | le16_to_cpu(vce_clock_info->usEVClkLow); 1689 vce_state->ecclk = ((uint32_t)vce_clock_info->ucECClkHigh << 16) | le16_to_cpu(vce_clock_info->usECClkLow); 1690 1691 *clock_info = (void *)((unsigned long)(clock_arrays->clockInfo) + (clockInfoIndex * clock_arrays->ucEntrySize)); 1692 1693 return 0; 1694 } 1695 1696 1697 static int pp_tables_initialize(struct pp_hwmgr *hwmgr) 1698 { 1699 int result; 1700 const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table; 1701 1702 if (hwmgr->chip_id == CHIP_RAVEN) 1703 return 0; 1704 1705 hwmgr->need_pp_table_upload = true; 1706 1707 powerplay_table = get_powerplay_table(hwmgr); 1708 1709 result = init_powerplay_tables(hwmgr, powerplay_table); 1710 1711 PP_ASSERT_WITH_CODE((result == 0), 1712 "init_powerplay_tables failed", return result); 1713 1714 result = set_platform_caps(hwmgr, 1715 le32_to_cpu(powerplay_table->ulPlatformCaps)); 1716 1717 PP_ASSERT_WITH_CODE((result == 0), 1718 "set_platform_caps failed", return result); 1719 1720 result = init_thermal_controller(hwmgr, powerplay_table); 1721 1722 PP_ASSERT_WITH_CODE((result == 0), 1723 "init_thermal_controller failed", return result); 1724 1725 result = init_overdrive_limits(hwmgr, powerplay_table); 1726 1727 PP_ASSERT_WITH_CODE((result == 0), 1728 "init_overdrive_limits failed", return result); 1729 1730 result = init_clock_voltage_dependency(hwmgr, 1731 powerplay_table); 1732 1733 PP_ASSERT_WITH_CODE((result == 0), 1734 "init_clock_voltage_dependency failed", return result); 1735 1736 result = init_dpm2_parameters(hwmgr, powerplay_table); 1737 1738 PP_ASSERT_WITH_CODE((result == 0), 1739 "init_dpm2_parameters failed", return result); 1740 1741 result = init_phase_shedding_table(hwmgr, powerplay_table); 1742 1743 PP_ASSERT_WITH_CODE((result == 0), 1744 "init_phase_shedding_table failed", return result); 1745 1746 return result; 1747 } 1748 1749 static int pp_tables_uninitialize(struct pp_hwmgr *hwmgr) 1750 { 1751 if (hwmgr->chip_id == CHIP_RAVEN) 1752 return 0; 1753 1754 kfree(hwmgr->dyn_state.vddc_dependency_on_sclk); 1755 hwmgr->dyn_state.vddc_dependency_on_sclk = NULL; 1756 1757 kfree(hwmgr->dyn_state.vddci_dependency_on_mclk); 1758 hwmgr->dyn_state.vddci_dependency_on_mclk = NULL; 1759 1760 kfree(hwmgr->dyn_state.vddc_dependency_on_mclk); 1761 hwmgr->dyn_state.vddc_dependency_on_mclk = NULL; 1762 1763 kfree(hwmgr->dyn_state.mvdd_dependency_on_mclk); 1764 hwmgr->dyn_state.mvdd_dependency_on_mclk = NULL; 1765 1766 kfree(hwmgr->dyn_state.valid_mclk_values); 1767 hwmgr->dyn_state.valid_mclk_values = NULL; 1768 1769 kfree(hwmgr->dyn_state.valid_sclk_values); 1770 hwmgr->dyn_state.valid_sclk_values = NULL; 1771 1772 kfree(hwmgr->dyn_state.cac_leakage_table); 1773 hwmgr->dyn_state.cac_leakage_table = NULL; 1774 1775 kfree(hwmgr->dyn_state.vddc_phase_shed_limits_table); 1776 hwmgr->dyn_state.vddc_phase_shed_limits_table = NULL; 1777 1778 kfree(hwmgr->dyn_state.vce_clock_voltage_dependency_table); 1779 hwmgr->dyn_state.vce_clock_voltage_dependency_table = NULL; 1780 1781 kfree(hwmgr->dyn_state.uvd_clock_voltage_dependency_table); 1782 hwmgr->dyn_state.uvd_clock_voltage_dependency_table = NULL; 1783 1784 kfree(hwmgr->dyn_state.samu_clock_voltage_dependency_table); 1785 hwmgr->dyn_state.samu_clock_voltage_dependency_table = NULL; 1786 1787 kfree(hwmgr->dyn_state.acp_clock_voltage_dependency_table); 1788 hwmgr->dyn_state.acp_clock_voltage_dependency_table = NULL; 1789 1790 kfree(hwmgr->dyn_state.cac_dtp_table); 1791 hwmgr->dyn_state.cac_dtp_table = NULL; 1792 1793 kfree(hwmgr->dyn_state.ppm_parameter_table); 1794 hwmgr->dyn_state.ppm_parameter_table = NULL; 1795 1796 kfree(hwmgr->dyn_state.vdd_gfx_dependency_on_sclk); 1797 hwmgr->dyn_state.vdd_gfx_dependency_on_sclk = NULL; 1798 1799 return 0; 1800 } 1801 1802 const struct pp_table_func pptable_funcs = { 1803 .pptable_init = pp_tables_initialize, 1804 .pptable_fini = pp_tables_uninitialize, 1805 .pptable_get_number_of_vce_state_table_entries = 1806 get_number_of_vce_state_table_entries, 1807 .pptable_get_vce_state_table_entry = 1808 get_vce_state_table_entry, 1809 }; 1810 1811