Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 93e6b464 authored by Linux Build Service Account's avatar Linux Build Service Account Committed by Gerrit - the friendly Code Review server
Browse files

Merge "msm: mdss: add generating 128 bytes of DSC PPS"

parents 7879504c 08ba86f1

drivers/video/msm/mdss/mdss_dsi.h

+6 −0
Original line number Diff line number Diff line
@@ -342,6 +342,9 @@ struct panel_horizontal_idle { 
#define MDSS_DSI_COMMAND_COMPRESSION_MODE_CTRL2	0x02ac

#define MDSS_DSI_COMMAND_COMPRESSION_MODE_CTRL3	0x02b0





#define DSC_PPS_LEN		128



struct mdss_dsi_ctrl_pdata {

	int ndx;	/* panel_num */

	int (*on) (struct mdss_panel_data *pdata);
@@ -424,6 +427,8 @@ struct mdss_dsi_ctrl_pdata { 
	struct dsi_panel_cmds video2cmd;

	struct dsi_panel_cmds cmd2video;



	char pps_buf[DSC_PPS_LEN];	/* dsc pps */



	struct dcs_cmd_list cmdlist;

	struct completion dma_comp;

	struct completion mdp_comp;
@@ -553,6 +558,7 @@ int mdss_panel_get_dst_fmt(u32 bpp, char mipi_mode, u32 pixel_packing, 


int mdss_dsi_register_recovery_handler(struct mdss_dsi_ctrl_pdata *ctrl,

		struct mdss_intf_recovery *recovery);

void mdss_dsi_panel_dsc_pps_send(struct mdss_dsi_ctrl_pdata *ctrl);



static inline const char *__mdss_dsi_pm_name(enum dsi_pm_type module)

{

drivers/video/msm/mdss/mdss_dsi_host.c

+6 −2
Original line number Diff line number Diff line
@@ -1069,7 +1069,7 @@ static void mdss_dsi_mode_setup(struct mdss_panel_data *pdata) 
	struct dsc_desc *dsc = NULL;

	u64 clk_rate;

	u32 hbp, hfp, vbp, vfp, hspw, vspw, width, height;

	u32 ystride, bpp, dst_bpp;

	u32 ystride, bpp, dst_bpp, byte_num;

	u32 stream_ctrl, stream_total;

	u32 dummy_xres = 0, dummy_yres = 0;

	u32 hsync_period, vsync_period;
@@ -1143,7 +1143,11 @@ static void mdss_dsi_mode_setup(struct mdss_panel_data *pdata) 
		ystride = width * bpp + 1;



		if (dsc) {

			stream_ctrl = ((dsc->bytes_in_slice + 1) << 16) |

			byte_num =  dsc->bytes_per_pkt;

			if (pinfo->mipi.insert_dcs_cmd)

				byte_num++;



			stream_ctrl = (byte_num << 16) |

					(mipi->vc << 8) | DTYPE_DCS_LWRITE;

			stream_total = dsc->pic_height << 16 |

							dsc->pclk_per_line;

drivers/video/msm/mdss/mdss_dsi_panel.c

+175 −5
Original line number Diff line number Diff line
@@ -34,6 +34,11 @@ 


DEFINE_LED_TRIGGER(bl_led_trigger);



/*

 * rc_buf_thresh = {896, 1792, 2688, 3548, 4480, 5376, 6272, 6720,

 *		7168, 7616, 7744, 7872, 8000, 8064, 8192};

 *	(x >> 6) & 0x0ff)

 */

static u32 dsc_rc_buf_thresh[] = {0x0e, 0x1c, 0x2a, 0x38, 0x46, 0x54,

		0x62, 0x69, 0x70, 0x77, 0x79, 0x7b, 0x7d, 0x7e};

static char dsc_rc_range_min_qp[] = {0, 0, 1, 1, 3, 3, 3, 3, 3, 3, 5,
@@ -684,6 +689,9 @@ static int mdss_dsi_panel_on(struct mdss_panel_data *pdata) 
	if (on_cmds->cmd_cnt)

		mdss_dsi_panel_cmds_send(ctrl, on_cmds);



	if (pinfo->compression_mode == COMPRESSION_DSC)

		mdss_dsi_panel_dsc_pps_send(ctrl);



end:

	pinfo->blank_state = MDSS_PANEL_BLANK_UNBLANK;

	pr_debug("%s:-\n", __func__);
@@ -1014,6 +1022,160 @@ static int mdss_dsi_parse_fbc_params(struct device_node *np, 
	return 0;

}



static int mdss_dsc_to_buf(struct dsc_desc *dsc, char *buf,

			int pps_id, int major, int minor)

{

	char *bp;

	char data;

	int i, bpp;



	bp = buf;

	*bp++ = ((major << 4) | minor);		/* pps0 */

	*bp++ = pps_id;				/* pps1 */

	bp++;					/* pps2, reserved */



	data = dsc->line_buf_depth & 0x0f;

	data |= (dsc->bpc << 4);

	*bp++ = data;				 /* pps3 */



	bpp = dsc->bpp;

	bpp <<= 4;	/* 4 fraction bits */

	data = (bpp >> 8);

	data &= 0x03;		/* upper two bits */

	data |= (dsc->block_pred_enable << 5);

	data |= (dsc->convert_rgb << 4);

	data |= (dsc->enable_422 << 3);

	data |= (dsc->vbr_enable << 2);

	*bp++ = data;				/* pps4 */

	*bp++ = bpp;				/* pps5 */



	*bp++ = (dsc->pic_height >> 8);		/* pps6 */

	*bp++ = (dsc->pic_height & 0x0ff);	/* pps7 */

	*bp++ = (dsc->pic_width >> 8);		/* pps8 */

	*bp++ = (dsc->pic_width & 0x0ff);	/* pps9 */



	*bp++ = (dsc->slice_height >> 8);	/* pps10 */

	*bp++ = (dsc->slice_height & 0x0ff);	/* pps11 */

	*bp++ = (dsc->slice_width >> 8);	/* pps12 */

	*bp++ = (dsc->slice_width & 0x0ff);	/* pps13 */



	*bp++ = (dsc->chunk_size >> 8);		/* pps14 */

	*bp++ = (dsc->chunk_size & 0x0ff);	/* pps15 */



	data = dsc->initial_xmit_delay >> 8;

	data &= 0x03;

	*bp++ = data;				/* pps16, bit 0, 1 */

	*bp++ = dsc->initial_xmit_delay;	/* pps17 */



	*bp++ = (dsc->initial_dec_delay >> 8);	/* pps18 */

	*bp++ = dsc->initial_dec_delay;		/* pps19 */



	bp++;					/* pps20, reserved */



	*bp++ = (dsc->initial_scale_value & 0x3f); /* pps21 */



	data = (dsc->scale_increment_interval >> 8);

	data &= 0x0f;

	*bp++ =  data;				/* pps22 */

	*bp++ = dsc->scale_increment_interval;	/* pps23 */



	data = (dsc->scale_decrement_interval >> 8);

	data &= 0x0f;

	*bp++ = data;				/* pps24 */

	*bp++ = (dsc->scale_decrement_interval & 0x0ff);/* pps25 */



	bp++;			/* pps26, reserved */



	*bp++ = (dsc->first_line_bpg_offset & 0x1f);/* pps27 */



	*bp++ = (dsc->nfl_bpg_offset >> 8);	/* pps28 */

	*bp++ = (dsc->nfl_bpg_offset & 0x0ff);	/* pps29 */

	*bp++ = (dsc->slice_bpg_offset >> 8);	/* pps30 */

	*bp++ = (dsc->slice_bpg_offset & 0x0ff);/* pps31 */



	*bp++ = (dsc->initial_offset >> 8);	/* pps32 */

	*bp++ = (dsc->initial_offset & 0x0ff);	/* pps33 */



	*bp++ = (dsc->final_offset >> 8);	/* pps34 */

	*bp++ = (dsc->final_offset & 0x0ff);	/* pps35 */



	*bp++ = (dsc->min_qp_flatness & 0x1f);	/* pps36 */

	*bp++ = (dsc->max_qp_flatness & 0x1f);	/* pps37 */



	*bp++ = (dsc->rc_model_size >> 8);	/* pps38 */

	*bp++ = (dsc->rc_model_size & 0x0ff);	/* pps39 */



	*bp++ = (dsc->edge_factor & 0x0f);	/* pps40 */



	*bp++ = (dsc->quant_incr_limit0 & 0x1f);	/* pps41 */

	*bp++ = (dsc->quant_incr_limit1 & 0x1f);	/* pps42 */



	data = (dsc->tgt_offset_hi << 4);

	data |= (dsc->tgt_offset_lo & 0x0f);

	*bp++ = data;				/* pps43 */



	for (i = 0; i < 14; i++)

		*bp++ = dsc->buf_thresh[i];	/* pps44 - pps57 */



	for (i = 0; i < 15; i++) {		/* pps58 - pps87 */

		data = (dsc->range_min_qp[i] & 0x1f); /* 5 bits */

		data <<= 3;

		data |= ((dsc->range_max_qp[i] >> 2) & 0x07); /* 3 bits */

		*bp++ = data;

		data = (dsc->range_max_qp[i] & 0x03); /* 2 bits */

		data <<= 6;

		data |= (dsc->range_bpg_offset[i] & 0x3f); /* 6 bits */

		*bp++ = data;

	}



	/* pps88 to pps127 are reserved */



	return DSC_PPS_LEN;	/* 128 */

}



void mdss_dsi_panel_dsc_pps_send(struct mdss_dsi_ctrl_pdata *ctrl)

{

	struct mdss_panel_info *pinfo;

	struct dsc_desc *dsc;

	struct dsi_panel_cmds pcmds;

	struct dsi_cmd_desc cmd;



	pinfo = &(ctrl->panel_data.panel_info);

	if (pinfo->compression_mode != COMPRESSION_DSC)

		return;



	memset(&pcmds, 0, sizeof(pcmds));

	memset(&cmd, 0, sizeof(cmd));



	dsc = &pinfo->dsc;

	cmd.dchdr.dlen = mdss_dsc_to_buf(dsc, ctrl->pps_buf, 0 , 1, 0);

	cmd.dchdr.dtype = DTYPE_PPS;

	cmd.dchdr.last = 1;

	cmd.dchdr.wait = 10;

	cmd.dchdr.vc = 0;

	cmd.dchdr.ack = 0;

	cmd.payload = ctrl->pps_buf;



	pcmds.cmd_cnt = 1;

	pcmds.cmds = &cmd;

	pcmds.link_state = DSI_LP_MODE;



	mdss_dsi_panel_cmds_send(ctrl, &pcmds);

}



int mdss_dsc_initial_line_calc(int bpc, int xmit_delay,

			int slice_width, int slice_per_line)

{

	int ssm_delay;

	int total_pixels;



	ssm_delay = ((bpc < 10) ? 83 : 91);

	total_pixels = ssm_delay * 3 + 30 + xmit_delay + 6;

	total_pixels += ((slice_per_line > 1) ? (ssm_delay * 3) : 0);



	return CEIL(total_pixels, slice_width);

}



void mdss_dsc_parameters_calc(struct mdss_panel_info *pinfo)

{

	struct dsc_desc *dsc;
@@ -1035,8 +1197,6 @@ void mdss_dsc_parameters_calc(struct mdss_panel_info *pinfo) 
	dsc->min_qp_flatness = 3;

	dsc->max_qp_flatness = 12;

	dsc->line_buf_depth = 9;

	dsc->max_qp_flatness = 12;

	dsc->min_qp_flatness = 3;



	dsc->edge_factor = 6;

	dsc->quant_incr_limit0 = 11;
@@ -1049,7 +1209,6 @@ void mdss_dsc_parameters_calc(struct mdss_panel_info *pinfo) 
	dsc->range_max_qp = dsc_rc_range_max_qp;

	dsc->range_bpg_offset = dsc_rc_range_bpg_offset;



	dsc->slice_per_pkt = 1;

	dsc->initial_lines = 2;



	dsc->pic_width = pinfo->xres;
@@ -1068,7 +1227,12 @@ void mdss_dsc_parameters_calc(struct mdss_panel_info *pinfo) 
	else

		mux_words_size = 64;	/* bpc == 12 */



	slice_per_line  = dsc->pic_width / dsc->slice_width;

	slice_per_line = CEIL(dsc->pic_width, dsc->slice_width);



	dsc->pkt_per_line = slice_per_line / dsc->slice_per_pkt;

	if (slice_per_line % dsc->slice_per_pkt)

		dsc->pkt_per_line = 1;		/* default*/



	bytes_in_slice = CEIL(dsc->pic_width, slice_per_line);



	bytes_in_slice *= dsc->bpp;	/* bites per compressed pixel */
@@ -1076,6 +1240,9 @@ void mdss_dsc_parameters_calc(struct mdss_panel_info *pinfo) 


	dsc->bytes_in_slice = bytes_in_slice;



	pr_debug("%s: slice_per_line=%d pkt_per_line=%d bytes_in_slice=%d\n",

		__func__, slice_per_line, dsc->pkt_per_line, bytes_in_slice);



	total_bytes = bytes_in_slice * slice_per_line;

	dsc->eol_byte_num = total_bytes % 3;

	dsc->pclk_per_line =  CEIL(total_bytes, 3);
@@ -1091,13 +1258,15 @@ void mdss_dsc_parameters_calc(struct mdss_panel_info *pinfo) 


	dsc->initial_xmit_delay = dsc->rc_model_size / (2 * bpp);



	dsc->initial_lines = mdss_dsc_initial_line_calc(bpc,

		dsc->initial_xmit_delay, dsc->slice_width, slice_per_line);



	groups_per_line = CEIL(dsc->slice_width, 3);



	dsc->chunk_size = dsc->slice_width * bpp / 8;

	if ((dsc->slice_width * bpp) % 8)

		dsc->chunk_size++;



	dsc->pkt_per_line = CEIL(dsc->pic_width, dsc->slice_width);



	/* rbs-min */

	min_rate_buffer_size =  dsc->rc_model_size - dsc->initial_offset +
@@ -1236,6 +1405,7 @@ static int mdss_dsi_parse_dsc_params(struct device_node *np, 


	dsc->enable_422 = 0;

	dsc->convert_rgb = 1;

	dsc->vbr_enable = 0;



	dsc->config_by_manufacture_cmd = of_property_read_bool(np,

		"qcom,mdss-dsc-config-by-manufacture-cmd");

drivers/video/msm/mdss/mdss_panel.h

+1 −0
Original line number Diff line number Diff line
@@ -392,6 +392,7 @@ struct dsc_desc { 
	int line_buf_depth;

	bool config_by_manufacture_cmd;

	bool block_pred_enable;

	int vbr_enable;

	int enable_422;

	int convert_rgb;

	int input_10_bits;