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

Commit 596cb31b authored by Tatenda Chipeperekwa's avatar Tatenda Chipeperekwa Committed by Ajay Singh Parmar
Browse files

msm: mdss: dp: add support for link re-training 



Add support for link re-training after the main link is already
trained and active. Parse the requested lane count and link
bandwidth from the DPCD when hpd_irq is high, and re-train
the main link once the display, and therefore timing generator,
has been turned off.

CRs-Fixed: 1076516
Change-Id: Ifa1b609c532aa601f30e334e87a768bdda78958d
Signed-off-by: default avatarTatenda Chipeperekwa <tatendac@codeaurora.org>
parent 876d5731

drivers/video/fbdev/msm/mdss_dp.c

+449 −120
Original line number Diff line number Diff line
@@ -857,6 +857,18 @@ int mdss_dp_wait4train(struct mdss_dp_drv_pdata *dp_drv) 
	return ret;

}



static void mdss_dp_update_cable_status(struct mdss_dp_drv_pdata *dp,

		bool connected)

{

	mutex_lock(&dp->pd_msg_mutex);

	pr_debug("cable_connected to %d\n", connected);

	if (dp->cable_connected != connected)

		dp->cable_connected = connected;

	else

		pr_debug("no change in cable status\n");

	mutex_unlock(&dp->pd_msg_mutex);

}



static int dp_get_cable_status(struct platform_device *pdev, u32 vote)

{

	struct mdss_dp_drv_pdata *dp_ctrl = platform_get_drvdata(pdev);
@@ -1038,32 +1050,186 @@ static inline void mdss_dp_set_audio_switch_node( 
				val);

}



int mdss_dp_on(struct mdss_panel_data *pdata)

/**

 * mdss_dp_get_lane_mapping() - returns lane mapping based on given orientation

 * @orientation: usb plug orientation

 * @lane_map: the configured lane mapping

 *

 * Returns 0 when the lane mapping is successfully determined based on the

 * given usb plug orientation.

 */

static int mdss_dp_get_lane_mapping(struct mdss_dp_drv_pdata *dp,

		enum plug_orientation orientation,

		struct lane_mapping *lane_map)

{

	int ret = 0;



	pr_debug("enter: orientation = %d\n", orientation);



	if (!lane_map) {

		pr_err("invalid lane map input");

		ret = -EINVAL;

		goto exit;

	}



	/* Set the default lane mapping */

	lane_map->lane0 = 2;

	lane_map->lane1 = 3;

	lane_map->lane2 = 1;

	lane_map->lane3 = 0;



	if (orientation == ORIENTATION_CC2) {

		lane_map->lane0 = 1;

		lane_map->lane1 = 0;

		lane_map->lane2 = 2;

		lane_map->lane3 = 3;



		if (gpio_is_valid(dp->usbplug_cc_gpio)) {

			gpio_set_value(dp->usbplug_cc_gpio, 1);

			pr_debug("Configured cc gpio for new Orientation\n");

		}

	}



	pr_debug("lane0 = %d, lane1 = %d, lane2 =%d, lane3 =%d\n",

			lane_map->lane0, lane_map->lane1, lane_map->lane2,

			lane_map->lane3);



exit:

	return ret;

}



/**

 * mdss_dp_enable_mainlink_clocks() - enables Display Port main link clocks

 * @dp: Display Port Driver data

 *

 * Returns 0 when the main link clocks are successfully enabled.

 */

static int mdss_dp_enable_mainlink_clocks(struct mdss_dp_drv_pdata *dp)

{

	int ret = 0;



	dp->power_data[DP_CTRL_PM].clk_config[0].rate =

		((dp->link_rate * DP_LINK_RATE_MULTIPLIER) / 1000);/* KHz */



	dp->pixel_rate = dp->panel_data.panel_info.clk_rate;

	dp->power_data[DP_CTRL_PM].clk_config[3].rate =

		(dp->pixel_rate / 1000);/* KHz */



	ret = mdss_dp_clk_ctrl(dp, DP_CTRL_PM, true);

	if (ret) {

		pr_err("Unabled to start link clocks\n");

		ret = -EINVAL;

	}



	return ret;

}



