#include "dc_state.h"
#include "dc_state_priv.h"
#include "dc_plane_priv.h"
-#include "dc_stream_priv.h"
#include "gpio_service_interface.h"
#include "clk_mgr.h"
int i;
enum surface_update_type overall_type = UPDATE_TYPE_FAST;
- if (dc->idle_optimizations_allowed || dc_can_clear_cursor_limit(dc))
+ if (dc->idle_optimizations_allowed)
overall_type = UPDATE_TYPE_FULL;
if (stream_status == NULL || stream_status->plane_count != surface_count)
if (dsc_validate_context) {
stream->timing.dsc_cfg = *update->dsc_config;
stream->timing.flags.DSC = enable_dsc;
- if (dc->res_pool->funcs->validate_bandwidth(dc, dsc_validate_context, true) != DC_OK) {
+ if (!dc->res_pool->funcs->validate_bandwidth(dc, dsc_validate_context, true)) {
stream->timing.dsc_cfg = old_dsc_cfg;
stream->timing.flags.DSC = old_dsc_enabled;
update->dsc_config = NULL;
backup_and_set_minimal_pipe_split_policy(dc, base_context, policy);
/* commit minimal state */
- if (dc->res_pool->funcs->validate_bandwidth(dc, minimal_transition_context, false) == DC_OK) {
+ if (dc->res_pool->funcs->validate_bandwidth(dc, minimal_transition_context, false)) {
/* prevent underflow and corruption when reconfiguring pipes */
force_vsync_flip_in_minimal_transition_context(minimal_transition_context);
} else {
copy_stream_update_to_stream(dc, context, stream, stream_update);
if (update_type >= UPDATE_TYPE_FULL) {
- if (dc->res_pool->funcs->validate_bandwidth(dc, context, false) != DC_OK) {
+ if (!dc->res_pool->funcs->validate_bandwidth(dc, context, false)) {
DC_ERROR("Mode validation failed for stream update!\n");
dc_state_release(context);
return false;
void dc_query_current_properties(struct dc *dc, struct dc_current_properties *properties)
{
unsigned int i;
- unsigned int max_cursor_size = dc->caps.max_cursor_size;
- unsigned int stream_cursor_size;
+ bool subvp_sw_cursor_req = false;
- if (dc->debug.allow_sw_cursor_fallback && dc->res_pool->funcs->get_max_hw_cursor_size) {
- for (i = 0; i < dc->current_state->stream_count; i++) {
- stream_cursor_size = dc->res_pool->funcs->get_max_hw_cursor_size(dc,
- dc->current_state,
- dc->current_state->streams[i]);
-
- if (stream_cursor_size < max_cursor_size) {
- max_cursor_size = stream_cursor_size;
- }
+ for (i = 0; i < dc->current_state->stream_count; i++) {
+ if (check_subvp_sw_cursor_fallback_req(dc, dc->current_state->streams[i]) && !dc->current_state->streams[i]->hw_cursor_req) {
+ subvp_sw_cursor_req = true;
+ break;
}
}
-
- properties->cursor_size_limit = max_cursor_size;
+ properties->cursor_size_limit = subvp_sw_cursor_req ? 64 : dc->caps.max_cursor_size;
}
/**
else
return 0;
}
-
-bool dc_is_cursor_limit_pending(struct dc *dc)
-{
- uint32_t i;
-
- for (i = 0; i < dc->current_state->stream_count; i++) {
- if (dc_stream_is_cursor_limit_pending(dc, dc->current_state->streams[i]))
- return true;
- }
-
- return false;
-}
-
-bool dc_can_clear_cursor_limit(struct dc *dc)
-{
- uint32_t i;
-
- for (i = 0; i < dc->current_state->stream_count; i++) {
- if (dc_state_can_clear_stream_cursor_subvp_limit(dc->current_state->streams[i], dc->current_state))
- return true;
- }
-
- return false;
-}
return "Fail dp payload allocation";
case DC_FAIL_DP_LINK_BANDWIDTH:
return "Insufficient DP link bandwidth";
- case DC_FAIL_HW_CURSOR_SUPPORT:
- return "HW Cursor not supported";
case DC_ERROR_UNEXPECTED:
return "Unexpected error";
}
data->viewport_c.y += src.y / vpc_div;
}
+static bool is_subvp_high_refresh_candidate(struct dc_stream_state *stream)
+{
+ uint32_t refresh_rate;
+ struct dc *dc = stream->ctx->dc;
+
+ refresh_rate = (stream->timing.pix_clk_100hz * (uint64_t)100 +
+ stream->timing.v_total * stream->timing.h_total - (uint64_t)1);
+ refresh_rate = div_u64(refresh_rate, stream->timing.v_total);
+ refresh_rate = div_u64(refresh_rate, stream->timing.h_total);
+
+ /* If there's any stream that fits the SubVP high refresh criteria,
+ * we must return true. This is because cursor updates are asynchronous
+ * with full updates, so we could transition into a SubVP config and
+ * remain in HW cursor mode if there's no cursor update which will
+ * then cause corruption.
+ */
+ if ((refresh_rate >= 120 && refresh_rate <= 175 &&
+ stream->timing.v_addressable >= 1080 &&
+ stream->timing.v_addressable <= 2160) &&
+ (dc->current_state->stream_count > 1 ||
+ (dc->current_state->stream_count == 1 && !stream->allow_freesync)))
+ return true;
+
+ return false;
+}
+
static enum controller_dp_test_pattern convert_dp_to_controller_test_pattern(
enum dp_test_pattern test_pattern)
{
}
}
- /* clear subvp cursor limitations */
- for (i = 0; i < context->stream_count; i++) {
- dc_state_set_stream_subvp_cursor_limit(context->streams[i], context, false);
- }
-
res = dc_validate_global_state(dc, context, fast_validate);
/* calculate pixel rate divider after deciding pxiel clock & odm combine */
result = resource_build_scaling_params_for_context(dc, new_ctx);
if (result == DC_OK)
- result = dc->res_pool->funcs->validate_bandwidth(dc, new_ctx, fast_validate);
+ if (!dc->res_pool->funcs->validate_bandwidth(dc, new_ctx, fast_validate))
+ result = DC_FAIL_BANDWIDTH_VALIDATE;
return result;
}
return DC_OK;
}
+bool check_subvp_sw_cursor_fallback_req(const struct dc *dc, struct dc_stream_state *stream)
+{
+ if (!dc->debug.disable_subvp_high_refresh && is_subvp_high_refresh_candidate(stream))
+ return true;
+ if (dc->current_state->stream_count == 1 && stream->timing.v_addressable >= 2880 &&
+ ((stream->timing.pix_clk_100hz * 100) / stream->timing.v_total / stream->timing.h_total) < 120)
+ return true;
+ else if (dc->current_state->stream_count > 1 && stream->timing.v_addressable >= 1080 &&
+ ((stream->timing.pix_clk_100hz * 100) / stream->timing.v_total / stream->timing.h_total) < 120)
+ return true;
+
+ return false;
+}
+
struct dscl_prog_data *resource_get_dscl_prog_data(struct pipe_ctx *pipe_ctx)
{
return &pipe_ctx->plane_res.scl_data.dscl_prog_data;
* Authors: AMD
*
*/
-#include "dc_types.h"
#include "core_types.h"
#include "core_status.h"
#include "dc_state.h"
if (phantom_stream_status) {
phantom_stream_status->mall_stream_config.type = SUBVP_PHANTOM;
phantom_stream_status->mall_stream_config.paired_stream = main_stream;
- phantom_stream_status->mall_stream_config.subvp_limit_cursor_size = false;
- phantom_stream_status->mall_stream_config.cursor_size_limit_subvp = false;
}
- dc_state_set_stream_subvp_cursor_limit(main_stream, state, true);
-
return res;
}
return is_fams2_in_use;
}
-
-void dc_state_set_stream_subvp_cursor_limit(const struct dc_stream_state *stream,
- struct dc_state *state,
- bool limit)
-{
- struct dc_stream_status *stream_status;
-
- stream_status = dc_state_get_stream_status(state, stream);
-
- if (stream_status) {
- stream_status->mall_stream_config.subvp_limit_cursor_size = limit;
- }
-}
-
-bool dc_state_get_stream_subvp_cursor_limit(const struct dc_stream_state *stream,
- struct dc_state *state)
-{
- bool limit = false;
-
- struct dc_stream_status *stream_status;
-
- stream_status = dc_state_get_stream_status(state, stream);
-
- if (stream_status) {
- limit = stream_status->mall_stream_config.subvp_limit_cursor_size;
- }
-
- return limit;
-}
-
-void dc_state_set_stream_cursor_subvp_limit(const struct dc_stream_state *stream,
- struct dc_state *state,
- bool limit)
-{
- struct dc_stream_status *stream_status;
-
- stream_status = dc_state_get_stream_status(state, stream);
-
- if (stream_status) {
- stream_status->mall_stream_config.cursor_size_limit_subvp = limit;
- }
-}
-
-bool dc_state_get_stream_cursor_subvp_limit(const struct dc_stream_state *stream,
- struct dc_state *state)
-{
- bool limit = false;
-
- struct dc_stream_status *stream_status;
-
- stream_status = dc_state_get_stream_status(state, stream);
-
- if (stream_status) {
- limit = stream_status->mall_stream_config.cursor_size_limit_subvp;
- }
-
- return limit;
-}
-
-bool dc_state_can_clear_stream_cursor_subvp_limit(const struct dc_stream_state *stream,
- struct dc_state *state)
-{
- bool can_clear_limit = false;
-
- struct dc_stream_status *stream_status;
-
- stream_status = dc_state_get_stream_status(state, stream);
-
- if (stream_status) {
- can_clear_limit = dc_state_get_stream_cursor_subvp_limit(stream, state) &&
- (stream_status->mall_stream_config.type == SUBVP_PHANTOM ||
- stream->hw_cursor_req ||
- !stream_status->mall_stream_config.subvp_limit_cursor_size ||
- !stream->cursor_position.enable ||
- dc_stream_check_cursor_attributes(stream, state, &stream->cursor_attributes));
- }
-
- return can_clear_limit;
-}
-
-bool dc_state_is_subvp_in_use(struct dc_state *state)
-{
- uint32_t i;
-
- for (i = 0; i < state->stream_count; i++) {
- if (dc_state_get_stream_subvp_type(state, state->streams[i]) != SUBVP_NONE)
- return true;
- }
-
- return false;
-}
}
/*
- * dc_stream_check_cursor_attributes() - Check validitity of cursor attributes and surface address
+ * dc_stream_set_cursor_attributes() - Update cursor attributes and set cursor surface address
*/
-bool dc_stream_check_cursor_attributes(
- const struct dc_stream_state *stream,
- struct dc_state *state,
+bool dc_stream_set_cursor_attributes(
+ struct dc_stream_state *stream,
const struct dc_cursor_attributes *attributes)
{
- const struct dc *dc;
-
- unsigned int max_cursor_size;
+ struct dc *dc;
if (NULL == stream) {
dm_error("DC: dc_stream is NULL!\n");
dc = stream->ctx->dc;
- /* SubVP is not compatible with HW cursor larger than what can fit in cursor SRAM.
- * Therefore, if cursor is greater than this, fallback to SW cursor.
+ /* SubVP is not compatible with HW cursor larger than 64 x 64 x 4.
+ * Therefore, if cursor is greater than 64 x 64 x 4, fallback to SW cursor in the following case:
+ * 1. If the config is a candidate for SubVP high refresh (both single an dual display configs)
+ * 2. If not subvp high refresh, for single display cases, if resolution is >= 5K and refresh rate < 120hz
+ * 3. If not subvp high refresh, for multi display cases, if resolution is >= 4K and refresh rate < 120hz
*/
- if (dc->debug.allow_sw_cursor_fallback && dc->res_pool->funcs->get_max_hw_cursor_size) {
- max_cursor_size = dc->res_pool->funcs->get_max_hw_cursor_size(dc, state, stream);
- max_cursor_size = max_cursor_size * max_cursor_size * 4;
-
- if (attributes->height * attributes->width * 4 > max_cursor_size) {
+ if (dc->debug.allow_sw_cursor_fallback &&
+ attributes->height * attributes->width * 4 > 16384 &&
+ !stream->hw_cursor_req) {
+ if (check_subvp_sw_cursor_fallback_req(dc, stream))
return false;
- }
}
- return true;
-}
-
-/*
- * dc_stream_set_cursor_attributes() - Update cursor attributes and set cursor surface address
- */
-bool dc_stream_set_cursor_attributes(
- struct dc_stream_state *stream,
- const struct dc_cursor_attributes *attributes)
-{
- bool result = false;
-
- if (dc_stream_check_cursor_attributes(stream, stream->ctx->dc->current_state, attributes)) {
- stream->cursor_attributes = *attributes;
- result = true;
- }
+ stream->cursor_attributes = *attributes;
- return result;
+ return true;
}
bool dc_stream_program_cursor_attributes(
return dc_stream_get_max_flickerless_instant_vtotal_delta(stream, is_gaming, false);
}
-
-bool dc_stream_is_cursor_limit_pending(struct dc *dc, struct dc_stream_state *stream)
-{
- bool is_limit_pending = false;
-
- if (dc->current_state)
- is_limit_pending = dc_state_get_stream_cursor_subvp_limit(stream, dc->current_state);
-
- return is_limit_pending;
-}
-
-bool dc_stream_can_clear_cursor_limit(struct dc *dc, struct dc_stream_state *stream)
-{
- bool can_clear_limit = false;
-
- if (dc->current_state)
- can_clear_limit = dc_state_get_stream_cursor_subvp_limit(stream, dc->current_state) &&
- (stream->hw_cursor_req ||
- !stream->cursor_position.enable ||
- dc_stream_check_cursor_attributes(stream, dc->current_state, &stream->cursor_attributes));
-
- return can_clear_limit;
-}
uint32_t i2c_speed_in_khz_hdcp;
uint32_t dmdata_alloc_size;
unsigned int max_cursor_size;
- unsigned int max_buffered_cursor_size;
unsigned int max_video_width;
/*
* max video plane width that can be safely assumed to be always
bool dc_is_timing_changed(struct dc_stream_state *cur_stream,
struct dc_stream_state *new_stream);
-bool dc_is_cursor_limit_pending(struct dc *dc);
-bool dc_can_clear_cursor_limit(struct dc *dc);
-
#endif /* DC_INTERFACE_H_ */
const struct dc *dc,
const struct dc_state *state);
-
-void dc_state_set_stream_subvp_cursor_limit(const struct dc_stream_state *stream,
- struct dc_state *state,
- bool limit);
-
-bool dc_state_get_stream_subvp_cursor_limit(const struct dc_stream_state *stream,
- struct dc_state *state);
-
-void dc_state_set_stream_cursor_subvp_limit(const struct dc_stream_state *stream,
- struct dc_state *state,
- bool limit);
-
-bool dc_state_get_stream_cursor_subvp_limit(const struct dc_stream_state *stream,
- struct dc_state *state);
-
-bool dc_state_can_clear_stream_cursor_subvp_limit(const struct dc_stream_state *stream,
- struct dc_state *state);
-
-bool dc_state_is_subvp_in_use(struct dc_state *state);
-
#endif /* _DC_STATE_PRIV_H_ */
*/
enum mall_stream_type type;
struct dc_stream_state *paired_stream; // master / slave stream
- bool subvp_limit_cursor_size; /* stream has/is using subvp limiting hw cursor support */
- bool cursor_size_limit_subvp; /* stream is using hw cursor config preventing subvp */
};
struct dc_stream_status {
struct dc *dc,
struct dc_stream_state *stream);
-bool dc_stream_check_cursor_attributes(
- const struct dc_stream_state *stream,
- struct dc_state *state,
- const struct dc_cursor_attributes *attributes);
-
bool dc_stream_set_cursor_attributes(
struct dc_stream_state *stream,
const struct dc_cursor_attributes *attributes);
struct dc_surface_update *srf_updates,
struct dc_state *context);
-bool dc_stream_is_cursor_limit_pending(struct dc *dc, struct dc_stream_state *stream);
-bool dc_stream_can_clear_cursor_limit(struct dc *dc, struct dc_stream_state *stream);
-
#endif /* DC_STREAM_H_ */
*/
if (pipe->plane_state && !pipe->top_pipe && !pipe->prev_odm_pipe && !dcn32_is_center_timing(pipe) &&
!pipe->stream->hw_cursor_req &&
- !dc_state_get_stream_cursor_subvp_limit(pipe->stream, context) &&
!(pipe->stream->timing.pix_clk_100hz / 10000 > DCN3_2_MAX_SUBVP_PIXEL_RATE_MHZ) &&
(!dcn32_is_psr_capable(pipe) || (context->stream_count == 1 && dc->caps.dmub_caps.subvp_psr)) &&
dc_state_get_pipe_subvp_type(context, pipe) == SUBVP_NONE &&
static void populate_dml21_stream_overrides_from_stream_state(
struct dml2_stream_parameters *stream_desc,
- struct dc_stream_state *stream,
- struct dc_stream_status *stream_status)
+ struct dc_stream_state *stream)
{
switch (stream->debug.force_odm_combine_segments) {
case 0:
if (!stream->ctx->dc->debug.enable_single_display_2to1_odm_policy ||
stream->debug.force_odm_combine_segments > 0)
stream_desc->overrides.disable_dynamic_odm = true;
- stream_desc->overrides.disable_subvp = stream->ctx->dc->debug.force_disable_subvp ||
- stream->hw_cursor_req ||
- stream_status->mall_stream_config.cursor_size_limit_subvp;
+ stream_desc->overrides.disable_subvp = stream->ctx->dc->debug.force_disable_subvp || stream->hw_cursor_req;
}
static enum dml2_swizzle_mode gfx_addr3_to_dml2_swizzle_mode(enum swizzle_mode_addr3_values addr3_mode)
populate_dml21_timing_config_from_stream_state(&dml_dispcfg->stream_descriptors[disp_cfg_stream_location].timing, context->streams[stream_index], dml_ctx);
adjust_dml21_hblank_timing_config_from_pipe_ctx(&dml_dispcfg->stream_descriptors[disp_cfg_stream_location].timing, &context->res_ctx.pipe_ctx[stream_index]);
populate_dml21_output_config_from_stream_state(&dml_dispcfg->stream_descriptors[disp_cfg_stream_location].output, context->streams[stream_index], &context->res_ctx.pipe_ctx[stream_index]);
- populate_dml21_stream_overrides_from_stream_state(&dml_dispcfg->stream_descriptors[disp_cfg_stream_location], context->streams[stream_index], &context->stream_status[stream_index]);
+ populate_dml21_stream_overrides_from_stream_state(&dml_dispcfg->stream_descriptors[disp_cfg_stream_location], context->streams[stream_index]);
dml_dispcfg->stream_descriptors[disp_cfg_stream_location].overrides.hw.twait_budgeting.fclk_pstate = dml2_twait_budgeting_setting_if_needed;
dml_dispcfg->stream_descriptors[disp_cfg_stream_location].overrides.hw.twait_budgeting.uclk_pstate = dml2_twait_budgeting_setting_if_needed;
struct dce_hwseq *hws = dc->hwseq;
/* recalculate DML parameters */
- if (dc->res_pool->funcs->validate_bandwidth(dc, context, false) != DC_OK)
+ if (!dc->res_pool->funcs->validate_bandwidth(dc, context, false))
return false;
/* apply updated bandwidth parameters */
struct dce_hwseq *hws = dc->hwseq;
/* recalculate DML parameters */
- if (dc->res_pool->funcs->validate_bandwidth(dc, context, false) != DC_OK)
+ if (!dc->res_pool->funcs->validate_bandwidth(dc, context, false))
return false;
/* apply updated bandwidth parameters */
#ifndef _CORE_STATUS_H_
#define _CORE_STATUS_H_
-#include "dc_hw_types.h"
-
enum dc_status {
DC_OK = 1,
DC_NO_LINK_ENC_RESOURCE = 26,
DC_FAIL_DP_PAYLOAD_ALLOCATION = 27,
DC_FAIL_DP_LINK_BANDWIDTH = 28,
- DC_FAIL_HW_CURSOR_SUPPORT = 29,
DC_ERROR_UNEXPECTED = -1
};
/* Create a minimal link encoder object with no dc_link object
* associated with it. */
struct link_encoder *(*link_enc_create_minimal)(struct dc_context *ctx, enum engine_id eng_id);
-
- enum dc_status (*validate_bandwidth)(
+ bool (*validate_bandwidth)(
struct dc *dc,
struct dc_state *context,
bool fast_validate);
int (*get_power_profile)(const struct dc_state *context);
unsigned int (*get_det_buffer_size)(const struct dc_state *context);
unsigned int (*get_vstartup_for_pipe)(struct pipe_ctx *pipe_ctx);
- unsigned int (*get_max_hw_cursor_size)(const struct dc *dc,
- struct dc_state *state,
- const struct dc_stream_state *stream);
};
struct audio_support{
struct dc_state *context,
struct pipe_ctx *pipe_ctx);
+bool check_subvp_sw_cursor_fallback_req(const struct dc *dc, struct dc_stream_state *stream);
+
/* Get hw programming parameters container from pipe context
* @pipe_ctx: pipe context
* @dscl_prog_data: struct to hold programmable hw reg values
return DC_OK;
}
-static enum dc_status dce100_validate_bandwidth(
+static bool dce100_validate_bandwidth(
struct dc *dc,
struct dc_state *context,
bool fast_validate)
context->bw_ctx.bw.dce.yclk_khz = 0;
}
- return DC_OK;
+ return true;
}
static bool dce100_validate_surface_sets(
return DC_OK;
}
-static enum dc_status dce110_validate_bandwidth(
+static bool dce110_validate_bandwidth(
struct dc *dc,
struct dc_state *context,
bool fast_validate)
context->bw_ctx.bw.dce.yclk_khz,
context->bw_ctx.bw.dce.blackout_recovery_time_us);
}
- return result ? DC_OK : DC_FAIL_BANDWIDTH_VALIDATE;
+ return result;
}
static enum dc_status dce110_validate_plane(const struct dc_plane_state *plane_state,
return DC_OK;
}
-enum dc_status dce112_validate_bandwidth(
+bool dce112_validate_bandwidth(
struct dc *dc,
struct dc_state *context,
bool fast_validate)
context->bw_ctx.bw.dce.yclk_khz,
context->bw_ctx.bw.dce.blackout_recovery_time_us);
}
- return result ? DC_OK : DC_FAIL_BANDWIDTH_VALIDATE;
+ return result;
}
enum dc_status resource_map_phy_clock_resources(
struct dc_state *context,
struct dc_state *old_context);
-enum dc_status dce112_validate_bandwidth(
+bool dce112_validate_bandwidth(
struct dc *dc,
struct dc_state *context,
bool fast_validate);
}
}
-static enum dc_status dce60_validate_bandwidth(
+static bool dce60_validate_bandwidth(
struct dc *dc,
struct dc_state *context,
bool fast_validate)
context->bw_ctx.bw.dce.yclk_khz = 0;
}
- return DC_OK;
+ return true;
}
static bool dce60_validate_surface_sets(
}
}
-static enum dc_status dce80_validate_bandwidth(
+static bool dce80_validate_bandwidth(
struct dc *dc,
struct dc_state *context,
bool fast_validate)
context->bw_ctx.bw.dce.yclk_khz = 0;
}
- return DC_OK;
+ return true;
}
static bool dce80_validate_surface_sets(
*
*/
-#include "core_status.h"
#include "dm_services.h"
#include "dc.h"
*pool = NULL;
}
-static enum dc_status dcn10_validate_bandwidth(
+static bool dcn10_validate_bandwidth(
struct dc *dc,
struct dc_state *context,
bool fast_validate)
voltage_supported = dcn_validate_bandwidth(dc, context, fast_validate);
DC_FP_END();
- return voltage_supported ? DC_OK : DC_FAIL_BANDWIDTH_VALIDATE;
+ return voltage_supported;
}
static enum dc_status dcn10_validate_plane(const struct dc_plane_state *plane_state, struct dc_caps *caps)
return out;
}
-enum dc_status dcn20_validate_bandwidth(struct dc *dc, struct dc_state *context,
+bool dcn20_validate_bandwidth(struct dc *dc, struct dc_state *context,
bool fast_validate)
{
bool voltage_supported;
pipes = kcalloc(dc->res_pool->pipe_count, sizeof(display_e2e_pipe_params_st), GFP_KERNEL);
if (!pipes)
- return DC_FAIL_BANDWIDTH_VALIDATE;
+ return false;
DC_FP_START();
voltage_supported = dcn20_validate_bandwidth_fp(dc, context, fast_validate, pipes);
DC_FP_END();
kfree(pipes);
- return voltage_supported ? DC_OK : DC_FAIL_BANDWIDTH_VALIDATE;
+ return voltage_supported;
}
struct pipe_ctx *dcn20_acquire_free_pipe_for_layer(
struct dc_state *context,
display_e2e_pipe_params_st *pipes,
int pipe_cnt);
-enum dc_status dcn20_validate_bandwidth(struct dc *dc, struct dc_state *context, bool fast_validate);
+bool dcn20_validate_bandwidth(struct dc *dc, struct dc_state *context, bool fast_validate);
void dcn20_merge_pipes_for_validate(
struct dc *dc,
struct dc_state *context);
* with DC_FP_START()/DC_FP_END(). Use the same approach as for
* dcn20_validate_bandwidth in dcn20_resource.c.
*/
-static enum dc_status dcn21_validate_bandwidth(struct dc *dc, struct dc_state *context,
+static bool dcn21_validate_bandwidth(struct dc *dc, struct dc_state *context,
bool fast_validate)
{
bool voltage_supported;
pipes = kcalloc(dc->res_pool->pipe_count, sizeof(display_e2e_pipe_params_st), GFP_KERNEL);
if (!pipes)
- return DC_FAIL_BANDWIDTH_VALIDATE;
+ return false;
DC_FP_START();
voltage_supported = dcn21_validate_bandwidth_fp(dc, context, fast_validate, pipes);
DC_FP_END();
kfree(pipes);
- return voltage_supported ? DC_OK : DC_NOT_SUPPORTED;
+ return voltage_supported;
}
static void dcn21_destroy_resource_pool(struct resource_pool **pool)
DC_FP_END();
}
-enum dc_status dcn30_validate_bandwidth(struct dc *dc,
+bool dcn30_validate_bandwidth(struct dc *dc,
struct dc_state *context,
bool fast_validate)
{
BW_VAL_TRACE_FINISH();
- return out ? DC_OK : DC_FAIL_BANDWIDTH_VALIDATE;
+ return out;
}
void dcn30_update_bw_bounding_box(struct dc *dc, struct clk_bw_params *bw_params)
enum mmhubbub_wbif_mode mode,
unsigned int urgent_watermark);
-enum dc_status dcn30_validate_bandwidth(struct dc *dc, struct dc_state *context,
+bool dcn30_validate_bandwidth(struct dc *dc, struct dc_state *context,
bool fast_validate);
bool dcn30_internal_validate_bw(
struct dc *dc,
DC_FP_END();
}
-enum dc_status dcn31_validate_bandwidth(struct dc *dc,
+bool dcn31_validate_bandwidth(struct dc *dc,
struct dc_state *context,
bool fast_validate)
{
BW_VAL_TRACE_FINISH();
- return out ? DC_OK : DC_FAIL_BANDWIDTH_VALIDATE;
+ return out;
}
static void dcn31_get_panel_config_defaults(struct dc_panel_config *panel_config)
struct resource_pool base;
};
-enum dc_status dcn31_validate_bandwidth(struct dc *dc,
+bool dcn31_validate_bandwidth(struct dc *dc,
struct dc_state *context,
bool fast_validate);
void dcn31_calculate_wm_and_dlg(
*panel_config = panel_config_defaults;
}
-enum dc_status dcn314_validate_bandwidth(struct dc *dc,
+bool dcn314_validate_bandwidth(struct dc *dc,
struct dc_state *context,
bool fast_validate)
{
BW_VAL_TRACE_FINISH();
- return out ? DC_OK : DC_FAIL_BANDWIDTH_VALIDATE;
+ return out;
}
static struct resource_funcs dcn314_res_pool_funcs = {
struct resource_pool base;
};
-enum dc_status dcn314_validate_bandwidth(struct dc *dc,
+bool dcn314_validate_bandwidth(struct dc *dc,
struct dc_state *context,
bool fast_validate);
*
*/
-#include "dc_types.h"
#include "dm_services.h"
#include "dc.h"
return out;
}
-enum dc_status dcn32_validate_bandwidth(struct dc *dc,
+bool dcn32_validate_bandwidth(struct dc *dc,
struct dc_state *context,
bool fast_validate)
{
- unsigned int i;
- enum dc_status status;
- const struct dc_stream_state *stream;
-
- /* reset cursor limitations on subvp */
- for (i = 0; i < context->stream_count; i++) {
- stream = context->streams[i];
-
- if (dc_state_can_clear_stream_cursor_subvp_limit(stream, context)) {
- dc_state_set_stream_cursor_subvp_limit(stream, context, false);
- }
- }
+ bool out = false;
if (dc->debug.using_dml2)
- status = dml2_validate(dc, context,
+ out = dml2_validate(dc, context,
context->power_source == DC_POWER_SOURCE_DC ? context->bw_ctx.dml2_dc_power_source : context->bw_ctx.dml2,
- fast_validate) ? DC_OK : DC_FAIL_BANDWIDTH_VALIDATE;
+ fast_validate);
else
- status = dml1_validate(dc, context, fast_validate) ? DC_OK : DC_FAIL_BANDWIDTH_VALIDATE;
-
- if (!fast_validate && status == DC_OK && dc_state_is_subvp_in_use(context)) {
- /* check new stream configuration still supports cursor if subvp used */
- for (i = 0; i < context->stream_count; i++) {
- stream = context->streams[i];
-
- if (dc_state_get_stream_subvp_type(context, stream) != SUBVP_PHANTOM &&
- stream->cursor_position.enable &&
- !dc_stream_check_cursor_attributes(stream, context, &stream->cursor_attributes)) {
- /* hw cursor cannot be supported with subvp active, so disable subvp for now */
- dc_state_set_stream_cursor_subvp_limit(stream, context, true);
- status = DC_FAIL_HW_CURSOR_SUPPORT;
- }
- };
- }
-
- if (!fast_validate && status == DC_FAIL_HW_CURSOR_SUPPORT) {
- /* attempt to validate again with subvp disabled due to cursor */
- if (dc->debug.using_dml2)
- status = dml2_validate(dc, context,
- context->power_source == DC_POWER_SOURCE_DC ? context->bw_ctx.dml2_dc_power_source : context->bw_ctx.dml2,
- fast_validate) ? DC_OK : DC_FAIL_BANDWIDTH_VALIDATE;
- else
- status = dml1_validate(dc, context, fast_validate) ? DC_OK : DC_FAIL_BANDWIDTH_VALIDATE;
- }
-
- return status;
+ out = dml1_validate(dc, context, fast_validate);
+ return out;
}
int dcn32_populate_dml_pipes_from_context(
DC_FP_END();
}
-unsigned int dcn32_get_max_hw_cursor_size(const struct dc *dc,
- struct dc_state *state,
- const struct dc_stream_state *stream)
-{
- bool limit_cur_to_buf;
-
- limit_cur_to_buf = dc_state_get_stream_subvp_cursor_limit(stream, state) &&
- !stream->hw_cursor_req;
-
- return limit_cur_to_buf ? dc->caps.max_buffered_cursor_size : dc->caps.max_cursor_size;
-}
-
static struct resource_funcs dcn32_res_pool_funcs = {
.destroy = dcn32_destroy_resource_pool,
.link_enc_create = dcn32_link_encoder_create,
.add_phantom_pipes = dcn32_add_phantom_pipes,
.build_pipe_pix_clk_params = dcn20_build_pipe_pix_clk_params,
.calculate_mall_ways_from_bytes = dcn32_calculate_mall_ways_from_bytes,
- .get_vstartup_for_pipe = dcn10_get_vstartup_for_pipe,
- .get_max_hw_cursor_size = dcn32_get_max_hw_cursor_size,
+ .get_vstartup_for_pipe = dcn10_get_vstartup_for_pipe
};
static uint32_t read_pipe_fuses(struct dc_context *ctx)
unsigned int pipe_cnt,
unsigned int index);
-enum dc_status dcn32_validate_bandwidth(struct dc *dc,
+bool dcn32_validate_bandwidth(struct dc *dc,
struct dc_state *context,
bool fast_validate);
unsigned int dcn32_calculate_mall_ways_from_bytes(const struct dc *dc, unsigned int total_size_in_mall_bytes);
-unsigned int dcn32_get_max_hw_cursor_size(const struct dc *dc,
- struct dc_state *state,
- const struct dc_stream_state *stream);
-
/* definitions for run time init of reg offsets */
/* CLK SRC */
.add_phantom_pipes = dcn32_add_phantom_pipes,
.build_pipe_pix_clk_params = dcn20_build_pipe_pix_clk_params,
.calculate_mall_ways_from_bytes = dcn32_calculate_mall_ways_from_bytes,
- .get_vstartup_for_pipe = dcn10_get_vstartup_for_pipe,
- .get_max_hw_cursor_size = dcn32_get_max_hw_cursor_size,
+ .get_vstartup_for_pipe = dcn10_get_vstartup_for_pipe
};
static uint32_t read_pipe_fuses(struct dc_context *ctx)
}
-static enum dc_status dcn35_validate_bandwidth(struct dc *dc,
+static bool dcn35_validate_bandwidth(struct dc *dc,
struct dc_state *context,
bool fast_validate)
{
fast_validate);
if (fast_validate)
- return out ? DC_OK : DC_FAIL_BANDWIDTH_VALIDATE;
+ return out;
DC_FP_START();
dcn35_decide_zstate_support(dc, context);
DC_FP_END();
- return out ? DC_OK : DC_FAIL_BANDWIDTH_VALIDATE;
+ return out;
}
enum dc_status dcn35_patch_unknown_plane_state(struct dc_plane_state *plane_state)
}
-static enum dc_status dcn351_validate_bandwidth(struct dc *dc,
+static bool dcn351_validate_bandwidth(struct dc *dc,
struct dc_state *context,
bool fast_validate)
{
fast_validate);
if (fast_validate)
- return out ? DC_OK : DC_FAIL_BANDWIDTH_VALIDATE;
+ return out;
DC_FP_START();
dcn35_decide_zstate_support(dc, context);
DC_FP_END();
- return out ? DC_OK : DC_FAIL_BANDWIDTH_VALIDATE;
+ return out;
}
static struct resource_funcs dcn351_res_pool_funcs = {
}
-static enum dc_status dcn35_validate_bandwidth(struct dc *dc,
+static bool dcn35_validate_bandwidth(struct dc *dc,
struct dc_state *context,
bool fast_validate)
{
fast_validate);
if (fast_validate)
- return out ? DC_OK : DC_FAIL_BANDWIDTH_VALIDATE;
+ return out;
DC_FP_START();
dcn35_decide_zstate_support(dc, context);
DC_FP_END();
- return out ? DC_OK : DC_FAIL_BANDWIDTH_VALIDATE;
+ return out;
}
return DC_OK;
}
-enum dc_status dcn401_validate_bandwidth(struct dc *dc,
+bool dcn401_validate_bandwidth(struct dc *dc,
struct dc_state *context,
bool fast_validate)
{
- unsigned int i;
- enum dc_status status = DC_OK;
- const struct dc_stream_state *stream;
-
- /* reset cursor limitations on subvp */
- for (i = 0; i < context->stream_count; i++) {
- stream = context->streams[i];
-
- if (dc_state_can_clear_stream_cursor_subvp_limit(stream, context)) {
- dc_state_set_stream_cursor_subvp_limit(stream, context, false);
- }
- }
-
+ bool out = false;
if (dc->debug.using_dml2)
- status = dml2_validate(dc, context,
+ out = dml2_validate(dc, context,
context->power_source == DC_POWER_SOURCE_DC ? context->bw_ctx.dml2_dc_power_source : context->bw_ctx.dml2,
- fast_validate) ? DC_OK : DC_FAIL_BANDWIDTH_VALIDATE;
-
- if (!fast_validate && status == DC_OK && dc_state_is_subvp_in_use(context)) {
- /* check new stream configuration still supports cursor if subvp used */
- for (i = 0; i < context->stream_count; i++) {
- stream = context->streams[i];
-
- if (dc_state_get_stream_subvp_type(context, stream) != SUBVP_PHANTOM &&
- stream->cursor_position.enable &&
- !dc_stream_check_cursor_attributes(stream, context, &stream->cursor_attributes)) {
- /* hw cursor cannot be supported with subvp active, so disable subvp for now */
- dc_state_set_stream_cursor_subvp_limit(stream, context, true);
- status = DC_FAIL_HW_CURSOR_SUPPORT;
- }
- };
- }
-
- if (!fast_validate && status == DC_FAIL_HW_CURSOR_SUPPORT) {
- /* attempt to validate again with subvp disabled due to cursor */
- if (dc->debug.using_dml2)
- status = dml2_validate(dc, context,
- context->power_source == DC_POWER_SOURCE_DC ? context->bw_ctx.dml2_dc_power_source : context->bw_ctx.dml2,
- fast_validate) ? DC_OK : DC_FAIL_BANDWIDTH_VALIDATE;
- }
-
- return status;
+ fast_validate);
+ return out;
}
void dcn401_prepare_mcache_programming(struct dc *dc,
.build_pipe_pix_clk_params = dcn401_build_pipe_pix_clk_params,
.calculate_mall_ways_from_bytes = dcn32_calculate_mall_ways_from_bytes,
.get_power_profile = dcn401_get_power_profile,
- .get_vstartup_for_pipe = dcn401_get_vstartup_for_pipe,
- .get_max_hw_cursor_size = dcn32_get_max_hw_cursor_size
+ .get_vstartup_for_pipe = dcn401_get_vstartup_for_pipe
};
static uint32_t read_pipe_fuses(struct dc_context *ctx)
enum dc_status dcn401_patch_unknown_plane_state(struct dc_plane_state *plane_state);
-enum dc_status dcn401_validate_bandwidth(struct dc *dc,
+bool dcn401_validate_bandwidth(struct dc *dc,
struct dc_state *context,
bool fast_validate);