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

Commit 6a8f089c authored by Adrian Salido-Moreno's avatar Adrian Salido-Moreno Committed by Gerrit - the friendly Code Review server
Browse files

msm: mdss: dsi: add support for multiple panel timing settings 



Some DSI panels support more than one resolution or panel timing.
Add support to parse and configure different panel timing settings
and ability to switch between them dynamically if possible.

Change-Id: I532587eaa763499c9d51909937339093cd74a8cf
Signed-off-by: default avatarChandan Uddaraju <chandanu@codeaurora.org>
Signed-off-by: default avatarAdrian Salido-Moreno <adrianm@codeaurora.org>
parent eb1e8c29

Documentation/devicetree/bindings/fb/mdss-dsi-panel.txt

+41 −0
Original line number Diff line number Diff line
@@ -378,6 +378,8 @@ Optional properties: 
						go blank during transition.

					"dynamic-switch-immediate"= Switch on next frame update. Panel will

						not go blank for this transition.

					"dynamic-resolution-switch-immediate"= Switch the panel resolution. Panel will

						not go blank for this transition.

- qcom,mdss-dsi-post-mode-switch-on-command:		Multiple dcs packets used for turning on DSI panel

					after panel has switch modes.

					Refer to "qcom,mdss-dsi-on-command" section for adding commands.
@@ -395,6 +397,20 @@ Optional properties: 
			   for any commands that we send.

- qcom,mdss-dsi-force-clock-lane-hs:	Boolean to force dsi clock lanes to HS mode always.



- qcom,mdss-dsi-display-timings:	Parent node that lists the different resolutions that the panel supports.

					Each child represents timings settings for a specific resolution.



Additional properties added to the second level nodes that represent timings properties:

- qcom,mdss-dsi-timing-default:		Property that specifies the current child as the default

					timing configuration that will be used.

- qcom,mdss-dsi-timing-switch-command:	List of commands that need to be sent

					to panel when the resolution/timing switch happens dynamically.

					Refer to "qcom,mdss-dsi-on-command" section for adding commands.

- qcom,mdss-dsi-timing-switch-command-state:	String that specifies the ctrl state for sending resolution switch

					commands.

					"dsi_lp_mode" = DSI low power mode (default)

					"dsi_hs_mode" = DSI high speed mode



Note, if a given optional qcom,* binding is not present, then the driver will configure

the default values specified.
@@ -530,5 +546,30 @@ Example: 
						<128 240 64>;

		qcom,mdss-dsi-panel-orientation = "180"

		qcom,mdss-dsi-force-clock-lane-hs;

		qcom,mdss-dsi-display-timings {

			wqhd {

				qcom,mdss-dsi-timing-default;

				qcom,mdss-dsi-panel-width = <720>;

				qcom,mdss-dsi-panel-height = <2560>;

				qcom,mdss-dsi-h-front-porch = <20>;

				qcom,mdss-dsi-h-back-porch = <8>;

				qcom,mdss-dsi-h-pulse-width = <8>;

				qcom,mdss-dsi-h-sync-skew = <0>;

				qcom,mdss-dsi-v-back-porch = <4>;

				qcom,mdss-dsi-v-front-porch = <728>;

				qcom,mdss-dsi-v-pulse-width = <4>;

				qcom,mdss-dsi-panel-framerate = <60>;

				qcom,mdss-dsi-panel-timings = [E6 38 26 00 68 6E 2A 3C 2C 03 04 00];

				qcom,mdss-dsi-t-clk-post = <0x02>;

				qcom,mdss-dsi-t-clk-pre = <0x2a>;

				qcom,mdss-dsi-on-command = [05 01 00 00 a0 00 02 11 00

					05 01 00 00 02 00 02 29 00];

				qcom,mdss-dsi-on-command-state = "dsi_lp_mode";

				qcom,mdss-dsi-timing-switch-command = [

					29 00 00 00 00 00 02 B0 04

					29 00 00 00 00 00 02 F1 00];

				qcom,mdss-dsi-timing-switch-command-state = "dsi_lp_mode";

			};

		};

	};

};

drivers/video/msm/mdss/mdss_dsi.c

