Commit 6702a9ac authored by Harry Wentland's avatar Harry Wentland Committed by Alex Deucher
Browse files

drm/amd/display: Move scl_data to plane_res 



find -name Makefile -o -name Kconfig -o -name "*.c" -o -name "*.h" \
-o -name "*.cpp" -o -name "*.hpp" | \
xargs sed -i 's/\.scl_data/\.plane_res.scl_data/g'

find -name Makefile -o -name Kconfig -o -name "*.c" -o -name "*.h" \
-o -name "*.cpp" -o -name "*.hpp" | \
xargs sed -i 's/->scl_data/->plane_res.scl_data/g'

Signed-off-by: default avatarHarry Wentland <harry.wentland@amd.com>
Reviewed-by: default avatarTony Cheng <Tony.Cheng@amd.com>
Acked-by: default avatarHarry Wentland <Harry.Wentland@amd.com>
Signed-off-by: default avatarAlex Deucher <alexander.deucher@amd.com>
parent 79b06f0c

drivers/gpu/drm/amd/display/dc/calcs/dce_calcs.c

+18 −18
Original line number Diff line number Diff line
@@ -2613,13 +2613,13 @@ static void populate_initial_data( 
		data->h_total[num_displays + 4] = bw_int_to_fixed(pipe[i].stream->timing.h_total);

		data->v_total[num_displays + 4] = bw_int_to_fixed(pipe[i].stream->timing.v_total);

		data->pixel_rate[num_displays + 4] = bw_frc_to_fixed(pipe[i].stream->timing.pix_clk_khz, 1000);

		data->src_width[num_displays + 4] = bw_int_to_fixed(pipe[i].scl_data.viewport.width);

		data->src_width[num_displays + 4] = bw_int_to_fixed(pipe[i].plane_res.scl_data.viewport.width);

		data->pitch_in_pixels[num_displays + 4] = data->src_width[num_displays + 4];

		data->src_height[num_displays + 4] = bw_int_to_fixed(pipe[i].scl_data.viewport.height);

		data->h_taps[num_displays + 4] = bw_int_to_fixed(pipe[i].scl_data.taps.h_taps);

		data->v_taps[num_displays + 4] = bw_int_to_fixed(pipe[i].scl_data.taps.v_taps);

		data->h_scale_ratio[num_displays + 4] = fixed31_32_to_bw_fixed(pipe[i].scl_data.ratios.horz.value);

		data->v_scale_ratio[num_displays + 4] = fixed31_32_to_bw_fixed(pipe[i].scl_data.ratios.vert.value);

		data->src_height[num_displays + 4] = bw_int_to_fixed(pipe[i].plane_res.scl_data.viewport.height);

		data->h_taps[num_displays + 4] = bw_int_to_fixed(pipe[i].plane_res.scl_data.taps.h_taps);

		data->v_taps[num_displays + 4] = bw_int_to_fixed(pipe[i].plane_res.scl_data.taps.v_taps);

		data->h_scale_ratio[num_displays + 4] = fixed31_32_to_bw_fixed(pipe[i].plane_res.scl_data.ratios.horz.value);

		data->v_scale_ratio[num_displays + 4] = fixed31_32_to_bw_fixed(pipe[i].plane_res.scl_data.ratios.vert.value);

		switch (pipe[i].plane_state->rotation) {

		case ROTATION_ANGLE_0:

			data->rotation_angle[num_displays + 4] = bw_int_to_fixed(0);
@@ -2667,16 +2667,16 @@ static void populate_initial_data( 
			data->fbc_en[num_displays * 2 + j] = false;

			data->lpt_en[num_displays * 2 + j] = false;



			data->src_height[num_displays * 2 + j] = bw_int_to_fixed(pipe[i].bottom_pipe->scl_data.viewport.height);

			data->src_width[num_displays * 2 + j] = bw_int_to_fixed(pipe[i].bottom_pipe->scl_data.viewport.width);

			data->src_height[num_displays * 2 + j] = bw_int_to_fixed(pipe[i].bottom_pipe->plane_res.scl_data.viewport.height);

			data->src_width[num_displays * 2 + j] = bw_int_to_fixed(pipe[i].bottom_pipe->plane_res.scl_data.viewport.width);

			data->pitch_in_pixels[num_displays * 2 + j] = bw_int_to_fixed(

					pipe[i].bottom_pipe->plane_state->plane_size.grph.surface_pitch);

			data->h_taps[num_displays * 2 + j] = bw_int_to_fixed(pipe[i].bottom_pipe->scl_data.taps.h_taps);

			data->v_taps[num_displays * 2 + j] = bw_int_to_fixed(pipe[i].bottom_pipe->scl_data.taps.v_taps);

			data->h_taps[num_displays * 2 + j] = bw_int_to_fixed(pipe[i].bottom_pipe->plane_res.scl_data.taps.h_taps);

			data->v_taps[num_displays * 2 + j] = bw_int_to_fixed(pipe[i].bottom_pipe->plane_res.scl_data.taps.v_taps);

			data->h_scale_ratio[num_displays * 2 + j] = fixed31_32_to_bw_fixed(

					pipe[i].bottom_pipe->scl_data.ratios.horz.value);

					pipe[i].bottom_pipe->plane_res.scl_data.ratios.horz.value);

			data->v_scale_ratio[num_displays * 2 + j] = fixed31_32_to_bw_fixed(

					pipe[i].bottom_pipe->scl_data.ratios.vert.value);

					pipe[i].bottom_pipe->plane_res.scl_data.ratios.vert.value);

			switch (pipe[i].bottom_pipe->plane_state->rotation) {

			case ROTATION_ANGLE_0:

				data->rotation_angle[num_displays * 2 + j] = bw_int_to_fixed(0);
@@ -2711,13 +2711,13 @@ static void populate_initial_data( 
		data->v_total[num_displays + 4] = bw_int_to_fixed(pipe[i].stream->timing.v_total);

		data->pixel_rate[num_displays + 4] = bw_frc_to_fixed(pipe[i].stream->timing.pix_clk_khz, 1000);

		if (pipe[i].plane_state) {

			data->src_width[num_displays + 4] = bw_int_to_fixed(pipe[i].scl_data.viewport.width);

			data->src_width[num_displays + 4] = bw_int_to_fixed(pipe[i].plane_res.scl_data.viewport.width);

			data->pitch_in_pixels[num_displays + 4] = data->src_width[num_displays + 4];

			data->src_height[num_displays + 4] = bw_int_to_fixed(pipe[i].scl_data.viewport.height);

			data->h_taps[num_displays + 4] = bw_int_to_fixed(pipe[i].scl_data.taps.h_taps);

			data->v_taps[num_displays + 4] = bw_int_to_fixed(pipe[i].scl_data.taps.v_taps);

			data->h_scale_ratio[num_displays + 4] = fixed31_32_to_bw_fixed(pipe[i].scl_data.ratios.horz.value);

			data->v_scale_ratio[num_displays + 4] = fixed31_32_to_bw_fixed(pipe[i].scl_data.ratios.vert.value);

			data->src_height[num_displays + 4] = bw_int_to_fixed(pipe[i].plane_res.scl_data.viewport.height);

			data->h_taps[num_displays + 4] = bw_int_to_fixed(pipe[i].plane_res.scl_data.taps.h_taps);

			data->v_taps[num_displays + 4] = bw_int_to_fixed(pipe[i].plane_res.scl_data.taps.v_taps);

			data->h_scale_ratio[num_displays + 4] = fixed31_32_to_bw_fixed(pipe[i].plane_res.scl_data.ratios.horz.value);

			data->v_scale_ratio[num_displays + 4] = fixed31_32_to_bw_fixed(pipe[i].plane_res.scl_data.ratios.vert.value);

			switch (pipe[i].plane_state->rotation) {

			case ROTATION_ANGLE_0:

				data->rotation_angle[num_displays + 4] = bw_int_to_fixed(0);

drivers/gpu/drm/amd/display/dc/calcs/dcn_calcs.c

+42 −42
Original line number Diff line number Diff line
@@ -244,10 +244,10 @@ static void pipe_ctx_to_e2e_pipe_params ( 
	input->src.source_scan         = dm_horz;

	input->src.sw_mode             = pipe->plane_state->tiling_info.gfx9.swizzle;



	input->src.viewport_width      = pipe->scl_data.viewport.width;

	input->src.viewport_height     = pipe->scl_data.viewport.height;

	input->src.data_pitch          = pipe->scl_data.viewport.width;

	input->src.data_pitch_c        = pipe->scl_data.viewport.width;

	input->src.viewport_width      = pipe->plane_res.scl_data.viewport.width;

	input->src.viewport_height     = pipe->plane_res.scl_data.viewport.height;

	input->src.data_pitch          = pipe->plane_res.scl_data.viewport.width;

	input->src.data_pitch_c        = pipe->plane_res.scl_data.viewport.width;

	input->src.cur0_src_width      = 128; /* TODO: Cursor calcs, not curently stored */

	input->src.cur0_bpp            = 32;
@@ -341,21 +341,21 @@ static void pipe_ctx_to_e2e_pipe_params ( 
		break;

	}



	input->scale_taps.htaps                = pipe->scl_data.taps.h_taps;

	input->scale_ratio_depth.hscl_ratio    = pipe->scl_data.ratios.horz.value/4294967296.0;

	input->scale_ratio_depth.vscl_ratio    = pipe->scl_data.ratios.vert.value/4294967296.0;

	input->scale_ratio_depth.vinit =  pipe->scl_data.inits.v.value/4294967296.0;

	input->scale_taps.htaps                = pipe->plane_res.scl_data.taps.h_taps;

	input->scale_ratio_depth.hscl_ratio    = pipe->plane_res.scl_data.ratios.horz.value/4294967296.0;

	input->scale_ratio_depth.vscl_ratio    = pipe->plane_res.scl_data.ratios.vert.value/4294967296.0;

	input->scale_ratio_depth.vinit =  pipe->plane_res.scl_data.inits.v.value/4294967296.0;

	if (input->scale_ratio_depth.vinit < 1.0)

			input->scale_ratio_depth.vinit = 1;

	input->scale_taps.vtaps = pipe->scl_data.taps.v_taps;

	input->scale_taps.vtaps_c = pipe->scl_data.taps.v_taps_c;

	input->scale_taps.htaps_c              = pipe->scl_data.taps.h_taps_c;

	input->scale_ratio_depth.hscl_ratio_c  = pipe->scl_data.ratios.horz_c.value/4294967296.0;

	input->scale_ratio_depth.vscl_ratio_c  = pipe->scl_data.ratios.vert_c.value/4294967296.0;

	input->scale_ratio_depth.vinit_c       = pipe->scl_data.inits.v_c.value/4294967296.0;

	input->scale_taps.vtaps = pipe->plane_res.scl_data.taps.v_taps;

	input->scale_taps.vtaps_c = pipe->plane_res.scl_data.taps.v_taps_c;

	input->scale_taps.htaps_c              = pipe->plane_res.scl_data.taps.h_taps_c;

	input->scale_ratio_depth.hscl_ratio_c  = pipe->plane_res.scl_data.ratios.horz_c.value/4294967296.0;

	input->scale_ratio_depth.vscl_ratio_c  = pipe->plane_res.scl_data.ratios.vert_c.value/4294967296.0;

	input->scale_ratio_depth.vinit_c       = pipe->plane_res.scl_data.inits.v_c.value/4294967296.0;

	if (input->scale_ratio_depth.vinit_c < 1.0)

			input->scale_ratio_depth.vinit_c = 1;

	switch (pipe->scl_data.lb_params.depth) {

	switch (pipe->plane_res.scl_data.lb_params.depth) {

	case LB_PIXEL_DEPTH_30BPP:

		input->scale_ratio_depth.lb_depth = 30; break;

	case LB_PIXEL_DEPTH_36BPP:
@@ -367,11 +367,11 @@ static void pipe_ctx_to_e2e_pipe_params ( 


	input->dest.vactive        = pipe->stream->timing.v_addressable;



	input->dest.recout_width   = pipe->scl_data.recout.width;

	input->dest.recout_height  = pipe->scl_data.recout.height;

	input->dest.recout_width   = pipe->plane_res.scl_data.recout.width;

	input->dest.recout_height  = pipe->plane_res.scl_data.recout.height;



	input->dest.full_recout_width   = pipe->scl_data.recout.width;

	input->dest.full_recout_height  = pipe->scl_data.recout.height;

	input->dest.full_recout_width   = pipe->plane_res.scl_data.recout.width;

	input->dest.full_recout_height  = pipe->plane_res.scl_data.recout.height;



	input->dest.htotal         = pipe->stream->timing.h_total;

	input->dest.hblank_start   = input->dest.htotal - pipe->stream->timing.h_front_porch;
@@ -885,38 +885,38 @@ bool dcn_validate_bandwidth( 
			v->source_scan[input_idx] = dcn_bw_hor;



		} else {

			v->viewport_height[input_idx] =  pipe->scl_data.viewport.height;

			v->viewport_width[input_idx] = pipe->scl_data.viewport.width;

			v->scaler_rec_out_width[input_idx] = pipe->scl_data.recout.width;

			v->scaler_recout_height[input_idx] = pipe->scl_data.recout.height;

			v->viewport_height[input_idx] =  pipe->plane_res.scl_data.viewport.height;

			v->viewport_width[input_idx] = pipe->plane_res.scl_data.viewport.width;

			v->scaler_rec_out_width[input_idx] = pipe->plane_res.scl_data.recout.width;

			v->scaler_recout_height[input_idx] = pipe->plane_res.scl_data.recout.height;

			if (pipe->bottom_pipe && pipe->bottom_pipe->plane_state == pipe->plane_state) {

				if (pipe->plane_state->rotation % 2 == 0) {

					int viewport_end = pipe->scl_data.viewport.width

							+ pipe->scl_data.viewport.x;

					int viewport_b_end = pipe->bottom_pipe->scl_data.viewport.width

							+ pipe->bottom_pipe->scl_data.viewport.x;

					int viewport_end = pipe->plane_res.scl_data.viewport.width

							+ pipe->plane_res.scl_data.viewport.x;

					int viewport_b_end = pipe->bottom_pipe->plane_res.scl_data.viewport.width

							+ pipe->bottom_pipe->plane_res.scl_data.viewport.x;



					if (viewport_end > viewport_b_end)

						v->viewport_width[input_idx] = viewport_end

							- pipe->bottom_pipe->scl_data.viewport.x;

							- pipe->bottom_pipe->plane_res.scl_data.viewport.x;

					else

						v->viewport_width[input_idx] = viewport_b_end

									- pipe->scl_data.viewport.x;

									- pipe->plane_res.scl_data.viewport.x;

				} else  {

					int viewport_end = pipe->scl_data.viewport.height

						+ pipe->scl_data.viewport.y;

					int viewport_b_end = pipe->bottom_pipe->scl_data.viewport.height

						+ pipe->bottom_pipe->scl_data.viewport.y;

					int viewport_end = pipe->plane_res.scl_data.viewport.height

						+ pipe->plane_res.scl_data.viewport.y;

					int viewport_b_end = pipe->bottom_pipe->plane_res.scl_data.viewport.height

						+ pipe->bottom_pipe->plane_res.scl_data.viewport.y;



					if (viewport_end > viewport_b_end)

						v->viewport_height[input_idx] = viewport_end

							- pipe->bottom_pipe->scl_data.viewport.y;

							- pipe->bottom_pipe->plane_res.scl_data.viewport.y;

					else

						v->viewport_height[input_idx] = viewport_b_end

									- pipe->scl_data.viewport.y;

									- pipe->plane_res.scl_data.viewport.y;

				}

				v->scaler_rec_out_width[input_idx] = pipe->scl_data.recout.width

						+ pipe->bottom_pipe->scl_data.recout.width;

				v->scaler_rec_out_width[input_idx] = pipe->plane_res.scl_data.recout.width

						+ pipe->bottom_pipe->plane_res.scl_data.recout.width;

			}



			v->dcc_enable[input_idx] = pipe->plane_state->dcc.enable ? dcn_bw_yes : dcn_bw_no;
@@ -924,11 +924,11 @@ bool dcn_validate_bandwidth( 
					pipe->plane_state->format);

			v->source_surface_mode[input_idx] = tl_sw_mode_to_bw_defs(

					pipe->plane_state->tiling_info.gfx9.swizzle);

			v->lb_bit_per_pixel[input_idx] = tl_lb_bpp_to_int(pipe->scl_data.lb_params.depth);

			v->override_hta_ps[input_idx] = pipe->scl_data.taps.h_taps;

			v->override_vta_ps[input_idx] = pipe->scl_data.taps.v_taps;

			v->override_hta_pschroma[input_idx] = pipe->scl_data.taps.h_taps_c;

			v->override_vta_pschroma[input_idx] = pipe->scl_data.taps.v_taps_c;

			v->lb_bit_per_pixel[input_idx] = tl_lb_bpp_to_int(pipe->plane_res.scl_data.lb_params.depth);

			v->override_hta_ps[input_idx] = pipe->plane_res.scl_data.taps.h_taps;

			v->override_vta_ps[input_idx] = pipe->plane_res.scl_data.taps.v_taps;

			v->override_hta_pschroma[input_idx] = pipe->plane_res.scl_data.taps.h_taps_c;

			v->override_vta_pschroma[input_idx] = pipe->plane_res.scl_data.taps.v_taps_c;

			v->source_scan[input_idx] = (pipe->plane_state->rotation % 2) ? dcn_bw_vert : dcn_bw_hor;

		}

		if (v->is_line_buffer_bpp_fixed == dcn_bw_yes)

drivers/gpu/drm/amd/display/dc/core/dc_resource.c

+50 −50
Original line number Diff line number Diff line
@@ -432,7 +432,7 @@ static void calculate_viewport(struct pipe_ctx *pipe_ctx) 
{

	const struct dc_plane_state *plane_state = pipe_ctx->plane_state;

	const struct dc_stream_state *stream = pipe_ctx->stream;

	struct scaler_data *data = &pipe_ctx->scl_data;

	struct scaler_data *data = &pipe_ctx->plane_res.scl_data;

	struct rect surf_src = plane_state->src_rect;

	struct rect clip = { 0 };

	int vpc_div = (data->format == PIXEL_FORMAT_420BPP8
@@ -539,53 +539,53 @@ static void calculate_recout(struct pipe_ctx *pipe_ctx, struct view *recout_skip 
			pipe_ctx->plane_state->rotation == ROTATION_ANGLE_270)

		rect_swap_helper(&surf_src);



	pipe_ctx->scl_data.recout.x = stream->dst.x;

	pipe_ctx->plane_res.scl_data.recout.x = stream->dst.x;

	if (stream->src.x < surf_clip.x)

		pipe_ctx->scl_data.recout.x += (surf_clip.x

		pipe_ctx->plane_res.scl_data.recout.x += (surf_clip.x

			- stream->src.x) * stream->dst.width

						/ stream->src.width;



	pipe_ctx->scl_data.recout.width = surf_clip.width *

	pipe_ctx->plane_res.scl_data.recout.width = surf_clip.width *

			stream->dst.width / stream->src.width;

	if (pipe_ctx->scl_data.recout.width + pipe_ctx->scl_data.recout.x >

	if (pipe_ctx->plane_res.scl_data.recout.width + pipe_ctx->plane_res.scl_data.recout.x >

			stream->dst.x + stream->dst.width)

		pipe_ctx->scl_data.recout.width =

		pipe_ctx->plane_res.scl_data.recout.width =

			stream->dst.x + stream->dst.width

						- pipe_ctx->scl_data.recout.x;

						- pipe_ctx->plane_res.scl_data.recout.x;



	pipe_ctx->scl_data.recout.y = stream->dst.y;

	pipe_ctx->plane_res.scl_data.recout.y = stream->dst.y;

	if (stream->src.y < surf_clip.y)

		pipe_ctx->scl_data.recout.y += (surf_clip.y

		pipe_ctx->plane_res.scl_data.recout.y += (surf_clip.y

			- stream->src.y) * stream->dst.height

						/ stream->src.height;



	pipe_ctx->scl_data.recout.height = surf_clip.height *

	pipe_ctx->plane_res.scl_data.recout.height = surf_clip.height *

			stream->dst.height / stream->src.height;

	if (pipe_ctx->scl_data.recout.height + pipe_ctx->scl_data.recout.y >

	if (pipe_ctx->plane_res.scl_data.recout.height + pipe_ctx->plane_res.scl_data.recout.y >

			stream->dst.y + stream->dst.height)

		pipe_ctx->scl_data.recout.height =

		pipe_ctx->plane_res.scl_data.recout.height =

			stream->dst.y + stream->dst.height

						- pipe_ctx->scl_data.recout.y;

						- pipe_ctx->plane_res.scl_data.recout.y;



	/* Handle h & vsplit */

	if (pipe_ctx->top_pipe && pipe_ctx->top_pipe->plane_state ==

		pipe_ctx->plane_state) {

		if (stream->view_format == VIEW_3D_FORMAT_TOP_AND_BOTTOM) {

			pipe_ctx->scl_data.recout.height /= 2;

			pipe_ctx->scl_data.recout.y += pipe_ctx->scl_data.recout.height;

			pipe_ctx->plane_res.scl_data.recout.height /= 2;

			pipe_ctx->plane_res.scl_data.recout.y += pipe_ctx->plane_res.scl_data.recout.height;

			/* Floor primary pipe, ceil 2ndary pipe */

			pipe_ctx->scl_data.recout.height += pipe_ctx->scl_data.recout.height % 2;

			pipe_ctx->plane_res.scl_data.recout.height += pipe_ctx->plane_res.scl_data.recout.height % 2;

		} else {

			pipe_ctx->scl_data.recout.width /= 2;

			pipe_ctx->scl_data.recout.x += pipe_ctx->scl_data.recout.width;

			pipe_ctx->scl_data.recout.width += pipe_ctx->scl_data.recout.width % 2;

			pipe_ctx->plane_res.scl_data.recout.width /= 2;

			pipe_ctx->plane_res.scl_data.recout.x += pipe_ctx->plane_res.scl_data.recout.width;

			pipe_ctx->plane_res.scl_data.recout.width += pipe_ctx->plane_res.scl_data.recout.width % 2;

		}

	} else if (pipe_ctx->bottom_pipe &&

			pipe_ctx->bottom_pipe->plane_state == pipe_ctx->plane_state) {

		if (stream->view_format == VIEW_3D_FORMAT_TOP_AND_BOTTOM)

			pipe_ctx->scl_data.recout.height /= 2;

			pipe_ctx->plane_res.scl_data.recout.height /= 2;

		else

			pipe_ctx->scl_data.recout.width /= 2;

			pipe_ctx->plane_res.scl_data.recout.width /= 2;

	}



	/* Unclipped recout offset = stream dst offset + ((surf dst offset - stream surf_src offset)
@@ -601,8 +601,8 @@ static void calculate_recout(struct pipe_ctx *pipe_ctx, struct view *recout_skip 
			surf_src.y * plane_state->dst_rect.height / surf_src.height

					* stream->dst.height / stream->src.height;



	recout_skip->width = pipe_ctx->scl_data.recout.x - recout_full_x;

	recout_skip->height = pipe_ctx->scl_data.recout.y - recout_full_y;

	recout_skip->width = pipe_ctx->plane_res.scl_data.recout.x - recout_full_x;

	recout_skip->height = pipe_ctx->plane_res.scl_data.recout.y - recout_full_y;

}



static void calculate_scaling_ratios(struct pipe_ctx *pipe_ctx)
@@ -619,36 +619,36 @@ static void calculate_scaling_ratios(struct pipe_ctx *pipe_ctx) 
			pipe_ctx->plane_state->rotation == ROTATION_ANGLE_270)

		rect_swap_helper(&surf_src);



	pipe_ctx->scl_data.ratios.horz = dal_fixed31_32_from_fraction(

	pipe_ctx->plane_res.scl_data.ratios.horz = dal_fixed31_32_from_fraction(

					surf_src.width,

					plane_state->dst_rect.width);

	pipe_ctx->scl_data.ratios.vert = dal_fixed31_32_from_fraction(

	pipe_ctx->plane_res.scl_data.ratios.vert = dal_fixed31_32_from_fraction(

					surf_src.height,

					plane_state->dst_rect.height);



	if (stream->view_format == VIEW_3D_FORMAT_SIDE_BY_SIDE)

		pipe_ctx->scl_data.ratios.horz.value *= 2;

		pipe_ctx->plane_res.scl_data.ratios.horz.value *= 2;

	else if (stream->view_format == VIEW_3D_FORMAT_TOP_AND_BOTTOM)

		pipe_ctx->scl_data.ratios.vert.value *= 2;

		pipe_ctx->plane_res.scl_data.ratios.vert.value *= 2;



	pipe_ctx->scl_data.ratios.vert.value = div64_s64(

		pipe_ctx->scl_data.ratios.vert.value * in_h, out_h);

	pipe_ctx->scl_data.ratios.horz.value = div64_s64(

		pipe_ctx->scl_data.ratios.horz.value * in_w, out_w);

	pipe_ctx->plane_res.scl_data.ratios.vert.value = div64_s64(

		pipe_ctx->plane_res.scl_data.ratios.vert.value * in_h, out_h);

	pipe_ctx->plane_res.scl_data.ratios.horz.value = div64_s64(

		pipe_ctx->plane_res.scl_data.ratios.horz.value * in_w, out_w);



	pipe_ctx->scl_data.ratios.horz_c = pipe_ctx->scl_data.ratios.horz;

	pipe_ctx->scl_data.ratios.vert_c = pipe_ctx->scl_data.ratios.vert;

	pipe_ctx->plane_res.scl_data.ratios.horz_c = pipe_ctx->plane_res.scl_data.ratios.horz;

	pipe_ctx->plane_res.scl_data.ratios.vert_c = pipe_ctx->plane_res.scl_data.ratios.vert;



	if (pipe_ctx->scl_data.format == PIXEL_FORMAT_420BPP8

			|| pipe_ctx->scl_data.format == PIXEL_FORMAT_420BPP10) {

		pipe_ctx->scl_data.ratios.horz_c.value /= 2;

		pipe_ctx->scl_data.ratios.vert_c.value /= 2;

	if (pipe_ctx->plane_res.scl_data.format == PIXEL_FORMAT_420BPP8

			|| pipe_ctx->plane_res.scl_data.format == PIXEL_FORMAT_420BPP10) {

		pipe_ctx->plane_res.scl_data.ratios.horz_c.value /= 2;

		pipe_ctx->plane_res.scl_data.ratios.vert_c.value /= 2;

	}

}



static void calculate_inits_and_adj_vp(struct pipe_ctx *pipe_ctx, struct view *recout_skip)

{

	struct scaler_data *data = &pipe_ctx->scl_data;

	struct scaler_data *data = &pipe_ctx->plane_res.scl_data;

	struct rect src = pipe_ctx->plane_state->src_rect;

	int vpc_div = (data->format == PIXEL_FORMAT_420BPP8

			|| data->format == PIXEL_FORMAT_420BPP10) ? 2 : 1;
@@ -823,14 +823,14 @@ bool resource_build_scaling_params(struct pipe_ctx *pipe_ctx) 
	 * lb depth calculation requires recout and taps require scaling ratios.

	 * Inits require viewport, taps, ratios and recout of split pipe

	 */

	pipe_ctx->scl_data.format = convert_pixel_format_to_dalsurface(

	pipe_ctx->plane_res.scl_data.format = convert_pixel_format_to_dalsurface(

			pipe_ctx->plane_state->format);



	calculate_scaling_ratios(pipe_ctx);



	calculate_viewport(pipe_ctx);



	if (pipe_ctx->scl_data.viewport.height < 16 || pipe_ctx->scl_data.viewport.width < 16)

	if (pipe_ctx->plane_res.scl_data.viewport.height < 16 || pipe_ctx->plane_res.scl_data.viewport.width < 16)

		return false;



	calculate_recout(pipe_ctx, &recout_skip);
@@ -839,21 +839,21 @@ bool resource_build_scaling_params(struct pipe_ctx *pipe_ctx) 
	 * Setting line buffer pixel depth to 24bpp yields banding

	 * on certain displays, such as the Sharp 4k

	 */

	pipe_ctx->scl_data.lb_params.depth = LB_PIXEL_DEPTH_30BPP;

	pipe_ctx->plane_res.scl_data.lb_params.depth = LB_PIXEL_DEPTH_30BPP;



	pipe_ctx->scl_data.h_active = timing->h_addressable;

	pipe_ctx->scl_data.v_active = timing->v_addressable;

	pipe_ctx->plane_res.scl_data.h_active = timing->h_addressable;

	pipe_ctx->plane_res.scl_data.v_active = timing->v_addressable;



	/* Taps calculations */

	res = pipe_ctx->xfm->funcs->transform_get_optimal_number_of_taps(

		pipe_ctx->xfm, &pipe_ctx->scl_data, &plane_state->scaling_quality);

		pipe_ctx->xfm, &pipe_ctx->plane_res.scl_data, &plane_state->scaling_quality);



	if (!res) {

		/* Try 24 bpp linebuffer */

		pipe_ctx->scl_data.lb_params.depth = LB_PIXEL_DEPTH_24BPP;

		pipe_ctx->plane_res.scl_data.lb_params.depth = LB_PIXEL_DEPTH_24BPP;



		res = pipe_ctx->xfm->funcs->transform_get_optimal_number_of_taps(

			pipe_ctx->xfm, &pipe_ctx->scl_data, &plane_state->scaling_quality);

			pipe_ctx->xfm, &pipe_ctx->plane_res.scl_data, &plane_state->scaling_quality);

	}



	if (res)
@@ -865,10 +865,10 @@ bool resource_build_scaling_params(struct pipe_ctx *pipe_ctx) 
				"y:%d\n dst_rect:\nheight:%d width:%d x:%d "

				"y:%d\n",

				__func__,

				pipe_ctx->scl_data.viewport.height,

				pipe_ctx->scl_data.viewport.width,

				pipe_ctx->scl_data.viewport.x,

				pipe_ctx->scl_data.viewport.y,

				pipe_ctx->plane_res.scl_data.viewport.height,

				pipe_ctx->plane_res.scl_data.viewport.width,

				pipe_ctx->plane_res.scl_data.viewport.x,

				pipe_ctx->plane_res.scl_data.viewport.y,

				plane_state->dst_rect.height,

				plane_state->dst_rect.width,

				plane_state->dst_rect.x,

drivers/gpu/drm/amd/display/dc/core/dc_stream.c

+3 −3
Original line number Diff line number Diff line
@@ -223,9 +223,9 @@ bool dc_stream_set_cursor_position( 
		struct dc_cursor_mi_param param = {

			.pixel_clk_khz = stream->timing.pix_clk_khz,

			.ref_clk_khz = core_dc->res_pool->ref_clock_inKhz,

			.viewport_x_start = pipe_ctx->scl_data.viewport.x,

			.viewport_width = pipe_ctx->scl_data.viewport.width,

			.h_scale_ratio = pipe_ctx->scl_data.ratios.horz

			.viewport_x_start = pipe_ctx->plane_res.scl_data.viewport.x,

			.viewport_width = pipe_ctx->plane_res.scl_data.viewport.width,

			.h_scale_ratio = pipe_ctx->plane_res.scl_data.ratios.horz

		};



		if (pipe_ctx->stream != stream ||

drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.c

+17 −17
Original line number Diff line number Diff line
@@ -914,7 +914,7 @@ static void get_surface_visual_confirm_color(const struct pipe_ctx *pipe_ctx, 
{

	uint32_t color_value = MAX_TG_COLOR_VALUE * (4 - pipe_ctx->pipe_idx) / 4;



	switch (pipe_ctx->scl_data.format) {

	switch (pipe_ctx->plane_res.scl_data.format) {

	case PIXEL_FORMAT_ARGB8888:

		/* set boarder color to red */

		color->color_r_cr = color_value;
@@ -964,7 +964,7 @@ static void program_scaler(const struct core_dc *dc, 


	pipe_ctx->xfm->funcs->transform_set_pixel_storage_depth(

		pipe_ctx->xfm,

		pipe_ctx->scl_data.lb_params.depth,

		pipe_ctx->plane_res.scl_data.lb_params.depth,

		&pipe_ctx->stream->bit_depth_params);



	if (pipe_ctx->tg->funcs->set_overscan_blank_color)
@@ -973,7 +973,7 @@ static void program_scaler(const struct core_dc *dc, 
				&color);



	pipe_ctx->xfm->funcs->transform_set_scaler(pipe_ctx->xfm,

		&pipe_ctx->scl_data);

		&pipe_ctx->plane_res.scl_data);

}



static enum dc_status dce110_prog_pixclk_crtc_otg(
@@ -1114,10 +1114,10 @@ static enum dc_status apply_single_controller_ctx_to_hw( 
				&stream->sink->link->cur_link_settings);

	}



	pipe_ctx->scl_data.lb_params.alpha_en = pipe_ctx->bottom_pipe != 0;

	pipe_ctx->plane_res.scl_data.lb_params.alpha_en = pipe_ctx->bottom_pipe != 0;

	/* program_scaler and allocate_mem_input are not new asic */

	if ((!pipe_ctx_old ||

	     memcmp(&pipe_ctx_old->scl_data, &pipe_ctx->scl_data,

	     memcmp(&pipe_ctx_old->plane_res.scl_data, &pipe_ctx->plane_res.scl_data,

		    sizeof(struct scaler_data)) != 0) &&

	     pipe_ctx->plane_state) {

		program_scaler(dc, pipe_ctx);
@@ -1927,14 +1927,14 @@ static void set_default_colors(struct pipe_ctx *pipe_ctx) 
		default_adjust.out_color_space =

				pipe_ctx->stream->output_color_space;

	default_adjust.csc_adjust_type = GRAPHICS_CSC_ADJUST_TYPE_SW;

	default_adjust.surface_pixel_format = pipe_ctx->scl_data.format;

	default_adjust.surface_pixel_format = pipe_ctx->plane_res.scl_data.format;



	/* display color depth */

	default_adjust.color_depth =

		pipe_ctx->stream->timing.display_color_depth;



	/* Lb color depth */

	default_adjust.lb_color_depth = pipe_ctx->scl_data.lb_params.depth;

	default_adjust.lb_color_depth = pipe_ctx->plane_res.scl_data.lb_params.depth;



	pipe_ctx->xfm->funcs->opp_set_csc_default(

					pipe_ctx->xfm, &default_adjust);
@@ -2096,7 +2096,7 @@ static void set_plane_config( 


	pipe_ctx->xfm->funcs->transform_set_gamut_remap(pipe_ctx->xfm, &adjust);



	pipe_ctx->scl_data.lb_params.alpha_en = pipe_ctx->bottom_pipe != 0;

	pipe_ctx->plane_res.scl_data.lb_params.alpha_en = pipe_ctx->bottom_pipe != 0;

	program_scaler(dc, pipe_ctx);



	program_surface_visibility(dc, pipe_ctx);
@@ -2552,7 +2552,7 @@ static void dce110_program_front_end_for_pipe( 


	pipe_ctx->xfm->funcs->transform_set_gamut_remap(pipe_ctx->xfm, &adjust);



	pipe_ctx->scl_data.lb_params.alpha_en = pipe_ctx->bottom_pipe != 0;

	pipe_ctx->plane_res.scl_data.lb_params.alpha_en = pipe_ctx->bottom_pipe != 0;



	program_scaler(dc, pipe_ctx);
@@ -2602,14 +2602,14 @@ static void dce110_program_front_end_for_pipe( 
			"viewport:%d, %d, %d, %d\n"

			"recout:  %d, %d, %d, %d\n",

			pipe_ctx->pipe_idx,

			pipe_ctx->scl_data.viewport.width,

			pipe_ctx->scl_data.viewport.height,

			pipe_ctx->scl_data.viewport.x,

			pipe_ctx->scl_data.viewport.y,

			pipe_ctx->scl_data.recout.width,

			pipe_ctx->scl_data.recout.height,

			pipe_ctx->scl_data.recout.x,

			pipe_ctx->scl_data.recout.y);

			pipe_ctx->plane_res.scl_data.viewport.width,

			pipe_ctx->plane_res.scl_data.viewport.height,

			pipe_ctx->plane_res.scl_data.viewport.x,

			pipe_ctx->plane_res.scl_data.viewport.y,

			pipe_ctx->plane_res.scl_data.recout.width,

			pipe_ctx->plane_res.scl_data.recout.height,

			pipe_ctx->plane_res.scl_data.recout.x,

			pipe_ctx->plane_res.scl_data.recout.y);

}



static void dce110_apply_ctx_for_surface(