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

Commit 00c09d70 authored by Paulo Zanoni's avatar Paulo Zanoni Committed by Daniel Vetter
Browse files

drm/i915: create the DDI encoder 



Now intel_ddi_init is just like intel_hdmi_init and intel_dp_init: it
inits the encoder and then calls the proper init_connector functions.
Notice that for non-eDP ports we call both HDMI and DP connector init,
so we have 2 connectors attached to each DDI encoder.

After this change, intel_hdmi_init and intel_dp_init are only called
by Ivy Bridge and earlier, while hardware containing DDI outputs
should call intel_ddi_init.

Also added/removed quite a few "static" keywords due to the fact that
some function pointers were moved from intel_dp.c and intel_hdmi.c to
intel_ddi.c.

DP finally works on Haswell now! \o/

Signed-off-by: default avatarPaulo Zanoni <paulo.r.zanoni@intel.com>
Reviewed-by: default avatarDamien Lespiau <damien.lespiau@intel.com>
Signed-off-by: default avatarDaniel Vetter <daniel.vetter@ffwll.ch>
parent bcbc889b

drivers/gpu/drm/i915/intel_ddi.c

+106 −37
Original line number Diff line number Diff line
@@ -64,7 +64,7 @@ static enum port intel_ddi_get_encoder_port(struct intel_encoder *intel_encoder) 
	int type = intel_encoder->type;



	if (type == INTEL_OUTPUT_DISPLAYPORT || type == INTEL_OUTPUT_EDP ||

	    type == INTEL_OUTPUT_HDMI) {

	    type == INTEL_OUTPUT_HDMI || type == INTEL_OUTPUT_UNKNOWN) {

		struct intel_digital_port *intel_dig_port =

			enc_to_dig_port(encoder);

		return intel_dig_port->port;
@@ -227,35 +227,6 @@ void hsw_fdi_link_train(struct drm_crtc *crtc) 
	DRM_DEBUG_KMS("FDI train done.\n");

}



/* For DDI connections, it is possible to support different outputs over the

 * same DDI port, such as HDMI or DP or even VGA via FDI. So we don't know by

 * the time the output is detected what exactly is on the other end of it. This

 * function aims at providing support for this detection and proper output

 * configuration.

 */

void intel_ddi_init(struct drm_device *dev, enum port port)

{

	/* For now, we don't do any proper output detection and assume that we

	 * handle HDMI only */



	switch(port){

	case PORT_A:

		DRM_DEBUG_DRIVER("Found digital output on DDI port A\n");

		intel_dp_init(dev, DDI_BUF_CTL_A, PORT_A);

		break;

	/* Assume that the  ports B, C and D are working in HDMI mode for now */

	case PORT_B:

	case PORT_C:

	case PORT_D:

		intel_hdmi_init(dev, DDI_BUF_CTL(port), port);

		break;

	default:

		DRM_DEBUG_DRIVER("No handlers defined for port %d, skipping DDI initialization\n",

				port);

		break;

	}

}



/* WRPLL clock dividers */

struct wrpll_tmds_clock {