+16 −30
Original line number Diff line number Diff line
@@ -612,15 +612,18 @@ int mdss_dsi_switch_mode(struct mdss_panel_data *pdata, int mode) 
	ctrl_pdata = container_of(pdata, struct mdss_dsi_ctrl_pdata,

		panel_data);



	if (pinfo->dms_mode != DYNAMIC_MODE_SWITCH_IMMEDIATE) {

		pr_debug("%s: Dynamic mode switch not enabled.\n", __func__);

	if ((pinfo->dms_mode != DYNAMIC_MODE_RESOLUTION_SWITCH_IMMEDIATE) &&

			(pinfo->dms_mode != DYNAMIC_MODE_SWITCH_IMMEDIATE)) {

		pr_err("%s: Dynamic mode switch not enabled.\n", __func__);

		return -EPERM;

	}



	if (mode == MIPI_VIDEO_PANEL) {

		mode = DSI_VIDEO_MODE;

		mode = SWITCH_TO_VIDEO_MODE;

	} else if (mode == MIPI_CMD_PANEL) {

		mode = DSI_CMD_MODE;

		mode = SWITCH_TO_CMD_MODE;

	} else if (mode == SWITCH_RESOLUTION) {

		pr_debug("Resolution switch mode selected\n");

	} else {

		pr_err("Invalid mode selected, mode=%d\n", mode);

		return -EINVAL;
@@ -753,6 +756,7 @@ int mdss_dsi_on(struct mdss_panel_data *pdata) 
		mdss_dsi_phy_sw_reset(ctrl_pdata);

		mdss_dsi_phy_init(ctrl_pdata);

		mdss_dsi_ctrl_setup(ctrl_pdata);

		pr_debug("%s: reset Phy and call ctrl_setup\n", __func__);

	}



	/* DSI link clocks need to be on prior to ctrl sw reset */
@@ -857,8 +861,9 @@ static int mdss_dsi_unblank(struct mdss_panel_data *pdata) 
				panel_data);

	mipi  = &pdata->panel_info.mipi;



	pr_debug("%s+: ctrl=%p ndx=%d cur_blank_state=%d\n", __func__,

		ctrl_pdata, ctrl_pdata->ndx, pdata->panel_info.blank_state);

	pr_debug("%s+: ctrl=%p ndx=%d cur_blank_state=%d ctrl_state=%x\n",

			__func__, ctrl_pdata, ctrl_pdata->ndx,

			pdata->panel_info.blank_state, ctrl_pdata->ctrl_state);



	mdss_dsi_clk_ctrl(ctrl_pdata, DSI_ALL_CLKS, 1);
@@ -934,9 +939,9 @@ static int mdss_dsi_blank(struct mdss_panel_data *pdata, int power_state) 
		pr_info("%s: switching to %s mode\n", __func__,

			(pdata->panel_info.mipi.mode ? "video" : "command"));

		if (pdata->panel_info.type == MIPI_CMD_PANEL) {

			ctrl_pdata->switch_mode(pdata, DSI_VIDEO_MODE);

			ctrl_pdata->switch_mode(pdata, SWITCH_TO_VIDEO_MODE);

		} else if (pdata->panel_info.type == MIPI_VIDEO_PANEL) {

			ctrl_pdata->switch_mode(pdata, DSI_CMD_MODE);

			ctrl_pdata->switch_mode(pdata, SWITCH_TO_CMD_MODE);

			mdss_dsi_set_tear_off(ctrl_pdata);

		}

	}
@@ -1423,28 +1428,6 @@ int mdss_dsi_register_recovery_handler(struct mdss_dsi_ctrl_pdata *ctrl, 
	return 0;

}



static int mdss_dsi_clk_refresh(struct mdss_panel_data *pdata)

{

	struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL;

	int rc = 0;



	ctrl_pdata = container_of(pdata, struct mdss_dsi_ctrl_pdata,

							panel_data);

	rc = mdss_dsi_clk_div_config(&pdata->panel_info,

			pdata->panel_info.mipi.frame_rate);

	if (rc) {

		pr_err("%s: unable to initialize the clk dividers\n",

								__func__);

		return rc;

	}

	ctrl_pdata->refresh_clk_rate = false;

	ctrl_pdata->pclk_rate = pdata->panel_info.mipi.dsi_pclk_rate;

	ctrl_pdata->byte_clk_rate = pdata->panel_info.clk_rate / 8;

	pr_debug("%s ctrl_pdata->byte_clk_rate=%d ctrl_pdata->pclk_rate=%d\n",

		__func__, ctrl_pdata->byte_clk_rate, ctrl_pdata->pclk_rate);

	return rc;

}



static int mdss_dsi_event_handler(struct mdss_panel_data *pdata,

				  int event, void *arg)

