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

Commit 430b60ef authored by Govinda Rajulu Chenna's avatar Govinda Rajulu Chenna Committed by Gerrit - the friendly Code Review server
Browse files

drm/msm/dp: add panel as input parameter to dp_display_ops 



Add dp_panel as one of the input parameter to dp_display_ops,
those are dealing with stream specific configurations.
dp_display module uses panel parameter to extract the stream
specific information to configure the stream specific hw modules.

CRs-Fixed: 2192818
Change-Id: I7ea6c4315238dddd3d2f4413eaa620841343d6ad
Signed-off-by: default avatarGovinda Rajulu Chenna <gchenna@codeaurora.org>
parent 2ae90b26

drivers/gpu/drm/msm/dp/dp_catalog_v420.c

+19 −5
Original line number Diff line number Diff line
@@ -132,7 +132,7 @@ static void dp_catalog_panel_config_msa_v420(struct dp_catalog_panel *panel, 
					bool fixed_nvid)

{

	u32 pixel_m, pixel_n;

	u32 mvid, nvid;

	u32 mvid, nvid, reg_off = 0;

	u64 mvid_calc;

	u32 const nvid_fixed = 0x8000;

	u32 const link_rate_hbr2 = 540000;
@@ -145,6 +145,11 @@ static void dp_catalog_panel_config_msa_v420(struct dp_catalog_panel *panel, 
		return;

	}



	if (panel->stream_id >= DP_STREAM_MAX) {

		pr_err("invalid stream id:%d\n", panel->stream_id);

		return;

	}



	catalog = dp_catalog_get_priv_v420(panel);

	if (fixed_nvid) {

		pr_debug("use fixed NVID=0x%x\n", nvid_fixed);
@@ -168,8 +173,13 @@ static void dp_catalog_panel_config_msa_v420(struct dp_catalog_panel *panel, 
	} else {

		io_data = catalog->io->dp_mmss_cc;



		pixel_m = dp_read(catalog, io_data, MMSS_DP_PIXEL_M_V420);

		pixel_n = dp_read(catalog, io_data, MMSS_DP_PIXEL_N_V420);

		if (panel->stream_id == DP_STREAM_1)

			reg_off = MMSS_DP_PIXEL1_M_V420 - MMSS_DP_PIXEL_M_V420;



		pixel_m = dp_read(catalog, io_data,

				MMSS_DP_PIXEL_M_V420 + reg_off);

		pixel_n = dp_read(catalog, io_data,

				MMSS_DP_PIXEL_N_V420 + reg_off);

		pr_debug("pixel_m=0x%x, pixel_n=0x%x\n", pixel_m, pixel_n);



		mvid = (pixel_m & 0xFFFF) * 5;
@@ -185,9 +195,13 @@ static void dp_catalog_panel_config_msa_v420(struct dp_catalog_panel *panel, 
	}



	io_data = catalog->io->dp_link;



	if (panel->stream_id == DP_STREAM_1)

		reg_off = DP1_SOFTWARE_MVID - DP_SOFTWARE_MVID;



	pr_debug("mvid=0x%x, nvid=0x%x\n", mvid, nvid);

	dp_write(catalog, io_data, DP_SOFTWARE_MVID, mvid);

	dp_write(catalog, io_data, DP_SOFTWARE_NVID, nvid);

	dp_write(catalog, io_data, DP_SOFTWARE_MVID + reg_off, mvid);

	dp_write(catalog, io_data, DP_SOFTWARE_NVID + reg_off, nvid);

}



static void dp_catalog_ctrl_phy_lane_cfg_v420(struct dp_catalog_ctrl *ctrl,

drivers/gpu/drm/msm/dp/dp_display.c

+74 −40
Original line number Diff line number Diff line
@@ -408,7 +408,7 @@ static void dp_display_send_hpd_event(struct dp_display_private *dp) 
		bpp[HPD_STRING_SIZE], pattern[HPD_STRING_SIZE];

	char *envp[5];



	connector = dp->dp_display.connector;

	connector = dp->dp_display.base_connector;



	if (!connector) {

		pr_err("connector not set\n");
@@ -417,7 +417,7 @@ static void dp_display_send_hpd_event(struct dp_display_private *dp) 


	connector->status = connector->funcs->detect(connector, false);



	dev = dp->dp_display.connector->dev;

	dev = connector->dev;



	snprintf(name, HPD_STRING_SIZE, "name=%s", connector->name);

	snprintf(status, HPD_STRING_SIZE, "status=%s",
@@ -454,10 +454,10 @@ static void dp_display_post_open(struct dp_display *dp_display) 
		return;

	}



	connector = dp->dp_display.connector;

	connector = dp->dp_display.base_connector;



	if (!connector) {

		pr_err("connector not set\n");

		pr_err("base connector not set\n");

		return;

	}
@@ -509,10 +509,11 @@ static int dp_display_process_hpd_high(struct dp_display_private *dp) 
		dp->debug->psm_enabled = false;

	}



	if (!dp->dp_display.connector)

	if (!dp->dp_display.base_connector)

		return 0;



	rc = dp->panel->read_sink_caps(dp->panel, dp->dp_display.connector);

	rc = dp->panel->read_sink_caps(dp->panel,

			dp->dp_display.base_connector);

	if (rc) {

		/*

		 * ETIMEDOUT --> cable may have been removed
@@ -925,6 +926,7 @@ static int dp_init_sub_modules(struct dp_display_private *dp) 
	panel_in.aux = dp->aux;

	panel_in.catalog = &dp->catalog->panel;

	panel_in.link = dp->link;

	panel_in.connector = dp->dp_display.base_connector;



	dp->panel = dp_panel_get(&panel_in);

	if (IS_ERR(dp->panel)) {
@@ -970,8 +972,10 @@ static int dp_init_sub_modules(struct dp_display_private *dp) 
	}



	dp->debug = dp_debug_get(dev, dp->panel, dp->usbpd,

				dp->link, dp->aux, &dp->dp_display.connector,

				dp->link, dp->aux,

				&dp->dp_display.base_connector,

				dp->catalog);



	if (IS_ERR(dp->debug)) {

		rc = PTR_ERR(dp->debug);

		pr_err("failed to initialize debug, rc = %d\n", rc);
@@ -1032,50 +1036,60 @@ static void dp_display_post_init(struct dp_display *dp_display) 
	pr_debug("%s\n", rc ? "failed" : "success");

}



static int dp_display_set_mode(struct dp_display *dp_display,

static int dp_display_set_mode(struct dp_display *dp_display, void *panel,

		struct dp_display_mode *mode)

{

	const u32 num_components = 3, default_bpp = 24;

	struct dp_display_private *dp;

	struct dp_panel *dp_panel;



	if (!dp_display) {

	if (!dp_display || !panel) {

		pr_err("invalid input\n");

		return -EINVAL;

	}



	dp_panel = panel;

	if (!dp_panel->connector) {

		pr_err("invalid connector input\n");

		return -EINVAL;

	}



	dp = container_of(dp_display, struct dp_display_private, dp_display);



	mutex_lock(&dp->session_lock);

	mode->timing.bpp =

		dp_display->connector->display_info.bpc * num_components;

		dp_panel->connector->display_info.bpc * num_components;

	if (!mode->timing.bpp)

		mode->timing.bpp = default_bpp;



	mode->timing.bpp = dp->panel->get_mode_bpp(dp->panel,

			mode->timing.bpp, mode->timing.pixel_clk_khz);



	dp->panel->pinfo = mode->timing;

	dp->panel->init(dp->panel);

	dp_panel->pinfo = mode->timing;

	dp_panel->init(dp_panel);

	mutex_unlock(&dp->session_lock);



	return 0;

}



static int dp_display_prepare(struct dp_display *dp)

static int dp_display_prepare(struct dp_display *dp, void *panel)

{

	return 0;

}



static int dp_display_enable(struct dp_display *dp_display)

static int dp_display_enable(struct dp_display *dp_display, void *panel)

{

	int rc = 0;

	struct dp_display_private *dp;

	struct dp_panel *dp_panel;



	if (!dp_display) {

	if (!dp_display || !panel) {

		pr_err("invalid input\n");

		return -EINVAL;

	}



	dp = container_of(dp_display, struct dp_display_private, dp_display);

	dp_panel = panel;



	mutex_lock(&dp->session_lock);
@@ -1091,30 +1105,32 @@ static int dp_display_enable(struct dp_display *dp_display) 


	dp->aux->init(dp->aux, dp->parser->aux_cfg);



	dp->panel->set_stream_id(dp->panel, DP_STREAM_0);

	dp_panel->set_stream_id(dp->panel, DP_STREAM_0);



	rc = dp->ctrl->on(dp->ctrl);

	if (!rc)

		dp->power_on = true;



	if (dp->debug->tpg_state)

		dp->panel->tpg_config(dp->panel, true);

		dp_panel->tpg_config(dp_panel, true);



end:

	mutex_unlock(&dp->session_lock);

	return rc;

}



static int dp_display_post_enable(struct dp_display *dp_display)

static int dp_display_post_enable(struct dp_display *dp_display, void *panel)

{

	struct dp_display_private *dp;

	struct dp_panel *dp_panel;



	if (!dp_display) {

	if (!dp_display || !panel) {

		pr_err("invalid input\n");

		return -EINVAL;

	}



	dp = container_of(dp_display, struct dp_display_private, dp_display);

	dp_panel = panel;



	mutex_lock(&dp->session_lock);
@@ -1128,7 +1144,7 @@ static int dp_display_post_enable(struct dp_display *dp_display) 
		goto end;

	}



	dp->panel->spd_config(dp->panel);

	dp_panel->spd_config(dp_panel);



	if (dp->audio_supported) {

		dp->audio->bw_code = dp->link->link_params.bw_code;
@@ -1145,7 +1161,7 @@ static int dp_display_post_enable(struct dp_display *dp_display) 
		queue_delayed_work(dp->wq, &dp->hdcp_cb_work, HZ / 2);

	}



	dp->panel->setup_hdr(dp->panel, NULL);

	dp_panel->setup_hdr(dp_panel, NULL);

end:

	/* clear framework event notifier */

	dp_display->post_open = NULL;
@@ -1156,11 +1172,11 @@ static int dp_display_post_enable(struct dp_display *dp_display) 
	return 0;

}



static int dp_display_pre_disable(struct dp_display *dp_display)

static int dp_display_pre_disable(struct dp_display *dp_display, void *panel)

{

	struct dp_display_private *dp;



	if (!dp_display) {

	if (!dp_display || !panel) {

		pr_err("invalid input\n");

		return -EINVAL;

	}
@@ -1196,19 +1212,21 @@ static int dp_display_pre_disable(struct dp_display *dp_display) 
	return 0;

}



static int dp_display_disable(struct dp_display *dp_display)

static int dp_display_disable(struct dp_display *dp_display, void *panel)

{

	struct dp_display_private *dp;

	struct drm_connector *connector;

	struct sde_connector_state *c_state;

	struct dp_panel *dp_panel;



	if (!dp_display) {

	if (!dp_display || !panel) {

		pr_err("invalid input\n");

		return -EINVAL;

	}



	dp = container_of(dp_display, struct dp_display_private, dp_display);

	connector = dp->dp_display.connector;

	dp_panel = panel;

	connector = dp_panel->connector;

	c_state = to_sde_connector_state(connector->state);



	mutex_lock(&dp->session_lock);
@@ -1219,7 +1237,8 @@ static int dp_display_disable(struct dp_display *dp_display) 
	}



	dp->ctrl->off(dp->ctrl);

	dp->panel->deinit(dp->panel);

	dp_panel->set_stream_id(dp_panel, DP_STREAM_MAX);

	dp_panel->deinit(dp_panel);

	dp->aux->deinit(dp->aux);



	connector->hdr_eotf = 0;
@@ -1292,32 +1311,39 @@ static struct dp_debug *dp_get_debug(struct dp_display *dp_display) 
	return dp->debug;

}



static int dp_display_unprepare(struct dp_display *dp)

static int dp_display_unprepare(struct dp_display *dp, void *panel)

{

	return 0;

}



static int dp_display_validate_mode(struct dp_display *dp, u32 mode_pclk_khz)

static int dp_display_validate_mode(struct dp_display *dp, void *panel,

		u32 mode_pclk_khz)

{

	const u32 num_components = 3, default_bpp = 24;

	struct dp_display_private *dp_display;

	struct drm_dp_link *link_info;

	u32 mode_rate_khz = 0, supported_rate_khz = 0, mode_bpp = 0;

	struct dp_panel *dp_panel;



	if (!dp || !mode_pclk_khz || !dp->connector) {

	if (!dp || !mode_pclk_khz || !panel) {

		pr_err("invalid params\n");

		return -EINVAL;

	}



	dp_panel = panel;

	if (!dp_panel->connector) {

		pr_err("invalid connector\n");

		return -EINVAL;

	}



	dp_display = container_of(dp, struct dp_display_private, dp_display);

	link_info = &dp_display->panel->link_info;



	mode_bpp = dp->connector->display_info.bpc * num_components;

	mode_bpp = dp_panel->connector->display_info.bpc * num_components;

	if (!mode_bpp)

		mode_bpp = default_bpp;



	mode_bpp = dp_display->panel->get_mode_bpp(dp_display->panel,

			mode_bpp, mode_pclk_khz);

	mode_bpp = dp_panel->get_mode_bpp(dp_panel, mode_bpp, mode_pclk_khz);



	mode_rate_khz = mode_pclk_khz * mode_bpp;

	supported_rate_khz = link_info->num_lanes * link_info->rate * 8;
@@ -1328,40 +1354,48 @@ static int dp_display_validate_mode(struct dp_display *dp, u32 mode_pclk_khz) 
	return MODE_OK;

}



static int dp_display_get_modes(struct dp_display *dp,

static int dp_display_get_modes(struct dp_display *dp, void *panel,

	struct dp_display_mode *dp_mode)

{

	struct dp_display_private *dp_display;

	struct dp_panel *dp_panel;

	int ret = 0;



	if (!dp || !dp->connector) {

	if (!dp || !panel) {

		pr_err("invalid params\n");

		return 0;

	}



	dp_panel = panel;

	if (!dp_panel->connector) {

		pr_err("invalid connector\n");

		return 0;

	}



	dp_display = container_of(dp, struct dp_display_private, dp_display);



	ret = dp_display->panel->get_modes(dp_display->panel,

		dp->connector, dp_mode);

	ret = dp_panel->get_modes(dp_panel, dp_panel->connector, dp_mode);

	if (dp_mode->timing.pixel_clk_khz)

		dp->max_pclk_khz = dp_mode->timing.pixel_clk_khz;

	return ret;

}



static int dp_display_config_hdr(struct dp_display *dp_display,

static int dp_display_config_hdr(struct dp_display *dp_display, void *panel,

			struct drm_msm_ext_hdr_metadata *hdr)

{

	int rc = 0;

	struct dp_display_private *dp;

	struct dp_panel *dp_panel;



	if (!dp_display) {

	if (!dp_display || !panel) {

		pr_err("invalid input\n");

		return -EINVAL;

	}



	dp = container_of(dp_display, struct dp_display_private, dp_display);

	dp_panel = panel;



	rc = dp->panel->setup_hdr(dp->panel, hdr);

	rc = dp_panel->setup_hdr(dp_panel, hdr);



	return rc;

}

drivers/gpu/drm/msm/dp/dp_display.h

+13 −11
Original line number Diff line number Diff line
@@ -23,27 +23,29 @@ 
struct dp_display {

	struct drm_device *drm_dev;

	struct dp_bridge *bridge;

	struct drm_connector *connector;

	struct drm_connector *base_connector;

	void *base_dp_panel;

	bool is_connected;

	u32 max_pclk_khz;



	int (*enable)(struct dp_display *dp_display);

	int (*post_enable)(struct dp_display *dp_display);

	int (*enable)(struct dp_display *dp_display, void *panel);

	int (*post_enable)(struct dp_display *dp_display, void *panel);



	int (*pre_disable)(struct dp_display *dp_display);

	int (*disable)(struct dp_display *dp_display);

	int (*pre_disable)(struct dp_display *dp_display, void *panel);

	int (*disable)(struct dp_display *dp_display, void *panel);



	int (*set_mode)(struct dp_display *dp_display,

	int (*set_mode)(struct dp_display *dp_display, void *panel,

			struct dp_display_mode *mode);

	int (*validate_mode)(struct dp_display *dp_display, u32 mode_pclk_khz);

	int (*get_modes)(struct dp_display *dp_display,

	int (*validate_mode)(struct dp_display *dp_display, void *panel,

			u32 mode_pclk_khz);

	int (*get_modes)(struct dp_display *dp_display, void *panel,

		struct dp_display_mode *dp_mode);

	int (*prepare)(struct dp_display *dp_display);

	int (*unprepare)(struct dp_display *dp_display);

	int (*prepare)(struct dp_display *dp_display, void *panel);

	int (*unprepare)(struct dp_display *dp_display, void *panel);

	int (*request_irq)(struct dp_display *dp_display);

	struct dp_debug *(*get_debug)(struct dp_display *dp_display);

	void (*post_open)(struct dp_display *dp_display);

	int (*config_hdr)(struct dp_display *dp_display,

	int (*config_hdr)(struct dp_display *dp_display, void *panel,

				struct drm_msm_ext_hdr_metadata *hdr_meta);

	void (*post_init)(struct dp_display *dp_display);

};

drivers/gpu/drm/msm/dp/dp_drm.c

+106 −17
Original line number Diff line number Diff line
@@ -127,26 +127,36 @@ static void dp_bridge_pre_enable(struct drm_bridge *drm_bridge) 
	bridge = to_dp_bridge(drm_bridge);

	dp = bridge->display;



	if (!bridge->connector) {

		pr_err("Invalid connector\n");

		return;

	}



	if (!bridge->dp_panel) {

		pr_err("Invalid dp_panel\n");

		return;

	}



	/* By this point mode should have been validated through mode_fixup */

	rc = dp->set_mode(dp, &bridge->dp_mode);

	rc = dp->set_mode(dp, bridge->dp_panel, &bridge->dp_mode);

	if (rc) {

		pr_err("[%d] failed to perform a mode set, rc=%d\n",

		       bridge->id, rc);

		return;

	}



	rc = dp->prepare(dp);

	rc = dp->prepare(dp, bridge->dp_panel);

	if (rc) {

		pr_err("[%d] DP display prepare failed, rc=%d\n",

		       bridge->id, rc);

		return;

	}



	rc = dp->enable(dp);

	rc = dp->enable(dp, bridge->dp_panel);

	if (rc) {

		pr_err("[%d] DP display enable failed, rc=%d\n",

		       bridge->id, rc);

		dp->unprepare(dp);

		dp->unprepare(dp, bridge->dp_panel);

	}

}
@@ -162,9 +172,19 @@ static void dp_bridge_enable(struct drm_bridge *drm_bridge) 
	}



	bridge = to_dp_bridge(drm_bridge);

	if (!bridge->connector) {

		pr_err("Invalid connector\n");

		return;

	}



	if (!bridge->dp_panel) {

		pr_err("Invalid dp_panel\n");

		return;

	}



	dp = bridge->display;



	rc = dp->post_enable(dp);

	rc = dp->post_enable(dp, bridge->dp_panel);

	if (rc)

		pr_err("[%d] DP display post enable failed, rc=%d\n",

		       bridge->id, rc);
@@ -182,12 +202,22 @@ static void dp_bridge_disable(struct drm_bridge *drm_bridge) 
	}



	bridge = to_dp_bridge(drm_bridge);

	if (!bridge->connector) {

		pr_err("Invalid connector\n");

		return;

	}



	if (!bridge->dp_panel) {

		pr_err("Invalid dp_panel\n");

		return;

	}



	dp = bridge->display;



	if (dp && dp->connector)

		sde_connector_helper_bridge_disable(dp->connector);

	if (dp)

		sde_connector_helper_bridge_disable(bridge->connector);



	rc = dp->pre_disable(dp);

	rc = dp->pre_disable(dp, bridge->dp_panel);

	if (rc) {

		pr_err("[%d] DP display pre disable failed, rc=%d\n",

		       bridge->id, rc);
@@ -206,16 +236,26 @@ static void dp_bridge_post_disable(struct drm_bridge *drm_bridge) 
	}



	bridge = to_dp_bridge(drm_bridge);

	if (!bridge->connector) {

		pr_err("Invalid connector\n");

		return;

	}



	if (!bridge->dp_panel) {

		pr_err("Invalid dp_panel\n");

		return;

	}



	dp = bridge->display;



	rc = dp->disable(dp);

	rc = dp->disable(dp, bridge->dp_panel);

	if (rc) {

		pr_err("[%d] DP display disable failed, rc=%d\n",

		       bridge->id, rc);

		return;

	}



	rc = dp->unprepare(dp);

	rc = dp->unprepare(dp, bridge->dp_panel);

	if (rc) {

		pr_err("[%d] DP display unprepare failed, rc=%d\n",

		       bridge->id, rc);
@@ -236,6 +276,16 @@ static void dp_bridge_mode_set(struct drm_bridge *drm_bridge, 
	}



	bridge = to_dp_bridge(drm_bridge);

	if (!bridge->connector) {

		pr_err("Invalid connector\n");

		return;

	}



	if (!bridge->dp_panel) {

		pr_err("Invalid dp_panel\n");

		return;

	}



	dp = bridge->display;



	memset(&bridge->dp_mode, 0x0, sizeof(struct dp_display_mode));
@@ -258,6 +308,18 @@ static bool dp_bridge_mode_fixup(struct drm_bridge *drm_bridge, 
	}



	bridge = to_dp_bridge(drm_bridge);

	if (!bridge->connector) {

		pr_err("Invalid connector\n");

		ret = false;

		goto end;

	}



	if (!bridge->dp_panel) {

		pr_err("Invalid dp_panel\n");

		ret = false;

		goto end;

	}



	dp = bridge->display;



	convert_to_dp_mode(mode, &dp_mode, dp);
@@ -280,27 +342,39 @@ int dp_connector_config_hdr(struct drm_connector *connector, void *display, 
	struct sde_connector_state *c_state)

{

	struct dp_display *dp = display;

	struct sde_connector *sde_conn;



	if (!display || !c_state) {

	if (!display || !c_state || !connector) {

		pr_err("invalid params\n");

		return -EINVAL;

	}



	return dp->config_hdr(dp, &c_state->hdr_meta);

	sde_conn = to_sde_connector(connector);

	if (!sde_conn->drv_panel) {

		pr_err("invalid dp panel\n");

		return -EINVAL;

	}



	return dp->config_hdr(dp, sde_conn->drv_panel, &c_state->hdr_meta);

}



int dp_connector_post_init(struct drm_connector *connector, void *display)

{

	struct dp_display *dp_display = display;

	struct sde_connector *sde_conn;



	if (!dp_display)

	if (!dp_display || !connector)

		return -EINVAL;



	dp_display->connector = connector;

	dp_display->base_connector = connector;

	dp_display->bridge->connector = connector;



	if (dp_display->post_init)

		dp_display->post_init(dp_display);



	sde_conn = to_sde_connector(connector);

	dp_display->bridge->dp_panel = sde_conn->drv_panel;



	return 0;

}
@@ -407,10 +481,17 @@ int dp_connector_get_modes(struct drm_connector *connector, 
	struct dp_display *dp;

	struct dp_display_mode *dp_mode = NULL;

	struct drm_display_mode *m, drm_mode;

	struct sde_connector *sde_conn;



	if (!connector || !display)

		return 0;



	sde_conn = to_sde_connector(connector);

	if (!sde_conn->drv_panel) {

		pr_err("invalid dp panel\n");

		return 0;

	}



	dp = display;



	dp_mode = kzalloc(sizeof(*dp_mode),  GFP_KERNEL);
@@ -419,7 +500,7 @@ int dp_connector_get_modes(struct drm_connector *connector, 


	/* pluggable case assumes EDID is read when HPD */

	if (dp->is_connected) {

		rc = dp->get_modes(dp, dp_mode);

		rc = dp->get_modes(dp, sde_conn->drv_panel, dp_mode);

		if (!rc)

			pr_err("failed to get DP sink modes, rc=%d\n", rc);
@@ -507,12 +588,19 @@ enum drm_mode_status dp_connector_mode_valid(struct drm_connector *connector, 
{

	struct dp_display *dp_disp;

	struct dp_debug *debug;

	struct sde_connector *sde_conn;



	if (!mode || !display) {

	if (!mode || !display || !connector) {

		pr_err("invalid params\n");

		return MODE_ERROR;

	}



	sde_conn = to_sde_connector(connector);

	if (!sde_conn->drv_panel) {

		pr_err("invalid dp panel\n");

		return MODE_ERROR;

	}



	dp_disp = display;

	debug = dp_disp->get_debug(dp_disp);
@@ -527,5 +615,6 @@ enum drm_mode_status dp_connector_mode_valid(struct drm_connector *connector, 
			mode->picture_aspect_ratio != debug->aspect_ratio))

		return MODE_BAD;



	return dp_disp->validate_mode(dp_disp, mode->clock);

	return dp_disp->validate_mode(dp_disp, sde_conn->drv_panel,

			mode->clock);

}

drivers/gpu/drm/msm/dp/dp_drm.h

+2 −0
Original line number Diff line number Diff line
@@ -27,8 +27,10 @@ struct dp_bridge { 
	struct drm_bridge base;

	u32 id;



	struct drm_connector *connector;

	struct dp_display *display;

	struct dp_display_mode dp_mode;

	void *dp_panel;

};



/**