if (!rc)
                        DRM_DEBUG("DM: Failed to update backlight via AUX on eDP[%d]\n", bl_idx);
        } else {
-               rc = dc_link_set_backlight_level(link, brightness, 0);
+               struct set_backlight_level_params backlight_level_params = { 0 };
+
+               backlight_level_params.backlight_pwm_u16_16 = brightness;
+               backlight_level_params.transition_time_in_ms = 0;
+
+               rc = dc_link_set_backlight_level(link, &backlight_level_params);
                if (!rc)
                        DRM_DEBUG("DM: Failed to update backlight on eDP[%d]\n", bl_idx);
        }
 
 }
 
 bool dc_link_set_backlight_level(const struct dc_link *link,
-               uint32_t backlight_pwm_u16_16,
-               uint32_t frame_ramp)
+               struct set_backlight_level_params *backlight_level_params)
 {
        return link->dc->link_srv->edp_set_backlight_level(link,
-                       backlight_pwm_u16_16, frame_ramp);
+                       backlight_level_params);
 }
 
 bool dc_link_set_backlight_level_nits(struct dc_link *link,
 
        bool subvp_psr;
        bool gecc_enable;
        uint8_t fams_ver;
+       bool aux_backlight_support;
 };
 
 struct dc_scl_caps {
  * and 16 bit fractional, where 1.0 is max backlight value.
  */
 bool dc_link_set_backlight_level(const struct dc_link *dc_link,
-               uint32_t backlight_pwm_u16_16,
-               uint32_t frame_ramp);
+               struct set_backlight_level_params *backlight_level_params);
 
 /* Set/get nits-based backlight level of an embedded panel (eDP, LVDS). */
 bool dc_link_set_backlight_level_nits(struct dc_link *link,
 
        enum dc_power_source_type power_source;
 };
 
+struct set_backlight_level_params {
+       /* backlight in pwm */
+       uint32_t backlight_pwm_u16_16;
+       /* brightness ramping */
+       uint32_t frame_ramp;
+       /* backlight control type
+        * 0: PWM backlight control
+        * 1: VESA AUX backlight control
+        * 2: AMD AUX backlight control
+        */
+       enum backlight_control_type control_type;
+       /* backlight in millinits */
+       uint32_t backlight_millinits;
+       /* transition time in ms */
+       uint32_t transition_time_in_ms;
+       /* minimum luminance in nits */
+       uint32_t min_luminance;
+       /* maximum luminance in nits */
+       uint32_t max_luminance;
+       /* minimum backlight in pwm */
+       uint32_t min_backlight_pwm;
+       /* maximum backlight in pwm */
+       uint32_t max_backlight_pwm;
+       /* AUX HW instance */
+       uint8_t aux_inst;
+};
+
 #endif /* DC_TYPES_H_ */
 
 }
 
 bool dce110_set_backlight_level(struct pipe_ctx *pipe_ctx,
-       struct set_backlight_level_params *params)
+       struct set_backlight_level_params *backlight_level_params)
 {
-       uint32_t backlight_pwm_u16_16 = params->backlight_pwm_u16_16;
-       uint32_t frame_ramp = params->frame_ramp;
+       uint32_t backlight_pwm_u16_16 = backlight_level_params->backlight_pwm_u16_16;
+       uint32_t frame_ramp = backlight_level_params->frame_ramp;
        struct dc_link *link = pipe_ctx->stream->link;
        struct dc  *dc = link->ctx->dc;
        struct abm *abm = pipe_ctx->stream_res.abm;
 
        pipe_ctx->stream->dpms_off = true;
 }
 