{
@@ -1555,6 +1538,9 @@ static int mdss_dsi_event_handler(struct mdss_panel_data *pdata, 
		if (ctrl_pdata->check_status)

			rc = ctrl_pdata->check_status(ctrl_pdata);

		break;

	case MDSS_EVENT_PANEL_TIMING_SWITCH:

		rc = mdss_dsi_panel_timing_switch(ctrl_pdata, arg);

		break;

	default:

		pr_debug("%s: unhandled event=%d\n", __func__, event);

		break;

drivers/video/msm/mdss/mdss_dsi.h

+14 −0
Original line number Diff line number Diff line
@@ -251,6 +251,16 @@ struct dsi_panel_cmds { 
	int link_state;

};



struct dsi_panel_timing {

	struct mdss_panel_timing timing;

	uint32_t phy_timing[12];

	/* DSI_CLKOUT_TIMING_CTRL */

	char t_clk_post;

	char t_clk_pre;

	struct dsi_panel_cmds on_cmds;

	struct dsi_panel_cmds switch_cmds;

};



struct dsi_kickoff_action {

	struct list_head act_entry;

	void (*action) (void *);
@@ -460,6 +470,7 @@ void mdss_dsi_irq_handler_config(struct mdss_dsi_ctrl_pdata *ctrl_pdata); 
void mdss_dsi_set_tx_power_mode(int mode, struct mdss_panel_data *pdata);

int mdss_dsi_clk_div_config(struct mdss_panel_info *panel_info,

			    int frame_rate);

int mdss_dsi_clk_refresh(struct mdss_panel_data *pdata);

int mdss_dsi_clk_init(struct platform_device *pdev,

		      struct mdss_dsi_ctrl_pdata *ctrl_pdata);

int mdss_dsi_shadow_clk_init(struct platform_device *pdev,
@@ -497,6 +508,9 @@ u32 mdss_dsi_panel_cmd_read(struct mdss_dsi_ctrl_pdata *ctrl, char cmd0, 
int mdss_dsi_panel_init(struct device_node *node,

		struct mdss_dsi_ctrl_pdata *ctrl_pdata,

		bool cmd_cfg_cont_splash);

int mdss_dsi_panel_timing_switch(struct mdss_dsi_ctrl_pdata *ctrl_pdata,

			struct mdss_panel_timing *timing);



int mdss_panel_get_dst_fmt(u32 bpp, char mipi_mode, u32 pixel_packing,

				char *dst_format);

drivers/video/msm/mdss/mdss_dsi_host.c

+8 −8
Original line number Diff line number Diff line
@@ -1034,7 +1034,6 @@ static void mdss_dsi_mode_setup(struct mdss_panel_data *pdata) 
	struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL;

	struct mdss_panel_info *pinfo;

	struct mipi_panel_info *mipi;

	u32 clk_rate;

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

	u32 ystride, bpp, dst_bpp;

	u32 stream_ctrl, stream_total;
@@ -1046,9 +1045,6 @@ static void mdss_dsi_mode_setup(struct mdss_panel_data *pdata) 


	pinfo = &pdata->panel_info;



	clk_rate = pdata->panel_info.clk_rate;

	clk_rate = min(clk_rate, pdata->panel_info.clk_max);



	dst_bpp = pdata->panel_info.fbc.enabled ?

		(pdata->panel_info.fbc.target_bpp) : (pinfo->bpp);
@@ -1061,6 +1057,8 @@ static void mdss_dsi_mode_setup(struct mdss_panel_data *pdata) 
	width = mult_frac(pdata->panel_info.xres, dst_bpp,

			pdata->panel_info.bpp);

	height = pdata->panel_info.yres;

	pr_debug("%s: fbc=%d width=%d height=%d dst_bpp=%d\n", __func__,

			pdata->panel_info.fbc.enabled, width, height, dst_bpp);



	if (pdata->panel_info.type == MIPI_VIDEO_PANEL) {

		dummy_xres = mult_frac((pdata->panel_info.lcdc.border_left +
@@ -1070,11 +1068,11 @@ static void mdss_dsi_mode_setup(struct mdss_panel_data *pdata) 
				pdata->panel_info.lcdc.border_bottom;

	}



	mipi = &pdata->panel_info.mipi;

	if (pdata->panel_info.type == MIPI_VIDEO_PANEL) {

		vsync_period = vspw + vbp + height + dummy_yres + vfp;

		hsync_period = hspw + hbp + width + dummy_xres + hfp;



	mipi = &pdata->panel_info.mipi;

	if (pdata->panel_info.type == MIPI_VIDEO_PANEL) {

		if (ctrl_pdata->timing_db_mode)

			MIPI_OUTP((ctrl_pdata->ctrl_base) + 0x1e8, 0x1);

		MIPI_OUTP((ctrl_pdata->ctrl_base) + 0x24,
@@ -1360,9 +1358,11 @@ static int mdss_dsi_cmds2buf_tx(struct mdss_dsi_ctrl_pdata *ctrl, 
			if (IS_ERR_VALUE(len)) {

				mdss_dsi_disable_irq(ctrl, DSI_CMD_TERM);

				pr_err("%s: failed to call cmd_dma_tx for cmd = 0x%x\n",

					__func__,  cmds->payload[0]);

					__func__,  cm->payload[0]);

				return 0;

			}

			pr_debug("%s: cmd_dma_tx for cmd = 0x%x, len = %d\n",

					__func__,  cm->payload[0], len);



			if (!wait || dchdr->wait > VSYNC_PERIOD)

				usleep(dchdr->wait * 1000);

drivers/video/msm/mdss/mdss_dsi_panel.c

+244 −90
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 
#include <linux/leds.h>

#include <linux/qpnp/pwm.h>

#include <linux/err.h>

#include <linux/string.h>



#include "mdss_dsi.h"
@@ -140,7 +141,7 @@ u32 mdss_dsi_panel_cmd_read(struct mdss_dsi_ctrl_pdata *ctrl, char cmd0, 
}



static void mdss_dsi_panel_cmds_send(struct mdss_dsi_ctrl_pdata *ctrl,

			struct dsi_panel_cmds *pcmds)

			struct dsi_panel_cmds *pcmds, u32 flags)

{

	struct dcs_cmd_req cmdreq;

	struct mdss_panel_info *pinfo;
@@ -154,7 +155,7 @@ static void mdss_dsi_panel_cmds_send(struct mdss_dsi_ctrl_pdata *ctrl, 
	memset(&cmdreq, 0, sizeof(cmdreq));

	cmdreq.cmds = pcmds->cmds;

	cmdreq.cmds_cnt = pcmds->cmd_cnt;

	cmdreq.flags = CMD_REQ_COMMIT;

	cmdreq.flags = flags;



	/*Panel ON/Off commands should be sent in DSI Low Power Mode*/

	if (pcmds->link_state == DSI_LP_MODE)
@@ -541,16 +542,30 @@ static void mdss_dsi_panel_switch_mode(struct mdss_panel_data *pdata, 
	ctrl_pdata = container_of(pdata, struct mdss_dsi_ctrl_pdata,

				panel_data);



	if (mode == DSI_CMD_MODE)

	if (mipi->dms_mode != DYNAMIC_MODE_RESOLUTION_SWITCH_IMMEDIATE) {

		if (mode == SWITCH_TO_CMD_MODE)

			pcmds = &ctrl_pdata->video2cmd;

		else

			pcmds = &ctrl_pdata->cmd2video;

	} else if ((mipi->dms_mode ==

				DYNAMIC_MODE_RESOLUTION_SWITCH_IMMEDIATE)

			&& pdata->current_timing

			&& !list_empty(&pdata->timings_list)) {

		struct dsi_panel_timing *pt;



	mdss_dsi_panel_cmds_send(ctrl_pdata, pcmds);

		pt = container_of(pdata->current_timing,

				struct dsi_panel_timing, timing);



		pr_debug("%s: sending switch commands\n", __func__);

		pcmds = &pt->switch_cmds;

	} else {

		pr_warn("%s: Invalid mode switch attempted\n", __func__);

		return;

	}



	mdss_dsi_panel_cmds_send(ctrl_pdata, pcmds, 0);

}



static void mdss_dsi_panel_bl_ctrl(struct mdss_panel_data *pdata,

							u32 bl_level)

{
@@ -641,7 +656,7 @@ static int mdss_dsi_panel_on(struct mdss_panel_data *pdata) 
		on_cmds = &ctrl->post_dms_on_cmds;



	if (on_cmds->cmd_cnt)

		mdss_dsi_panel_cmds_send(ctrl, on_cmds);

		mdss_dsi_panel_cmds_send(ctrl, on_cmds, CMD_REQ_COMMIT);



end:

	pinfo->blank_state = MDSS_PANEL_BLANK_UNBLANK;
@@ -671,7 +686,7 @@ static int mdss_dsi_panel_off(struct mdss_panel_data *pdata) 
	}



	if (ctrl->off_cmds.cmd_cnt)

		mdss_dsi_panel_cmds_send(ctrl, &ctrl->off_cmds);

		mdss_dsi_panel_cmds_send(ctrl, &ctrl->off_cmds, CMD_REQ_COMMIT);



end:

	pinfo->blank_state = MDSS_PANEL_BLANK_BLANK;
@@ -906,9 +921,8 @@ int mdss_panel_get_dst_fmt(u32 bpp, char mipi_mode, u32 pixel_packing, 
	return rc;

}





static int mdss_dsi_parse_fbc_params(struct device_node *np,

				struct mdss_panel_info *panel_info)

				struct fbc_panel_info *fbc)

{

	int rc, fbc_enabled = 0;

	u32 tmp;
@@ -916,59 +930,58 @@ static int mdss_dsi_parse_fbc_params(struct device_node *np, 
	fbc_enabled = of_property_read_bool(np,	"qcom,mdss-dsi-fbc-enable");

	if (fbc_enabled) {

		pr_debug("%s:%d FBC panel enabled.\n", __func__, __LINE__);

		panel_info->fbc.enabled = 1;

		fbc->enabled = 1;

		rc = of_property_read_u32(np, "qcom,mdss-dsi-fbc-bpp", &tmp);

		panel_info->fbc.target_bpp =	(!rc ? tmp : panel_info->bpp);

		fbc->target_bpp =	(!rc ? tmp : 24);

		rc = of_property_read_u32(np, "qcom,mdss-dsi-fbc-packing",

				&tmp);

		panel_info->fbc.comp_mode = (!rc ? tmp : 0);

		panel_info->fbc.qerr_enable = of_property_read_bool(np,

		fbc->comp_mode = (!rc ? tmp : 0);

		fbc->qerr_enable = of_property_read_bool(np,

			"qcom,mdss-dsi-fbc-quant-error");

		rc = of_property_read_u32(np, "qcom,mdss-dsi-fbc-bias", &tmp);

		panel_info->fbc.cd_bias = (!rc ? tmp : 0);

		panel_info->fbc.pat_enable = of_property_read_bool(np,

		fbc->cd_bias = (!rc ? tmp : 0);

		fbc->pat_enable = of_property_read_bool(np,

				"qcom,mdss-dsi-fbc-pat-mode");

		panel_info->fbc.vlc_enable = of_property_read_bool(np,

		fbc->vlc_enable = of_property_read_bool(np,

				"qcom,mdss-dsi-fbc-vlc-mode");

		panel_info->fbc.bflc_enable = of_property_read_bool(np,

		fbc->bflc_enable = of_property_read_bool(np,

				"qcom,mdss-dsi-fbc-bflc-mode");

		rc = of_property_read_u32(np, "qcom,mdss-dsi-fbc-h-line-budget",

				&tmp);

		panel_info->fbc.line_x_budget = (!rc ? tmp : 0);

		fbc->line_x_budget = (!rc ? tmp : 0);

		rc = of_property_read_u32(np, "qcom,mdss-dsi-fbc-budget-ctrl",

				&tmp);

		panel_info->fbc.block_x_budget = (!rc ? tmp : 0);

		fbc->block_x_budget = (!rc ? tmp : 0);

		rc = of_property_read_u32(np, "qcom,mdss-dsi-fbc-block-budget",

				&tmp);

		panel_info->fbc.block_budget = (!rc ? tmp : 0);

		fbc->block_budget = (!rc ? tmp : 0);

		rc = of_property_read_u32(np,

				"qcom,mdss-dsi-fbc-lossless-threshold", &tmp);

		panel_info->fbc.lossless_mode_thd = (!rc ? tmp : 0);

		fbc->lossless_mode_thd = (!rc ? tmp : 0);

		rc = of_property_read_u32(np,

				"qcom,mdss-dsi-fbc-lossy-threshold", &tmp);

		panel_info->fbc.lossy_mode_thd = (!rc ? tmp : 0);

		fbc->lossy_mode_thd = (!rc ? tmp : 0);

		rc = of_property_read_u32(np, "qcom,mdss-dsi-fbc-rgb-threshold",

				&tmp);

		panel_info->fbc.lossy_rgb_thd = (!rc ? tmp : 0);

		fbc->lossy_rgb_thd = (!rc ? tmp : 0);

		rc = of_property_read_u32(np,

				"qcom,mdss-dsi-fbc-lossy-mode-idx", &tmp);

		panel_info->fbc.lossy_mode_idx = (!rc ? tmp : 0);

		fbc->lossy_mode_idx = (!rc ? tmp : 0);

		rc = of_property_read_u32(np,

				"qcom,mdss-dsi-fbc-slice-height", &tmp);

		panel_info->fbc.slice_height = (!rc ? tmp : 0);

		panel_info->fbc.pred_mode = of_property_read_bool(np,

		fbc->slice_height = (!rc ? tmp : 0);

		fbc->pred_mode = of_property_read_bool(np,

				"qcom,mdss-dsi-fbc-2d-pred-mode");

		panel_info->fbc.enc_mode = of_property_read_bool(np,

		fbc->enc_mode = of_property_read_bool(np,

				"qcom,mdss-dsi-fbc-ver2-mode");

		rc = of_property_read_u32(np,

				"qcom,mdss-dsi-fbc-max-pred-err", &tmp);

		panel_info->fbc.max_pred_err = (!rc ? tmp : 0);

		fbc->max_pred_err = (!rc ? tmp : 0);

	} else {

		pr_debug("%s:%d Panel does not support FBC.\n",

				__func__, __LINE__);

		panel_info->fbc.enabled = 0;

		panel_info->fbc.target_bpp =

			panel_info->bpp;

		fbc->enabled = 0;

		fbc->target_bpp = 24;

	}

	return 0;

}
@@ -1133,6 +1146,17 @@ static void mdss_dsi_parse_dms_config(struct device_node *np, 
	/* default mode is suspend_resume */

	pinfo->mipi.dms_mode = DYNAMIC_MODE_SWITCH_SUSPEND_RESUME;

	data = of_get_property(np, "qcom,dynamic-mode-switch-type", NULL);

	if (data && !strcmp(data, "dynamic-resolution-switch-immediate")) {

		if (!list_empty(&ctrl->panel_data.timings_list))

			pinfo->mipi.dms_mode =

				DYNAMIC_MODE_RESOLUTION_SWITCH_IMMEDIATE;

		else

			pinfo->mipi.dms_mode =

				DYNAMIC_MODE_SWITCH_DISABLED;



		goto exit;

	}



	if (data && !strcmp(data, "dynamic-switch-immediate"))

		pinfo->mipi.dms_mode = DYNAMIC_MODE_SWITCH_IMMEDIATE;

	else
@@ -1445,14 +1469,50 @@ static void mdss_dsi_parse_dfps_config(struct device_node *pan_node, 
	return;

}



static int mdss_panel_parse_dt(struct device_node *np,

			struct mdss_dsi_ctrl_pdata *ctrl_pdata)

int mdss_dsi_panel_timing_switch(struct mdss_dsi_ctrl_pdata *ctrl,

			struct mdss_panel_timing *timing)

{

	struct dsi_panel_timing *pt;

	struct mdss_panel_info *pinfo = &ctrl->panel_data.panel_info;

	int i;



	if (!timing)

		return -EINVAL;



	if (timing == ctrl->panel_data.current_timing) {

		pr_warn("%s: panel timing \"%s\" already set\n", __func__,

				timing->name);

		return 0; /* nothing to do */

	}



	pr_debug("%s: ndx=%d switching to panel timing \"%s\"\n", __func__,

			ctrl->ndx, timing->name);



	mdss_panel_info_from_timing(timing, pinfo);



	pt = container_of(timing, struct dsi_panel_timing, timing);

	pinfo->mipi.t_clk_pre = pt->t_clk_pre;

	pinfo->mipi.t_clk_post = pt->t_clk_post;



	for (i = 0; i < ARRAY_SIZE(pt->phy_timing); i++)

		pinfo->mipi.dsi_phy_db.timing[i] = pt->phy_timing[i];



	ctrl->on_cmds = pt->on_cmds;



	ctrl->panel_data.current_timing = timing;

	if (!timing->clk_rate)

		ctrl->refresh_clk_rate = true;

	mdss_dsi_clk_refresh(&ctrl->panel_data);



	return 0;

}



static int __mdss_dsi_timing_from_dt(struct device_node *np,

	struct dsi_panel_timing *pt)

{

	u32 tmp;

	int rc, i, len;

	const char *data;

	static const char *pdest;

	struct mdss_panel_info *pinfo = &(ctrl_pdata->panel_data.panel_info);



	rc = of_property_read_u32(np, "qcom,mdss-dsi-panel-width", &tmp);

	if (rc) {
@@ -1460,7 +1520,7 @@ static int mdss_panel_parse_dt(struct device_node *np, 
						__func__, __LINE__);

		return -EINVAL;

	}

	pinfo->xres = (!rc ? tmp : 640);

	pt->timing.xres = tmp;



	rc = of_property_read_u32(np, "qcom,mdss-dsi-panel-height", &tmp);

	if (rc) {
@@ -1468,31 +1528,157 @@ static int mdss_panel_parse_dt(struct device_node *np, 
						__func__, __LINE__);

		return -EINVAL;

	}

	pinfo->yres = (!rc ? tmp : 480);

	pt->timing.yres = tmp;



	rc = of_property_read_u32(np, "qcom,mdss-dsi-h-front-porch", &tmp);

	pt->timing.h_front_porch = (!rc ? tmp : 6);

	rc = of_property_read_u32(np, "qcom,mdss-dsi-h-back-porch", &tmp);

	pt->timing.h_back_porch = (!rc ? tmp : 6);

	rc = of_property_read_u32(np, "qcom,mdss-dsi-h-pulse-width", &tmp);

	pt->timing.h_pulse_width = (!rc ? tmp : 2);

	rc = of_property_read_u32(np, "qcom,mdss-dsi-h-sync-skew", &tmp);

	pt->timing.hsync_skew = (!rc ? tmp : 0);

	rc = of_property_read_u32(np, "qcom,mdss-dsi-v-back-porch", &tmp);

	pt->timing.v_back_porch = (!rc ? tmp : 6);

	rc = of_property_read_u32(np, "qcom,mdss-dsi-v-front-porch", &tmp);

	pt->timing.v_front_porch = (!rc ? tmp : 6);

	rc = of_property_read_u32(np, "qcom,mdss-dsi-v-pulse-width", &tmp);

	pt->timing.v_pulse_width = (!rc ? tmp : 2);



	rc = of_property_read_u32(np,

		"qcom,mdss-pan-physical-width-dimension", &tmp);

	pinfo->physical_width = (!rc ? tmp : 0);

	rc = of_property_read_u32(np,

		"qcom,mdss-pan-physical-height-dimension", &tmp);

	pinfo->physical_height = (!rc ? tmp : 0);

	rc = of_property_read_u32(np, "qcom,mdss-dsi-h-left-border", &tmp);

	pinfo->lcdc.border_left = (!rc ? tmp : 0);

	pt->timing.border_left = !rc ? tmp : 0;

	rc = of_property_read_u32(np, "qcom,mdss-dsi-h-right-border", &tmp);

	if (!rc)

		pinfo->lcdc.border_right = tmp;



	pinfo->lcdc.xres_pad = (pinfo->lcdc.border_left +

				pinfo->lcdc.border_right);



	pt->timing.border_right = !rc ? tmp : 0;

	rc = of_property_read_u32(np, "qcom,mdss-dsi-v-top-border", &tmp);

	pinfo->lcdc.border_top = (!rc ? tmp : 0);

	pt->timing.border_top = !rc ? tmp : 0;

	rc = of_property_read_u32(np, "qcom,mdss-dsi-v-bottom-border", &tmp);

	pt->timing.border_bottom = !rc ? tmp : 0;



	rc = of_property_read_u32(np, "qcom,mdss-dsi-panel-framerate", &tmp);

	pt->timing.frame_rate = !rc ? tmp : DEFAULT_FRAME_RATE;

	rc = of_property_read_u32(np, "qcom,mdss-dsi-panel-clockrate", &tmp);

	pt->timing.clk_rate = !rc ? tmp : 0;



	data = of_get_property(np, "qcom,mdss-dsi-panel-timings", &len);

	if ((!data) || (len != 12)) {

		pr_err("%s:%d, Unable to read Phy timing settings",

		       __func__, __LINE__);

		return -EINVAL;

	}

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

		pt->phy_timing[i] = data[i];



	rc = of_property_read_u32(np, "qcom,mdss-dsi-t-clk-pre", &tmp);

	pt->t_clk_pre = (!rc ? tmp : 0x24);

	rc = of_property_read_u32(np, "qcom,mdss-dsi-t-clk-post", &tmp);

	pt->t_clk_post = (!rc ? tmp : 0x03);



	mdss_dsi_parse_dcs_cmds(np, &pt->on_cmds,

		"qcom,mdss-dsi-on-command", "qcom,mdss-dsi-on-command-state");



	mdss_dsi_parse_dcs_cmds(np, &pt->switch_cmds,

		"qcom,mdss-dsi-timing-switch-command",

		"qcom,mdss-dsi-timing-switch-command-state");



	mdss_dsi_parse_fbc_params(np, &pt->timing.fbc);

	if (np->name) {

		pt->timing.name = kstrdup(np->name, GFP_KERNEL);

		pr_info("%s: found new timing \"%s\" (%p)\n", __func__,

				np->name, &pt->timing);

	}



	return 0;

}



static int __mdss_panel_parse_display_timings(struct device_node *np,

		struct mdss_panel_data *panel_data)

{

	struct mdss_dsi_ctrl_pdata *ctrl;

	struct dsi_panel_timing *modedb;

	struct device_node *timings_np;

	struct device_node *entry;

	int num_timings, rc;

	int i = 0, active_ndx = 0;



	ctrl = container_of(panel_data, struct mdss_dsi_ctrl_pdata, panel_data);



	INIT_LIST_HEAD(&panel_data->timings_list);



	timings_np = of_get_child_by_name(np, "qcom,mdss-dsi-display-timings");

	if (!timings_np) {

		struct dsi_panel_timing pt;



		/*

		 * display timings node is not available, fallback to reading

		 * timings directly from root node instead

		 */

		pr_debug("reading display-timings from panel node\n");

		rc = __mdss_dsi_timing_from_dt(np, &pt);

		if (!rc)

		pinfo->lcdc.border_bottom = tmp;

			rc = mdss_dsi_panel_timing_switch(ctrl, &pt.timing);



		return rc;

	}



	num_timings = of_get_child_count(timings_np);

	if (num_timings == 0) {

		pr_err("no timings found within display-timings\n");

		rc = -EINVAL;

		goto exit;

	}



	modedb = kzalloc(num_timings * sizeof(*modedb), GFP_KERNEL);

	if (!modedb) {

		pr_err("unable to allocate modedb\n");

		rc = -ENOMEM;

		goto exit;

	}



	for_each_child_of_node(timings_np, entry) {

		rc = __mdss_dsi_timing_from_dt(entry, modedb + i);

		if (rc) {

			kfree(modedb);

			goto exit;

		}

		/* if default is set, use it otherwise use first as default */

		if (of_property_read_bool(entry,

				"qcom,mdss-dsi-timing-default"))

			active_ndx = i;



		list_add(&modedb[i].timing.list,

				&panel_data->timings_list);

		i++;

	}



	/* Configure default timing settings */

	rc = mdss_dsi_panel_timing_switch(ctrl, &modedb[active_ndx].timing);

	if (rc)

		pr_err("unable to configure default timing settings\n");



exit:

	of_node_put(timings_np);



	return rc;

}



static int mdss_panel_parse_dt(struct device_node *np,

			struct mdss_dsi_ctrl_pdata *ctrl_pdata)

{

	u32 tmp;

	int rc;

	const char *data;

	static const char *pdest;

	struct mdss_panel_info *pinfo = &(ctrl_pdata->panel_data.panel_info);



	pinfo->lcdc.yres_pad = (pinfo->lcdc.border_top +

				pinfo->lcdc.border_bottom);

	rc = __mdss_panel_parse_display_timings(np, &ctrl_pdata->panel_data);

	if (rc)

		return rc;

	rc = of_property_read_u32(np,

		"qcom,mdss-pan-physical-width-dimension", &tmp);

	pinfo->physical_width = (!rc ? tmp : 0);

	rc = of_property_read_u32(np,

		"qcom,mdss-pan-physical-height-dimension", &tmp);

	pinfo->physical_height = (!rc ? tmp : 0);



	rc = of_property_read_u32(np, "qcom,mdss-dsi-bpp", &tmp);

	if (rc) {
@@ -1542,20 +1728,6 @@ static int mdss_panel_parse_dt(struct device_node *np, 
				__func__);

		pinfo->pdest = DISPLAY_1;

	}

	rc = of_property_read_u32(np, "qcom,mdss-dsi-h-front-porch", &tmp);

	pinfo->lcdc.h_front_porch = (!rc ? tmp : 6);

	rc = of_property_read_u32(np, "qcom,mdss-dsi-h-back-porch", &tmp);

	pinfo->lcdc.h_back_porch = (!rc ? tmp : 6);

	rc = of_property_read_u32(np, "qcom,mdss-dsi-h-pulse-width", &tmp);

	pinfo->lcdc.h_pulse_width = (!rc ? tmp : 2);

	rc = of_property_read_u32(np, "qcom,mdss-dsi-h-sync-skew", &tmp);

	pinfo->lcdc.hsync_skew = (!rc ? tmp : 0);

	rc = of_property_read_u32(np, "qcom,mdss-dsi-v-back-porch", &tmp);

	pinfo->lcdc.v_back_porch = (!rc ? tmp : 6);

	rc = of_property_read_u32(np, "qcom,mdss-dsi-v-front-porch", &tmp);

	pinfo->lcdc.v_front_porch = (!rc ? tmp : 6);

	rc = of_property_read_u32(np, "qcom,mdss-dsi-v-pulse-width", &tmp);

	pinfo->lcdc.v_pulse_width = (!rc ? tmp : 2);

	rc = of_property_read_u32(np,

		"qcom,mdss-dsi-underflow-color", &tmp);

	pinfo->lcdc.underflow_clr = (!rc ? tmp : 0xff);
@@ -1705,11 +1877,6 @@ static int mdss_panel_parse_dt(struct device_node *np, 
	pinfo->mipi.data_lane3 = of_property_read_bool(np,

		"qcom,mdss-dsi-lane-3-state");



	rc = of_property_read_u32(np, "qcom,mdss-dsi-t-clk-pre", &tmp);

	pinfo->mipi.t_clk_pre = (!rc ? tmp : 0x24);

	rc = of_property_read_u32(np, "qcom,mdss-dsi-t-clk-post", &tmp);

	pinfo->mipi.t_clk_post = (!rc ? tmp : 0x03);



	pinfo->mipi.rx_eot_ignore = of_property_read_bool(np,

		"qcom,mdss-dsi-rx-eot-ignore");

	pinfo->mipi.tx_eot_append = of_property_read_bool(np,
@@ -1732,14 +1899,6 @@ static int mdss_panel_parse_dt(struct device_node *np, 
	pinfo->mipi.frame_rate = (!rc ? tmp : 60);

	rc = of_property_read_u32(np, "qcom,mdss-dsi-panel-clockrate", &tmp);

	pinfo->clk_rate = (!rc ? tmp : 0);

	data = of_get_property(np, "qcom,mdss-dsi-panel-timings", &len);

	if ((!data) || (len != 12)) {

		pr_err("%s:%d, Unable to read Phy timing settings",

		       __func__, __LINE__);

		goto error;

	}

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

		pinfo->mipi.dsi_phy_db.timing[i] = data[i];



	pinfo->mipi.lp11_init = of_property_read_bool(np,

					"qcom,mdss-dsi-lp11-init");
@@ -1756,16 +1915,11 @@ static int mdss_panel_parse_dt(struct device_node *np, 


	mdss_dsi_parse_lane_swap(np, &(pinfo->mipi.dlane_swap));



	mdss_dsi_parse_fbc_params(np, pinfo);



	mdss_panel_parse_te_params(np, pinfo);



	mdss_dsi_parse_reset_seq(np, pinfo->rst_seq, &(pinfo->rst_seq_len),

		"qcom,mdss-dsi-reset-sequence");



	mdss_dsi_parse_dcs_cmds(np, &ctrl_pdata->on_cmds,

		"qcom,mdss-dsi-on-command", "qcom,mdss-dsi-on-command-state");



	mdss_dsi_parse_dcs_cmds(np, &ctrl_pdata->off_cmds,

		"qcom,mdss-dsi-off-command", "qcom,mdss-dsi-off-command-state");