dc_z10_restore(dc);
 
-               if (dc->ctx->dmub_srv)
-                       dc_dmub_srv_wait_phy_init(dc->ctx->dmub_srv);
-
                dc->hwss.init_hw(dc);
 
                if (dc->hwss.init_sys_ctx != NULL &&
 
        return true;
 }
 
-void dc_dmub_srv_wait_phy_init(struct dc_dmub_srv *dc_dmub_srv)
+bool dc_dmub_srv_optimized_init_done(struct dc_dmub_srv *dc_dmub_srv)
 {
-       struct dmub_srv *dmub = dc_dmub_srv->dmub;
-       struct dc_context *dc_ctx = dc_dmub_srv->ctx;
-       enum dmub_status status;
-
-       for (;;) {
-               /* Wait up to a second for PHY init. */
-               status = dmub_srv_wait_for_phy_init(dmub, 1000000);
-               if (status == DMUB_STATUS_OK)
-                       /* Initialization OK */
-                       break;
+       struct dmub_srv *dmub;
+       union dmub_fw_boot_status status;
 
-               DC_ERROR("DMCUB PHY init failed: status=%d\n", status);
-               ASSERT(0);
+       if (!dc_dmub_srv || !dc_dmub_srv->dmub)
+               return false;
 
-               if (status != DMUB_STATUS_TIMEOUT)
-                       /*
-                        * Server likely initialized or we don't have
-                        * DMCUB HW support - this won't end.
-                        */
-                       break;
+       dmub = dc_dmub_srv->dmub;
 
-               /* Continue spinning so we don't hang the ASIC. */
-       }
+       return status.bits.optimized_init_done;
 }
 
 bool dc_dmub_srv_notify_stream_mask(struct dc_dmub_srv *dc_dmub_srv,
 
 
 void dc_dmub_srv_wait_idle(struct dc_dmub_srv *dc_dmub_srv);
 
-void dc_dmub_srv_wait_phy_init(struct dc_dmub_srv *dc_dmub_srv);
+bool dc_dmub_srv_optimized_init_done(struct dc_dmub_srv *dc_dmub_srv);
 
 bool dc_dmub_srv_cmd_run(struct dc_dmub_srv *dc_dmub_srv, union dmub_rb_cmd *cmd, enum dm_dmub_wait_type wait_type);
 
 
        if (!dcb->funcs->is_accelerated_mode(dcb))
                hws->funcs.disable_vga(dc->hwseq);
 
-       hws->funcs.bios_golden_init(dc);
+       if (!dc_dmub_srv_optimized_init_done(dc->ctx->dmub_srv))
+               hws->funcs.bios_golden_init(dc);
+
 
        if (dc->ctx->dc_bios->fw_info_valid) {
                res_pool->ref_clocks.xtalin_clock_inKhz =
 
 
        bool (*is_hw_init)(struct dmub_srv *dmub);
 
-       bool (*is_phy_init)(struct dmub_srv *dmub);
        void (*enable_dmub_boot_options)(struct dmub_srv *dmub,
                                const struct dmub_srv_hw_params *params);
 
 
 #undef DMUB_SF
 };
 
-/* Shared functions. */
-
-bool dmub_dcn21_is_phy_init(struct dmub_srv *dmub)
-{
-       return REG_READ(DMCUB_SCRATCH10) == 0;
-}
 
 
 extern const struct dmub_srv_common_regs dmub_srv_dcn21_regs;
 
-/* Hardware functions. */
-
-bool dmub_dcn21_is_phy_init(struct dmub_srv *dmub);
-
 #endif /* _DMUB_DCN21_H_ */
 
 
                funcs->get_diagnostic_data = dmub_dcn20_get_diagnostic_data;
 
-               if (asic == DMUB_ASIC_DCN21) {
+               if (asic == DMUB_ASIC_DCN21)
                        dmub->regs = &dmub_srv_dcn21_regs;
 
-                       funcs->is_phy_init = dmub_dcn21_is_phy_init;
-               }
                if (asic == DMUB_ASIC_DCN30) {
                        dmub->regs = &dmub_srv_dcn30_regs;
 
        return DMUB_STATUS_TIMEOUT;
 }
 
-enum dmub_status dmub_srv_wait_for_phy_init(struct dmub_srv *dmub,
-                                           uint32_t timeout_us)
-{
-       uint32_t i = 0;
-
-       if (!dmub->hw_init)
-               return DMUB_STATUS_INVALID;
-
-       if (!dmub->hw_funcs.is_phy_init)
-               return DMUB_STATUS_OK;
-
-       for (i = 0; i <= timeout_us; i += 10) {
-               if (dmub->hw_funcs.is_phy_init(dmub))
-                       return DMUB_STATUS_OK;
-
-               udelay(10);
-       }
-
-       return DMUB_STATUS_TIMEOUT;
-}
-
 enum dmub_status dmub_srv_wait_for_idle(struct dmub_srv *dmub,
                                        uint32_t timeout_us)
 {