1 // SPDX-License-Identifier: MIT 2 3 // Copyright 2026 Advanced Micro Devices, Inc. 4 5 #include "reg_helper.h" 6 #include "core_types.h" 7 #include "dcn42_pg_cntl.h" 8 #include "dccg.h" 9 #include "resource.h" 10 11 #define TO_DCN_PG_CNTL(pg_cntl)\ 12 container_of(pg_cntl, struct dcn_pg_cntl, base) 13 14 #define REG(reg) \ 15 (pg_cntl_dcn->regs->reg) 16 17 #undef FN 18 #define FN(reg_name, field_name) \ 19 pg_cntl_dcn->pg_cntl_shift->field_name, pg_cntl_dcn->pg_cntl_mask->field_name 20 21 #define CTX \ 22 pg_cntl_dcn->base.ctx 23 #define DC_LOGGER \ 24 pg_cntl->ctx->logger 25 26 /* 27 * ONO PG Workoaround: Saved FGCG repeaters states captured before powering up an ONO 28 * domain so it can be restored once the domain is powered up. 29 */ 30 struct dcn42_global_fgcg_rep_state { 31 uint32_t dmu_rep_fgcg; 32 uint32_t dccg_global_ono_rep_fgcg; 33 uint32_t az_rep_fgcg; 34 }; 35 36 /* Save and disable FGCG repeaters before powering up the ONO domain. */ 37 static void pg_cntl42_save_and_disable_global_fgcg_rep(struct pg_cntl *pg_cntl, 38 struct dcn42_global_fgcg_rep_state *state) 39 { 40 struct dcn_pg_cntl *pg_cntl_dcn = TO_DCN_PG_CNTL(pg_cntl); 41 42 REG_GET(DMU_CLK_CNTL, LONO_FGCG_REP_DIS, &state->dmu_rep_fgcg); 43 if (pg_cntl->ctx->dc->res_pool->dccg->funcs->dccg_get_global_fgcg_status) 44 state->dccg_global_ono_rep_fgcg = pg_cntl->ctx->dc->res_pool->dccg->funcs->dccg_get_global_fgcg_status(pg_cntl->ctx->dc->res_pool->dccg); 45 REG_GET(AZ_CLOCK_CNTL, AZ_GLOBAL_FGCG_REP_DIS, &state->az_rep_fgcg); 46 47 REG_UPDATE(DMU_CLK_CNTL, LONO_FGCG_REP_DIS, 1); 48 if (pg_cntl->ctx->dc->res_pool->dccg->funcs->dccg_enable_global_fgcg) 49 pg_cntl->ctx->dc->res_pool->dccg->funcs->dccg_enable_global_fgcg(pg_cntl->ctx->dc->res_pool->dccg, false); 50 REG_UPDATE(AZ_CLOCK_CNTL, AZ_GLOBAL_FGCG_REP_DIS, 1); 51 } 52 53 /* Restore FGCG repeaters after the ONO domains are powered up. */ 54 static void pg_cntl42_restore_global_fgcg_rep(struct pg_cntl *pg_cntl, 55 struct dcn42_global_fgcg_rep_state *state) 56 { 57 struct dcn_pg_cntl *pg_cntl_dcn = TO_DCN_PG_CNTL(pg_cntl); 58 59 REG_UPDATE(DMU_CLK_CNTL, LONO_FGCG_REP_DIS, state->dmu_rep_fgcg); 60 if (pg_cntl->ctx->dc->res_pool->dccg->funcs->dccg_enable_global_fgcg) 61 pg_cntl->ctx->dc->res_pool->dccg->funcs->dccg_enable_global_fgcg(pg_cntl->ctx->dc->res_pool->dccg, state->dccg_global_ono_rep_fgcg); 62 REG_UPDATE(AZ_CLOCK_CNTL, AZ_GLOBAL_FGCG_REP_DIS, state->az_rep_fgcg); 63 } 64 65 static bool should_skip_pg_control(bool dc_in_idle_opt, bool power_on, bool block_enabled) 66 { 67 if (dc_in_idle_opt) 68 return true; 69 70 if (power_on && block_enabled) 71 return true; 72 73 if (!power_on && !block_enabled) 74 return true; 75 76 return false; 77 } 78 79 80 static bool pg_cntl42_dsc_pg_status(struct pg_cntl *pg_cntl, unsigned int dsc_inst) 81 { 82 struct dcn_pg_cntl *pg_cntl_dcn = TO_DCN_PG_CNTL(pg_cntl); 83 uint32_t pwr_status = 0; 84 85 switch (dsc_inst) { 86 case 0: /* DSC0 */ 87 REG_GET(DOMAIN16_PG_STATUS, DOMAIN_PGFSM_PWR_STATUS, &pwr_status); 88 break; 89 case 1: /* DSC1 */ 90 REG_GET(DOMAIN17_PG_STATUS, DOMAIN_PGFSM_PWR_STATUS, &pwr_status); 91 break; 92 case 2: /* DSC2 */ 93 REG_GET(DOMAIN18_PG_STATUS, DOMAIN_PGFSM_PWR_STATUS, &pwr_status); 94 break; 95 case 3: /* DSC3 */ 96 REG_GET(DOMAIN19_PG_STATUS, DOMAIN_PGFSM_PWR_STATUS, &pwr_status); 97 break; 98 default: 99 BREAK_TO_DEBUGGER(); 100 break; 101 } 102 103 return pwr_status == 0; 104 } 105 106 void pg_cntl42_dsc_pg_control(struct pg_cntl *pg_cntl, unsigned int dsc_inst, bool power_on) 107 { 108 struct dcn_pg_cntl *pg_cntl_dcn = TO_DCN_PG_CNTL(pg_cntl); 109 uint32_t power_gate = power_on ? 0 : 1; 110 uint32_t pwr_status = power_on ? 0 : 2; 111 uint32_t org_ip_request_cntl = 0; 112 struct dcn42_global_fgcg_rep_state fgcg_rep_state = {0}; 113 bool block_pg_disabled = pg_cntl->ctx->dc->debug.ignore_pg || pg_cntl->ctx->dc->debug.disable_dsc_power_gate; 114 115 if (block_pg_disabled && !power_on) 116 return; 117 118 bool block_enabled = pg_cntl42_dsc_pg_status(pg_cntl, dsc_inst); 119 if (should_skip_pg_control(pg_cntl->ctx->dc->idle_optimizations_allowed, power_on, block_enabled)) 120 return; 121 122 REG_GET(DC_IP_REQUEST_CNTL, IP_REQUEST_EN, &org_ip_request_cntl); 123 if (org_ip_request_cntl == 0) 124 REG_SET(DC_IP_REQUEST_CNTL, 0, IP_REQUEST_EN, 1); 125 126 if (power_on) 127 pg_cntl42_save_and_disable_global_fgcg_rep(pg_cntl, &fgcg_rep_state); 128 129 switch (dsc_inst) { 130 case 0: /* DSC0 */ 131 REG_UPDATE(DOMAIN16_PG_CONFIG, 132 DOMAIN_POWER_GATE, power_gate); 133 134 REG_WAIT(DOMAIN16_PG_STATUS, 135 DOMAIN_PGFSM_PWR_STATUS, pwr_status, 136 1, 1000); 137 break; 138 case 1: /* DSC1 */ 139 REG_UPDATE(DOMAIN17_PG_CONFIG, 140 DOMAIN_POWER_GATE, power_gate); 141 142 REG_WAIT(DOMAIN17_PG_STATUS, 143 DOMAIN_PGFSM_PWR_STATUS, pwr_status, 144 1, 1000); 145 break; 146 case 2: /* DSC2 */ 147 REG_UPDATE(DOMAIN18_PG_CONFIG, 148 DOMAIN_POWER_GATE, power_gate); 149 150 REG_WAIT(DOMAIN18_PG_STATUS, 151 DOMAIN_PGFSM_PWR_STATUS, pwr_status, 152 1, 1000); 153 break; 154 case 3: /* DSC3 */ 155 REG_UPDATE(DOMAIN19_PG_CONFIG, 156 DOMAIN_POWER_GATE, power_gate); 157 158 REG_WAIT(DOMAIN19_PG_STATUS, 159 DOMAIN_PGFSM_PWR_STATUS, pwr_status, 160 1, 1000); 161 break; 162 default: 163 BREAK_TO_DEBUGGER(); 164 break; 165 } 166 167 if (power_on) 168 pg_cntl42_restore_global_fgcg_rep(pg_cntl, &fgcg_rep_state); 169 170 if (dsc_inst < MAX_PIPES) 171 pg_cntl->pg_pipe_res_enable[PG_DSC][dsc_inst] = power_on; 172 } 173 174 static bool pg_cntl42_hubp_dpp_pg_status(struct pg_cntl *pg_cntl, unsigned int hubp_dpp_inst) 175 { 176 struct dcn_pg_cntl *pg_cntl_dcn = TO_DCN_PG_CNTL(pg_cntl); 177 uint32_t pwr_status = 0; 178 179 switch (hubp_dpp_inst) { 180 case 0: 181 /* DPP0 & HUBP0 */ 182 REG_GET(DOMAIN0_PG_STATUS, DOMAIN_PGFSM_PWR_STATUS, &pwr_status); 183 break; 184 case 1: 185 /* DPP1 & HUBP1 */ 186 REG_GET(DOMAIN1_PG_STATUS, DOMAIN_PGFSM_PWR_STATUS, &pwr_status); 187 break; 188 case 2: 189 /* DPP2 & HUBP2 */ 190 REG_GET(DOMAIN2_PG_STATUS, DOMAIN_PGFSM_PWR_STATUS, &pwr_status); 191 break; 192 case 3: 193 /* DPP3 & HUBP3 */ 194 REG_GET(DOMAIN3_PG_STATUS, DOMAIN_PGFSM_PWR_STATUS, &pwr_status); 195 break; 196 default: 197 BREAK_TO_DEBUGGER(); 198 break; 199 } 200 201 return pwr_status == 0; 202 } 203 204 void pg_cntl42_hubp_dpp_pg_control(struct pg_cntl *pg_cntl, unsigned int hubp_dpp_inst, bool power_on) 205 { 206 struct dcn_pg_cntl *pg_cntl_dcn = TO_DCN_PG_CNTL(pg_cntl); 207 uint32_t power_gate = power_on ? 0 : 1; 208 uint32_t pwr_status = power_on ? 0 : 2; 209 uint32_t org_ip_request_cntl; 210 struct dcn42_global_fgcg_rep_state fgcg_rep_state = {0}; 211 bool block_pg_disabled = pg_cntl->ctx->dc->debug.ignore_pg || 212 pg_cntl->ctx->dc->debug.disable_hubp_power_gate || 213 pg_cntl->ctx->dc->debug.disable_dpp_power_gate; 214 215 if (block_pg_disabled && !power_on) 216 return; 217 218 bool block_enabled = pg_cntl42_hubp_dpp_pg_status(pg_cntl, hubp_dpp_inst); 219 if (should_skip_pg_control(pg_cntl->ctx->dc->idle_optimizations_allowed, power_on, block_enabled)) 220 return; 221 222 REG_GET(DC_IP_REQUEST_CNTL, IP_REQUEST_EN, &org_ip_request_cntl); 223 if (org_ip_request_cntl == 0) 224 REG_SET(DC_IP_REQUEST_CNTL, 0, IP_REQUEST_EN, 1); 225 226 if (power_on) 227 pg_cntl42_save_and_disable_global_fgcg_rep(pg_cntl, &fgcg_rep_state); 228 229 switch (hubp_dpp_inst) { 230 case 0: 231 /* DPP0 & HUBP0 */ 232 REG_UPDATE(DOMAIN0_PG_CONFIG, DOMAIN_POWER_GATE, power_gate); 233 REG_WAIT(DOMAIN0_PG_STATUS, DOMAIN_PGFSM_PWR_STATUS, pwr_status, 1, 1000); 234 break; 235 case 1: 236 /* DPP1 & HUBP1 */ 237 REG_UPDATE(DOMAIN1_PG_CONFIG, DOMAIN_POWER_GATE, power_gate); 238 REG_WAIT(DOMAIN1_PG_STATUS, DOMAIN_PGFSM_PWR_STATUS, pwr_status, 1, 1000); 239 break; 240 case 2: 241 /* DPP2 & HUBP2 */ 242 REG_UPDATE(DOMAIN2_PG_CONFIG, DOMAIN_POWER_GATE, power_gate); 243 REG_WAIT(DOMAIN2_PG_STATUS, DOMAIN_PGFSM_PWR_STATUS, pwr_status, 1, 1000); 244 break; 245 case 3: 246 /* DPP3 & HUBP3 */ 247 REG_UPDATE(DOMAIN3_PG_CONFIG, DOMAIN_POWER_GATE, power_gate); 248 REG_WAIT(DOMAIN3_PG_STATUS, DOMAIN_PGFSM_PWR_STATUS, pwr_status, 1, 1000); 249 break; 250 default: 251 BREAK_TO_DEBUGGER(); 252 break; 253 } 254 255 if (power_on) 256 pg_cntl42_restore_global_fgcg_rep(pg_cntl, &fgcg_rep_state); 257 258 DC_LOG_DEBUG("HUBP DPP instance %d, power %s", hubp_dpp_inst, 259 power_on ? "ON" : "OFF"); 260 261 if (hubp_dpp_inst < MAX_PIPES) { 262 pg_cntl->pg_pipe_res_enable[PG_HUBP][hubp_dpp_inst] = power_on; 263 pg_cntl->pg_pipe_res_enable[PG_DPP][hubp_dpp_inst] = power_on; 264 } 265 } 266 267 static bool pg_cntl42_hpo_pg_status(struct pg_cntl *pg_cntl) 268 { 269 struct dcn_pg_cntl *pg_cntl_dcn = TO_DCN_PG_CNTL(pg_cntl); 270 uint32_t pwr_status = 0; 271 272 REG_GET(DOMAIN25_PG_STATUS, 273 DOMAIN_PGFSM_PWR_STATUS, &pwr_status); 274 275 return pwr_status == 0; 276 } 277 278 void pg_cntl42_hpo_pg_control(struct pg_cntl *pg_cntl, bool power_on) 279 { 280 struct dcn_pg_cntl *pg_cntl_dcn = TO_DCN_PG_CNTL(pg_cntl); 281 uint32_t power_gate = power_on ? 0 : 1; 282 uint32_t pwr_status = power_on ? 0 : 2; 283 uint32_t org_ip_request_cntl; 284 uint32_t power_forceon; 285 struct dcn42_global_fgcg_rep_state fgcg_rep_state = {0}; 286 287 bool block_pg_disabled = pg_cntl->ctx->dc->debug.ignore_pg || 288 pg_cntl->ctx->dc->debug.disable_hpo_power_gate; 289 290 if (block_pg_disabled && !power_on) 291 return; 292 293 bool block_enabled = pg_cntl42_hpo_pg_status(pg_cntl); 294 295 if (should_skip_pg_control(pg_cntl->ctx->dc->idle_optimizations_allowed, power_on, block_enabled)) 296 return; 297 298 REG_GET(DOMAIN25_PG_CONFIG, DOMAIN_POWER_FORCEON, &power_forceon); 299 if (power_forceon) 300 return; 301 302 REG_GET(DC_IP_REQUEST_CNTL, IP_REQUEST_EN, &org_ip_request_cntl); 303 if (org_ip_request_cntl == 0) 304 REG_SET(DC_IP_REQUEST_CNTL, 0, IP_REQUEST_EN, 1); 305 if (power_on) 306 pg_cntl42_save_and_disable_global_fgcg_rep(pg_cntl, &fgcg_rep_state); 307 308 REG_UPDATE(DOMAIN25_PG_CONFIG, DOMAIN_POWER_GATE, power_gate); 309 REG_WAIT(DOMAIN25_PG_STATUS, DOMAIN_PGFSM_PWR_STATUS, pwr_status, 1, 1000); 310 311 if (power_on) 312 pg_cntl42_restore_global_fgcg_rep(pg_cntl, &fgcg_rep_state); 313 314 pg_cntl->pg_res_enable[PG_HPO] = power_on; 315 } 316 317 static bool pg_cntl42_io_clk_status(struct pg_cntl *pg_cntl) 318 { 319 struct dcn_pg_cntl *pg_cntl_dcn = TO_DCN_PG_CNTL(pg_cntl); 320 uint32_t pwr_status = 0; 321 322 REG_GET(DOMAIN22_PG_STATUS, 323 DOMAIN_PGFSM_PWR_STATUS, &pwr_status); 324 325 return pwr_status == 0; 326 } 327 328 void pg_cntl42_io_clk_pg_control(struct pg_cntl *pg_cntl, bool power_on) 329 { 330 struct dcn_pg_cntl *pg_cntl_dcn = TO_DCN_PG_CNTL(pg_cntl); 331 uint32_t power_gate = power_on ? 0 : 1; 332 uint32_t pwr_status = power_on ? 0 : 2; 333 uint32_t org_ip_request_cntl; 334 uint32_t power_forceon; 335 336 bool block_pg_disabled = pg_cntl->ctx->dc->debug.ignore_pg || 337 pg_cntl->ctx->dc->debug.disable_io_clk_power_gate; 338 339 if (block_pg_disabled && !power_on) 340 return; 341 342 bool block_enabled = pg_cntl42_io_clk_status(pg_cntl); 343 344 if (should_skip_pg_control(pg_cntl->ctx->dc->idle_optimizations_allowed, power_on, block_enabled)) 345 return; 346 347 REG_GET(DOMAIN22_PG_CONFIG, DOMAIN_POWER_FORCEON, &power_forceon); 348 if (power_forceon) 349 return; 350 351 if (!power_on) { 352 if (!pg_cntl->pg_res_enable[PG_DCCG] || !pg_cntl->pg_res_enable[PG_DCIO] || !pg_cntl->pg_res_enable[PG_DCOH]) 353 return; 354 } 355 REG_GET(DC_IP_REQUEST_CNTL, IP_REQUEST_EN, &org_ip_request_cntl); 356 if (org_ip_request_cntl == 0) 357 REG_SET(DC_IP_REQUEST_CNTL, 0, IP_REQUEST_EN, 1); 358 359 /* DCCG, DCOH, DCIO */ 360 REG_UPDATE(DOMAIN22_PG_CONFIG, DOMAIN_POWER_GATE, power_gate); 361 REG_WAIT(DOMAIN22_PG_STATUS, DOMAIN_PGFSM_PWR_STATUS, pwr_status, 1, 1000); 362 363 pg_cntl->pg_res_enable[PG_DCCG] = power_on; 364 pg_cntl->pg_res_enable[PG_DCOH] = power_on; 365 pg_cntl->pg_res_enable[PG_DCIO] = power_on; 366 } 367 368 static bool pg_cntl42_plane_otg_status(struct pg_cntl *pg_cntl) 369 { 370 struct dcn_pg_cntl *pg_cntl_dcn = TO_DCN_PG_CNTL(pg_cntl); 371 uint32_t pwr_status = 0; 372 373 REG_GET(DOMAIN24_PG_STATUS, 374 DOMAIN_PGFSM_PWR_STATUS, &pwr_status); 375 376 return pwr_status == 0; 377 } 378 379 void pg_cntl42_mpcc_pg_control(struct pg_cntl *pg_cntl, 380 unsigned int mpcc_inst, bool power_on) 381 { 382 if (pg_cntl->ctx->dc->idle_optimizations_allowed) 383 return; 384 385 if (mpcc_inst < MAX_PIPES) 386 pg_cntl->pg_pipe_res_enable[PG_MPCC][mpcc_inst] = power_on; 387 } 388 389 void pg_cntl42_opp_pg_control(struct pg_cntl *pg_cntl, 390 unsigned int opp_inst, bool power_on) 391 { 392 if (pg_cntl->ctx->dc->idle_optimizations_allowed) 393 return; 394 395 if (opp_inst < MAX_PIPES) 396 pg_cntl->pg_pipe_res_enable[PG_OPP][opp_inst] = power_on; 397 } 398 399 void pg_cntl42_optc_pg_control(struct pg_cntl *pg_cntl, 400 unsigned int optc_inst, bool power_on) 401 { 402 // Defer the ONO domain power up/down to plane_otg_pg_control 403 if (pg_cntl->ctx->dc->idle_optimizations_allowed) 404 return; 405 406 if (optc_inst < MAX_PIPES) 407 pg_cntl->pg_pipe_res_enable[PG_OPTC][optc_inst] = power_on; 408 } 409 static bool pg_cntl42_mem_status(struct pg_cntl *pg_cntl) 410 { 411 struct dcn_pg_cntl *pg_cntl_dcn = TO_DCN_PG_CNTL(pg_cntl); 412 uint32_t pwr_status = 0; 413 414 REG_GET(DOMAIN23_PG_STATUS, 415 DOMAIN_PGFSM_PWR_STATUS, &pwr_status); 416 417 return pwr_status == 0; 418 } 419 420 void pg_cntl42_mem_pg_control(struct pg_cntl *pg_cntl, bool power_on) 421 { 422 struct dcn_pg_cntl *pg_cntl_dcn = TO_DCN_PG_CNTL(pg_cntl); 423 uint32_t power_gate = power_on ? 0 : 1; 424 uint32_t pwr_status = power_on ? 0 : 2; 425 uint32_t org_ip_request_cntl; 426 uint32_t power_forceon; 427 428 bool block_pg_disabled = pg_cntl->ctx->dc->debug.ignore_pg || 429 pg_cntl->ctx->dc->debug.disable_mem_power_gate; 430 431 if (block_pg_disabled && !power_on) 432 return; 433 434 bool block_enabled = pg_cntl42_mem_status(pg_cntl); 435 if (should_skip_pg_control(pg_cntl->ctx->dc->idle_optimizations_allowed, power_on, block_enabled)) 436 return; 437 REG_GET(DOMAIN23_PG_CONFIG, DOMAIN_POWER_FORCEON, &power_forceon); 438 if (power_forceon) 439 return; 440 441 if (!power_on) { 442 if (!pg_cntl->pg_res_enable[PG_DCHUBBUB] || !pg_cntl->pg_res_enable[PG_DCHVM]) 443 return; 444 } 445 REG_GET(DC_IP_REQUEST_CNTL, IP_REQUEST_EN, &org_ip_request_cntl); 446 if (org_ip_request_cntl == 0) 447 REG_SET(DC_IP_REQUEST_CNTL, 0, IP_REQUEST_EN, 1); 448 449 /* DCHUBBUB, DCHUBBUBMEMn, DCHVM */ 450 REG_UPDATE(DOMAIN23_PG_CONFIG, DOMAIN_POWER_GATE, power_gate); 451 REG_WAIT(DOMAIN23_PG_STATUS, DOMAIN_PGFSM_PWR_STATUS, pwr_status, 1, 1000); 452 453 pg_cntl->pg_res_enable[PG_DCHUBBUB] = power_on; 454 pg_cntl->pg_res_enable[PG_DCHVM] = power_on; 455 } 456 static bool pg_cntl42_dio_pg_status(struct pg_cntl *pg_cntl) 457 { 458 struct dcn_pg_cntl *pg_cntl_dcn = TO_DCN_PG_CNTL(pg_cntl); 459 uint32_t pwr_status = 0; 460 461 REG_GET(DOMAIN26_PG_STATUS, 462 DOMAIN_PGFSM_PWR_STATUS, &pwr_status); 463 464 return pwr_status == 0; 465 } 466 467 void pg_cntl42_dio_pg_control(struct pg_cntl *pg_cntl, bool power_on) 468 { 469 struct dcn_pg_cntl *pg_cntl_dcn = TO_DCN_PG_CNTL(pg_cntl); 470 uint32_t power_gate = power_on ? 0 : 1; 471 uint32_t pwr_status = power_on ? 0 : 2; 472 uint32_t org_ip_request_cntl; 473 struct dcn42_global_fgcg_rep_state fgcg_rep_state = {0}; 474 475 bool block_pg_disabled = pg_cntl->ctx->dc->debug.ignore_pg || 476 pg_cntl->ctx->dc->debug.disable_dio_power_gate; 477 478 if (block_pg_disabled && !power_on) 479 return; 480 481 bool block_enabled = pg_cntl42_dio_pg_status(pg_cntl); 482 if (should_skip_pg_control(pg_cntl->ctx->dc->idle_optimizations_allowed, power_on, block_enabled)) 483 return; 484 485 REG_GET(DC_IP_REQUEST_CNTL, IP_REQUEST_EN, &org_ip_request_cntl); 486 if (org_ip_request_cntl == 0) 487 REG_SET(DC_IP_REQUEST_CNTL, 0, IP_REQUEST_EN, 1); 488 if (power_on) 489 pg_cntl42_save_and_disable_global_fgcg_rep(pg_cntl, &fgcg_rep_state); 490 491 /* DIO */ 492 REG_UPDATE(DOMAIN26_PG_CONFIG, DOMAIN_POWER_GATE, power_gate); 493 REG_WAIT(DOMAIN26_PG_STATUS, DOMAIN_PGFSM_PWR_STATUS, pwr_status, 1, 1000); 494 495 if (power_on) 496 pg_cntl42_restore_global_fgcg_rep(pg_cntl, &fgcg_rep_state); 497 498 pg_cntl->pg_res_enable[PG_DIO] = power_on; 499 500 } 501 502 void pg_cntl42_plane_otg_pg_control(struct pg_cntl *pg_cntl, bool power_on) 503 { 504 struct dcn_pg_cntl *pg_cntl_dcn = TO_DCN_PG_CNTL(pg_cntl); 505 uint32_t power_gate = power_on ? 0 : 1; 506 uint32_t pwr_status = power_on ? 0 : 2; 507 uint32_t org_ip_request_cntl; 508 unsigned int i; 509 bool all_mpcc_disabled = true, all_opp_disabled = true; 510 bool all_optc_disabled = true, all_stream_disabled = true; 511 512 bool block_pg_disabled = pg_cntl->ctx->dc->debug.ignore_pg || 513 pg_cntl->ctx->dc->debug.disable_optc_power_gate; 514 515 if (block_pg_disabled && !power_on) 516 return; 517 518 bool block_enabled = pg_cntl42_plane_otg_status(pg_cntl); 519 520 if (should_skip_pg_control(pg_cntl->ctx->dc->idle_optimizations_allowed, power_on, block_enabled)) 521 return; 522 523 for (i = 0; i < pg_cntl->ctx->dc->res_pool->pipe_count; i++) { 524 struct pipe_ctx *pipe_ctx = &pg_cntl->ctx->dc->current_state->res_ctx.pipe_ctx[i]; 525 526 if (pipe_ctx) { 527 if (pipe_ctx->stream) 528 all_stream_disabled = false; 529 } 530 531 if (pg_cntl->pg_pipe_res_enable[PG_MPCC][i]) 532 all_mpcc_disabled = false; 533 534 if (pg_cntl->pg_pipe_res_enable[PG_OPP][i]) 535 all_opp_disabled = false; 536 537 if (pg_cntl->pg_pipe_res_enable[PG_OPTC][i]) 538 all_optc_disabled = false; 539 } 540 541 if (!power_on) { 542 if (!all_mpcc_disabled || !all_opp_disabled || !all_optc_disabled 543 || !all_stream_disabled) 544 return; 545 } 546 547 REG_GET(DC_IP_REQUEST_CNTL, IP_REQUEST_EN, &org_ip_request_cntl); 548 if (org_ip_request_cntl == 0) 549 REG_SET(DC_IP_REQUEST_CNTL, 0, IP_REQUEST_EN, 1); 550 551 /* MPC, OPP, OPTC, DWB */ 552 REG_UPDATE(DOMAIN24_PG_CONFIG, DOMAIN_POWER_GATE, power_gate); 553 REG_WAIT(DOMAIN24_PG_STATUS, DOMAIN_PGFSM_PWR_STATUS, pwr_status, 1, 1000); 554 555 for (i = 0; i < pg_cntl->ctx->dc->res_pool->pipe_count; i++) { 556 pg_cntl->pg_pipe_res_enable[PG_MPCC][i] = power_on; 557 pg_cntl->pg_pipe_res_enable[PG_OPP][i] = power_on; 558 pg_cntl->pg_pipe_res_enable[PG_OPTC][i] = power_on; 559 } 560 } 561 562 563 void pg_cntl42_init_pg_status(struct pg_cntl *pg_cntl) 564 { 565 unsigned int i = 0; 566 bool block_enabled; 567 568 pg_cntl->pg_res_enable[PG_HPO] = pg_cntl42_hpo_pg_status(pg_cntl); 569 570 block_enabled = pg_cntl42_io_clk_status(pg_cntl); 571 pg_cntl->pg_res_enable[PG_DCCG] = block_enabled; 572 pg_cntl->pg_res_enable[PG_DCIO] = block_enabled; 573 pg_cntl->pg_res_enable[PG_DCOH] = block_enabled; 574 575 block_enabled = pg_cntl42_dio_pg_status(pg_cntl); 576 pg_cntl->pg_res_enable[PG_DIO] = block_enabled; 577 578 block_enabled = pg_cntl42_mem_status(pg_cntl); 579 pg_cntl->pg_res_enable[PG_DCHUBBUB] = block_enabled; 580 pg_cntl->pg_res_enable[PG_DCHVM] = block_enabled; 581 582 for (i = 0; i < pg_cntl->ctx->dc->res_pool->pipe_count; i++) { 583 block_enabled = pg_cntl42_hubp_dpp_pg_status(pg_cntl, i); 584 pg_cntl->pg_pipe_res_enable[PG_HUBP][i] = block_enabled; 585 pg_cntl->pg_pipe_res_enable[PG_DPP][i] = block_enabled; 586 } 587 588 /* DSC count can be lower than pipe count (e.g. DCN42B has 4 pipes, 3 DSCs) */ 589 for (i = 0; i < (unsigned int)pg_cntl->ctx->dc->res_pool->res_cap->num_dsc; i++) { 590 block_enabled = pg_cntl42_dsc_pg_status(pg_cntl, i); 591 pg_cntl->pg_pipe_res_enable[PG_DSC][i] = block_enabled; 592 } 593 594 block_enabled = pg_cntl42_plane_otg_status(pg_cntl); 595 for (i = 0; i < pg_cntl->ctx->dc->res_pool->pipe_count; i++) { 596 pg_cntl->pg_pipe_res_enable[PG_MPCC][i] = block_enabled; 597 pg_cntl->pg_pipe_res_enable[PG_OPP][i] = block_enabled; 598 pg_cntl->pg_pipe_res_enable[PG_OPTC][i] = block_enabled; 599 } 600 } 601 602 static const struct pg_cntl_funcs pg_cntl42_funcs = { 603 .init_pg_status = pg_cntl42_init_pg_status, 604 .dsc_pg_control = pg_cntl42_dsc_pg_control, 605 .hubp_dpp_pg_control = pg_cntl42_hubp_dpp_pg_control, 606 .hpo_pg_control = pg_cntl42_hpo_pg_control, 607 .io_clk_pg_control = pg_cntl42_io_clk_pg_control, 608 .plane_otg_pg_control = pg_cntl42_plane_otg_pg_control, 609 .mpcc_pg_control = pg_cntl42_mpcc_pg_control, 610 .opp_pg_control = pg_cntl42_opp_pg_control, 611 .optc_pg_control = pg_cntl42_optc_pg_control, 612 .mem_pg_control = pg_cntl42_mem_pg_control, 613 .dio_pg_control = pg_cntl42_dio_pg_control 614 }; 615 616 struct pg_cntl *pg_cntl42_create( 617 struct dc_context *ctx, 618 const struct pg_cntl_registers *regs, 619 const struct pg_cntl_shift *pg_cntl_shift, 620 const struct pg_cntl_mask *pg_cntl_mask) 621 { 622 struct dcn_pg_cntl *pg_cntl_dcn = kzalloc_obj(*pg_cntl_dcn); 623 struct pg_cntl *base; 624 625 if (pg_cntl_dcn == NULL) { 626 BREAK_TO_DEBUGGER(); 627 return NULL; 628 } 629 630 base = &pg_cntl_dcn->base; 631 base->ctx = ctx; 632 base->funcs = &pg_cntl42_funcs; 633 base->inst = 0; 634 635 pg_cntl_dcn->regs = regs; 636 pg_cntl_dcn->pg_cntl_shift = pg_cntl_shift; 637 pg_cntl_dcn->pg_cntl_mask = pg_cntl_mask; 638 639 memset(base->pg_pipe_res_enable, 0, PG_HW_PIPE_RESOURCES_NUM_ELEMENT * MAX_PIPES * sizeof(bool)); 640 memset(base->pg_res_enable, 0, PG_HW_RESOURCES_NUM_ELEMENT * sizeof(bool)); 641 642 return &pg_cntl_dcn->base; 643 } 644 645 void dcn42_pg_cntl_destroy(struct pg_cntl **pg_cntl) 646 { 647 struct dcn_pg_cntl *pg_cntl_dcn = TO_DCN_PG_CNTL(*pg_cntl); 648 649 kfree(pg_cntl_dcn); 650 *pg_cntl = NULL; 651 } 652