dc_surface.o dc_link_dp.o dc_link_ddc.o dc_debug.o dc_stream.o \
 dc_link_enc_cfg.o dc_link_dpia.o dc_link_dpcd.o
 
-ifdef CONFIG_DRM_AMD_DC_DCN
 DISPLAY_CORE += dc_vm_helper.o
-endif
 
 AMD_DISPLAY_CORE = $(addprefix $(AMDDALPATH)/dc/core/,$(DISPLAY_CORE))
 
 
        case DCE_VERSION_12_1:
                *h = dal_cmd_tbl_helper_dce112_get_table2();
                return true;
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        case DCN_VERSION_1_0:
        case DCN_VERSION_1_01:
        case DCN_VERSION_2_0:
        case DCN_VERSION_3_16:
                *h = dal_cmd_tbl_helper_dce112_get_table2();
                return true;
-#endif
+
        default:
                /* Unsupported DCE */
                BREAK_TO_DEBUGGER();
 
        kfree(dc->bw_dceip);
        dc->bw_dceip = NULL;
 
-#ifdef CONFIG_DRM_AMD_DC_DCN
        kfree(dc->dcn_soc);
        dc->dcn_soc = NULL;
 
        kfree(dc->dcn_ip);
        dc->dcn_ip = NULL;
 
-#endif
        kfree(dc->vm_helper);
        dc->vm_helper = NULL;
 
        struct dc_context *dc_ctx;
        struct bw_calcs_dceip *dc_dceip;
        struct bw_calcs_vbios *dc_vbios;
-#ifdef CONFIG_DRM_AMD_DC_DCN
        struct dcn_soc_bounding_box *dcn_soc;
        struct dcn_ip_params *dcn_ip;
-#endif
 
        dc->config = init_params->flags;
 
        }
 
        dc->bw_vbios = dc_vbios;
-#ifdef CONFIG_DRM_AMD_DC_DCN
        dcn_soc = kzalloc(sizeof(*dcn_soc), GFP_KERNEL);
        if (!dcn_soc) {
                dm_error("%s: failed to create dcn_soc\n", __func__);
        }
 
        dc->dcn_ip = dcn_ip;
-#endif
 
        if (!dc_construct_ctx(dc, init_params)) {
                dm_error("%s: failed to create ctx\n", __func__);
        return (result == DC_OK);
 }
 
-#if defined(CONFIG_DRM_AMD_DC_DCN)
 bool dc_acquire_release_mpc_3dlut(
                struct dc *dc, bool acquire,
                struct dc_stream_state *stream,
        }
        return ret;
 }
-#endif
+
 static bool is_flip_pending_in_pipes(struct dc *dc, struct dc_state *context)
 {
        int i;
        return false;
 }
 
-#ifdef CONFIG_DRM_AMD_DC_DCN
 /* Perform updates here which need to be deferred until next vupdate
  *
  * i.e. blnd lut, 3dlut, and shaper lut bypass regs are double buffered
                                dc->res_pool->dpps[i]->funcs->dpp_deferred_update(dc->res_pool->dpps[i]);
        }
 }
-#endif /* CONFIG_DRM_AMD_DC_DCN */
 
 void dc_post_update_surfaces_to_stream(struct dc *dc)
 {
                        dc->hwss.disable_plane(dc, &context->res_ctx.pipe_ctx[i]);
                }
 
-#ifdef CONFIG_DRM_AMD_DC_DCN
        process_deferred_updates(dc);
-#endif
 
        dc->hwss.optimize_bandwidth(dc, context);
 
         * initialize and obtain IP and SOC the base DML instance from DC is
         * initially copied into every context
         */
-#ifdef CONFIG_DRM_AMD_DC_DCN
        memcpy(&context->bw_ctx.dml, &dc->dml, sizeof(struct display_mode_lib));
-#endif
 }
 
 struct dc_state *dc_create_state(struct dc *dc)
        int i;
        enum surface_update_type overall_type = UPDATE_TYPE_FAST;
 
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        if (dc->idle_optimizations_allowed)
                overall_type = UPDATE_TYPE_FULL;
 
