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

Commit a5ca4772 authored by Xiaowen Wu's avatar Xiaowen Wu Committed by Tatenda Chipeperekwa
Browse files

drm/msm/dp: add encoder and connector reservation dp-mst 



Currently the dp-mst connector is created and destroyed dynamically,
which requires drm client to handle hot-plug and update the whole
connector list when device is connected or disconnected.

A reservation approach is added to allow connector to be created statically
for mst port in devicetree at system startup stage, and drm client can
control the connector in the same way as non-mst connectors. This optional
devicetree property is useful for system with a built-in mst-hub, and can
simplify the drm client design.

Change-Id: Ied59a5302b3f4cd1553619e6ee5acd7ce62df9ac
Signed-off-by: default avatarXiaowen Wu <wxiaowen@codeaurora.org>
Signed-off-by: default avatarTatenda Chipeperekwa <tatendac@codeaurora.org>
parent b6394708

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

+75 −0
Original line number Diff line number Diff line
@@ -2346,6 +2346,77 @@ static int dp_display_update_pps(struct dp_display *dp_display, 
	return 0;

}



static int dp_display_mst_connector_update_link_info(

			struct dp_display *dp_display,

			struct drm_connector *connector)

{

	int rc = 0;

	struct sde_connector *sde_conn;

	struct dp_panel *dp_panel;

	struct dp_display_private *dp;



	if (!dp_display || !connector) {

		pr_err("invalid input\n");

		return -EINVAL;

	}



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



	if (!dp->mst.drm_registered) {

		pr_debug("drm mst not registered\n");

		return -EPERM;

	}



	sde_conn = to_sde_connector(connector);

	if (!sde_conn->drv_panel) {

		pr_err("invalid panel for connector:%d\n", connector->base.id);

		return -EINVAL;

	}



	dp_panel = sde_conn->drv_panel;



	memcpy(dp_panel->dpcd, dp->panel->dpcd,

			DP_RECEIVER_CAP_SIZE + 1);

	memcpy(dp_panel->dsc_dpcd, dp->panel->dsc_dpcd,

			DP_RECEIVER_DSC_CAP_SIZE + 1);

	memcpy(&dp_panel->link_info, &dp->panel->link_info,

			sizeof(dp_panel->link_info));



	DP_MST_DEBUG("dp mst connector:%d link info updated\n");



	return rc;

}



static int dp_display_mst_get_fixed_topology_port(

			struct dp_display *dp_display,

			u32 strm_id, u32 *port_num)

{

	struct dp_display_private *dp;

	u32 port;



	if (!dp_display) {

		pr_err("invalid input\n");

		return -EINVAL;

	}



	if (strm_id >= DP_STREAM_MAX) {

		pr_err("invalid stream id:%d\n", strm_id);

		return -EINVAL;

	}



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



	port = dp->parser->mst_fixed_port[strm_id];



	if (!port || port > 255)

		return -ENOENT;



	if (port_num)

		*port_num = port;



	return 0;

}



static int dp_display_get_mst_caps(struct dp_display *dp_display,

			struct dp_mst_caps *mst_caps)

{
@@ -2429,12 +2500,16 @@ static int dp_display_probe(struct platform_device *pdev) 
					dp_display_mst_connector_uninstall;

	g_dp_display->mst_connector_update_edid =

					dp_display_mst_connector_update_edid;

	g_dp_display->mst_connector_update_link_info =

				dp_display_mst_connector_update_link_info;

	g_dp_display->get_mst_caps = dp_display_get_mst_caps;

	g_dp_display->set_stream_info = dp_display_set_stream_info;

	g_dp_display->update_pps = dp_display_update_pps;

	g_dp_display->convert_to_dp_mode = dp_display_convert_to_dp_mode;

	g_dp_display->mst_get_connector_info =

					dp_display_mst_get_connector_info;

	g_dp_display->mst_get_fixed_topology_port =

					dp_display_mst_get_fixed_topology_port;



	rc = component_add(&pdev->dev, &dp_display_comp_ops);