	u32 clock;
@@ -642,7 +613,7 @@ static const struct wrpll_tmds_clock wrpll_tmds_clock_table[] = { 
	{298000,	2,	21,	19},

};



void intel_ddi_mode_set(struct drm_encoder *encoder,

static void intel_ddi_mode_set(struct drm_encoder *encoder,

			       struct drm_display_mode *mode,

			       struct drm_display_mode *adjusted_mode)

{
@@ -1192,7 +1163,7 @@ void intel_ddi_disable_pipe_clock(struct intel_crtc *intel_crtc) 
			   TRANS_CLK_SEL_DISABLED);

}



void intel_ddi_pre_enable(struct intel_encoder *intel_encoder)

static void intel_ddi_pre_enable(struct intel_encoder *intel_encoder)

{

	struct drm_encoder *encoder = &intel_encoder->base;

	struct drm_crtc *crtc = encoder->crtc;
@@ -1234,7 +1205,7 @@ static void intel_wait_ddi_buf_idle(struct drm_i915_private *dev_priv, 
	DRM_ERROR("Timeout waiting for DDI BUF %c idle bit\n", port_name(port));

}



void intel_ddi_post_disable(struct intel_encoder *intel_encoder)

static void intel_ddi_post_disable(struct intel_encoder *intel_encoder)

{

	struct drm_encoder *encoder = &intel_encoder->base;

	struct drm_i915_private *dev_priv = encoder->dev->dev_private;
@@ -1267,7 +1238,7 @@ void intel_ddi_post_disable(struct intel_encoder *intel_encoder) 
	I915_WRITE(PORT_CLK_SEL(port), PORT_CLK_SEL_NONE);

}



void intel_enable_ddi(struct intel_encoder *intel_encoder)

static void intel_enable_ddi(struct intel_encoder *intel_encoder)

{

	struct drm_encoder *encoder = &intel_encoder->base;

	struct drm_device *dev = encoder->dev;
@@ -1288,7 +1259,7 @@ void intel_enable_ddi(struct intel_encoder *intel_encoder) 
	}

}



void intel_disable_ddi(struct intel_encoder *intel_encoder)

static void intel_disable_ddi(struct intel_encoder *intel_encoder)

{

	struct drm_encoder *encoder = &intel_encoder->base;

	int type = intel_encoder->type;
@@ -1371,3 +1342,101 @@ void intel_ddi_prepare_link_retrain(struct drm_encoder *encoder) 


	udelay(600);

}



static void intel_ddi_hot_plug(struct intel_encoder *intel_encoder)

{

	struct intel_dp *intel_dp = enc_to_intel_dp(&intel_encoder->base);

	int type = intel_encoder->type;



	if (type == INTEL_OUTPUT_DISPLAYPORT || type == INTEL_OUTPUT_EDP)

		intel_dp_check_link_status(intel_dp);

}



static void intel_ddi_destroy(struct drm_encoder *encoder)

{

	/* HDMI has nothing special to destroy, so we can go with this. */

	intel_dp_encoder_destroy(encoder);

}



static bool intel_ddi_mode_fixup(struct drm_encoder *encoder,

				 const struct drm_display_mode *mode,

				 struct drm_display_mode *adjusted_mode)

{

	struct intel_encoder *intel_encoder = to_intel_encoder(encoder);

	int type = intel_encoder->type;



	WARN(type == INTEL_OUTPUT_UNKNOWN, "mode_fixup() on unknown output!\n");



	if (type == INTEL_OUTPUT_HDMI)

		return intel_hdmi_mode_fixup(encoder, mode, adjusted_mode);

	else

		return intel_dp_mode_fixup(encoder, mode, adjusted_mode);

}



static const struct drm_encoder_funcs intel_ddi_funcs = {

	.destroy = intel_ddi_destroy,

};



static const struct drm_encoder_helper_funcs intel_ddi_helper_funcs = {

	.mode_fixup = intel_ddi_mode_fixup,

	.mode_set = intel_ddi_mode_set,

	.disable = intel_encoder_noop,

};



void intel_ddi_init(struct drm_device *dev, enum port port)

{

	struct intel_digital_port *intel_dig_port;

	struct intel_encoder *intel_encoder;

	struct drm_encoder *encoder;

	struct intel_connector *hdmi_connector = NULL;

	struct intel_connector *dp_connector = NULL;



	intel_dig_port = kzalloc(sizeof(struct intel_digital_port), GFP_KERNEL);

	if (!intel_dig_port)

		return;



	dp_connector = kzalloc(sizeof(struct intel_connector), GFP_KERNEL);

	if (!dp_connector) {

		kfree(intel_dig_port);

		return;

	}



	if (port != PORT_A) {

		hdmi_connector = kzalloc(sizeof(struct intel_connector),

					 GFP_KERNEL);

		if (!hdmi_connector) {

			kfree(dp_connector);

			kfree(intel_dig_port);

			return;

		}

	}



	intel_encoder = &intel_dig_port->base;

	encoder = &intel_encoder->base;



	drm_encoder_init(dev, encoder, &intel_ddi_funcs,

			 DRM_MODE_ENCODER_TMDS);

	drm_encoder_helper_add(encoder, &intel_ddi_helper_funcs);



	intel_encoder->enable = intel_enable_ddi;

	intel_encoder->pre_enable = intel_ddi_pre_enable;

	intel_encoder->disable = intel_disable_ddi;

	intel_encoder->post_disable = intel_ddi_post_disable;

	intel_encoder->get_hw_state = intel_ddi_get_hw_state;



	intel_dig_port->port = port;

	if (hdmi_connector)

		intel_dig_port->hdmi.sdvox_reg = DDI_BUF_CTL(port);

	else

		intel_dig_port->hdmi.sdvox_reg = 0;

	intel_dig_port->dp.output_reg = DDI_BUF_CTL(port);



	intel_encoder->type = INTEL_OUTPUT_UNKNOWN;

	intel_encoder->crtc_mask =  (1 << 0) | (1 << 1) | (1 << 2);

	intel_encoder->cloneable = false;

	intel_encoder->hot_plug = intel_ddi_hot_plug;



	if (hdmi_connector)

		intel_hdmi_init_connector(intel_dig_port, hdmi_connector);

	intel_dp_init_connector(intel_dig_port, dp_connector);

}

drivers/gpu/drm/i915/intel_dp.c

+15 −30
Original line number Diff line number Diff line
@@ -685,7 +685,7 @@ intel_dp_i2c_init(struct intel_dp *intel_dp, 
	return ret;

}



static bool

bool

intel_dp_mode_fixup(struct drm_encoder *encoder,

		    const struct drm_display_mode *mode,

		    struct drm_display_mode *adjusted_mode)
@@ -2110,7 +2110,7 @@ intel_dp_handle_test_request(struct intel_dp *intel_dp) 
 *  4. Check link status on receipt of hot-plug interrupt