-#endif
        if (stream_status == NULL || stream_status->plane_count != surface_count)
                overall_type = UPDATE_TYPE_FULL;
 
        }
 
        if (update_type == UPDATE_TYPE_FULL) {
-#if defined(CONFIG_DRM_AMD_DC_DCN)
                dc_allow_idle_optimizations(dc, false);
 
-#endif
                if (get_seamless_boot_stream_count(context) == 0)
                        dc->hwss.prepare_bandwidth(dc, context);
 
                }
        }
 
-#ifdef CONFIG_DRM_AMD_DC_DCN
        if (stream->test_pattern.type != DP_TEST_PATTERN_VIDEO_MODE) {
                struct pipe_ctx *mpcc_pipe;
                struct pipe_ctx *odm_pipe;
                        for (odm_pipe = mpcc_pipe; odm_pipe; odm_pipe = odm_pipe->next_odm_pipe)
                                odm_pipe->ttu_regs.min_ttu_vblank = MAX_TTU;
        }
-#endif
 
        if ((update_type != UPDATE_TYPE_FAST) && stream->update_flags.bits.dsc_changed)
                if (top_pipe_to_program &&
        }
        if (dc->hwss.program_front_end_for_ctx && update_type != UPDATE_TYPE_FAST) {
                dc->hwss.program_front_end_for_ctx(dc, context);
-#ifdef CONFIG_DRM_AMD_DC_DCN
                if (dc->debug.validate_dml_output) {
                        for (i = 0; i < dc->res_pool->pipe_count; i++) {
                                struct pipe_ctx *cur_pipe = &context->res_ctx.pipe_ctx[i];
                                                &context->res_ctx.pipe_ctx[i].ttu_regs);
                        }
                }
-#endif
        }
 
        // Update Type FAST, Surface updates
        return true;
 }
 
-#if defined(CONFIG_DRM_AMD_DC_DCN)
-
 void dc_allow_idle_optimizations(struct dc *dc, bool allow)
 {
        if (dc->debug.disable_idle_power_optimizations)
        if (dc->hwss.hardware_release)
                dc->hwss.hardware_release(dc);
 }
-#endif
 
 /*
  *****************************************************************************
  */
 bool dc_is_dmub_outbox_supported(struct dc *dc)
 {
-#if defined(CONFIG_DRM_AMD_DC_DCN)
-       /* YELLOW_CARP B0 USB4 DPIA needs dmub notifications for interrupts */
+       /* DCN31 B0 USB4 DPIA needs dmub notifications for interrupts */
        if (dc->ctx->asic_id.chip_family == FAMILY_YELLOW_CARP &&
            dc->ctx->asic_id.hw_internal_rev == YELLOW_CARP_B0 &&
            !dc->debug.dpia_debug.bits.disable_dpia)
                return true;
-#endif
+
        /* dmub aux needs dmub notifications to be enabled */
        return dc->debug.enable_dmub_aux_for_legacy_ddc;
 }
 
                struct dc *dc,
                struct dc_state *context)
 {
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        DC_LOGGER_INIT(dc->ctx->logger);
        CLOCK_TRACE("Current: dispclk_khz:%d  max_dppclk_khz:%d  dcfclk_khz:%d\n"
                        "dcfclk_deep_sleep_khz:%d  fclk_khz:%d  socclk_khz:%d\n",
                        context->bw_ctx.bw.dcn.clk.dcfclk_deep_sleep_khz,
                        context->bw_ctx.bw.dcn.clk.fclk_khz,
                        context->bw_ctx.bw.dcn.clk.socclk_khz);
-#endif
 }
 
 /**
 
 
 static void apply_dpia_mst_dsc_always_on_wa(struct dc_link *link)
 {
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        /* Apply work around for tunneled MST on certain USB4 docks. Always use DSC if dock
         * reports DSC support.
         */
                        link->dpcd_caps.dsc_caps.dsc_basic_caps.fields.dsc_support.DSC_SUPPORT &&
                        !link->dc->debug.dpia_debug.bits.disable_mst_dsc_work_around)
                link->wa_flags.dpia_mst_dsc_always_on = true;
-#endif
 }
 
 static void revert_dpia_mst_dsc_always_on_wa(struct dc_link *link)
 
        else
                link->lttpr_support = LTTPR_CHECK_EXT_SUPPORT;
 
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        /* Check DP tunnel LTTPR mode debug option. */
        if (link->ep_type == DISPLAY_ENDPOINT_USB4_DPIA &&
            link->dc->debug.dpia_debug.bits.force_non_lttpr)
                link->lttpr_support = LTTPR_UNSUPPORTED;