	if (rc) {

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

+4 −0
Original line number Diff line number Diff line
@@ -100,9 +100,13 @@ struct dp_display { 
	int (*mst_connector_update_edid)(struct dp_display *dp_display,

			struct drm_connector *connector,

			struct edid *edid);

	int (*mst_connector_update_link_info)(struct dp_display *dp_display,

			struct drm_connector *connector);

	int (*mst_get_connector_info)(struct dp_display *dp_display,

			struct drm_connector *connector,

			struct dp_mst_connector *mst_conn);

	int (*mst_get_fixed_topology_port)(struct dp_display *dp_display,

			u32 strm_id, u32 *port_num);

	int (*get_mst_caps)(struct dp_display *dp_display,

			struct dp_mst_caps *mst_caps);

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

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

+325 −2
Original line number Diff line number Diff line
@@ -23,7 +23,6 @@ 
#define DP_MST_DEBUG(fmt, ...) pr_debug(fmt, ##__VA_ARGS__)

#define DP_MST_INFO_LOG(fmt, ...) pr_debug(fmt, ##__VA_ARGS__)



#define MAX_DP_MST_STREAMS		2

#define MAX_DP_MST_DRM_ENCODERS		2

#define MAX_DP_MST_DRM_BRIDGES		2

#define HPD_STRING_SIZE			30
@@ -102,6 +101,10 @@ struct dp_mst_bridge { 
	int pbn;

	int num_slots;

	int start_slot;



	u32 fixed_port_num;

	bool fixed_port_added;

	struct drm_connector *fixed_connector;

};



struct dp_mst_private {
@@ -902,6 +905,10 @@ static void dp_mst_bridge_mode_set(struct drm_bridge *drm_bridge, 


/* DP MST Bridge APIs */



static struct drm_connector *

dp_mst_drm_fixed_connector_init(struct dp_display *dp_display,

				struct drm_encoder *encoder);



static const struct drm_bridge_funcs dp_mst_bridge_ops = {

	.attach       = dp_mst_bridge_attach,

	.mode_fixup   = dp_mst_bridge_mode_fixup,
@@ -969,6 +976,23 @@ int dp_mst_drm_bridge_init(void *data, struct drm_encoder *encoder) 


	DP_MST_DEBUG("mst drm bridge init. bridge id:%d\n", i);



	/*

	 * If fixed topology port is defined, connector will be created

	 * immediately.

	 */

	rc = display->mst_get_fixed_topology_port(display, bridge->id,

			&bridge->fixed_port_num);

	if (!rc) {

		bridge->fixed_connector =

			dp_mst_drm_fixed_connector_init(display,

				bridge->encoder);

		if (bridge->fixed_connector == NULL) {

			pr_err("failed to create fixed connector\n");

			rc = -ENOMEM;

			goto end;

		}

	}



	return 0;



end:
@@ -1161,7 +1185,8 @@ dp_mst_atomic_best_encoder(struct drm_connector *connector, 
	}



	for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {

		if (!mst->mst_bridge[i].encoder_active_sts) {

		if (!mst->mst_bridge[i].encoder_active_sts &&

			!mst->mst_bridge[i].fixed_connector) {

			mst->mst_bridge[i].encoder_active_sts = true;

			mst->mst_bridge[i].connector = connector;

			mst->mst_bridge[i].dp_panel = conn->drv_panel;
@@ -1368,6 +1393,7 @@ dp_mst_add_connector(struct drm_dp_mst_topology_mgr *mgr, 


	if (!connector) {

		pr_err("mst sde_connector_init failed\n");

		drm_modeset_unlock_all(dev);

		return connector;

	}
@@ -1375,6 +1401,7 @@ dp_mst_add_connector(struct drm_dp_mst_topology_mgr *mgr, 
	if (rc) {

		pr_err("mst connector install failed\n");

		sde_connector_destroy(connector);

		drm_modeset_unlock_all(dev);

		return NULL;

	}
@@ -1424,6 +1451,291 @@ static void dp_mst_destroy_connector(struct drm_dp_mst_topology_mgr *mgr, 
	drm_connector_put(connector);

}



static enum drm_connector_status

dp_mst_fixed_connector_detect(struct drm_connector *connector, bool force,

			void *display)

{

	struct dp_display *dp_display = display;

	struct dp_mst_private *mst = dp_display->dp_mst_prv_info;

	int i;



	for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {

		if (mst->mst_bridge[i].fixed_connector != connector)

			continue;



		if (!mst->mst_bridge[i].fixed_port_added)

			break;



		return dp_mst_connector_detect(connector, force, display);

	}



	return connector_status_disconnected;

}



static struct drm_encoder *

dp_mst_fixed_atomic_best_encoder(struct drm_connector *connector,

			void *display, struct drm_connector_state *state)

{

	struct dp_display *dp_display = display;

	struct dp_mst_private *mst = dp_display->dp_mst_prv_info;

	struct sde_connector *conn = to_sde_connector(connector);

	struct drm_encoder *enc = NULL;

	u32 i;



	for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {

		if (mst->mst_bridge[i].connector == connector) {

			enc = mst->mst_bridge[i].encoder;

			goto end;

		}

	}



	for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {

		if (mst->mst_bridge[i].fixed_connector == connector) {

			mst->mst_bridge[i].encoder_active_sts = true;

			mst->mst_bridge[i].connector = connector;

			mst->mst_bridge[i].dp_panel = conn->drv_panel;

			enc = mst->mst_bridge[i].encoder;

			break;

		}

	}



end:

	if (enc)

		DP_MST_DEBUG("mst connector:%d atomic best encoder:%d\n",

			connector->base.id, i);

	else

		DP_MST_DEBUG("mst connector:%d atomic best encoder failed\n",

				connector->base.id);



	return enc;

}



static u32 dp_mst_find_fixed_port_num(struct drm_dp_mst_branch *mstb,

		struct drm_dp_mst_port *target)

{

	struct drm_dp_mst_port *port;

	u32 port_num = 0;



	/*

	 * search through reversed order of adding sequence, so the port number

	 * will be unique once topology is fixed

	 */

	list_for_each_entry_reverse(port, &mstb->ports, next) {

		if (port->mstb)

			port_num += dp_mst_find_fixed_port_num(port->mstb,

						target);

		else if (!port->input) {

			++port_num;

			if (port == target)

				break;

		}

	}



	return port_num;

}



static struct drm_connector *

dp_mst_find_fixed_connector(struct dp_mst_private *dp_mst,

		struct drm_dp_mst_port *port)

{

	struct dp_display *dp_display = dp_mst->dp_display;

	struct drm_connector *connector = NULL;

	struct sde_connector *c_conn;

	u32 port_num;

	int i;



	mutex_lock(&port->mgr->lock);

	port_num = dp_mst_find_fixed_port_num(port->mgr->mst_primary, port);

	mutex_unlock(&port->mgr->lock);



	if (!port_num)

		return NULL;



	for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {

		if (dp_mst->mst_bridge[i].fixed_port_num == port_num) {

			connector = dp_mst->mst_bridge[i].fixed_connector;

			c_conn = to_sde_connector(connector);

			c_conn->mst_port = port;

			dp_display->mst_connector_update_link_info(dp_display,

					connector);

			dp_mst->mst_bridge[i].fixed_port_added = true;

			DP_MST_DEBUG("found fixed connector %d\n",

					DRMID(connector));

			break;

		}

	}



	return connector;

}



static int

dp_mst_find_first_available_encoder_idx(struct dp_mst_private *dp_mst)

{

	int enc_idx = MAX_DP_MST_DRM_BRIDGES;

	int i;



	for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {

		if (!dp_mst->mst_bridge[i].fixed_connector) {

			enc_idx = i;

			break;

		}

	}



	return enc_idx;

}



static struct drm_connector *

dp_mst_add_fixed_connector(struct drm_dp_mst_topology_mgr *mgr,

		struct drm_dp_mst_port *port, const char *pathprop)

{

	struct dp_mst_private *dp_mst;

	struct drm_device *dev;

	struct dp_display *dp_display;

	struct drm_connector *connector;

	int i, enc_idx;



	DP_MST_DEBUG("enter\n");



	dp_mst = container_of(mgr, struct dp_mst_private, mst_mgr);



	dp_display = dp_mst->dp_display;

	dev = dp_display->drm_dev;



	if (port->input || port->mstb)

		enc_idx = MAX_DP_MST_DRM_BRIDGES;

	else {

		/* if port is already reserved, return immediately */

		connector = dp_mst_find_fixed_connector(dp_mst, port);

		if (connector != NULL)

			return connector;



		/* first available bridge index for non-reserved port */

		enc_idx = dp_mst_find_first_available_encoder_idx(dp_mst);

	}



	/* add normal connector */

	connector = dp_mst_add_connector(mgr, port, pathprop);

	if (!connector) {

		DP_MST_DEBUG("failed to add connector\n");

		return NULL;

	}



	drm_modeset_lock_all(dev);



	/* clear encoder list */

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

		connector->encoder_ids[i] = 0;



	/* re-attach encoders from first available encoders */

	for (i = enc_idx; i < MAX_DP_MST_DRM_BRIDGES; i++)

		drm_connector_attach_encoder(connector,

				dp_mst->mst_bridge[i].encoder);



	drm_modeset_unlock_all(dev);



	DP_MST_DEBUG("add mst connector:%d\n", connector->base.id);



	return connector;

}



static void dp_mst_register_fixed_connector(struct drm_connector *connector)

{

	struct sde_connector *c_conn = to_sde_connector(connector);

	struct dp_display *dp_display = c_conn->display;

	struct dp_mst_private *dp_mst = dp_display->dp_mst_prv_info;

	int i;



	DP_MST_DEBUG("enter\n");



	/* skip connector registered for fixed topology ports */

	for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {

		if (dp_mst->mst_bridge[i].fixed_connector == connector) {

			DP_MST_DEBUG("found fixed connector %d\n",

					DRMID(connector));

			return;

		}

	}



	dp_mst_register_connector(connector);

}



static void dp_mst_destroy_fixed_connector(struct drm_dp_mst_topology_mgr *mgr,

					   struct drm_connector *connector)

{

	struct dp_mst_private *dp_mst;

	int i;



	DP_MST_DEBUG("enter\n");



	dp_mst = container_of(mgr, struct dp_mst_private, mst_mgr);



	/* skip connector destroy for fixed topology ports */

	for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {

		if (dp_mst->mst_bridge[i].fixed_connector == connector) {

			dp_mst->mst_bridge[i].fixed_port_added = false;

			DP_MST_DEBUG("destroy fixed connector %d\n",

					DRMID(connector));

			return;

		}

	}



	dp_mst_destroy_connector(mgr, connector);

}



static struct drm_connector *

dp_mst_drm_fixed_connector_init(struct dp_display *dp_display,

			struct drm_encoder *encoder)

{

	static const struct sde_connector_ops dp_mst_connector_ops = {

		.post_init  = NULL,

		.detect     = dp_mst_fixed_connector_detect,

		.get_modes  = dp_mst_connector_get_modes,

		.mode_valid = dp_mst_connector_mode_valid,

		.get_info   = dp_mst_connector_get_info,

		.get_mode_info  = dp_mst_connector_get_mode_info,

		.atomic_best_encoder = dp_mst_fixed_atomic_best_encoder,

		.atomic_check = dp_mst_connector_atomic_check,

		.config_hdr = dp_mst_connector_config_hdr,

		.pre_destroy = dp_mst_connector_pre_destroy,

	};

	struct drm_device *dev;

	struct drm_connector *connector;

	int rc;



	DP_MST_DEBUG("enter\n");



	dev = dp_display->drm_dev;



	connector = sde_connector_init(dev,

				encoder,

				NULL,

				dp_display,

				&dp_mst_connector_ops,

				DRM_CONNECTOR_POLL_HPD,

				DRM_MODE_CONNECTOR_DisplayPort);



	if (!connector) {

		pr_err("mst sde_connector_init failed\n");

		return NULL;

	}



	rc = dp_display->mst_connector_install(dp_display, connector);

	if (rc) {

		pr_err("mst connector install failed\n");

		sde_connector_destroy(connector);

		return NULL;

	}



	drm_object_attach_property(&connector->base,

			dev->mode_config.path_property, 0);

	drm_object_attach_property(&connector->base,

			dev->mode_config.tile_property, 0);



	DP_MST_DEBUG("add mst fixed connector:%d\n", connector->base.id);



	return connector;

}



static void dp_mst_hotplug(struct drm_dp_mst_topology_mgr *mgr)

{

	struct dp_mst_private *mst = container_of(mgr, struct dp_mst_private,
@@ -1569,6 +1881,13 @@ static const struct drm_dp_mst_topology_cbs dp_mst_drm_cbs = { 
	.hotplug = dp_mst_hotplug,

};



static const struct drm_dp_mst_topology_cbs dp_mst_fixed_drm_cbs = {

	.add_connector = dp_mst_add_fixed_connector,

	.register_connector = dp_mst_register_fixed_connector,

	.destroy_connector = dp_mst_destroy_fixed_connector,

	.hotplug = dp_mst_hotplug,

};



static void dp_mst_sim_init(struct dp_mst_private *mst)

{

	INIT_WORK(&mst->simulator.probe_work, dp_mst_sim_link_probe_work);
@@ -1633,6 +1952,10 @@ int dp_mst_init(struct dp_display *dp_display) 
	}

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



	/* choose fixed callback function if fixed topology is found */

	if (!dp_display->mst_get_fixed_topology_port(dp_display, 0, NULL))

		dp_mst.mst_mgr.cbs = &dp_mst_fixed_drm_cbs;



	DP_MST_INFO_LOG("dp drm mst topology manager init completed\n");



	return ret;

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

+7 −0
Original line number Diff line number Diff line
@@ -703,6 +703,7 @@ static int dp_parser_catalog(struct dp_parser *parser) 
static int dp_parser_mst(struct dp_parser *parser)

{

	struct device *dev = &parser->pdev->dev;

	int i;



	parser->has_mst = of_property_read_bool(dev->of_node,

			"qcom,mst-enable");
@@ -710,6 +711,12 @@ static int dp_parser_mst(struct dp_parser *parser) 


	pr_debug("mst parsing successful. mst:%d\n", parser->has_mst);



	for (i = 0; i < MAX_DP_MST_STREAMS; i++) {

		of_property_read_u32_index(dev->of_node,

				"qcom,mst-fixed-topology-ports", i,

				&parser->mst_fixed_port[i]);

	}



	return 0;

}

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

+3 −0
Original line number Diff line number Diff line
@@ -12,6 +12,7 @@ 
#define AUX_CFG_LEN	10

#define DP_MAX_PIXEL_CLK_KHZ	675000

#define DP_MAX_LINK_CLK_KHZ	810000

#define MAX_DP_MST_STREAMS	2



enum dp_pm_type {

	DP_CORE_PM,
@@ -195,6 +196,7 @@ static inline char *dp_phy_aux_config_type_to_string(u32 cfg_type) 
 * @max_dp_dsc_blks: maximum DSC blks for DP interface

 * @max_dp_dsc_input_width_pixs: Maximum input width for DSC block

 * @has_widebus: widebus (2PPC) feature eanble status

  *@mst_fixed_port: mst port_num reserved for fixed topology

 * @parse: function to be called by client to parse device tree.

 * @get_io: function to be called by client to get io data.

 * @get_io_buf: function to be called by client to get io buffers.
@@ -224,6 +226,7 @@ struct dp_parser { 
	u32 max_dp_dsc_blks;

	u32 max_dp_dsc_input_width_pixs;

	bool lphw_hpd;

	u32 mst_fixed_port[MAX_DP_MST_STREAMS];



	int (*parse)(struct dp_parser *parser);

	struct dp_io_data *(*get_io)(struct dp_parser *parser, char *name);