 */



static void

void

intel_dp_check_link_status(struct intel_dp *intel_dp)

{

	struct intel_encoder *intel_encoder = &dp_to_dig_port(intel_dp)->base;
@@ -2469,7 +2469,7 @@ intel_dp_destroy(struct drm_connector *connector) 
	kfree(connector);

}



static void intel_dp_encoder_destroy(struct drm_encoder *encoder)

void intel_dp_encoder_destroy(struct drm_encoder *encoder)

{

	struct intel_digital_port *intel_dig_port = enc_to_dig_port(encoder);

	struct intel_dp *intel_dp = &intel_dig_port->dp;
@@ -2489,12 +2489,6 @@ static const struct drm_encoder_helper_funcs intel_dp_helper_funcs = { 
	.disable = intel_encoder_noop,

};



static const struct drm_encoder_helper_funcs intel_dp_helper_funcs_hsw = {

	.mode_fixup = intel_dp_mode_fixup,

	.mode_set = intel_ddi_mode_set,

	.disable = intel_encoder_noop,

};



static const struct drm_connector_funcs intel_dp_connector_funcs = {

	.dpms = intel_connector_dpms,

	.detect = intel_dp_detect,
@@ -2690,7 +2684,7 @@ intel_dp_init_panel_power_sequencer(struct drm_device *dev, 
		      I915_READ(PCH_PP_DIVISOR));

}



static void

void

intel_dp_init_connector(struct intel_digital_port *intel_dig_port,

			struct intel_connector *intel_connector)

{
@@ -2723,8 +2717,11 @@ intel_dp_init_connector(struct intel_digital_port *intel_dig_port, 
		type = DRM_MODE_CONNECTOR_eDP;

		intel_encoder->type = INTEL_OUTPUT_EDP;

	} else {

		/* The intel_encoder->type value may be INTEL_OUTPUT_UNKNOWN for

		 * DDI or INTEL_OUTPUT_DISPLAYPORT for the older gens, so don't

		 * rewrite it.

		 */

		type = DRM_MODE_CONNECTOR_DisplayPort;

		intel_encoder->type = INTEL_OUTPUT_DISPLAYPORT;

	}



	drm_connector_init(dev, connector, &intel_dp_connector_funcs, type);
@@ -2869,30 +2866,18 @@ intel_dp_init(struct drm_device *dev, int output_reg, enum port port) 


	drm_encoder_init(dev, &intel_encoder->base, &intel_dp_enc_funcs,

			 DRM_MODE_ENCODER_TMDS);



	if (IS_HASWELL(dev)) {

		drm_encoder_helper_add(&intel_encoder->base,

				       &intel_dp_helper_funcs_hsw);



		intel_encoder->enable = intel_enable_ddi;

		intel_encoder->pre_enable = intel_ddi_pre_enable;

		intel_encoder->disable = intel_disable_ddi;

		intel_encoder->post_disable = intel_ddi_post_disable;

		intel_encoder->get_hw_state = intel_ddi_get_hw_state;

	} else {

		drm_encoder_helper_add(&intel_encoder->base,

				       &intel_dp_helper_funcs);

	drm_encoder_helper_add(&intel_encoder->base, &intel_dp_helper_funcs);



	intel_encoder->enable = intel_enable_dp;

	intel_encoder->pre_enable = intel_pre_enable_dp;

	intel_encoder->disable = intel_disable_dp;

	intel_encoder->post_disable = intel_post_disable_dp;

	intel_encoder->get_hw_state = intel_dp_get_hw_state;

	}



	intel_dig_port->port = port;

	intel_dig_port->dp.output_reg = output_reg;



	intel_encoder->type = INTEL_OUTPUT_DISPLAYPORT;

	intel_encoder->crtc_mask = (1 << 0) | (1 << 1) | (1 << 2);

	intel_encoder->cloneable = false;

	intel_encoder->hot_plug = intel_dp_hot_plug;

drivers/gpu/drm/i915/intel_drv.h

+13 −7
Original line number Diff line number Diff line
@@ -94,6 +94,7 @@ 
#define INTEL_OUTPUT_HDMI 6

#define INTEL_OUTPUT_DISPLAYPORT 7

#define INTEL_OUTPUT_EDP 8

#define INTEL_OUTPUT_UNKNOWN 9



#define INTEL_DVO_CHIP_NONE 0

#define INTEL_DVO_CHIP_LVDS 1
@@ -421,7 +422,12 @@ extern void intel_attach_broadcast_rgb_property(struct drm_connector *connector) 
extern void intel_crt_init(struct drm_device *dev);

extern void intel_hdmi_init(struct drm_device *dev,

			    int sdvox_reg, enum port port);

extern void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port,

				      struct intel_connector *intel_connector);

extern struct intel_hdmi *enc_to_intel_hdmi(struct drm_encoder *encoder);

extern bool intel_hdmi_mode_fixup(struct drm_encoder *encoder,

				  const struct drm_display_mode *mode,

				  struct drm_display_mode *adjusted_mode);

extern void intel_dip_infoframe_csum(struct dip_infoframe *avi_if);

extern bool intel_sdvo_init(struct drm_device *dev, uint32_t sdvo_reg,

			    bool is_sdvob);
@@ -434,6 +440,8 @@ extern void intel_mark_fb_idle(struct drm_i915_gem_object *obj); 
extern bool intel_lvds_init(struct drm_device *dev);

extern void intel_dp_init(struct drm_device *dev, int output_reg,

			  enum port port);

extern void intel_dp_init_connector(struct intel_digital_port *intel_dig_port,

				    struct intel_connector *intel_connector);

void

intel_dp_set_m_n(struct drm_crtc *crtc, struct drm_display_mode *mode,

		 struct drm_display_mode *adjusted_mode);
@@ -441,6 +449,11 @@ extern void intel_dp_init_link_config(struct intel_dp *intel_dp); 
extern void intel_dp_start_link_train(struct intel_dp *intel_dp);

extern void intel_dp_complete_link_train(struct intel_dp *intel_dp);

extern void intel_dp_sink_dpms(struct intel_dp *intel_dp, int mode);

extern void intel_dp_encoder_destroy(struct drm_encoder *encoder);

extern void intel_dp_check_link_status(struct intel_dp *intel_dp);

extern bool intel_dp_mode_fixup(struct drm_encoder *encoder,

				const struct drm_display_mode *mode,

				struct drm_display_mode *adjusted_mode);

extern bool intel_dpd_is_edp(struct drm_device *dev);

extern void ironlake_edp_backlight_on(struct intel_dp *intel_dp);

extern void ironlake_edp_backlight_off(struct intel_dp *intel_dp);
@@ -635,13 +648,8 @@ extern void intel_disable_gt_powersave(struct drm_device *dev); 
extern void gen6_gt_check_fifodbg(struct drm_i915_private *dev_priv);

extern void ironlake_teardown_rc6(struct drm_device *dev);



extern void intel_enable_ddi(struct intel_encoder *intel_encoder);

extern void intel_disable_ddi(struct intel_encoder *intel_encoder);

extern bool intel_ddi_get_hw_state(struct intel_encoder *encoder,

				   enum pipe *pipe);

extern void intel_ddi_mode_set(struct drm_encoder *encoder,

				struct drm_display_mode *mode,

				struct drm_display_mode *adjusted_mode);

extern int intel_ddi_get_cdclk_freq(struct drm_i915_private *dev_priv);

extern void intel_ddi_pll_init(struct drm_device *dev);

extern void intel_ddi_enable_pipe_func(struct drm_crtc *crtc);
@@ -651,8 +659,6 @@ extern void intel_ddi_enable_pipe_clock(struct intel_crtc *intel_crtc); 
extern void intel_ddi_disable_pipe_clock(struct intel_crtc *intel_crtc);

extern void intel_ddi_setup_hw_pll_state(struct drm_device *dev);

extern bool intel_ddi_pll_mode_set(struct drm_crtc *crtc, int clock);

extern void intel_ddi_pre_enable(struct intel_encoder *intel_encoder);

extern void intel_ddi_post_disable(struct intel_encoder *intel_encoder);

extern void intel_ddi_put_crtc_pll(struct drm_crtc *crtc);

extern void intel_ddi_set_pipe_settings(struct drm_crtc *crtc);

extern void intel_ddi_prepare_link_retrain(struct drm_encoder *encoder);

drivers/gpu/drm/i915/intel_hdmi.c

+10 −26
Original line number Diff line number Diff line
@@ -760,7 +760,7 @@ static int intel_hdmi_mode_valid(struct drm_connector *connector, 
	return MODE_OK;

}



static bool intel_hdmi_mode_fixup(struct drm_encoder *encoder,

bool intel_hdmi_mode_fixup(struct drm_encoder *encoder,

			   const struct drm_display_mode *mode,

			   struct drm_display_mode *adjusted_mode)

{
@@ -926,12 +926,6 @@ static void intel_hdmi_destroy(struct drm_connector *connector) 
	kfree(connector);

}



static const struct drm_encoder_helper_funcs intel_hdmi_helper_funcs_hsw = {

	.mode_fixup = intel_hdmi_mode_fixup,

	.mode_set = intel_ddi_mode_set,

	.disable = intel_encoder_noop,

};



static const struct drm_encoder_helper_funcs intel_hdmi_helper_funcs = {

	.mode_fixup = intel_hdmi_mode_fixup,

	.mode_set = intel_hdmi_mode_set,
@@ -963,7 +957,7 @@ intel_hdmi_add_properties(struct intel_hdmi *intel_hdmi, struct drm_connector *c 
	intel_attach_broadcast_rgb_property(connector);

}



static void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port,

void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port,

			       struct intel_connector *intel_connector)

{

	struct drm_connector *connector = &intel_connector->base;
@@ -1059,21 +1053,11 @@ void intel_hdmi_init(struct drm_device *dev, int sdvox_reg, enum port port) 


	drm_encoder_init(dev, &intel_encoder->base, &intel_hdmi_enc_funcs,

			 DRM_MODE_ENCODER_TMDS);

	if (IS_HASWELL(dev)) {

		intel_encoder->pre_enable = intel_ddi_pre_enable;

		intel_encoder->enable = intel_enable_ddi;

		intel_encoder->disable = intel_disable_ddi;

		intel_encoder->post_disable = intel_ddi_post_disable;

		intel_encoder->get_hw_state = intel_ddi_get_hw_state;

		drm_encoder_helper_add(&intel_encoder->base,

				       &intel_hdmi_helper_funcs_hsw);

	} else {

	drm_encoder_helper_add(&intel_encoder->base, &intel_hdmi_helper_funcs);



	intel_encoder->enable = intel_enable_hdmi;

	intel_encoder->disable = intel_disable_hdmi;

	intel_encoder->get_hw_state = intel_hdmi_get_hw_state;

		drm_encoder_helper_add(&intel_encoder->base,

				       &intel_hdmi_helper_funcs);

	}



	intel_encoder->type = INTEL_OUTPUT_HDMI;

	intel_encoder->crtc_mask = (1 << 0) | (1 << 1) | (1 << 2);