diff options
Diffstat (limited to 'meta-amd-bsp/recipes-kernel/linux-4.19/linux-yocto-4.19.8/1135-drm-amd-display-Restructure-DCN10-hubbub.patch')
| -rw-r--r-- | meta-amd-bsp/recipes-kernel/linux-4.19/linux-yocto-4.19.8/1135-drm-amd-display-Restructure-DCN10-hubbub.patch | 478 |
1 files changed, 478 insertions, 0 deletions
diff --git a/meta-amd-bsp/recipes-kernel/linux-4.19/linux-yocto-4.19.8/1135-drm-amd-display-Restructure-DCN10-hubbub.patch b/meta-amd-bsp/recipes-kernel/linux-4.19/linux-yocto-4.19.8/1135-drm-amd-display-Restructure-DCN10-hubbub.patch new file mode 100644 index 00000000..e016765c --- /dev/null +++ b/meta-amd-bsp/recipes-kernel/linux-4.19/linux-yocto-4.19.8/1135-drm-amd-display-Restructure-DCN10-hubbub.patch @@ -0,0 +1,478 @@ +From 38fb023657405244d675d6bf0baa9e1baffe1439 Mon Sep 17 00:00:00 2001 +From: Eryk Brol <eryk.brol@amd.com> +Date: Fri, 4 Jan 2019 10:29:00 -0500 +Subject: [PATCH 1135/2940] drm/amd/display: Restructure DCN10 hubbub + +[Why] +Change DCN10 hubbub to use hubbub as a base and allow all future DCN +hubbubs to do the same instead of using DCN10_hubbub. This increases +readability and doesn't require future hubbubs to inherit anything +other than the base hubbub struct. + +[How] +Create separate DCN10_hubbub struct which uses the hubbub struct as +a base. + +Signed-off-by: Eryk Brol <eryk.brol@amd.com> +Reviewed-by: Jun Lei <Jun.Lei@amd.com> +Acked-by: Leo Li <sunpeng.li@amd.com> +Signed-off-by: Alex Deucher <alexander.deucher@amd.com> +--- + .../drm/amd/display/dc/dcn10/dcn10_hubbub.c | 131 ++++++++++-------- + .../drm/amd/display/dc/dcn10/dcn10_hubbub.h | 9 +- + .../drm/amd/display/dc/dcn10/dcn10_resource.c | 8 +- + .../gpu/drm/amd/display/dc/inc/hw/dchubbub.h | 4 + + 4 files changed, 88 insertions(+), 64 deletions(-) + +diff --git a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubbub.c b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubbub.c +index eb31a5ed6dff..5a4614c371bc 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubbub.c ++++ b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubbub.c +@@ -29,19 +29,20 @@ + #include "reg_helper.h" + + #define CTX \ +- hubbub->ctx ++ hubbub1->base.ctx + #define DC_LOGGER \ +- hubbub->ctx->logger ++ hubbub1->base.ctx->logger + #define REG(reg)\ +- hubbub->regs->reg ++ hubbub1->regs->reg + + #undef FN + #define FN(reg_name, field_name) \ +- hubbub->shifts->field_name, hubbub->masks->field_name ++ hubbub1->shifts->field_name, hubbub1->masks->field_name + + void hubbub1_wm_read_state(struct hubbub *hubbub, + struct dcn_hubbub_wm *wm) + { ++ struct dcn10_hubbub *hubbub1 = TO_DCN10_HUBBUB(hubbub); + struct dcn_hubbub_wm_set *s; + + memset(wm, 0, sizeof(struct dcn_hubbub_wm)); +@@ -89,12 +90,14 @@ void hubbub1_wm_read_state(struct hubbub *hubbub, + + void hubbub1_disable_allow_self_refresh(struct hubbub *hubbub) + { ++ struct dcn10_hubbub *hubbub1 = TO_DCN10_HUBBUB(hubbub); + REG_UPDATE(DCHUBBUB_ARB_DRAM_STATE_CNTL, + DCHUBBUB_ARB_ALLOW_SELF_REFRESH_FORCE_ENABLE, 0); + } + + bool hububu1_is_allow_self_refresh_enabled(struct hubbub *hubbub) + { ++ struct dcn10_hubbub *hubbub1 = TO_DCN10_HUBBUB(hubbub); + uint32_t enable = 0; + + REG_GET(DCHUBBUB_ARB_DRAM_STATE_CNTL, +@@ -107,6 +110,8 @@ bool hububu1_is_allow_self_refresh_enabled(struct hubbub *hubbub) + bool hubbub1_verify_allow_pstate_change_high( + struct hubbub *hubbub) + { ++ struct dcn10_hubbub *hubbub1 = TO_DCN10_HUBBUB(hubbub); ++ + /* pstate latency is ~20us so if we wait over 40us and pstate allow + * still not asserted, we are probably stuck and going to hang + * +@@ -193,7 +198,7 @@ bool hubbub1_verify_allow_pstate_change_high( + * 31: SOC pstate change request + */ + +- REG_WRITE(DCHUBBUB_TEST_DEBUG_INDEX, hubbub->debug_test_index_pstate); ++ REG_WRITE(DCHUBBUB_TEST_DEBUG_INDEX, hubbub1->debug_test_index_pstate); + + for (i = 0; i < pstate_wait_timeout_us; i++) { + debug_data = REG_READ(DCHUBBUB_TEST_DEBUG_DATA); +@@ -244,6 +249,8 @@ static uint32_t convert_and_clamp( + + void hubbub1_wm_change_req_wa(struct hubbub *hubbub) + { ++ struct dcn10_hubbub *hubbub1 = TO_DCN10_HUBBUB(hubbub); ++ + REG_UPDATE_SEQ(DCHUBBUB_ARB_WATERMARK_CHANGE_CNTL, + DCHUBBUB_ARB_WATERMARK_CHANGE_REQUEST, 0, 1); + } +@@ -254,7 +261,9 @@ void hubbub1_program_watermarks( + unsigned int refclk_mhz, + bool safe_to_lower) + { +- uint32_t force_en = hubbub->ctx->dc->debug.disable_stutter ? 1 : 0; ++ struct dcn10_hubbub *hubbub1 = TO_DCN10_HUBBUB(hubbub); ++ ++ uint32_t force_en = hubbub1->base.ctx->dc->debug.disable_stutter ? 1 : 0; + /* + * Need to clamp to max of the register values (i.e. no wrap) + * for dcn1, all wm registers are 21-bit wide +@@ -264,8 +273,8 @@ void hubbub1_program_watermarks( + + /* Repeat for water mark set A, B, C and D. */ + /* clock state A */ +- if (safe_to_lower || watermarks->a.urgent_ns > hubbub->watermarks.a.urgent_ns) { +- hubbub->watermarks.a.urgent_ns = watermarks->a.urgent_ns; ++ if (safe_to_lower || watermarks->a.urgent_ns > hubbub1->watermarks.a.urgent_ns) { ++ hubbub1->watermarks.a.urgent_ns = watermarks->a.urgent_ns; + prog_wm_value = convert_and_clamp(watermarks->a.urgent_ns, + refclk_mhz, 0x1fffff); + REG_WRITE(DCHUBBUB_ARB_DATA_URGENCY_WATERMARK_A, prog_wm_value); +@@ -276,8 +285,8 @@ void hubbub1_program_watermarks( + } + + if (REG(DCHUBBUB_ARB_PTE_META_URGENCY_WATERMARK_A)) { +- if (safe_to_lower || watermarks->a.pte_meta_urgent_ns > hubbub->watermarks.a.pte_meta_urgent_ns) { +- hubbub->watermarks.a.pte_meta_urgent_ns = watermarks->a.pte_meta_urgent_ns; ++ if (safe_to_lower || watermarks->a.pte_meta_urgent_ns > hubbub1->watermarks.a.pte_meta_urgent_ns) { ++ hubbub1->watermarks.a.pte_meta_urgent_ns = watermarks->a.pte_meta_urgent_ns; + prog_wm_value = convert_and_clamp(watermarks->a.pte_meta_urgent_ns, + refclk_mhz, 0x1fffff); + REG_WRITE(DCHUBBUB_ARB_PTE_META_URGENCY_WATERMARK_A, prog_wm_value); +@@ -289,8 +298,8 @@ void hubbub1_program_watermarks( + + if (REG(DCHUBBUB_ARB_ALLOW_SR_ENTER_WATERMARK_A)) { + if (safe_to_lower || watermarks->a.cstate_pstate.cstate_enter_plus_exit_ns +- > hubbub->watermarks.a.cstate_pstate.cstate_enter_plus_exit_ns) { +- hubbub->watermarks.a.cstate_pstate.cstate_enter_plus_exit_ns = ++ > hubbub1->watermarks.a.cstate_pstate.cstate_enter_plus_exit_ns) { ++ hubbub1->watermarks.a.cstate_pstate.cstate_enter_plus_exit_ns = + watermarks->a.cstate_pstate.cstate_enter_plus_exit_ns; + prog_wm_value = convert_and_clamp( + watermarks->a.cstate_pstate.cstate_enter_plus_exit_ns, +@@ -302,8 +311,8 @@ void hubbub1_program_watermarks( + } + + if (safe_to_lower || watermarks->a.cstate_pstate.cstate_exit_ns +- > hubbub->watermarks.a.cstate_pstate.cstate_exit_ns) { +- hubbub->watermarks.a.cstate_pstate.cstate_exit_ns = ++ > hubbub1->watermarks.a.cstate_pstate.cstate_exit_ns) { ++ hubbub1->watermarks.a.cstate_pstate.cstate_exit_ns = + watermarks->a.cstate_pstate.cstate_exit_ns; + prog_wm_value = convert_and_clamp( + watermarks->a.cstate_pstate.cstate_exit_ns, +@@ -316,8 +325,8 @@ void hubbub1_program_watermarks( + } + + if (safe_to_lower || watermarks->a.cstate_pstate.pstate_change_ns +- > hubbub->watermarks.a.cstate_pstate.pstate_change_ns) { +- hubbub->watermarks.a.cstate_pstate.pstate_change_ns = ++ > hubbub1->watermarks.a.cstate_pstate.pstate_change_ns) { ++ hubbub1->watermarks.a.cstate_pstate.pstate_change_ns = + watermarks->a.cstate_pstate.pstate_change_ns; + prog_wm_value = convert_and_clamp( + watermarks->a.cstate_pstate.pstate_change_ns, +@@ -329,8 +338,8 @@ void hubbub1_program_watermarks( + } + + /* clock state B */ +- if (safe_to_lower || watermarks->b.urgent_ns > hubbub->watermarks.b.urgent_ns) { +- hubbub->watermarks.b.urgent_ns = watermarks->b.urgent_ns; ++ if (safe_to_lower || watermarks->b.urgent_ns > hubbub1->watermarks.b.urgent_ns) { ++ hubbub1->watermarks.b.urgent_ns = watermarks->b.urgent_ns; + prog_wm_value = convert_and_clamp(watermarks->b.urgent_ns, + refclk_mhz, 0x1fffff); + REG_WRITE(DCHUBBUB_ARB_DATA_URGENCY_WATERMARK_B, prog_wm_value); +@@ -341,8 +350,8 @@ void hubbub1_program_watermarks( + } + + if (REG(DCHUBBUB_ARB_PTE_META_URGENCY_WATERMARK_B)) { +- if (safe_to_lower || watermarks->b.pte_meta_urgent_ns > hubbub->watermarks.b.pte_meta_urgent_ns) { +- hubbub->watermarks.b.pte_meta_urgent_ns = watermarks->b.pte_meta_urgent_ns; ++ if (safe_to_lower || watermarks->b.pte_meta_urgent_ns > hubbub1->watermarks.b.pte_meta_urgent_ns) { ++ hubbub1->watermarks.b.pte_meta_urgent_ns = watermarks->b.pte_meta_urgent_ns; + prog_wm_value = convert_and_clamp(watermarks->b.pte_meta_urgent_ns, + refclk_mhz, 0x1fffff); + REG_WRITE(DCHUBBUB_ARB_PTE_META_URGENCY_WATERMARK_B, prog_wm_value); +@@ -354,8 +363,8 @@ void hubbub1_program_watermarks( + + if (REG(DCHUBBUB_ARB_ALLOW_SR_ENTER_WATERMARK_B)) { + if (safe_to_lower || watermarks->b.cstate_pstate.cstate_enter_plus_exit_ns +- > hubbub->watermarks.b.cstate_pstate.cstate_enter_plus_exit_ns) { +- hubbub->watermarks.b.cstate_pstate.cstate_enter_plus_exit_ns = ++ > hubbub1->watermarks.b.cstate_pstate.cstate_enter_plus_exit_ns) { ++ hubbub1->watermarks.b.cstate_pstate.cstate_enter_plus_exit_ns = + watermarks->b.cstate_pstate.cstate_enter_plus_exit_ns; + prog_wm_value = convert_and_clamp( + watermarks->b.cstate_pstate.cstate_enter_plus_exit_ns, +@@ -367,8 +376,8 @@ void hubbub1_program_watermarks( + } + + if (safe_to_lower || watermarks->b.cstate_pstate.cstate_exit_ns +- > hubbub->watermarks.b.cstate_pstate.cstate_exit_ns) { +- hubbub->watermarks.b.cstate_pstate.cstate_exit_ns = ++ > hubbub1->watermarks.b.cstate_pstate.cstate_exit_ns) { ++ hubbub1->watermarks.b.cstate_pstate.cstate_exit_ns = + watermarks->b.cstate_pstate.cstate_exit_ns; + prog_wm_value = convert_and_clamp( + watermarks->b.cstate_pstate.cstate_exit_ns, +@@ -381,8 +390,8 @@ void hubbub1_program_watermarks( + } + + if (safe_to_lower || watermarks->b.cstate_pstate.pstate_change_ns +- > hubbub->watermarks.b.cstate_pstate.pstate_change_ns) { +- hubbub->watermarks.b.cstate_pstate.pstate_change_ns = ++ > hubbub1->watermarks.b.cstate_pstate.pstate_change_ns) { ++ hubbub1->watermarks.b.cstate_pstate.pstate_change_ns = + watermarks->b.cstate_pstate.pstate_change_ns; + prog_wm_value = convert_and_clamp( + watermarks->b.cstate_pstate.pstate_change_ns, +@@ -394,8 +403,8 @@ void hubbub1_program_watermarks( + } + + /* clock state C */ +- if (safe_to_lower || watermarks->c.urgent_ns > hubbub->watermarks.c.urgent_ns) { +- hubbub->watermarks.c.urgent_ns = watermarks->c.urgent_ns; ++ if (safe_to_lower || watermarks->c.urgent_ns > hubbub1->watermarks.c.urgent_ns) { ++ hubbub1->watermarks.c.urgent_ns = watermarks->c.urgent_ns; + prog_wm_value = convert_and_clamp(watermarks->c.urgent_ns, + refclk_mhz, 0x1fffff); + REG_WRITE(DCHUBBUB_ARB_DATA_URGENCY_WATERMARK_C, prog_wm_value); +@@ -406,8 +415,8 @@ void hubbub1_program_watermarks( + } + + if (REG(DCHUBBUB_ARB_PTE_META_URGENCY_WATERMARK_C)) { +- if (safe_to_lower || watermarks->c.pte_meta_urgent_ns > hubbub->watermarks.c.pte_meta_urgent_ns) { +- hubbub->watermarks.c.pte_meta_urgent_ns = watermarks->c.pte_meta_urgent_ns; ++ if (safe_to_lower || watermarks->c.pte_meta_urgent_ns > hubbub1->watermarks.c.pte_meta_urgent_ns) { ++ hubbub1->watermarks.c.pte_meta_urgent_ns = watermarks->c.pte_meta_urgent_ns; + prog_wm_value = convert_and_clamp(watermarks->c.pte_meta_urgent_ns, + refclk_mhz, 0x1fffff); + REG_WRITE(DCHUBBUB_ARB_PTE_META_URGENCY_WATERMARK_C, prog_wm_value); +@@ -419,8 +428,8 @@ void hubbub1_program_watermarks( + + if (REG(DCHUBBUB_ARB_ALLOW_SR_ENTER_WATERMARK_C)) { + if (safe_to_lower || watermarks->c.cstate_pstate.cstate_enter_plus_exit_ns +- > hubbub->watermarks.c.cstate_pstate.cstate_enter_plus_exit_ns) { +- hubbub->watermarks.c.cstate_pstate.cstate_enter_plus_exit_ns = ++ > hubbub1->watermarks.c.cstate_pstate.cstate_enter_plus_exit_ns) { ++ hubbub1->watermarks.c.cstate_pstate.cstate_enter_plus_exit_ns = + watermarks->c.cstate_pstate.cstate_enter_plus_exit_ns; + prog_wm_value = convert_and_clamp( + watermarks->c.cstate_pstate.cstate_enter_plus_exit_ns, +@@ -432,8 +441,8 @@ void hubbub1_program_watermarks( + } + + if (safe_to_lower || watermarks->c.cstate_pstate.cstate_exit_ns +- > hubbub->watermarks.c.cstate_pstate.cstate_exit_ns) { +- hubbub->watermarks.c.cstate_pstate.cstate_exit_ns = ++ > hubbub1->watermarks.c.cstate_pstate.cstate_exit_ns) { ++ hubbub1->watermarks.c.cstate_pstate.cstate_exit_ns = + watermarks->c.cstate_pstate.cstate_exit_ns; + prog_wm_value = convert_and_clamp( + watermarks->c.cstate_pstate.cstate_exit_ns, +@@ -446,8 +455,8 @@ void hubbub1_program_watermarks( + } + + if (safe_to_lower || watermarks->c.cstate_pstate.pstate_change_ns +- > hubbub->watermarks.c.cstate_pstate.pstate_change_ns) { +- hubbub->watermarks.c.cstate_pstate.pstate_change_ns = ++ > hubbub1->watermarks.c.cstate_pstate.pstate_change_ns) { ++ hubbub1->watermarks.c.cstate_pstate.pstate_change_ns = + watermarks->c.cstate_pstate.pstate_change_ns; + prog_wm_value = convert_and_clamp( + watermarks->c.cstate_pstate.pstate_change_ns, +@@ -459,8 +468,8 @@ void hubbub1_program_watermarks( + } + + /* clock state D */ +- if (safe_to_lower || watermarks->d.urgent_ns > hubbub->watermarks.d.urgent_ns) { +- hubbub->watermarks.d.urgent_ns = watermarks->d.urgent_ns; ++ if (safe_to_lower || watermarks->d.urgent_ns > hubbub1->watermarks.d.urgent_ns) { ++ hubbub1->watermarks.d.urgent_ns = watermarks->d.urgent_ns; + prog_wm_value = convert_and_clamp(watermarks->d.urgent_ns, + refclk_mhz, 0x1fffff); + REG_WRITE(DCHUBBUB_ARB_DATA_URGENCY_WATERMARK_D, prog_wm_value); +@@ -471,8 +480,8 @@ void hubbub1_program_watermarks( + } + + if (REG(DCHUBBUB_ARB_PTE_META_URGENCY_WATERMARK_D)) { +- if (safe_to_lower || watermarks->d.pte_meta_urgent_ns > hubbub->watermarks.d.pte_meta_urgent_ns) { +- hubbub->watermarks.d.pte_meta_urgent_ns = watermarks->d.pte_meta_urgent_ns; ++ if (safe_to_lower || watermarks->d.pte_meta_urgent_ns > hubbub1->watermarks.d.pte_meta_urgent_ns) { ++ hubbub1->watermarks.d.pte_meta_urgent_ns = watermarks->d.pte_meta_urgent_ns; + prog_wm_value = convert_and_clamp(watermarks->d.pte_meta_urgent_ns, + refclk_mhz, 0x1fffff); + REG_WRITE(DCHUBBUB_ARB_PTE_META_URGENCY_WATERMARK_D, prog_wm_value); +@@ -484,8 +493,8 @@ void hubbub1_program_watermarks( + + if (REG(DCHUBBUB_ARB_ALLOW_SR_ENTER_WATERMARK_D)) { + if (safe_to_lower || watermarks->d.cstate_pstate.cstate_enter_plus_exit_ns +- > hubbub->watermarks.d.cstate_pstate.cstate_enter_plus_exit_ns) { +- hubbub->watermarks.d.cstate_pstate.cstate_enter_plus_exit_ns = ++ > hubbub1->watermarks.d.cstate_pstate.cstate_enter_plus_exit_ns) { ++ hubbub1->watermarks.d.cstate_pstate.cstate_enter_plus_exit_ns = + watermarks->d.cstate_pstate.cstate_enter_plus_exit_ns; + prog_wm_value = convert_and_clamp( + watermarks->d.cstate_pstate.cstate_enter_plus_exit_ns, +@@ -497,8 +506,8 @@ void hubbub1_program_watermarks( + } + + if (safe_to_lower || watermarks->d.cstate_pstate.cstate_exit_ns +- > hubbub->watermarks.d.cstate_pstate.cstate_exit_ns) { +- hubbub->watermarks.d.cstate_pstate.cstate_exit_ns = ++ > hubbub1->watermarks.d.cstate_pstate.cstate_exit_ns) { ++ hubbub1->watermarks.d.cstate_pstate.cstate_exit_ns = + watermarks->d.cstate_pstate.cstate_exit_ns; + prog_wm_value = convert_and_clamp( + watermarks->d.cstate_pstate.cstate_exit_ns, +@@ -511,8 +520,8 @@ void hubbub1_program_watermarks( + } + + if (safe_to_lower || watermarks->d.cstate_pstate.pstate_change_ns +- > hubbub->watermarks.d.cstate_pstate.pstate_change_ns) { +- hubbub->watermarks.d.cstate_pstate.pstate_change_ns = ++ > hubbub1->watermarks.d.cstate_pstate.pstate_change_ns) { ++ hubbub1->watermarks.d.cstate_pstate.pstate_change_ns = + watermarks->d.cstate_pstate.pstate_change_ns; + prog_wm_value = convert_and_clamp( + watermarks->d.cstate_pstate.pstate_change_ns, +@@ -543,6 +552,8 @@ void hubbub1_update_dchub( + struct hubbub *hubbub, + struct dchub_init_data *dh_data) + { ++ struct dcn10_hubbub *hubbub1 = TO_DCN10_HUBBUB(hubbub); ++ + if (REG(DCHUBBUB_SDPIF_FB_TOP) == 0) { + ASSERT(false); + /*should not come here*/ +@@ -602,6 +613,8 @@ void hubbub1_update_dchub( + + void hubbub1_toggle_watermark_change_req(struct hubbub *hubbub) + { ++ struct dcn10_hubbub *hubbub1 = TO_DCN10_HUBBUB(hubbub); ++ + uint32_t watermark_change_req; + + REG_GET(DCHUBBUB_ARB_WATERMARK_CHANGE_CNTL, +@@ -618,6 +631,8 @@ void hubbub1_toggle_watermark_change_req(struct hubbub *hubbub) + + void hubbub1_soft_reset(struct hubbub *hubbub, bool reset) + { ++ struct dcn10_hubbub *hubbub1 = TO_DCN10_HUBBUB(hubbub); ++ + uint32_t reset_en = reset ? 1 : 0; + + REG_UPDATE(DCHUBBUB_SOFT_RESET, +@@ -760,7 +775,9 @@ static bool hubbub1_get_dcc_compression_cap(struct hubbub *hubbub, + const struct dc_dcc_surface_param *input, + struct dc_surface_dcc_cap *output) + { +- struct dc *dc = hubbub->ctx->dc; ++ struct dcn10_hubbub *hubbub1 = TO_DCN10_HUBBUB(hubbub); ++ struct dc *dc = hubbub1->base.ctx->dc; ++ + /* implement section 1.6.2.1 of DCN1_Programming_Guide.docx */ + enum dcc_control dcc_control; + unsigned int bpe; +@@ -772,10 +789,10 @@ static bool hubbub1_get_dcc_compression_cap(struct hubbub *hubbub, + if (dc->debug.disable_dcc == DCC_DISABLE) + return false; + +- if (!hubbub->funcs->dcc_support_pixel_format(input->format, &bpe)) ++ if (!hubbub1->base.funcs->dcc_support_pixel_format(input->format, &bpe)) + return false; + +- if (!hubbub->funcs->dcc_support_swizzle(input->swizzle_mode, bpe, ++ if (!hubbub1->base.funcs->dcc_support_swizzle(input->swizzle_mode, bpe, + &segment_order_horz, &segment_order_vert)) + return false; + +@@ -854,18 +871,20 @@ void hubbub1_construct(struct hubbub *hubbub, + const struct dcn_hubbub_shift *hubbub_shift, + const struct dcn_hubbub_mask *hubbub_mask) + { +- hubbub->ctx = ctx; ++ struct dcn10_hubbub *hubbub1 = TO_DCN10_HUBBUB(hubbub); ++ ++ hubbub1->base.ctx = ctx; + +- hubbub->funcs = &hubbub1_funcs; ++ hubbub1->base.funcs = &hubbub1_funcs; + +- hubbub->regs = hubbub_regs; +- hubbub->shifts = hubbub_shift; +- hubbub->masks = hubbub_mask; ++ hubbub1->regs = hubbub_regs; ++ hubbub1->shifts = hubbub_shift; ++ hubbub1->masks = hubbub_mask; + +- hubbub->debug_test_index_pstate = 0x7; ++ hubbub1->debug_test_index_pstate = 0x7; + #if defined(CONFIG_DRM_AMD_DC_DCN1_01) + if (ctx->dce_version == DCN_VERSION_1_01) +- hubbub->debug_test_index_pstate = 0xB; ++ hubbub1->debug_test_index_pstate = 0xB; + #endif + } + +diff --git a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubbub.h b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubbub.h +index aca67633ee58..14e23e26a2cd 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubbub.h ++++ b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubbub.h +@@ -29,6 +29,9 @@ + #include "core_types.h" + #include "dchubbub.h" + ++#define TO_DCN10_HUBBUB(hubbub)\ ++ container_of(hubbub, struct dcn10_hubbub, base) ++ + #define HUBHUB_REG_LIST_DCN()\ + SR(DCHUBBUB_ARB_DATA_URGENCY_WATERMARK_A),\ + SR(DCHUBBUB_ARB_PTE_META_URGENCY_WATERMARK_A),\ +@@ -165,10 +168,8 @@ struct dcn_hubbub_mask { + + struct dc; + +- +-struct hubbub { +- const struct hubbub_funcs *funcs; +- struct dc_context *ctx; ++struct dcn10_hubbub { ++ struct hubbub base; + const struct dcn_hubbub_registers *regs; + const struct dcn_hubbub_shift *shifts; + const struct dcn_hubbub_mask *masks; +diff --git a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_resource.c b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_resource.c +index ea0628bebe0d..4f8cbe33ca29 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_resource.c ++++ b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_resource.c +@@ -678,18 +678,18 @@ static struct mpc *dcn10_mpc_create(struct dc_context *ctx) + + static struct hubbub *dcn10_hubbub_create(struct dc_context *ctx) + { +- struct hubbub *hubbub = kzalloc(sizeof(struct hubbub), ++ struct dcn10_hubbub *dcn10_hubbub = kzalloc(sizeof(struct dcn10_hubbub), + GFP_KERNEL); + +- if (!hubbub) ++ if (!dcn10_hubbub) + return NULL; + +- hubbub1_construct(hubbub, ctx, ++ hubbub1_construct(&dcn10_hubbub->base, ctx, + &hubbub_reg, + &hubbub_shift, + &hubbub_mask); + +- return hubbub; ++ return &dcn10_hubbub->base; + } + + static struct timing_generator *dcn10_timing_generator_create( +diff --git a/drivers/gpu/drm/amd/display/dc/inc/hw/dchubbub.h b/drivers/gpu/drm/amd/display/dc/inc/hw/dchubbub.h +index dc0bb5bd8cac..9d2d8e51306c 100644 +--- a/drivers/gpu/drm/amd/display/dc/inc/hw/dchubbub.h ++++ b/drivers/gpu/drm/amd/display/dc/inc/hw/dchubbub.h +@@ -75,5 +75,9 @@ struct hubbub_funcs { + struct dcn_hubbub_wm *wm); + }; + ++struct hubbub { ++ const struct hubbub_funcs *funcs; ++ struct dc_context *ctx; ++}; + + #endif +-- +2.17.1 + |