-#endif
 
        if (link->lttpr_support > LTTPR_UNSUPPORTED) {
                /* By reading LTTPR capability, RX assumes that we will enable
                 * only if required.
                 */
                if (link->ep_type == DISPLAY_ENDPOINT_USB4_DPIA &&
-#if defined(CONFIG_DRM_AMD_DC_DCN)
                                !link->dc->debug.dpia_debug.bits.disable_force_tbt3_work_around &&
-#endif
                                link->dpcd_caps.is_branch_dev &&
                                link->dpcd_caps.branch_dev_id == DP_BRANCH_DEVICE_ID_90CC24 &&
                                link->dpcd_caps.branch_hw_revision == DP_BRANCH_HW_REV_10 &&
 
                                dp_translate_training_aux_read_interval(
                                        link->dpcd_caps.lttpr_caps.aux_rd_interval[hop - 1]);
 
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        /* Check debug option for extending aux read interval. */
        if (link->dc->debug.dpia_debug.bits.extend_aux_rd_interval)
                wait_time_microsec = DPIA_DEBUG_EXTENDED_AUX_RD_INTERVAL_US;
-#endif
 
        return wait_time_microsec;
 }
 
 #include "dce110/dce110_resource.h"
 #include "dce112/dce112_resource.h"
 #include "dce120/dce120_resource.h"
-#if defined(CONFIG_DRM_AMD_DC_DCN)
 #include "dcn10/dcn10_resource.h"
 #include "dcn20/dcn20_resource.h"
 #include "dcn21/dcn21_resource.h"
 #include "dcn31/dcn31_resource.h"
 #include "dcn315/dcn315_resource.h"
 #include "dcn316/dcn316_resource.h"
-#endif
 
 #define DC_LOGGER_INIT(logger)
 
                else
                        dc_version = DCE_VERSION_12_0;
                break;
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        case FAMILY_RV:
                dc_version = DCN_VERSION_1_0;
                if (ASICREV_IS_RAVEN2(asic_id.hw_internal_rev))
                if (ASICREV_IS_GC_10_3_7(asic_id.hw_internal_rev))
                        dc_version = DCN_VERSION_3_16;
                break;
-#endif
 
        default:
                dc_version = DCE_VERSION_UNKNOWN;
                }
        }
 
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        for (i = 0; i < caps->num_mpc_3dlut; i++) {
                pool->mpc_lut[i] = dc_create_3dlut_func();
                if (pool->mpc_lut[i] == NULL)
                if (pool->mpc_shaper[i] == NULL)
                        DC_ERR("DC: failed to create MPC shaper!\n");
        }
-#endif
+
        dc->caps.dynamic_audio = false;
        if (pool->audio_count < pool->stream_enc_count) {
                dc->caps.dynamic_audio = true;
        return pool->funcs->acquire_idle_pipe_for_layer(context, pool, head_pipe->stream);
 }
 
-#if defined(CONFIG_DRM_AMD_DC_DCN)
 static int acquire_first_split_pipe(
                struct resource_context *res_ctx,
                const struct resource_pool *pool,
        }
        return -1;
 }
