}
 
 
-enum dc_status dc_link_aux_configure_timeout(struct ddc_service *ddc,
+uint32_t dc_link_aux_configure_timeout(struct ddc_service *ddc,
                uint32_t timeout)
 {
-       enum dc_status status = DC_OK;
+       uint32_t prev_timeout = 0;
        struct ddc *ddc_pin = ddc->ddc_pin;
 
-       if (ddc->ctx->dc->res_pool->engines[ddc_pin->pin_data->en]->funcs->configure_timeout == NULL)
-               return DC_ERROR_UNEXPECTED;
-       if (!ddc->ctx->dc->res_pool->engines[ddc_pin->pin_data->en]->funcs->configure_timeout(ddc, timeout))
-               status = DC_ERROR_UNEXPECTED;
-       return status;
+       if (ddc->ctx->dc->res_pool->engines[ddc_pin->pin_data->en]->funcs->configure_timeout)
+               prev_timeout =
+                               ddc->ctx->dc->res_pool->engines[ddc_pin->pin_data->en]->funcs->configure_timeout(ddc, timeout);
+       return prev_timeout;
 }
 
 /*test only function*/
 
        union dp_downstream_port_present ds_port = { 0 };
        enum dc_status status = DC_ERROR_UNEXPECTED;
        uint32_t read_dpcd_retry_cnt = 3;
+       uint32_t prev_timeout_val;
        int i;
        struct dp_sink_hw_fw_revision dp_hw_fw_revision;
 
        link->is_lttpr_mode_transparent = true;
 
        if (ext_timeout_support) {
-               status = dc_link_aux_configure_timeout(link->ddc, LINK_AUX_DEFAULT_EXTENDED_TIMEOUT_PERIOD);
+               prev_timeout_val =
+                               dc_link_aux_configure_timeout(link->ddc,
+                                               LINK_AUX_DEFAULT_EXTENDED_TIMEOUT_PERIOD);
        }
 
        memset(dpcd_data, '\0', sizeof(dpcd_data));
                return false;
        }
 
-       if (ext_timeout_support && link->dpcd_caps.dpcd_rev.raw >= 0x14) {
+       if (ext_timeout_support) {
                status = core_link_read_dpcd(
                                link,
                                DP_PHY_REPEATER_CNT,
                                        &link->dpcd_caps.lttpr_caps.max_ext_timeout,
                                        sizeof(link->dpcd_caps.lttpr_caps.max_ext_timeout));
                } else {
-                       dc_link_aux_configure_timeout(link->ddc, LINK_AUX_DEFAULT_TIMEOUT_PERIOD);
+                       dc_link_aux_configure_timeout(link->ddc, prev_timeout_val);
                }
        }
 
 
        AUX_DEFER_RETRY_COUNTER = 6
 };
 
-#define TIME_OUT_INCREMENT      1016
-#define TIME_OUT_MULTIPLIER_8  8
-#define TIME_OUT_MULTIPLIER_16  16
-#define TIME_OUT_MULTIPLIER_32  32
-#define TIME_OUT_MULTIPLIER_64  64
-#define MAX_TIMEOUT_LENGTH      127
+#define TIME_OUT_INCREMENT        1016
+#define TIME_OUT_MULTIPLIER_8     8
+#define TIME_OUT_MULTIPLIER_16    16
+#define TIME_OUT_MULTIPLIER_32    32
+#define TIME_OUT_MULTIPLIER_64    64
+#define MAX_TIMEOUT_LENGTH        127
+#define DEFAULT_AUX_ENGINE_MULT   0
+#define DEFAULT_AUX_ENGINE_LENGTH 69
 
 static void release_engine(
        struct dce_aux *engine)
 
 }
 
-static bool dce_aux_configure_timeout(struct ddc_service *ddc,
+static uint32_t dce_aux_configure_timeout(struct ddc_service *ddc,
                uint32_t timeout_in_us)
 {
        uint32_t multiplier = 0;
        uint32_t length = 0;
+       uint32_t prev_length = 0;
+       uint32_t prev_mult = 0;
+       uint32_t prev_timeout_val = 0;
        struct ddc *ddc_pin = ddc->ddc_pin;
        struct dce_aux *aux_engine = ddc->ctx->dc->res_pool->engines[ddc_pin->pin_data->en];
        struct aux_engine_dce110 *aux110 = FROM_AUX_ENGINE(aux_engine);
        aux110->polling_timeout_period = timeout_in_us * SW_AUX_TIMEOUT_PERIOD_MULTIPLIER;
 
        /* 2-Update aux timeout period length and multiplier */
-       if (timeout_in_us <= TIME_OUT_INCREMENT) {
+       if (timeout_in_us == 0) {
+               multiplier = DEFAULT_AUX_ENGINE_MULT;
+               length = DEFAULT_AUX_ENGINE_LENGTH;
+       } else if (timeout_in_us <= TIME_OUT_INCREMENT) {
                multiplier = 0;
                length = timeout_in_us/TIME_OUT_MULTIPLIER_8;
                if (timeout_in_us % TIME_OUT_MULTIPLIER_8 != 0)
 
        length = (length < MAX_TIMEOUT_LENGTH) ? length : MAX_TIMEOUT_LENGTH;
 
+       REG_GET_2(AUX_DPHY_RX_CONTROL1, AUX_RX_TIMEOUT_LEN, &prev_length, AUX_RX_TIMEOUT_LEN_MUL, &prev_mult);
+
+       switch (prev_mult) {
+       case 0:
+               prev_timeout_val = prev_length * TIME_OUT_MULTIPLIER_8;
+               break;
+       case 1:
+               prev_timeout_val = prev_length * TIME_OUT_MULTIPLIER_16;
+               break;
+       case 2:
+               prev_timeout_val = prev_length * TIME_OUT_MULTIPLIER_32;
+               break;
+       case 3:
+               prev_timeout_val = prev_length * TIME_OUT_MULTIPLIER_64;
+               break;
+       default:
+               prev_timeout_val = DEFAULT_AUX_ENGINE_LENGTH * TIME_OUT_MULTIPLIER_8;
+               break;
+       }
+
        REG_UPDATE_SEQ_2(AUX_DPHY_RX_CONTROL1, AUX_RX_TIMEOUT_LEN, length, AUX_RX_TIMEOUT_LEN_MUL, multiplier);
 
-       return true;
+       return prev_timeout_val;
 }
 
 static struct dce_aux_funcs aux_functions = {