/**

 * mdss_dp_disable_mainlink_clocks() - disables Display Port main link clocks

 * @dp: Display Port Driver data

 */

static void mdss_dp_disable_mainlink_clocks(struct mdss_dp_drv_pdata *dp_drv)

{

	mdss_dp_clk_ctrl(dp_drv, DP_CTRL_PM, false);

}



/**

 * mdss_dp_configure_source_params() - configures DP transmitter source params

 * @dp: Display Port Driver data

 * @lane_map: usb port lane mapping

 *

 * Configures the DP transmitter source params including details such as lane

 * configuration, output format and sink/panel timing information.

 */

static void mdss_dp_configure_source_params(struct mdss_dp_drv_pdata *dp,

		struct lane_mapping *lane_map)

{

	mdss_dp_ctrl_lane_mapping(&dp->ctrl_io, *lane_map);

	mdss_dp_fill_link_cfg(dp);

	mdss_dp_mainlink_ctrl(&dp->ctrl_io, true);

	mdss_dp_config_ctrl(dp);

	mdss_dp_sw_mvid_nvid(&dp->ctrl_io);

	mdss_dp_timing_cfg(&dp->ctrl_io, &dp->panel_data.panel_info);

}



/**

 * mdss_dp_train_main_link() - initiates training of DP main link

 * @dp: Display Port Driver data

 *

 * Initiates training of the DP main link and checks the state of the main

 * link after the training is complete.

 */

static void mdss_dp_train_main_link(struct mdss_dp_drv_pdata *dp)

{

	int ready = 0;



	pr_debug("enter\n");



	mdss_dp_link_train(dp);

	mdss_dp_wait4train(dp);



	ready = mdss_dp_mainlink_ready(dp, BIT(0));



	pr_debug("main link %s\n", ready ? "READY" : "NOT READY");

}



static int mdss_dp_on_irq(struct mdss_dp_drv_pdata *dp_drv)