-#endif
 
 bool dc_add_plane_to_context(
                const struct dc *dc,
        while (head_pipe) {
                free_pipe = acquire_free_pipe_for_head(context, pool, head_pipe);
 
-       #if defined(CONFIG_DRM_AMD_DC_DCN)
                if (!free_pipe) {
                        int pipe_idx = acquire_first_split_pipe(&context->res_ctx, pool, stream);
                        if (pipe_idx >= 0)
                                free_pipe = &context->res_ctx.pipe_ctx[pipe_idx];
                }
-       #endif
+
                if (!free_pipe) {
                        dc_plane_state_release(plane_state);
                        return false;
                /* acquire new resources */
                pipe_idx = acquire_first_free_pipe(&context->res_ctx, pool, stream);
 
-#ifdef CONFIG_DRM_AMD_DC_DCN
        if (pipe_idx < 0)
                pipe_idx = acquire_first_split_pipe(&context->res_ctx, pool, stream);
-#endif
 
        if (pipe_idx < 0 || context->res_ctx.pipe_ctx[pipe_idx].stream_res.tg == NULL)
                return DC_NO_CONTROLLER_RESOURCE;
                if (!dc->res_pool->funcs->validate_bandwidth(dc, new_ctx, fast_validate))
                        result = DC_FAIL_BANDWIDTH_VALIDATE;
 
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        /*
         * Only update link encoder to stream assignment after bandwidth validation passed.
         * TODO: Split out assignment and validation.
        if (result == DC_OK && dc->res_pool->funcs->link_encs_assign && fast_validate == false)
                dc->res_pool->funcs->link_encs_assign(
                        dc, new_ctx, new_ctx->streams, new_ctx->stream_count);
-#endif
 
        return result;
 }
        case SURFACE_PIXEL_FORMAT_GRPH_ARGB2101010:
        case SURFACE_PIXEL_FORMAT_GRPH_ABGR2101010:
        case SURFACE_PIXEL_FORMAT_GRPH_ABGR2101010_XR_BIAS:
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        case SURFACE_PIXEL_FORMAT_GRPH_RGBE:
        case SURFACE_PIXEL_FORMAT_GRPH_RGBE_ALPHA:
-#endif
                return 32;
        case SURFACE_PIXEL_FORMAT_GRPH_ARGB16161616:
        case SURFACE_PIXEL_FORMAT_GRPH_ABGR16161616:
        /* TODO - get transmitter to phy idx mapping from DMUB */
        uint8_t phy_idx = transmitter - TRANSMITTER_UNIPHY_A;
 
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        if (dc->ctx->dce_version == DCN_VERSION_3_1 &&
                        dc->ctx->asic_id.hw_internal_rev == YELLOW_CARP_B0) {
                switch (transmitter) {
                        break;
                }
        }
-#endif
+
        return phy_idx;
 }
 
 
        const struct dc_cursor_attributes *attributes)
 {
        struct dc  *dc;
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        bool reset_idle_optimizations = false;
-#endif
 
        if (NULL == stream) {
                dm_error("DC: dc_stream is NULL!\n");
 #endif
        program_cursor_attributes(dc, stream, attributes);
 
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        /* re-enable idle optimizations if necessary */
        if (reset_idle_optimizations)
                dc_allow_idle_optimizations(dc, true);
 
-#endif
        return true;
 }
 
        const struct dc_cursor_position *position)
 {
        struct dc  *dc;
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        bool reset_idle_optimizations = false;
-#endif
 
        if (NULL == stream) {
                dm_error("DC: dc_stream is NULL!\n");
        stream->cursor_position = *position;
 
        program_cursor_position(dc, stream, position);
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        /* re-enable idle optimizations if necessary */
        if (reset_idle_optimizations)
                dc_allow_idle_optimizations(dc, true);
 
-#endif
        return true;
 }
 
 
        unsigned int max_compressed_blk_size;
        unsigned int max_uncompressed_blk_size;
        bool independent_64b_blks;
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        //These bitfields to be used starting with DCN
        struct {
                uint32_t dcc_256_64_64 : 1;//available in ASICs before DCN (the worst compression case)
                uint32_t dcc_256_128_128 : 1;           //available starting with DCN
                uint32_t dcc_256_256_unconstrained : 1;  //available in ASICs before DCN (the best compression case)
        } dcc_controls;
-#endif
 };
 
 struct dc_surface_dcc_cap {
        bool enable_4to1MPC;
        bool enable_windowed_mpo_odm;
        bool allow_edp_hotplug_detection;
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        bool clamp_min_dcfclk;
-#endif
        uint64_t vblank_alignment_dto_params;
        uint8_t  vblank_alignment_max_frame_time_diff;
        bool is_asymmetric_memory;
        DCN_PWR_STATE_LOW_POWER = 3,
 };
 
-#if defined(CONFIG_DRM_AMD_DC_DCN)
 enum dcn_zstate_support_state {
        DCN_ZSTATE_SUPPORT_UNKNOWN,
        DCN_ZSTATE_SUPPORT_ALLOW,
        DCN_ZSTATE_SUPPORT_ALLOW_Z10_ONLY,
        DCN_ZSTATE_SUPPORT_DISALLOW,
 };
-#endif
 /*
  * For any clocks that may differ per pipe
  * only the max is stored in this structure
        int phyclk_khz;
        int dramclk_khz;
        bool p_state_change_support;
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        enum dcn_zstate_support_state zstate_support;
        bool dtbclk_en;
-#endif
        enum dcn_pwr_state pwr_state;
        /*
         * Elements below are not compared for the purposes of
        bool disable_pplib_clock_request;
        bool disable_clock_gate;
        bool disable_mem_low_power;
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        bool pstate_enabled;
-#endif
        bool disable_dmcu;
        bool disable_psr;
        bool force_abm_enable;
        bool remove_disconnect_edp;
        unsigned int force_odm_combine; //bit vector based on otg inst
        unsigned int seamless_boot_odm_combine;
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        unsigned int force_odm_combine_4to1; //bit vector based on otg inst
        bool disable_z9_mpc;
-#endif
        unsigned int force_fclk_khz;
        bool enable_tri_buf;
        bool dmub_offload_enabled;
        bool dmcub_emulation;
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        bool disable_idle_power_optimizations;
        unsigned int mall_size_override;
        unsigned int mall_additional_timer_percent;
        bool mall_error_as_fatal;
-#endif
        bool dmub_command_table; /* for testing only */
        struct dc_bw_validation_profile bw_val_profile;
        bool disable_fec;
         * watermarks are not affected.
         */
        unsigned int force_min_dcfclk_mhz;
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        int dwb_fi_phase;
-#endif
        bool disable_timing_sync;
        bool cm_in_bypass;
        int force_clock_mode;/*every mode change.*/
        enum det_size crb_alloc_policy;
        int crb_alloc_policy_min_disp_count;
        bool disable_z10;
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        bool enable_z9_disable_interface;
        bool enable_sw_cntl_psr;
        union dpia_debug_options dpia_debug;
-#endif
        bool apply_vendor_specific_lttpr_wa;
        bool extended_blank_optimization;
        union aux_wake_wa_options aux_wake_wa;
        /* Inputs into BW and WM calculations. */
        struct bw_calcs_dceip *bw_dceip;
        struct bw_calcs_vbios *bw_vbios;
-#ifdef CONFIG_DRM_AMD_DC_DCN
        struct dcn_soc_bounding_box *dcn_soc;
        struct dcn_ip_params *dcn_ip;
        struct display_mode_lib dml;
-#endif
 
        /* HW functions */
        struct hw_sequencer_funcs hwss;
        /* Require to optimize clocks and bandwidth for added/removed planes */
        bool optimized_required;
        bool wm_optimized_required;
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        bool idle_optimizations_allowed;
-#endif
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        bool enable_c20_dtm_b0;
-#endif
 
        /* Require to maintain clocks and bandwidth for UEFI enabled HW */
 
        uint64_t log_mask;
 
        struct dpcd_vendor_signature vendor_signature;
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        bool force_smu_not_present;
-#endif
 };
 
 struct dc_callback_init {
        struct dc_transfer_func *in_shaper_func;
        struct dc_transfer_func *blend_tf;
 
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        struct dc_transfer_func *gamcor_tf;
-#endif
        enum surface_pixel_format format;
        enum dc_rotation_angle rotation;
        enum plane_stereo_format stereo_format;
                const struct dc *dc,
                struct dc_state *dst_ctx);
 
