xref: /linux/drivers/gpu/drm/amd/display/dc/pg/dcn42/dcn42_pg_cntl.c (revision 81b3e948d623f6a33e233f8f53dd7f6f22aeb474)
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