-static bool dmub_abm_set_pipe(struct abm *abm, uint32_t otg_inst,
+bool dcn21_dmub_abm_set_pipe(struct abm *abm, uint32_t otg_inst,
                uint32_t option, uint32_t panel_inst, uint32_t pwrseq_inst)
 {
        union dmub_rb_cmd cmd;
                        abm->funcs->set_pipe_ex(abm, otg_inst, SET_ABM_PIPE_IMMEDIATELY_DISABLE,
                                        panel_cntl->inst, panel_cntl->pwrseq_inst);
                } else {
-                               dmub_abm_set_pipe(abm,
+                       dcn21_dmub_abm_set_pipe(abm,
                                                otg_inst,
                                                SET_ABM_PIPE_IMMEDIATELY_DISABLE,
                                                panel_cntl->inst,
                                        panel_cntl->inst,
                                        panel_cntl->pwrseq_inst);
        } else {
-               dmub_abm_set_pipe(abm, otg_inst,
+                       dcn21_dmub_abm_set_pipe(abm, otg_inst,
                                  SET_ABM_PIPE_NORMAL,
                                  panel_cntl->inst,
                                  panel_cntl->pwrseq_inst);
 }
 
 bool dcn21_set_backlight_level(struct pipe_ctx *pipe_ctx,
-       struct set_backlight_level_params *params)
+       struct set_backlight_level_params *backlight_level_params)
 {
        struct dc_context *dc = pipe_ctx->stream->ctx;
        struct abm *abm = pipe_ctx->stream_res.abm;
        struct timing_generator *tg = pipe_ctx->stream_res.tg;
        struct panel_cntl *panel_cntl = pipe_ctx->stream->link->panel_cntl;
        uint32_t otg_inst;
-       uint32_t backlight_pwm_u16_16 = params->backlight_pwm_u16_16;
-       uint32_t frame_ramp = params->frame_ramp;
+       uint32_t backlight_pwm_u16_16 = backlight_level_params->backlight_pwm_u16_16;
+       uint32_t frame_ramp = backlight_level_params->frame_ramp;
 
        if (!abm || !tg || !panel_cntl)
                return false;
        otg_inst = tg->inst;
 
        if (dc->dc->res_pool->dmcu) {
-               dce110_set_backlight_level(pipe_ctx, params);
+               dce110_set_backlight_level(pipe_ctx, backlight_level_params);
                return true;
        }
 
                                        panel_cntl->inst,
                                        panel_cntl->pwrseq_inst);
        } else {
-               dmub_abm_set_pipe(abm,
+                       dcn21_dmub_abm_set_pipe(abm,
                                  otg_inst,
                                  SET_ABM_PIPE_NORMAL,
                                  panel_cntl->inst,
 
 void dcn21_PLAT_58856_wa(struct dc_state *context,
                struct pipe_ctx *pipe_ctx);
 
+bool dcn21_dmub_abm_set_pipe(struct abm *abm, uint32_t otg_inst,
+       uint32_t option, uint32_t panel_inst, uint32_t pwrseq_inst);
 void dcn21_set_pipe(struct pipe_ctx *pipe_ctx);
 void dcn21_set_abm_immediate_disable(struct pipe_ctx *pipe_ctx);
 bool dcn21_set_backlight_level(struct pipe_ctx *pipe_ctx,
 
 #include "dce/dmub_outbox.h"
 #include "link.h"
 #include "dcn10/dcn10_hwseq.h"
+#include "dcn21/dcn21_hwseq.h"
 #include "inc/link_enc_cfg.h"
 #include "dcn30/dcn30_vpg.h"
 #include "dce/dce_i2c_hw.h"
+#include "dce/dmub_abm_lcd.h"
 
 #define DC_LOGGER_INIT(logger)
 
                pipe_ctx[i]->stream_res.tg->funcs->set_static_screen_control(pipe_ctx[i]->stream_res.tg,
                                        triggers, params->num_frames);
 }
+
+static void dmub_abm_set_backlight(struct dc_context *dc,
+       struct set_backlight_level_params *backlight_level_params, uint32_t panel_inst)
+{
+       union dmub_rb_cmd cmd;
+
+       memset(&cmd, 0, sizeof(cmd));
+       cmd.abm_set_backlight.header.type = DMUB_CMD__ABM;
+       cmd.abm_set_backlight.header.sub_type = DMUB_CMD__ABM_SET_BACKLIGHT;
+       cmd.abm_set_backlight.abm_set_backlight_data.frame_ramp = backlight_level_params->frame_ramp;
+       cmd.abm_set_backlight.abm_set_backlight_data.backlight_user_level = backlight_level_params->backlight_pwm_u16_16;
+       cmd.abm_set_backlight.abm_set_backlight_data.backlight_control_type = backlight_level_params->control_type;
+       cmd.abm_set_backlight.abm_set_backlight_data.min_luminance = backlight_level_params->min_luminance;
+       cmd.abm_set_backlight.abm_set_backlight_data.max_luminance = backlight_level_params->max_luminance;
+       cmd.abm_set_backlight.abm_set_backlight_data.min_backlight_pwm = backlight_level_params->min_backlight_pwm;
+       cmd.abm_set_backlight.abm_set_backlight_data.max_backlight_pwm = backlight_level_params->max_backlight_pwm;
+       cmd.abm_set_backlight.abm_set_backlight_data.version = DMUB_CMD_ABM_CONTROL_VERSION_1;
+       cmd.abm_set_backlight.abm_set_backlight_data.panel_mask = (0x01 << panel_inst);
+       cmd.abm_set_backlight.header.payload_bytes = sizeof(struct dmub_cmd_abm_set_backlight_data);
+
+       dc_wake_and_execute_dmub_cmd(dc, &cmd, DM_DMUB_WAIT_TYPE_WAIT);
+}
+
+bool dcn31_set_backlight_level(struct pipe_ctx *pipe_ctx,
+       struct set_backlight_level_params *backlight_level_params)
+{
+       struct dc_context *dc = pipe_ctx->stream->ctx;
+       struct abm *abm = pipe_ctx->stream_res.abm;
+       struct timing_generator *tg = pipe_ctx->stream_res.tg;
+       struct panel_cntl *panel_cntl = pipe_ctx->stream->link->panel_cntl;
+       uint32_t otg_inst;
+
+       if (!abm || !tg || !panel_cntl)
+               return false;
+
+       otg_inst = tg->inst;
+
+               dcn21_dmub_abm_set_pipe(abm,
+                       otg_inst,
+                       SET_ABM_PIPE_NORMAL,
+                       panel_cntl->inst,
+                       panel_cntl->pwrseq_inst);
+
+       dmub_abm_set_backlight(dc, backlight_level_params, panel_cntl->inst);
+
+       return true;
+}
 
 void dcn31_reset_hw_ctx_wrap(
                struct dc *dc,
                struct dc_state *context);
+bool dcn31_set_backlight_level(struct pipe_ctx *pipe_ctx,
+               struct set_backlight_level_params *params);
 bool dcn31_is_abm_supported(struct dc *dc,
                struct dc_state *context, struct dc_stream_state *stream);
 void dcn31_init_pipes(struct dc *dc, struct dc_state *context);
 void dcn31_set_static_screen_control(struct pipe_ctx **pipe_ctx,
                int num_pipes, const struct dc_static_screen_params *params);
 
-
 #endif /* __DC_HWSS_DCN31_H__ */
 
        .set_flip_control_gsl = dcn20_set_flip_control_gsl,
        .get_vupdate_offset_from_vsync = dcn10_get_vupdate_offset_from_vsync,
        .calc_vupdate_position = dcn10_calc_vupdate_position,
-       .set_backlight_level = dcn21_set_backlight_level,
+       .set_backlight_level = dcn31_set_backlight_level,
        .set_abm_immediate_disable = dcn21_set_abm_immediate_disable,
        .set_pipe = dcn21_set_pipe,
        .enable_lvds_link_output = dce110_enable_lvds_link_output,
 
        .set_flip_control_gsl = dcn20_set_flip_control_gsl,
        .get_vupdate_offset_from_vsync = dcn10_get_vupdate_offset_from_vsync,
        .calc_vupdate_position = dcn10_calc_vupdate_position,
-       .set_backlight_level = dcn21_set_backlight_level,
+       .set_backlight_level = dcn31_set_backlight_level,
        .set_abm_immediate_disable = dcn21_set_abm_immediate_disable,
        .set_pipe = dcn21_set_pipe,
        .enable_lvds_link_output = dce110_enable_lvds_link_output,
 
        .calc_vupdate_position = dcn10_calc_vupdate_position,
        .apply_idle_power_optimizations = dcn32_apply_idle_power_optimizations,
        .does_plane_fit_in_mall = NULL,
-       .set_backlight_level = dcn21_set_backlight_level,
+       .set_backlight_level = dcn31_set_backlight_level,
        .set_abm_immediate_disable = dcn21_set_abm_immediate_disable,
        .hardware_release = dcn30_hardware_release,
        .set_pipe = dcn21_set_pipe,
 
                dc_dmub_srv_query_caps_cmd(dc->ctx->dmub_srv);
                dc->caps.dmub_caps.psr = dc->ctx->dmub_srv->dmub->feature_caps.psr;
                dc->caps.dmub_caps.mclk_sw = dc->ctx->dmub_srv->dmub->feature_caps.fw_assisted_mclk_switch_ver;
+               dc->caps.dmub_caps.aux_backlight_support = dc->ctx->dmub_srv->dmub->feature_caps.abm_aux_backlight_support;
        }
 
        if (dc->res_pool->pg_cntl) {
 
        .set_flip_control_gsl = dcn20_set_flip_control_gsl,
        .get_vupdate_offset_from_vsync = dcn10_get_vupdate_offset_from_vsync,
        .calc_vupdate_position = dcn10_calc_vupdate_position,
-       .set_backlight_level = dcn21_set_backlight_level,
+       .set_backlight_level = dcn31_set_backlight_level,
        .set_abm_immediate_disable = dcn21_set_abm_immediate_disable,
        .set_pipe = dcn21_set_pipe,
        .enable_lvds_link_output = dce110_enable_lvds_link_output,
 
        .set_flip_control_gsl = dcn20_set_flip_control_gsl,
        .get_vupdate_offset_from_vsync = dcn10_get_vupdate_offset_from_vsync,
        .calc_vupdate_position = dcn10_calc_vupdate_position,
-       .set_backlight_level = dcn21_set_backlight_level,
+       .set_backlight_level = dcn31_set_backlight_level,
        .set_abm_immediate_disable = dcn21_set_abm_immediate_disable,
        .set_pipe = dcn21_set_pipe,
        .enable_lvds_link_output = dce110_enable_lvds_link_output,
 
        .calc_vupdate_position = dcn10_calc_vupdate_position,
        .apply_idle_power_optimizations = dcn401_apply_idle_power_optimizations,
        .does_plane_fit_in_mall = NULL,
-       .set_backlight_level = dcn21_set_backlight_level,
+       .set_backlight_level = dcn31_set_backlight_level,
        .set_abm_immediate_disable = dcn21_set_abm_immediate_disable,
        .hardware_release = dcn401_hardware_release,
        .set_pipe = dcn21_set_pipe,
 
        struct fams2_global_control_lock_fast_params fams2_global_control_lock_fast_params;
 };
 
-struct set_backlight_level_params {
-       uint32_t backlight_pwm_u16_16;
-       uint32_t frame_ramp;
-};
-
 enum block_sequence_func {
        DMUB_SUBVP_PIPE_CONTROL_LOCK_FAST = 0,
        OPTC_PIPE_CONTROL_LOCK,
 
                        uint32_t *backlight_millinits_avg,
                        uint32_t *backlight_millinits_peak);
        bool (*edp_set_backlight_level)(const struct dc_link *link,
-                       uint32_t backlight_pwm_u16_16,
-                       uint32_t frame_ramp);
+                       struct set_backlight_level_params *backlight_level_params);
        bool (*edp_set_backlight_level_nits)(struct dc_link *link,
                        bool isHDR,
                        uint32_t backlight_millinits,
 
                        link->connector_signal != SIGNAL_TYPE_DISPLAY_PORT))
                return false;
 
-       if (link->backlight_control_type == BACKLIGHT_CONTROL_VESA_AUX) {
+       // use internal backlight control if dmub capabilities are not present
+       if (link->backlight_control_type == BACKLIGHT_CONTROL_VESA_AUX &&
+               !link->dc->caps.dmub_caps.aux_backlight_support) {
                uint8_t backlight_enable = 0;
                struct target_luminance_value *target_luminance = NULL;
 
                        (uint8_t *)(target_luminance),
                        sizeof(struct target_luminance_value)) != DC_OK)
                        return false;
-       } else {
+       } else if (link->backlight_control_type == BACKLIGHT_CONTROL_AMD_AUX) {
                struct dpcd_source_backlight_set dpcd_backlight_set;
                *(uint32_t *)&dpcd_backlight_set.backlight_level_millinits = backlight_millinits;
                *(uint16_t *)&dpcd_backlight_set.backlight_transition_time_ms = (uint16_t)transition_time_in_ms;
 }
 
 bool edp_set_backlight_level(const struct dc_link *link,
-               uint32_t backlight_pwm_u16_16,
-               uint32_t frame_ramp)
+               struct set_backlight_level_params *backlight_level_params)
 {
        struct dc  *dc = link->ctx->dc;
+       uint32_t backlight_pwm_u16_16 = backlight_level_params->backlight_pwm_u16_16;
+       uint32_t frame_ramp = backlight_level_params->frame_ramp;
        DC_LOGGER_INIT(link->ctx->logger);
        DC_LOG_BACKLIGHT("New Backlight level: %d (0x%X)\n",
                        backlight_pwm_u16_16, backlight_pwm_u16_16);
 
        if (dc_is_embedded_signal(link->connector_signal)) {
                struct pipe_ctx *pipe_ctx = get_pipe_from_link(link);
-               struct set_backlight_level_params backlight_level_param = { 0 };
 
                if (link->panel_cntl)
                        link->panel_cntl->stored_backlight_registers.USER_LEVEL = backlight_pwm_u16_16;
                        return false;
                }
 
-               backlight_level_param.backlight_pwm_u16_16 = backlight_pwm_u16_16;
-               backlight_level_param.frame_ramp = frame_ramp;
+               backlight_level_params->frame_ramp = frame_ramp;
 
                dc->hwss.set_backlight_level(
                                pipe_ctx,
-                               &backlight_level_param);
+                               backlight_level_params);
        }
        return true;
 }
 
                uint32_t *backlight_millinits_avg,
                uint32_t *backlight_millinits_peak);
 bool edp_set_backlight_level(const struct dc_link *link,
-               uint32_t backlight_pwm_u16_16,
-               uint32_t frame_ramp);
+               struct set_backlight_level_params *backlight_level_params);
 bool edp_set_backlight_level_nits(struct dc_link *link,
                bool isHDR,
                uint32_t backlight_millinits,