-#if defined(CONFIG_DRM_AMD_DC_DCN)
 bool dc_acquire_release_mpc_3dlut(
                struct dc *dc, bool acquire,
                struct dc_stream_state *stream,
                struct dc_3dlut **lut,
                struct dc_transfer_func **shaper);
-#endif
 
 void dc_resource_state_copy_construct(
                const struct dc_state *src_ctx,
 
 #include "dc_link.h"
 
-#if defined(CONFIG_DRM_AMD_DC_DCN)
 uint32_t dc_get_opp_for_plane(struct dc *dc, struct dc_plane_state *plane);
 
-#endif
 /*******************************************************************************
  * Sink Interfaces - A sink corresponds to a display output device
  ******************************************************************************/
 
 enum dc_status dc_set_clock(struct dc *dc, enum dc_clock_type clock_type, uint32_t clk_khz, uint32_t stepping);
 void dc_get_clock(struct dc *dc, enum dc_clock_type clock_type, struct dc_clock_config *clock_cfg);
-#if defined(CONFIG_DRM_AMD_DC_DCN)
 
 bool dc_is_plane_eligible_for_idle_optimizations(struct dc *dc, struct dc_plane_state *plane,
                                struct dc_cursor_attributes *cursor_attr);
 /* cleanup on driver unload */
 void dc_hardware_release(struct dc *dc);
 
-#endif
-
 bool dc_set_psr_allow_active(struct dc *dc, bool enable);
-#if defined(CONFIG_DRM_AMD_DC_DCN)
 void dc_z10_restore(const struct dc *dc);
 void dc_z10_save_init(struct dc *dc);
-#endif
 
 bool dc_is_dmub_outbox_supported(struct dc *dc);
 bool dc_enable_dmub_notifications(struct dc *dc);
 
                struct dc_context *ctx,
                struct dc_clocks *clks);
 
