pp_funcs->set_hard_min_fclk_by_freq(pp_handle, mhz);
 }
 
-void dm_pp_get_funcs_rv(
+void dm_pp_get_funcs(
                struct dc_context *ctx,
-               struct pp_smu_funcs_rv *funcs)
+               struct pp_smu_funcs *funcs)
 {
-       funcs->pp_smu.dm = ctx;
-       funcs->set_display_requirement = pp_rv_set_display_requirement;
-       funcs->set_wm_ranges = pp_rv_set_wm_ranges;
-       funcs->set_pme_wa_enable = pp_rv_set_pme_wa_enable;
-       funcs->set_display_count = pp_rv_set_active_display_count;
-       funcs->set_min_deep_sleep_dcfclk = pp_rv_set_min_deep_sleep_dcfclk;
-       funcs->set_hard_min_dcfclk_by_freq = pp_rv_set_hard_min_dcefclk_by_freq;
-       funcs->set_hard_min_fclk_by_freq = pp_rv_set_hard_min_fclk_by_freq;
+       funcs->rv_funcs.pp_smu.dm = ctx;
+       funcs->rv_funcs.set_display_requirement = pp_rv_set_display_requirement;
+       funcs->rv_funcs.set_wm_ranges = pp_rv_set_wm_ranges;
+       funcs->rv_funcs.set_pme_wa_enable = pp_rv_set_pme_wa_enable;
+       funcs->rv_funcs.set_display_count = pp_rv_set_active_display_count;
+       funcs->rv_funcs.set_min_deep_sleep_dcfclk = pp_rv_set_min_deep_sleep_dcfclk;
+       funcs->rv_funcs.set_hard_min_dcfclk_by_freq = pp_rv_set_hard_min_dcefclk_by_freq;
+       funcs->rv_funcs.set_hard_min_fclk_by_freq = pp_rv_set_hard_min_fclk_by_freq;
 }
 
 
 
 void dcn_bw_notify_pplib_of_wm_ranges(struct dc *dc)
 {
-       struct pp_smu_funcs_rv *pp = dc->res_pool->pp_smu;
+       struct pp_smu_funcs_rv *pp = &dc->res_pool->pp_smu->rv_funcs;
        struct pp_smu_wm_range_sets ranges = {0};
        int min_fclk_khz, min_dcfclk_khz, socclk_khz;
        const int overdrive = 5000000; /* 5 GHz to cover Overdrive */
 
                edp_receiver_ready_T9(link);
 }
 