{

	struct mdss_dp_drv_pdata *dp_drv = NULL;

	int ret = 0;

	enum plug_orientation orientation = ORIENTATION_NONE;

	struct lane_mapping ln_map;



	if (!pdata) {

		pr_err("Invalid input data\n");

		return -EINVAL;

	/* wait until link training is completed */

	mutex_lock(&dp_drv->train_mutex);



	pr_debug("enter\n");



	orientation = usbpd_get_plug_orientation(dp_drv->pd);

	pr_debug("plug orientation = %d\n", orientation);



	ret = mdss_dp_get_lane_mapping(dp_drv, orientation, &ln_map);

	if (ret)

		goto exit;



	mdss_dp_phy_share_lane_config(&dp_drv->phy_io,

			orientation, dp_drv->dpcd.max_lane_count);



	ret = mdss_dp_enable_mainlink_clocks(dp_drv);

	if (ret)

		goto exit;



	mdss_dp_mainlink_reset(&dp_drv->ctrl_io);



	reinit_completion(&dp_drv->idle_comp);



	mdss_dp_configure_source_params(dp_drv, &ln_map);



	mdss_dp_train_main_link(dp_drv);



	dp_drv->power_on = true;

	pr_debug("end\n");



exit:

	mutex_unlock(&dp_drv->train_mutex);

	return ret;

}



	dp_drv = container_of(pdata, struct mdss_dp_drv_pdata,

			panel_data);

int mdss_dp_on_hpd(struct mdss_dp_drv_pdata *dp_drv)

{

	int ret = 0;

	enum plug_orientation orientation = ORIENTATION_NONE;

	struct lane_mapping ln_map;



	/* wait until link training is completed */

	mutex_lock(&dp_drv->train_mutex);



	pr_debug("Enter++ cont_splash=%d\n", dp_drv->cont_splash);

	/* Default lane mapping */

	ln_map.lane0 = 2;

	ln_map.lane1 = 3;

	ln_map.lane2 = 1;

	ln_map.lane3 = 0;



	if (!dp_drv->cont_splash) { /* vote for clocks */

	if (dp_drv->cont_splash) {

		mdss_dp_aux_ctrl(&dp_drv->ctrl_io, true);

		goto link_training;

	}



	ret = mdss_dp_clk_ctrl(dp_drv, DP_CORE_PM, true);

	if (ret) {

		pr_err("Unabled to start core clocks\n");
@@ -1074,20 +1240,9 @@ int mdss_dp_on(struct mdss_panel_data *pdata) 
	orientation = usbpd_get_plug_orientation(dp_drv->pd);

	pr_debug("plug Orientation = %d\n", orientation);



		if (orientation == ORIENTATION_CC2) {

			/* update lane mapping */

			ln_map.lane0 = 1;

			ln_map.lane1 = 0;

			ln_map.lane2 = 2;

			ln_map.lane3 = 3;



			if (gpio_is_valid(dp_drv->usbplug_cc_gpio)) {

				gpio_set_value(

					dp_drv->usbplug_cc_gpio, 1);

				pr_debug("Configured cc gpio for new Orientation\n");

			}



		}

	ret = mdss_dp_get_lane_mapping(dp_drv, orientation, &ln_map);

	if (ret)

		goto exit;



	if (dp_drv->new_vic && (dp_drv->new_vic != dp_drv->vic))

		dp_init_panel_info(dp_drv, dp_drv->new_vic);
@@ -1109,45 +1264,21 @@ int mdss_dp_on(struct mdss_panel_data *pdata) 


	pr_debug("link_rate = 0x%x\n", dp_drv->link_rate);



		dp_drv->power_data[DP_CTRL_PM].clk_config[0].rate =

			((dp_drv->link_rate * DP_LINK_RATE_MULTIPLIER) /

			1000); /* KHz */



		dp_drv->pixel_rate = dp_drv->panel_data.panel_info.clk_rate;

		dp_drv->power_data[DP_CTRL_PM].clk_config[3].rate =

						(dp_drv->pixel_rate /

						1000); /* KHz */



		ret = mdss_dp_clk_ctrl(dp_drv, DP_CTRL_PM, true);

		if (ret) {

			pr_err("Unabled to start link clocks\n");

	ret = mdss_dp_enable_mainlink_clocks(dp_drv);

	if (ret)

		goto exit;

		}



	mdss_dp_mainlink_reset(&dp_drv->ctrl_io);



		mdss_dp_ctrl_lane_mapping(&dp_drv->ctrl_io, ln_map);

	reinit_completion(&dp_drv->idle_comp);

		mdss_dp_fill_link_cfg(dp_drv);

		mdss_dp_mainlink_ctrl(&dp_drv->ctrl_io, true);

		mdss_dp_config_ctrl(dp_drv);

		mdss_dp_sw_mvid_nvid(&dp_drv->ctrl_io);

		mdss_dp_timing_cfg(&dp_drv->ctrl_io,

				&dp_drv->panel_data.panel_info);

	} else {

		mdss_dp_aux_ctrl(&dp_drv->ctrl_io, true);

	}



	pr_debug("call link_training\n");

	mdss_dp_link_train(dp_drv);

	mdss_dp_configure_source_params(dp_drv, &ln_map);



	mdss_dp_wait4train(dp_drv);

link_training:

	mdss_dp_train_main_link(dp_drv);



	dp_drv->cont_splash = 0;



	if (mdss_dp_mainlink_ready(dp_drv, BIT(0)))

		pr_debug("mainlink ready\n");



	dp_drv->power_on = true;

	mdss_dp_set_audio_switch_node(dp_drv, true);

	pr_debug("End-\n");
@@ -1157,48 +1288,77 @@ exit: 
	return ret;

}



static void mdss_dp_mainlink_off(struct mdss_panel_data *pdata)

int mdss_dp_on(struct mdss_panel_data *pdata)

{

	struct mdss_dp_drv_pdata *dp_drv = NULL;

	const int idle_pattern_completion_timeout_ms = 3 * HZ / 100;



	if (!pdata) {

		pr_err("Invalid input data\n");

		return -EINVAL;

	}



	dp_drv = container_of(pdata, struct mdss_dp_drv_pdata,

			panel_data);

	if (!dp_drv) {

		pr_err("Invalid input data\n");

		return;



	return mdss_dp_on_hpd(dp_drv);

}



static void mdss_dp_reset_test_data(struct mdss_dp_drv_pdata *dp)

{

	dp->test_data = (const struct dpcd_test_request){ 0 };

}



static bool mdss_dp_is_link_training_requested(struct mdss_dp_drv_pdata *dp)

{

	return (dp->test_data.test_requested == TEST_LINK_TRAINING);

}



static bool mdss_dp_soft_hpd_reset(struct mdss_dp_drv_pdata *dp)

{

	return mdss_dp_is_link_training_requested(dp) &&

		dp->alt_mode.dp_status.hpd_irq;

}



static int mdss_dp_off_irq(struct mdss_dp_drv_pdata *dp_drv)

{

	if (!dp_drv->power_on) {

		pr_debug("panel already powered off\n");

		return 0;

	}

	pr_debug("Entered++\n");



	/* wait until link training is completed */

	mutex_lock(&dp_drv->train_mutex);



	reinit_completion(&dp_drv->idle_comp);

	mdss_dp_state_ctrl(&dp_drv->ctrl_io, ST_PUSH_IDLE);

	if (!wait_for_completion_timeout(&dp_drv->idle_comp,

			idle_pattern_completion_timeout_ms))

		pr_warn("PUSH_IDLE pattern timedout\n");

	pr_debug("start\n");



	mdss_dp_mainlink_ctrl(&dp_drv->ctrl_io, false);



	mdss_dp_audio_enable(&dp_drv->ctrl_io, false);



	/* Make sure the DP main link is disabled before clk disable */

	wmb();

	mdss_dp_disable_mainlink_clocks(dp_drv);

	dp_drv->power_on = false;



	mutex_unlock(&dp_drv->train_mutex);

	pr_debug("mainlink off done\n");

	complete_all(&dp_drv->irq_comp);

	pr_debug("end\n");



	return 0;

}



int mdss_dp_off(struct mdss_panel_data *pdata)

static int mdss_dp_off_hpd(struct mdss_dp_drv_pdata *dp_drv)

{

	struct mdss_dp_drv_pdata *dp_drv = NULL;



	dp_drv = container_of(pdata, struct mdss_dp_drv_pdata,

				panel_data);

	if (!dp_drv) {

		pr_err("Invalid input data\n");

		return -EINVAL;

	if (!dp_drv->power_on) {

		pr_debug("panel already powered off\n");

		return 0;

	}

	pr_debug("Entered++, cont_splash=%d\n", dp_drv->cont_splash);



	/* wait until link training is completed */

	mutex_lock(&dp_drv->train_mutex);



	if (dp_drv->link_clks_on)

	pr_debug("Entered++, cont_splash=%d\n", dp_drv->cont_splash);



	mdss_dp_mainlink_ctrl(&dp_drv->ctrl_io, false);



	mdss_dp_aux_ctrl(&dp_drv->ctrl_io, false);
@@ -1219,7 +1379,7 @@ int mdss_dp_off(struct mdss_panel_data *pdata) 


	/* Make sure DP is disabled before clk disable */

	wmb();

	mdss_dp_clk_ctrl(dp_drv, DP_CTRL_PM, false);

	mdss_dp_disable_mainlink_clocks(dp_drv);

	mdss_dp_clk_ctrl(dp_drv, DP_CORE_PM, false);



	mdss_dp_regulator_ctrl(dp_drv, false);
@@ -1232,6 +1392,23 @@ int mdss_dp_off(struct mdss_panel_data *pdata) 
	return 0;

}



int mdss_dp_off(struct mdss_panel_data *pdata)

{

	struct mdss_dp_drv_pdata *dp = NULL;



	dp = container_of(pdata, struct mdss_dp_drv_pdata,

				panel_data);

	if (!dp) {

		pr_err("Invalid input data\n");

		return -EINVAL;

	}



	if (mdss_dp_soft_hpd_reset(dp))

		return mdss_dp_off_irq(dp);

	else

		return mdss_dp_off_hpd(dp);

}



static void mdss_dp_send_cable_notification(

	struct mdss_dp_drv_pdata *dp, int val)

{
@@ -1634,6 +1811,34 @@ static int mdss_dp_sysfs_create(struct mdss_dp_drv_pdata *dp, 
	return 0;

}



static void mdss_dp_mainlink_push_idle(struct mdss_panel_data *pdata)

{

	struct mdss_dp_drv_pdata *dp_drv = NULL;

	const int idle_pattern_completion_timeout_ms = 3 * HZ / 100;



	dp_drv = container_of(pdata, struct mdss_dp_drv_pdata,

				panel_data);

	if (!dp_drv) {

		pr_err("Invalid input data\n");

		return;

	}

	pr_debug("Entered++\n");



	/* wait until link training is completed */

	mutex_lock(&dp_drv->train_mutex);



	mdss_dp_aux_set_sink_power_state(dp_drv, SINK_POWER_OFF);



	reinit_completion(&dp_drv->idle_comp);

	mdss_dp_state_ctrl(&dp_drv->ctrl_io, ST_PUSH_IDLE);

	if (!wait_for_completion_timeout(&dp_drv->idle_comp,

			idle_pattern_completion_timeout_ms))

		pr_warn("PUSH_IDLE pattern timedout\n");



	mutex_unlock(&dp_drv->train_mutex);

	pr_debug("mainlink off done\n");

}



static int mdss_dp_event_handler(struct mdss_panel_data *pdata,

				  int event, void *arg)

{
@@ -1670,7 +1875,7 @@ static int mdss_dp_event_handler(struct mdss_panel_data *pdata, 
	case MDSS_EVENT_BLANK:

		if (ops && ops->off)

			ops->off(dp->hdcp_data);

		mdss_dp_mainlink_off(pdata);

		mdss_dp_mainlink_push_idle(pdata);

		break;

	case MDSS_EVENT_FB_REGISTERED:

		fbi = (struct fb_info *)arg;
@@ -1976,10 +2181,8 @@ static void usbpd_connect_callback(struct usbpd_svid_handler *hdlr) 
		return;

	}



	mutex_lock(&dp_drv->pd_msg_mutex);

	dp_drv->cable_connected = true;

	mdss_dp_update_cable_status(dp_drv, true);

	dp_send_events(dp_drv, EV_USBPD_DISCOVER_MODES);

	mutex_unlock(&dp_drv->pd_msg_mutex);

	pr_debug("discover_mode event sent\n");

}
@@ -1994,10 +2197,8 @@ static void usbpd_disconnect_callback(struct usbpd_svid_handler *hdlr) 
	}



	pr_debug("cable disconnected\n");

	mutex_lock(&dp_drv->pd_msg_mutex);

	dp_drv->cable_connected = false;

	mdss_dp_update_cable_status(dp_drv, false);

	dp_drv->alt_mode.current_state = UNKNOWN_STATE;

	mutex_unlock(&dp_drv->pd_msg_mutex);

	mdss_dp_notify_clients(dp_drv, false);

}
@@ -2040,6 +2241,108 @@ end: 
	return ret;

}



/**

 * mdss_dp_send_test_response() - sends the test response to the sink

 * @dp: Display Port Driver data

 *

 * This function will send the test response to the sink but only after

 * any previous link training has been completed.

 */

static void mdss_dp_send_test_response(struct mdss_dp_drv_pdata *dp)

{

	mutex_lock(&dp->train_mutex);

	mdss_dp_aux_send_test_response(dp);

	mutex_unlock(&dp->train_mutex);

}



/**

 * mdss_dp_hpd_irq_notify_clients() - notifies DP clients of HPD IRQ tear down

 * @dp: Display Port Driver data

 *

 * This function will send a notification to display/audio clients of DP tear

 * down during an HPD IRQ. This happens only if HPD IRQ is toggled,

 * in which case the user space proceeds with shutdown of DP driver, including

 * mainlink disable, and pushing the controller into idle state.

 */

static int mdss_dp_hpd_irq_notify_clients(struct mdss_dp_drv_pdata *dp)

{

	const int irq_comp_timeout = HZ * 2;

	int ret = 0;



	if (dp->hpd_irq_toggled) {

		mdss_dp_notify_clients(dp, false);



		reinit_completion(&dp->irq_comp);

		ret = wait_for_completion_timeout(&dp->irq_comp,

				irq_comp_timeout);

		if (ret <= 0) {

			pr_warn("irq_comp timed out\n");

			return -EINVAL;

		}

	}



	return 0;

}



/**

 * mdss_dp_process_hpd_irq_high() - handle HPD IRQ transition to HIGH

 * @dp: Display Port Driver data

 *

 * This function will handle the HPD IRQ state transitions from HIGH to HIGH

 * or LOW to HIGH, indicating the start of a new test request.

 */

static void mdss_dp_process_hpd_irq_high(struct mdss_dp_drv_pdata *dp)

{

	pr_debug("enter: HPD IRQ High\n");



	dp->hpd_irq_on = true;



	mdss_dp_aux_parse_test_request(dp);



	mdss_dp_send_test_response(dp);



	if (mdss_dp_is_link_training_requested(dp)) {

		pr_info("%s requested: link rate = 0x%x, lane count = 0x%x\n",

				mdss_dp_get_test_name(TEST_LINK_TRAINING),

				dp->test_data.test_link_rate,

				dp->test_data.test_lane_count);

		dp->dpcd.max_lane_count =

			dp->test_data.test_lane_count;

		dp->link_rate = dp->test_data.test_link_rate;



		if (mdss_dp_hpd_irq_notify_clients(dp))

			return;



		mdss_dp_on_irq(dp);

	}



	mdss_dp_reset_test_data(dp);



	pr_debug("done\n");

}



/**

 * mdss_dp_process_hpd_irq_low() - handle HPD IRQ transition to LOW

 * @dp: Display Port Driver data

 *

 * This function will handle the HPD IRQ state transitions from HIGH to LOW,

 * indicating the end of a test request.

 */

static void mdss_dp_process_hpd_irq_low(struct mdss_dp_drv_pdata *dp)

{

	pr_debug("enter: HPD IRQ low\n");



	dp->hpd_irq_on = false;



	mdss_dp_update_cable_status(dp, false);

	mdss_dp_mainlink_push_idle(&dp->panel_data);

	mdss_dp_off_hpd(dp);



	mdss_dp_reset_test_data(dp);



	pr_debug("done\n");

}



static void usbpd_response_callback(struct usbpd_svid_handler *hdlr, u8 cmd,

				enum usbpd_svdm_cmd_type cmd_type,

				const u32 *vdos, int num_vdos)
@@ -2055,8 +2358,10 @@ static void usbpd_response_callback(struct usbpd_svid_handler *hdlr, u8 cmd, 
	pr_debug("callback -> cmd: 0x%x, *vdos = 0x%x, num_vdos = %d\n",

				cmd, *vdos, num_vdos);



	if (mdss_dp_validate_callback(cmd, cmd_type, num_vdos))

	if (mdss_dp_validate_callback(cmd, cmd_type, num_vdos)) {

		pr_debug("invalid callback received\n");

		return;

	}



	switch (cmd) {

	case USBPD_SVDM_DISCOVER_MODES:
@@ -2073,10 +2378,31 @@ static void usbpd_response_callback(struct usbpd_svid_handler *hdlr, u8 cmd, 
		dp_drv->alt_mode.dp_status.response = *vdos;

		mdss_dp_usbpd_ext_dp_status(&dp_drv->alt_mode.dp_status);



		if (!dp_drv->alt_mode.dp_status.hpd_high)

			return;

		dp_drv->hpd_irq_toggled = dp_drv->hpd_irq_on !=

			dp_drv->alt_mode.dp_status.hpd_irq;



		if (dp_drv->alt_mode.dp_status.hpd_irq) {

			mdss_dp_process_hpd_irq_high(dp_drv);

			break;

		}



		if (dp_drv->hpd_irq_toggled

				&& !dp_drv->alt_mode.dp_status.hpd_irq) {

			mdss_dp_process_hpd_irq_low(dp_drv);

			break;

		}



		if (!dp_drv->alt_mode.dp_status.hpd_high) {

			pr_debug("Attention: HPD low\n");

			mdss_dp_update_cable_status(dp_drv, false);

			mdss_dp_notify_clients(dp_drv, false);

			pr_debug("Attention: Notified clients\n");

			break;

		}



		pr_debug("Attention: HPD high\n");



		pr_debug("HPD high\n");

		mdss_dp_update_cable_status(dp_drv, true);



		dp_drv->alt_mode.current_state |= DP_STATUS_DONE;
@@ -2096,7 +2422,7 @@ static void usbpd_response_callback(struct usbpd_svid_handler *hdlr, u8 cmd, 
		break;

	case DP_VDM_CONFIGURE:

		dp_drv->alt_mode.current_state |= DP_CONFIGURE_DONE;

		pr_debug("config USBPD to DP done\n");

		pr_debug("Configure: config USBPD to DP done\n");



		if (dp_drv->alt_mode.dp_status.hpd_high)

			mdss_dp_host_init(&dp_drv->panel_data);
@@ -2259,7 +2585,10 @@ static int mdss_dp_probe(struct platform_device *pdev) 


	dp_drv->inited = true;

	dp_drv->wait_for_audio_comp = false;

	dp_drv->hpd_irq_on = false;

	mdss_dp_reset_test_data(dp_drv);

	init_completion(&dp_drv->audio_comp);

	init_completion(&dp_drv->irq_comp);



	pr_debug("done\n");

drivers/video/fbdev/msm/mdss_dp.h

+59 −10
Original line number Diff line number Diff line
@@ -70,8 +70,6 @@ 
#define EDP_INTR_ACK_SHIFT	1

#define EDP_INTR_MASK_SHIFT	2



#define EDP_MAX_LANE		4



/* isr */

#define EDP_INTR_HPD		BIT(0)

#define EDP_INTR_AUX_I2C_DONE	BIT(3)
@@ -105,7 +103,7 @@ 
	EDP_INTR_FRAME_END | EDP_INTR_CRC_UPDATED)



#define EDP_INTR_MASK2		(EDP_INTR_STATUS2 << 2)

#define EV_EVENT_STR(x)		#x

#define DP_ENUM_STR(x)		#x



struct edp_buf {

	char *start;	/* buffer start addr */
@@ -256,6 +254,13 @@ struct dpcd_link_status { 
	char req_pre_emphasis[4];

};



struct dpcd_test_request {

	u32 test_requested;

	u32 test_link_rate;

	u32 test_lane_count;

	u32 response;

};



struct display_timing_desc {

	u32 pclk;

	u32 h_addressable; /* addressable + boder = active */
@@ -401,6 +406,7 @@ struct mdss_dp_drv_pdata { 
	struct completion idle_comp;

	struct completion video_comp;

	struct completion audio_comp;

	struct completion irq_comp;

	struct mutex aux_mutex;

	struct mutex train_mutex;

	struct mutex pd_msg_mutex;
@@ -426,6 +432,8 @@ struct mdss_dp_drv_pdata { 
	u32 bpp;

	struct dp_statistic dp_stat;

	bool wait_for_audio_comp;

	bool hpd_irq_on;

	bool hpd_irq_toggled;



	/* event */

	struct workqueue_struct *workq;
@@ -443,8 +451,46 @@ struct mdss_dp_drv_pdata { 


	void *hdcp_data;

	struct hdcp_ops *hdcp_ops;

	struct dpcd_test_request test_data;

};



enum dp_lane_count {

	DP_LANE_COUNT_1	= 1,

	DP_LANE_COUNT_2	= 2,

	DP_LANE_COUNT_4	= 4,

};



enum test_response {

	TEST_NACK	= 0x0,

	TEST_ACK	= 0x1,

};



static inline char *mdss_dp_get_test_response(u32 test_response)

{

	switch (test_response) {

	case TEST_NACK:		return DP_ENUM_STR(TEST_NACK);

	case TEST_ACK:		return DP_ENUM_STR(TEST_ACK);

	default:		return "unknown";

	}

}



enum test_type {

	UNKNOWN_TEST		= 0,

	TEST_LINK_TRAINING	= BIT(0),

	TEST_PATTERN		= BIT(1),

	TEST_EDID_READ		= BIT(2),

};



static inline char *mdss_dp_get_test_name(u32 test_requested)

{

	switch (test_requested) {

	case TEST_LINK_TRAINING:	return DP_ENUM_STR(TEST_LINK_TRAINING);

	case TEST_PATTERN:		return DP_ENUM_STR(TEST_PATTERN);

	case TEST_EDID_READ:		return DP_ENUM_STR(TEST_EDID_READ);

	default:			return "unknown";

	}

}



static inline const char *__mdss_dp_pm_name(enum dp_pm_type module)

{

	switch (module) {
@@ -470,19 +516,19 @@ static inline char *mdss_dp_ev_event_to_string(int event) 
{

	switch (event) {

	case EV_EDP_AUX_SETUP:

		return EV_EVENT_STR(EV_EDP_AUX_SETUP);

		return DP_ENUM_STR(EV_EDP_AUX_SETUP);

	case EV_EDID_READ:

		return EV_EVENT_STR(EV_EDID_READ);

		return DP_ENUM_STR(EV_EDID_READ);

	case EV_DPCD_CAP_READ:

		return EV_EVENT_STR(EV_DPCD_CAP_READ);

		return DP_ENUM_STR(EV_DPCD_CAP_READ);

	case EV_DPCD_STATUS_READ:

		return EV_EVENT_STR(EV_DPCD_STATUS_READ);

		return DP_ENUM_STR(EV_DPCD_STATUS_READ);

	case EV_LINK_TRAIN:

		return EV_EVENT_STR(EV_LINK_TRAIN);

		return DP_ENUM_STR(EV_LINK_TRAIN);

	case EV_IDLE_PATTERNS_SENT:

		return EV_EVENT_STR(EV_IDLE_PATTERNS_SENT);

		return DP_ENUM_STR(EV_IDLE_PATTERNS_SENT);

	case EV_VIDEO_READY:

		return EV_EVENT_STR(EV_VIDEO_READY);

		return DP_ENUM_STR(EV_VIDEO_READY);

	default:

		return "unknown";

	}
@@ -492,6 +538,7 @@ void mdss_dp_phy_initialize(struct mdss_dp_drv_pdata *dp); 


void mdss_dp_dpcd_cap_read(struct mdss_dp_drv_pdata *dp);

int mdss_dp_dpcd_status_read(struct mdss_dp_drv_pdata *dp);

void mdss_dp_aux_parse_test_request(struct mdss_dp_drv_pdata *dp);

int mdss_dp_edid_read(struct mdss_dp_drv_pdata *dp);

int mdss_dp_link_train(struct mdss_dp_drv_pdata *dp);

void dp_aux_i2c_handler(struct mdss_dp_drv_pdata *dp, u32 isr);
@@ -503,5 +550,7 @@ void mdss_dp_sink_power_down(struct mdss_dp_drv_pdata *ep); 
void mdss_dp_lane_power_ctrl(struct mdss_dp_drv_pdata *ep, int up);

void mdss_dp_config_ctrl(struct mdss_dp_drv_pdata *ep);

char mdss_dp_gen_link_clk(struct mdss_panel_info *pinfo, char lane_cnt);

int mdss_dp_aux_set_sink_power_state(struct mdss_dp_drv_pdata *ep, char state);

void mdss_dp_aux_send_test_response(struct mdss_dp_drv_pdata *ep);



#endif /* MDSS_DP_H */

drivers/video/fbdev/msm/mdss_dp_aux.c

+203 −2

File changed.

Preview size limit exceeded, changes collapsed.