-#if defined(CONFIG_DRM_AMD_DC_DCN)
 void dm_helpers_enable_periodic_detection(struct dc_context *ctx, bool enable);
-#endif
 
 void dm_set_phyd32clk(struct dc_context *ctx, int freq_khz);
 
 
 #include "dc_bios_types.h"
 #include "mem_input.h"
 #include "hubp.h"
-#if defined(CONFIG_DRM_AMD_DC_DCN)
 #include "mpc.h"
-#endif
 #include "dwb.h"
 #include "mcif_wb.h"
 #include "panel_cntl.h"
        void (*update_bw_bounding_box)(
                        struct dc *dc,
                        struct clk_bw_params *bw_params);
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        bool (*acquire_post_bldn_3dlut)(
                        struct resource_context *res_ctx,
                        const struct resource_pool *pool,
                        const struct resource_pool *pool,
                        struct dc_3dlut **lut,
                        struct dc_transfer_func **shaper);
-#endif
+
        enum dc_status (*add_dsc_to_stream_resource)(
                        struct dc *dc, struct dc_state *state,
                        struct dc_stream_state *stream);
        struct hpo_dp_stream_encoder *hpo_dp_stream_enc[MAX_HPO_DP2_ENCODERS];
        unsigned int hpo_dp_link_enc_count;
        struct hpo_dp_link_encoder *hpo_dp_link_enc[MAX_HPO_DP2_LINK_ENCODERS];
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        struct dc_3dlut *mpc_lut[MAX_PIPES];
        struct dc_transfer_func *mpc_shaper[MAX_PIPES];
-#endif
+
        struct {
                unsigned int xtalin_clock_inKhz;
                unsigned int dccg_ref_clock_inKhz;
        struct dmcu *dmcu;
        struct dmub_psr *psr;
 
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        struct abm *multiple_abms[MAX_PIPES];
-#endif
 
        const struct resource_funcs *funcs;
        const struct resource_caps *res_cap;
        struct pipe_ctx *next_odm_pipe;
        struct pipe_ctx *prev_odm_pipe;
 
-#ifdef CONFIG_DRM_AMD_DC_DCN
        struct _vcs_dpi_display_dlg_regs_st dlg_regs;
        struct _vcs_dpi_display_ttu_regs_st ttu_regs;
        struct _vcs_dpi_display_rq_regs_st rq_regs;
        struct _vcs_dpi_display_e2e_pipe_params_st dml_input;
        int det_buffer_size_kb;
        bool unbounded_req;
-#endif
+
        union pipe_update_flags update_flags;
        struct dwbc *dwbc;
        struct mcif_wb *mcif_wb;
        bool is_hpo_dp_stream_enc_acquired[MAX_HPO_DP2_ENCODERS];
        unsigned int hpo_dp_link_enc_to_link_idx[MAX_HPO_DP2_LINK_ENCODERS];
        int hpo_dp_link_enc_ref_cnts[MAX_HPO_DP2_LINK_ENCODERS];
-#if defined(CONFIG_DRM_AMD_DC_DCN)
        bool is_mpc_3dlut_acquired[MAX_PIPES];
-#endif
 };
 
 struct dce_bw_output {
 
        /* Note: these are big structures, do *not* put on stack! */
        struct dm_pp_display_configuration pp_display_cfg;
-#ifdef CONFIG_DRM_AMD_DC_DCN
        struct dcn_bw_internal_vars dcn_bw_vars;
-#endif
 
        struct clk_mgr *clk_mgr;