+// Static helper function which calls the correct function
+// based on pp_smu version
+static void set_pme_wa_enable_by_version(struct dc *dc)
+{
+       struct pp_smu_funcs *pp_smu = NULL;
+
+       if (dc->res_pool->pp_smu)
+               pp_smu = dc->res_pool->pp_smu;
+
+       if (pp_smu) {
+               if (pp_smu->ctx.ver == PP_SMU_VER_RV && pp_smu->rv_funcs.set_pme_wa_enable)
+                       pp_smu->rv_funcs.set_pme_wa_enable(&(pp_smu->ctx));
+       }
+}
+
 void dce110_enable_audio_stream(struct pipe_ctx *pipe_ctx)
 {
-       struct dc *core_dc = pipe_ctx->stream->ctx->dc;
        /* notify audio driver for audio modes of monitor */
-       struct pp_smu_funcs_rv *pp_smu = core_dc->res_pool->pp_smu;
+       struct dc *core_dc = pipe_ctx->stream->ctx->dc;
+       struct pp_smu_funcs *pp_smu = NULL;
        unsigned int i, num_audio = 1;
 
+       if (core_dc->res_pool->pp_smu)
+               pp_smu = core_dc->res_pool->pp_smu;
+
        if (pipe_ctx->stream_res.audio) {
                for (i = 0; i < MAX_PIPES; i++) {
                        /*current_state not updated yet*/
 
                pipe_ctx->stream_res.audio->funcs->az_enable(pipe_ctx->stream_res.audio);
 
-               if (num_audio >= 1 && pp_smu != NULL && pp_smu->set_pme_wa_enable != NULL)
+               if (num_audio >= 1 && pp_smu != NULL)
                        /*this is the first audio. apply the PME w/a in order to wake AZ from D3*/
-                       pp_smu->set_pme_wa_enable(&pp_smu->pp_smu);
+                       set_pme_wa_enable_by_version(core_dc);
                /* un-mute audio */
                /* TODO: audio should be per stream rather than per link */
                pipe_ctx->stream_res.stream_enc->funcs->audio_mute_control(
 void dce110_disable_audio_stream(struct pipe_ctx *pipe_ctx, int option)
 {
        struct dc *dc = pipe_ctx->stream->ctx->dc;
+       struct pp_smu_funcs *pp_smu = NULL;
 
        pipe_ctx->stream_res.stream_enc->funcs->audio_mute_control(
                        pipe_ctx->stream_res.stream_enc, true);
        if (pipe_ctx->stream_res.audio) {
-               struct pp_smu_funcs_rv *pp_smu = dc->res_pool->pp_smu;
+               if (dc->res_pool->pp_smu)
+                       pp_smu = dc->res_pool->pp_smu;
 
                if (option != KEEP_ACQUIRED_RESOURCE ||
-                               !dc->debug.az_endpoint_mute_only) {
+                               !dc->debug.az_endpoint_mute_only)
                        /*only disalbe az_endpoint if power down or free*/
                        pipe_ctx->stream_res.audio->funcs->az_disable(pipe_ctx->stream_res.audio);
-               }
 
                if (dc_is_dp_signal(pipe_ctx->stream->signal))
                        pipe_ctx->stream_res.stream_enc->funcs->dp_audio_disable(
                        update_audio_usage(&dc->current_state->res_ctx, dc->res_pool, pipe_ctx->stream_res.audio, false);
                        pipe_ctx->stream_res.audio = NULL;
                }
-               if (pp_smu != NULL && pp_smu->set_pme_wa_enable != NULL)
+               if (pp_smu != NULL)
                        /*this is the first audio. apply the PME w/a in order to wake AZ from D3*/
-                       pp_smu->set_pme_wa_enable(&pp_smu->pp_smu);
+                       set_pme_wa_enable_by_version(dc);
 
                /* TODO: notify audio driver for if audio modes list changed
                 * add audio mode list change flag */
 
        struct pp_smu_display_requirement_rv *smu_req_cur =
                        &dc->res_pool->pp_smu_req;
        struct pp_smu_display_requirement_rv smu_req = *smu_req_cur;
-       struct pp_smu_funcs_rv *pp_smu = dc->res_pool->pp_smu;
+       struct pp_smu_funcs_rv *pp_smu = &dc->res_pool->pp_smu->rv_funcs;
        bool send_request_to_increase = false;
        bool send_request_to_lower = false;
        int display_count;
 
        *clk_src = NULL;
 }
 
-static struct pp_smu_funcs_rv *dcn10_pp_smu_create(struct dc_context *ctx)
+static struct pp_smu_funcs *dcn10_pp_smu_create(struct dc_context *ctx)
 {
-       struct pp_smu_funcs_rv *pp_smu = kzalloc(sizeof(*pp_smu), GFP_KERNEL);
+       struct pp_smu_funcs *pp_smu = kzalloc(sizeof(*pp_smu), GFP_KERNEL);
 
        if (!pp_smu)
                return pp_smu;
 
-       dm_pp_get_funcs_rv(ctx, pp_smu);
+       dm_pp_get_funcs(ctx, pp_smu);
        return pp_smu;
 }
 
 
  * interface to PPLIB/SMU to setup clocks and pstate requirements on SoC
  */
 
+typedef bool BOOLEAN;
+
 enum pp_smu_ver {
        /*
         * PP_SMU_INTERFACE_X should be interpreted as the interface defined
 
        const struct dc_context *ctx,
        struct dm_pp_wm_sets_with_clock_ranges *wm_with_clock_ranges);
 
-void dm_pp_get_funcs_rv(struct dc_context *ctx,
-               struct pp_smu_funcs_rv *funcs);
+void dm_pp_get_funcs(struct dc_context *ctx,
+               struct pp_smu_funcs *funcs);
 
 /* DAL calls this function to notify PP about completion of Mode Set.
  * For PP it means that current DCE clocks are those which were returned
 
 #include "os_types.h"
 #include "dc_types.h"
 
-struct pp_smu_funcs_rv;
+struct pp_smu_funcs;
 
 struct dm_pp_clock_range {
        int min_khz;
 
 extern const struct _vcs_dpi_ip_params_st dcn1_0_ip;
 extern const struct _vcs_dpi_soc_bounding_box_st dcn1_0_soc;
 
+static void set_soc_bounding_box_v2(struct display_mode_lib *lib,
+       const struct _vcs_dpi_soc_bounding_box_st *soc_bb)
+{
+       lib->soc =  *soc_bb;
+}
+
 static void set_soc_bounding_box(struct _vcs_dpi_soc_bounding_box_st *soc, enum dml_project project)
 {
        switch (project) {
        }
 }
 
+static void set_ip_params_v2(struct display_mode_lib *lib,
+       const struct _vcs_dpi_ip_params_st *ip_params)
+{
+       lib->ip =  *ip_params;
+}
+
 static void set_ip_params(struct _vcs_dpi_ip_params_st *ip, enum dml_project project)
 {
        switch (project) {
        }
 }
 
+void dml_init_instance_v2(struct display_mode_lib *lib,
+               const struct _vcs_dpi_soc_bounding_box_st *soc_bb,
+               const struct _vcs_dpi_ip_params_st *ip_params,
+               enum dml_project project)
+{
+       if (lib->project != project) {
+               set_soc_bounding_box_v2(lib, soc_bb);
+               set_ip_params_v2(lib, ip_params);
+               lib->project = project;
+       }
+}
+
 const char *dml_get_status_message(enum dm_validation_status status)
 {
        switch (status) {
 
 
 void dml_init_instance(struct display_mode_lib *lib, enum dml_project project);
 
+void dml_init_instance_v2(struct display_mode_lib *lib,
+               const struct _vcs_dpi_soc_bounding_box_st *soc_bb,
+               const struct _vcs_dpi_ip_params_st *ip_params,
+               enum dml_project project);
+
 const char *dml_get_status_message(enum dm_validation_status status);
 
 #endif
 
        struct stream_encoder *stream_enc[MAX_PIPES * 2];
        struct hubbub *hubbub;
        struct mpc *mpc;
-       struct pp_smu_funcs_rv *pp_smu;
+       struct pp_smu_funcs *pp_smu;
        struct pp_smu_display_requirement_rv pp_smu_req;
        struct dce_aux *engines[MAX_PIPES];
        struct dce_i2c_hw *hw_i2cs[MAX_PIPES];