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

Commit 367e4408 authored by Patrik Jakobsson's avatar Patrik Jakobsson
Browse files

drm/gma500: Rename psb_intel_encoder to gma_encoder 



The psb_intel_encoder is generic and should be named appropriately

Signed-off-by: default avatarPatrik Jakobsson <patrik.r.jakobsson@gmail.com>
parent a3d5d75f

drivers/gpu/drm/gma500/cdv_intel_crt.c

+15 −16
Original line number Diff line number Diff line
@@ -196,10 +196,9 @@ static enum drm_connector_status cdv_intel_crt_detect( 


static void cdv_intel_crt_destroy(struct drm_connector *connector)

{

	struct psb_intel_encoder *psb_intel_encoder =

					gma_attached_encoder(connector);

	struct gma_encoder *gma_encoder = gma_attached_encoder(connector);



	psb_intel_i2c_destroy(psb_intel_encoder->ddc_bus);

	psb_intel_i2c_destroy(gma_encoder->ddc_bus);

	drm_sysfs_connector_remove(connector);

	drm_connector_cleanup(connector);

	kfree(connector);
@@ -207,9 +206,9 @@ static void cdv_intel_crt_destroy(struct drm_connector *connector) 


static int cdv_intel_crt_get_modes(struct drm_connector *connector)

{

	struct psb_intel_encoder *psb_intel_encoder =

				gma_attached_encoder(connector);

	return psb_intel_ddc_get_modes(connector, &psb_intel_encoder->ddc_bus->adapter);

	struct gma_encoder *gma_encoder = gma_attached_encoder(connector);

	return psb_intel_ddc_get_modes(connector,

				       &gma_encoder->ddc_bus->adapter);

}



static int cdv_intel_crt_set_property(struct drm_connector *connector,
@@ -260,14 +259,14 @@ void cdv_intel_crt_init(struct drm_device *dev, 
{



	struct gma_connector *gma_connector;

	struct psb_intel_encoder *psb_intel_encoder;

	struct gma_encoder *gma_encoder;

	struct drm_connector *connector;

	struct drm_encoder *encoder;



	u32 i2c_reg;



	psb_intel_encoder = kzalloc(sizeof(struct psb_intel_encoder), GFP_KERNEL);

	if (!psb_intel_encoder)

	gma_encoder = kzalloc(sizeof(struct gma_encoder), GFP_KERNEL);

	if (!gma_encoder)

		return;



	gma_connector = kzalloc(sizeof(struct gma_connector), GFP_KERNEL);
@@ -279,11 +278,11 @@ void cdv_intel_crt_init(struct drm_device *dev, 
	drm_connector_init(dev, connector,

		&cdv_intel_crt_connector_funcs, DRM_MODE_CONNECTOR_VGA);



	encoder = &psb_intel_encoder->base;

	encoder = &gma_encoder->base;

	drm_encoder_init(dev, encoder,

		&cdv_intel_crt_enc_funcs, DRM_MODE_ENCODER_DAC);



	gma_connector_attach_encoder(gma_connector, psb_intel_encoder);

	gma_connector_attach_encoder(gma_connector, gma_encoder);



	/* Set up the DDC bus. */

	i2c_reg = GPIOA;
@@ -292,15 +291,15 @@ void cdv_intel_crt_init(struct drm_device *dev, 
	if (dev_priv->crt_ddc_bus != 0)

		i2c_reg = dev_priv->crt_ddc_bus;

	}*/

	psb_intel_encoder->ddc_bus = psb_intel_i2c_create(dev,

	gma_encoder->ddc_bus = psb_intel_i2c_create(dev,

							  i2c_reg, "CRTDDC_A");

	if (!psb_intel_encoder->ddc_bus) {

	if (!gma_encoder->ddc_bus) {

		dev_printk(KERN_ERR, &dev->pdev->dev, "DDC bus registration "

			   "failed.\n");

		goto failed_ddc;

	}



	psb_intel_encoder->type = INTEL_OUTPUT_ANALOG;

	gma_encoder->type = INTEL_OUTPUT_ANALOG;

	/*

	psb_intel_output->clone_mask = (1 << INTEL_ANALOG_CLONE_BIT);

	psb_intel_output->crtc_mask = (1 << 0) | (1 << 1);
@@ -316,10 +315,10 @@ void cdv_intel_crt_init(struct drm_device *dev, 


	return;

failed_ddc:

	drm_encoder_cleanup(&psb_intel_encoder->base);

	drm_encoder_cleanup(&gma_encoder->base);

	drm_connector_cleanup(&gma_connector->base);

	kfree(gma_connector);

failed_connector:

	kfree(psb_intel_encoder);

	kfree(gma_encoder);

	return;

}

drivers/gpu/drm/gma500/cdv_intel_display.c

+5 −5
Original line number Diff line number Diff line
@@ -497,14 +497,14 @@ static bool is_pipeb_lvds(struct drm_device *dev, struct drm_crtc *crtc) 
		return false;



	list_for_each_entry(connector, &mode_config->connector_list, head) {

		struct psb_intel_encoder *psb_intel_encoder =

		struct gma_encoder *gma_encoder =

					gma_attached_encoder(connector);



		if (!connector->encoder

		    || connector->encoder->crtc != crtc)

			continue;



		if (psb_intel_encoder->type == INTEL_OUTPUT_LVDS)

		if (gma_encoder->type == INTEL_OUTPUT_LVDS)

			return true;

	}
@@ -632,15 +632,15 @@ static int cdv_intel_crtc_mode_set(struct drm_crtc *crtc, 
	bool is_edp = false;



	list_for_each_entry(connector, &mode_config->connector_list, head) {

		struct psb_intel_encoder *psb_intel_encoder =

		struct gma_encoder *gma_encoder =

					gma_attached_encoder(connector);



		if (!connector->encoder

		    || connector->encoder->crtc != crtc)

			continue;



		ddi_select = psb_intel_encoder->ddi_select;

		switch (psb_intel_encoder->type) {

		ddi_select = gma_encoder->ddi_select;

		switch (gma_encoder->type) {

		case INTEL_OUTPUT_LVDS:

			is_lvds = true;

			break;

drivers/gpu/drm/gma500/cdv_intel_dp.c

+64 −66
Original line number Diff line number Diff line
@@ -69,7 +69,7 @@ struct cdv_intel_dp { 
	uint8_t link_bw;

	uint8_t lane_count;

	uint8_t dpcd[4];

	struct psb_intel_encoder *encoder;

	struct gma_encoder *encoder;

	struct i2c_adapter adapter;

	struct i2c_algo_dp_aux_data algo;

	uint8_t	train_set[4];
@@ -115,18 +115,18 @@ static uint32_t dp_vswing_premph_table[] = { 
 * If a CPU or PCH DP output is attached to an eDP panel, this function

 * will return true, and false otherwise.

 */

static bool is_edp(struct psb_intel_encoder *encoder)

static bool is_edp(struct gma_encoder *encoder)

{

	return encoder->type == INTEL_OUTPUT_EDP;

}





static void cdv_intel_dp_start_link_train(struct psb_intel_encoder *encoder);

static void cdv_intel_dp_complete_link_train(struct psb_intel_encoder *encoder);

static void cdv_intel_dp_link_down(struct psb_intel_encoder *encoder);

static void cdv_intel_dp_start_link_train(struct gma_encoder *encoder);

static void cdv_intel_dp_complete_link_train(struct gma_encoder *encoder);

static void cdv_intel_dp_link_down(struct gma_encoder *encoder);



static int

cdv_intel_dp_max_lane_count(struct psb_intel_encoder *encoder)

cdv_intel_dp_max_lane_count(struct gma_encoder *encoder)

{

	struct cdv_intel_dp *intel_dp = encoder->dev_priv;

	int max_lane_count = 4;
@@ -144,7 +144,7 @@ cdv_intel_dp_max_lane_count(struct psb_intel_encoder *encoder) 
}



static int

cdv_intel_dp_max_link_bw(struct psb_intel_encoder *encoder)

cdv_intel_dp_max_link_bw(struct gma_encoder *encoder)

{

	struct cdv_intel_dp *intel_dp = encoder->dev_priv;

	int max_link_bw = intel_dp->dpcd[DP_MAX_LINK_RATE];
@@ -181,7 +181,7 @@ cdv_intel_dp_max_data_rate(int max_link_clock, int max_lanes) 
	return (max_link_clock * max_lanes * 19) / 20;

}



static void cdv_intel_edp_panel_vdd_on(struct psb_intel_encoder *intel_encoder)

static void cdv_intel_edp_panel_vdd_on(struct gma_encoder *intel_encoder)

{

	struct drm_device *dev = intel_encoder->base.dev;

	struct cdv_intel_dp *intel_dp = intel_encoder->dev_priv;
@@ -201,7 +201,7 @@ static void cdv_intel_edp_panel_vdd_on(struct psb_intel_encoder *intel_encoder) 
	msleep(intel_dp->panel_power_up_delay);

}



static void cdv_intel_edp_panel_vdd_off(struct psb_intel_encoder *intel_encoder)

static void cdv_intel_edp_panel_vdd_off(struct gma_encoder *intel_encoder)

{

	struct drm_device *dev = intel_encoder->base.dev;

	u32 pp;
@@ -216,7 +216,7 @@ static void cdv_intel_edp_panel_vdd_off(struct psb_intel_encoder *intel_encoder) 
}



/* Returns true if the panel was already on when called */

static bool cdv_intel_edp_panel_on(struct psb_intel_encoder *intel_encoder)

static bool cdv_intel_edp_panel_on(struct gma_encoder *intel_encoder)

{

	struct drm_device *dev = intel_encoder->base.dev;

	struct cdv_intel_dp *intel_dp = intel_encoder->dev_priv;
@@ -243,7 +243,7 @@ static bool cdv_intel_edp_panel_on(struct psb_intel_encoder *intel_encoder) 
	return false;

}



static void cdv_intel_edp_panel_off (struct psb_intel_encoder *intel_encoder)

static void cdv_intel_edp_panel_off (struct gma_encoder *intel_encoder)

{

	struct drm_device *dev = intel_encoder->base.dev;

	u32 pp, idle_off_mask = PP_ON ;
@@ -275,7 +275,7 @@ static void cdv_intel_edp_panel_off (struct psb_intel_encoder *intel_encoder) 
	DRM_DEBUG_KMS("Over\n");

}



static void cdv_intel_edp_backlight_on (struct psb_intel_encoder *intel_encoder)

static void cdv_intel_edp_backlight_on (struct gma_encoder *intel_encoder)

{

	struct drm_device *dev = intel_encoder->base.dev;

	u32 pp;
@@ -295,7 +295,7 @@ static void cdv_intel_edp_backlight_on (struct psb_intel_encoder *intel_encoder) 
	gma_backlight_enable(dev);

}



static void cdv_intel_edp_backlight_off (struct psb_intel_encoder *intel_encoder)

static void cdv_intel_edp_backlight_off (struct gma_encoder *intel_encoder)

{

	struct drm_device *dev = intel_encoder->base.dev;

	struct cdv_intel_dp *intel_dp = intel_encoder->dev_priv;
@@ -315,7 +315,7 @@ static int 
cdv_intel_dp_mode_valid(struct drm_connector *connector,

		    struct drm_display_mode *mode)

{

	struct psb_intel_encoder *encoder = gma_attached_encoder(connector);

	struct gma_encoder *encoder = gma_attached_encoder(connector);

	struct cdv_intel_dp *intel_dp = encoder->dev_priv;

	int max_link_clock = cdv_intel_dp_link_clock(cdv_intel_dp_max_link_bw(encoder));

	int max_lanes = cdv_intel_dp_max_lane_count(encoder);
@@ -371,7 +371,7 @@ unpack_aux(uint32_t src, uint8_t *dst, int dst_bytes) 
}



static int

cdv_intel_dp_aux_ch(struct psb_intel_encoder *encoder,

cdv_intel_dp_aux_ch(struct gma_encoder *encoder,

		uint8_t *send, int send_bytes,

		uint8_t *recv, int recv_size)

{
@@ -473,7 +473,7 @@ cdv_intel_dp_aux_ch(struct psb_intel_encoder *encoder, 


/* Write data to the aux channel in native mode */

static int

cdv_intel_dp_aux_native_write(struct psb_intel_encoder *encoder,

cdv_intel_dp_aux_native_write(struct gma_encoder *encoder,

			  uint16_t address, uint8_t *send, int send_bytes)

{

	int ret;
@@ -505,7 +505,7 @@ cdv_intel_dp_aux_native_write(struct psb_intel_encoder *encoder, 


/* Write a single byte to the aux channel in native mode */

static int

cdv_intel_dp_aux_native_write_1(struct psb_intel_encoder *encoder,

cdv_intel_dp_aux_native_write_1(struct gma_encoder *encoder,

			    uint16_t address, uint8_t byte)

{

	return cdv_intel_dp_aux_native_write(encoder, address, &byte, 1);
@@ -513,7 +513,7 @@ cdv_intel_dp_aux_native_write_1(struct psb_intel_encoder *encoder, 


/* read bytes from a native aux channel */

static int

cdv_intel_dp_aux_native_read(struct psb_intel_encoder *encoder,

cdv_intel_dp_aux_native_read(struct gma_encoder *encoder,

			 uint16_t address, uint8_t *recv, int recv_bytes)

{

	uint8_t msg[4];
@@ -558,7 +558,7 @@ cdv_intel_dp_i2c_aux_ch(struct i2c_adapter *adapter, int mode, 
	struct cdv_intel_dp *intel_dp = container_of(adapter,

						struct cdv_intel_dp,

						adapter);

	struct psb_intel_encoder *encoder = intel_dp->encoder;

	struct gma_encoder *encoder = intel_dp->encoder;

	uint16_t address = algo_data->address;

	uint8_t msg[5];

	uint8_t reply[2];
@@ -648,7 +648,8 @@ cdv_intel_dp_i2c_aux_ch(struct i2c_adapter *adapter, int mode, 
}



static int

cdv_intel_dp_i2c_init(struct gma_connector *connector, struct psb_intel_encoder *encoder, const char *name)

cdv_intel_dp_i2c_init(struct gma_connector *connector,

		      struct gma_encoder *encoder, const char *name)

{

	struct cdv_intel_dp *intel_dp = encoder->dev_priv;

	int ret;
@@ -699,7 +700,7 @@ cdv_intel_dp_mode_fixup(struct drm_encoder *encoder, const struct drm_display_mo 
		    struct drm_display_mode *adjusted_mode)

{

	struct drm_psb_private *dev_priv = encoder->dev->dev_private;

	struct psb_intel_encoder *intel_encoder = to_psb_intel_encoder(encoder);

	struct gma_encoder *intel_encoder = to_gma_encoder(encoder);

	struct cdv_intel_dp *intel_dp = intel_encoder->dev_priv;

	int lane_count, clock;

	int max_lane_count = cdv_intel_dp_max_lane_count(intel_encoder);
@@ -802,13 +803,13 @@ cdv_intel_dp_set_m_n(struct drm_crtc *crtc, struct drm_display_mode *mode, 
	 * Find the lane count in the intel_encoder private

	 */

	list_for_each_entry(encoder, &mode_config->encoder_list, head) {

		struct psb_intel_encoder *intel_encoder;

		struct gma_encoder *intel_encoder;

		struct cdv_intel_dp *intel_dp;



		if (encoder->crtc != crtc)

			continue;



		intel_encoder = to_psb_intel_encoder(encoder);

		intel_encoder = to_gma_encoder(encoder);

		intel_dp = intel_encoder->dev_priv;

		if (intel_encoder->type == INTEL_OUTPUT_DISPLAYPORT) {

			lane_count = intel_dp->lane_count;
@@ -842,7 +843,7 @@ static void 
cdv_intel_dp_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,

		  struct drm_display_mode *adjusted_mode)

{

	struct psb_intel_encoder *intel_encoder = to_psb_intel_encoder(encoder);

	struct gma_encoder *intel_encoder = to_gma_encoder(encoder);

	struct drm_crtc *crtc = encoder->crtc;

	struct gma_crtc *gma_crtc = to_gma_crtc(crtc);

	struct cdv_intel_dp *intel_dp = intel_encoder->dev_priv;
@@ -909,7 +910,7 @@ cdv_intel_dp_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode 




/* If the sink supports it, try to set the power state appropriately */

static void cdv_intel_dp_sink_dpms(struct psb_intel_encoder *encoder, int mode)

static void cdv_intel_dp_sink_dpms(struct gma_encoder *encoder, int mode)

{

	struct cdv_intel_dp *intel_dp = encoder->dev_priv;

	int ret, i;
@@ -941,7 +942,7 @@ static void cdv_intel_dp_sink_dpms(struct psb_intel_encoder *encoder, int mode) 


static void cdv_intel_dp_prepare(struct drm_encoder *encoder)

{

	struct psb_intel_encoder *intel_encoder = to_psb_intel_encoder(encoder);

	struct gma_encoder *intel_encoder = to_gma_encoder(encoder);

	int edp = is_edp(intel_encoder);



	if (edp) {
@@ -958,7 +959,7 @@ static void cdv_intel_dp_prepare(struct drm_encoder *encoder) 


static void cdv_intel_dp_commit(struct drm_encoder *encoder)

{

	struct psb_intel_encoder *intel_encoder = to_psb_intel_encoder(encoder);

	struct gma_encoder *intel_encoder = to_gma_encoder(encoder);

	int edp = is_edp(intel_encoder);



	if (edp)
@@ -972,7 +973,7 @@ static void cdv_intel_dp_commit(struct drm_encoder *encoder) 
static void

cdv_intel_dp_dpms(struct drm_encoder *encoder, int mode)

{

	struct psb_intel_encoder *intel_encoder = to_psb_intel_encoder(encoder);

	struct gma_encoder *intel_encoder = to_gma_encoder(encoder);

	struct cdv_intel_dp *intel_dp = intel_encoder->dev_priv;

	struct drm_device *dev = encoder->dev;

	uint32_t dp_reg = REG_READ(intel_dp->output_reg);
@@ -1007,7 +1008,7 @@ cdv_intel_dp_dpms(struct drm_encoder *encoder, int mode) 
 * cases where the sink may still be asleep.

 */

static bool

cdv_intel_dp_aux_native_read_retry(struct psb_intel_encoder *encoder, uint16_t address,

cdv_intel_dp_aux_native_read_retry(struct gma_encoder *encoder, uint16_t address,

			       uint8_t *recv, int recv_bytes)

{

	int ret, i;
@@ -1032,7 +1033,7 @@ cdv_intel_dp_aux_native_read_retry(struct psb_intel_encoder *encoder, uint16_t a 
 * link status information

 */

static bool

cdv_intel_dp_get_link_status(struct psb_intel_encoder *encoder)

cdv_intel_dp_get_link_status(struct gma_encoder *encoder)

{

	struct cdv_intel_dp *intel_dp = encoder->dev_priv;

	return cdv_intel_dp_aux_native_read_retry(encoder,
@@ -1106,7 +1107,7 @@ cdv_intel_dp_pre_emphasis_max(uint8_t voltage_swing) 
}

*/

static void

cdv_intel_get_adjust_train(struct psb_intel_encoder *encoder)

cdv_intel_get_adjust_train(struct gma_encoder *encoder)

{

	struct cdv_intel_dp *intel_dp = encoder->dev_priv;

	uint8_t v = 0;
@@ -1165,7 +1166,7 @@ cdv_intel_clock_recovery_ok(uint8_t link_status[DP_LINK_STATUS_SIZE], int lane_c 
			 DP_LANE_CHANNEL_EQ_DONE|\

			 DP_LANE_SYMBOL_LOCKED)

static bool

cdv_intel_channel_eq_ok(struct psb_intel_encoder *encoder)

cdv_intel_channel_eq_ok(struct gma_encoder *encoder)

{

	struct cdv_intel_dp *intel_dp = encoder->dev_priv;

	uint8_t lane_align;
@@ -1185,7 +1186,7 @@ cdv_intel_channel_eq_ok(struct psb_intel_encoder *encoder) 
}



static bool

cdv_intel_dp_set_link_train(struct psb_intel_encoder *encoder,

cdv_intel_dp_set_link_train(struct gma_encoder *encoder,

			uint32_t dp_reg_value,

			uint8_t dp_train_pat)

{
@@ -1212,7 +1213,7 @@ cdv_intel_dp_set_link_train(struct psb_intel_encoder *encoder, 




static bool

cdv_intel_dplink_set_level(struct psb_intel_encoder *encoder,

cdv_intel_dplink_set_level(struct gma_encoder *encoder,

			uint8_t dp_train_pat)

{
@@ -1233,7 +1234,7 @@ cdv_intel_dplink_set_level(struct psb_intel_encoder *encoder, 
}



static void

cdv_intel_dp_set_vswing_premph(struct psb_intel_encoder *encoder, uint8_t signal_level)

cdv_intel_dp_set_vswing_premph(struct gma_encoder *encoder, uint8_t signal_level)

{

	struct drm_device *dev = encoder->base.dev;

	struct cdv_intel_dp *intel_dp = encoder->dev_priv;
@@ -1299,7 +1300,7 @@ cdv_intel_dp_set_vswing_premph(struct psb_intel_encoder *encoder, uint8_t signal 


/* Enable corresponding port and start training pattern 1 */

static void

cdv_intel_dp_start_link_train(struct psb_intel_encoder *encoder)

cdv_intel_dp_start_link_train(struct gma_encoder *encoder)

{

	struct drm_device *dev = encoder->base.dev;

	struct cdv_intel_dp *intel_dp = encoder->dev_priv;
@@ -1393,7 +1394,7 @@ cdv_intel_dp_start_link_train(struct psb_intel_encoder *encoder) 
}



static void

cdv_intel_dp_complete_link_train(struct psb_intel_encoder *encoder)

cdv_intel_dp_complete_link_train(struct gma_encoder *encoder)

{

	struct drm_device *dev = encoder->base.dev;

	struct cdv_intel_dp *intel_dp = encoder->dev_priv;
@@ -1479,7 +1480,7 @@ cdv_intel_dp_complete_link_train(struct psb_intel_encoder *encoder) 
}



static void

cdv_intel_dp_link_down(struct psb_intel_encoder *encoder)

cdv_intel_dp_link_down(struct gma_encoder *encoder)

{

	struct drm_device *dev = encoder->base.dev;

	struct cdv_intel_dp *intel_dp = encoder->dev_priv;
@@ -1503,8 +1504,7 @@ cdv_intel_dp_link_down(struct psb_intel_encoder *encoder) 
	REG_READ(intel_dp->output_reg);

}



static enum drm_connector_status

cdv_dp_detect(struct psb_intel_encoder *encoder)

static enum drm_connector_status cdv_dp_detect(struct gma_encoder *encoder)

{

	struct cdv_intel_dp *intel_dp = encoder->dev_priv;

	enum drm_connector_status status;
@@ -1532,7 +1532,7 @@ cdv_dp_detect(struct psb_intel_encoder *encoder) 
static enum drm_connector_status

cdv_intel_dp_detect(struct drm_connector *connector, bool force)

{

	struct psb_intel_encoder *encoder = gma_attached_encoder(connector);

	struct gma_encoder *encoder = gma_attached_encoder(connector);

	struct cdv_intel_dp *intel_dp = encoder->dev_priv;

	enum drm_connector_status status;

	struct edid *edid = NULL;
@@ -1566,8 +1566,7 @@ cdv_intel_dp_detect(struct drm_connector *connector, bool force) 


static int cdv_intel_dp_get_modes(struct drm_connector *connector)

{

	struct psb_intel_encoder *intel_encoder =

						gma_attached_encoder(connector);

	struct gma_encoder *intel_encoder = gma_attached_encoder(connector);

	struct cdv_intel_dp *intel_dp = intel_encoder->dev_priv;

	struct edid *edid = NULL;

	int ret = 0;
@@ -1623,7 +1622,7 @@ static int cdv_intel_dp_get_modes(struct drm_connector *connector) 
static bool

cdv_intel_dp_detect_audio(struct drm_connector *connector)

{

	struct psb_intel_encoder *encoder = gma_attached_encoder(connector);

	struct gma_encoder *encoder = gma_attached_encoder(connector);

	struct cdv_intel_dp *intel_dp = encoder->dev_priv;

	struct edid *edid;

	bool has_audio = false;
@@ -1649,7 +1648,7 @@ cdv_intel_dp_set_property(struct drm_connector *connector, 
		      uint64_t val)

{

	struct drm_psb_private *dev_priv = connector->dev->dev_private;

	struct psb_intel_encoder *encoder = gma_attached_encoder(connector);

	struct gma_encoder *encoder = gma_attached_encoder(connector);

	struct cdv_intel_dp *intel_dp = encoder->dev_priv;

	int ret;
@@ -1702,11 +1701,10 @@ cdv_intel_dp_set_property(struct drm_connector *connector, 
static void

cdv_intel_dp_destroy(struct drm_connector *connector)

{

	struct psb_intel_encoder *psb_intel_encoder =

						gma_attached_encoder(connector);

	struct cdv_intel_dp *intel_dp = psb_intel_encoder->dev_priv;

	struct gma_encoder *gma_encoder = gma_attached_encoder(connector);

	struct cdv_intel_dp *intel_dp = gma_encoder->dev_priv;



	if (is_edp(psb_intel_encoder)) {

	if (is_edp(gma_encoder)) {

	/*	cdv_intel_panel_destroy_backlight(connector->dev); */

		if (intel_dp->panel_fixed_mode) {

			kfree(intel_dp->panel_fixed_mode);
@@ -1802,7 +1800,7 @@ static void cdv_disable_intel_clock_gating(struct drm_device *dev) 
void

cdv_intel_dp_init(struct drm_device *dev, struct psb_intel_mode_device *mode_dev, int output_reg)

{

	struct psb_intel_encoder *psb_intel_encoder;

	struct gma_encoder *gma_encoder;

	struct gma_connector *gma_connector;

	struct drm_connector *connector;

	struct drm_encoder *encoder;
@@ -1810,8 +1808,8 @@ cdv_intel_dp_init(struct drm_device *dev, struct psb_intel_mode_device *mode_dev 
	const char *name = NULL;

	int type = DRM_MODE_CONNECTOR_DisplayPort;



	psb_intel_encoder = kzalloc(sizeof(struct psb_intel_encoder), GFP_KERNEL);

	if (!psb_intel_encoder)

	gma_encoder = kzalloc(sizeof(struct gma_encoder), GFP_KERNEL);

	if (!gma_encoder)

		return;

        gma_connector = kzalloc(sizeof(struct gma_connector), GFP_KERNEL);

        if (!gma_connector)
@@ -1824,21 +1822,21 @@ cdv_intel_dp_init(struct drm_device *dev, struct psb_intel_mode_device *mode_dev 
		type = DRM_MODE_CONNECTOR_eDP;



	connector = &gma_connector->base;

	encoder = &psb_intel_encoder->base;

	encoder = &gma_encoder->base;



	drm_connector_init(dev, connector, &cdv_intel_dp_connector_funcs, type);

	drm_encoder_init(dev, encoder, &cdv_intel_dp_enc_funcs, DRM_MODE_ENCODER_TMDS);



	gma_connector_attach_encoder(gma_connector, psb_intel_encoder);

	gma_connector_attach_encoder(gma_connector, gma_encoder);



	if (type == DRM_MODE_CONNECTOR_DisplayPort)

        	psb_intel_encoder->type = INTEL_OUTPUT_DISPLAYPORT;

		gma_encoder->type = INTEL_OUTPUT_DISPLAYPORT;

        else

		psb_intel_encoder->type = INTEL_OUTPUT_EDP;

		gma_encoder->type = INTEL_OUTPUT_EDP;





	psb_intel_encoder->dev_priv=intel_dp;

	intel_dp->encoder = psb_intel_encoder;

	gma_encoder->dev_priv=intel_dp;

	intel_dp->encoder = gma_encoder;

	intel_dp->output_reg = output_reg;

	

	drm_encoder_helper_add(encoder, &cdv_intel_dp_helper_funcs);
@@ -1854,21 +1852,21 @@ cdv_intel_dp_init(struct drm_device *dev, struct psb_intel_mode_device *mode_dev 
	switch (output_reg) {

		case DP_B:

			name = "DPDDC-B";

			psb_intel_encoder->ddi_select = (DP_MASK | DDI0_SELECT);

			gma_encoder->ddi_select = (DP_MASK | DDI0_SELECT);

			break;

		case DP_C:

			name = "DPDDC-C";

			psb_intel_encoder->ddi_select = (DP_MASK | DDI1_SELECT);

			gma_encoder->ddi_select = (DP_MASK | DDI1_SELECT);

			break;

	}



	cdv_disable_intel_clock_gating(dev);



	cdv_intel_dp_i2c_init(gma_connector, psb_intel_encoder, name);

	cdv_intel_dp_i2c_init(gma_connector, gma_encoder, name);

        /* FIXME:fail check */

	cdv_intel_dp_add_properties(connector);



	if (is_edp(psb_intel_encoder)) {

	if (is_edp(gma_encoder)) {

		int ret;

		struct edp_power_seq cur;

                u32 pp_on, pp_off, pp_div;
@@ -1922,11 +1920,11 @@ cdv_intel_dp_init(struct drm_device *dev, struct psb_intel_mode_device *mode_dev 
                              intel_dp->backlight_on_delay, intel_dp->backlight_off_delay);





		cdv_intel_edp_panel_vdd_on(psb_intel_encoder);

		ret = cdv_intel_dp_aux_native_read(psb_intel_encoder, DP_DPCD_REV,

		cdv_intel_edp_panel_vdd_on(gma_encoder);

		ret = cdv_intel_dp_aux_native_read(gma_encoder, DP_DPCD_REV,

					       intel_dp->dpcd,

					       sizeof(intel_dp->dpcd));

		cdv_intel_edp_panel_vdd_off(psb_intel_encoder);

		cdv_intel_edp_panel_vdd_off(gma_encoder);

		if (ret == 0) {

			/* if this fails, presume the device is a ghost */

			DRM_INFO("failed to retrieve link info, disabling eDP\n");
@@ -1949,5 +1947,5 @@ cdv_intel_dp_init(struct drm_device *dev, struct psb_intel_mode_device *mode_dev 
err_priv:

	kfree(gma_connector);

err_connector:

	kfree(psb_intel_encoder);

	kfree(gma_encoder);

}

drivers/gpu/drm/gma500/cdv_intel_hdmi.c

+29 −37
Original line number Diff line number Diff line
@@ -64,8 +64,8 @@ static void cdv_hdmi_mode_set(struct drm_encoder *encoder, 
			struct drm_display_mode *adjusted_mode)

{

	struct drm_device *dev = encoder->dev;

	struct psb_intel_encoder *psb_intel_encoder = to_psb_intel_encoder(encoder);

	struct mid_intel_hdmi_priv *hdmi_priv = psb_intel_encoder->dev_priv;

	struct gma_encoder *gma_encoder = to_gma_encoder(encoder);

	struct mid_intel_hdmi_priv *hdmi_priv = gma_encoder->dev_priv;

	u32 hdmib;

	struct drm_crtc *crtc = encoder->crtc;

	struct gma_crtc *gma_crtc = to_gma_crtc(crtc);
@@ -99,9 +99,8 @@ static bool cdv_hdmi_mode_fixup(struct drm_encoder *encoder, 
static void cdv_hdmi_dpms(struct drm_encoder *encoder, int mode)

{

	struct drm_device *dev = encoder->dev;

	struct psb_intel_encoder *psb_intel_encoder =

						to_psb_intel_encoder(encoder);

	struct mid_intel_hdmi_priv *hdmi_priv = psb_intel_encoder->dev_priv;

	struct gma_encoder *gma_encoder = to_gma_encoder(encoder);

	struct mid_intel_hdmi_priv *hdmi_priv = gma_encoder->dev_priv;

	u32 hdmib;



	hdmib = REG_READ(hdmi_priv->hdmi_reg);
@@ -116,9 +115,8 @@ static void cdv_hdmi_dpms(struct drm_encoder *encoder, int mode) 
static void cdv_hdmi_save(struct drm_connector *connector)

{

	struct drm_device *dev = connector->dev;

	struct psb_intel_encoder *psb_intel_encoder =

						gma_attached_encoder(connector);

	struct mid_intel_hdmi_priv *hdmi_priv = psb_intel_encoder->dev_priv;

	struct gma_encoder *gma_encoder = gma_attached_encoder(connector);

	struct mid_intel_hdmi_priv *hdmi_priv = gma_encoder->dev_priv;



	hdmi_priv->save_HDMIB = REG_READ(hdmi_priv->hdmi_reg);

}
@@ -126,9 +124,8 @@ static void cdv_hdmi_save(struct drm_connector *connector) 
static void cdv_hdmi_restore(struct drm_connector *connector)

{

	struct drm_device *dev = connector->dev;

	struct psb_intel_encoder *psb_intel_encoder =

						gma_attached_encoder(connector);

	struct mid_intel_hdmi_priv *hdmi_priv = psb_intel_encoder->dev_priv;

	struct gma_encoder *gma_encoder = gma_attached_encoder(connector);

	struct mid_intel_hdmi_priv *hdmi_priv = gma_encoder->dev_priv;



	REG_WRITE(hdmi_priv->hdmi_reg, hdmi_priv->save_HDMIB);

	REG_READ(hdmi_priv->hdmi_reg);
@@ -137,13 +134,12 @@ static void cdv_hdmi_restore(struct drm_connector *connector) 
static enum drm_connector_status cdv_hdmi_detect(

				struct drm_connector *connector, bool force)

{

	struct psb_intel_encoder *psb_intel_encoder =

						gma_attached_encoder(connector);

	struct mid_intel_hdmi_priv *hdmi_priv = psb_intel_encoder->dev_priv;

	struct gma_encoder *gma_encoder = gma_attached_encoder(connector);

	struct mid_intel_hdmi_priv *hdmi_priv = gma_encoder->dev_priv;

	struct edid *edid = NULL;

	enum drm_connector_status status = connector_status_disconnected;



	edid = drm_get_edid(connector, &psb_intel_encoder->i2c_bus->adapter);

	edid = drm_get_edid(connector, &gma_encoder->i2c_bus->adapter);



	hdmi_priv->has_hdmi_sink = false;

	hdmi_priv->has_hdmi_audio = false;
@@ -221,12 +217,11 @@ static int cdv_hdmi_set_property(struct drm_connector *connector, 
 */

static int cdv_hdmi_get_modes(struct drm_connector *connector)

{

	struct psb_intel_encoder *psb_intel_encoder =

						gma_attached_encoder(connector);

	struct gma_encoder *gma_encoder = gma_attached_encoder(connector);

	struct edid *edid = NULL;

	int ret = 0;



	edid = drm_get_edid(connector, &psb_intel_encoder->i2c_bus->adapter);

	edid = drm_get_edid(connector, &gma_encoder->i2c_bus->adapter);

	if (edid) {

		drm_mode_connector_update_edid_property(connector, edid);

		ret = drm_add_edid_modes(connector, edid);
@@ -256,11 +251,10 @@ static int cdv_hdmi_mode_valid(struct drm_connector *connector, 


static void cdv_hdmi_destroy(struct drm_connector *connector)

{

	struct psb_intel_encoder *psb_intel_encoder =

						gma_attached_encoder(connector);

	struct gma_encoder *gma_encoder = gma_attached_encoder(connector);



	if (psb_intel_encoder->i2c_bus)

		psb_intel_i2c_destroy(psb_intel_encoder->i2c_bus);

	if (gma_encoder->i2c_bus)

		psb_intel_i2c_destroy(gma_encoder->i2c_bus);

	drm_sysfs_connector_remove(connector);

	drm_connector_cleanup(connector);

	kfree(connector);
@@ -294,17 +288,16 @@ static const struct drm_connector_funcs cdv_hdmi_connector_funcs = { 
void cdv_hdmi_init(struct drm_device *dev,

			struct psb_intel_mode_device *mode_dev, int reg)

{

	struct psb_intel_encoder *psb_intel_encoder;

	struct gma_encoder *gma_encoder;

	struct gma_connector *gma_connector;

	struct drm_connector *connector;

	struct drm_encoder *encoder;

	struct mid_intel_hdmi_priv *hdmi_priv;

	int ddc_bus;



	psb_intel_encoder = kzalloc(sizeof(struct psb_intel_encoder),

				    GFP_KERNEL);

	gma_encoder = kzalloc(sizeof(struct gma_encoder), GFP_KERNEL);



	if (!psb_intel_encoder)

	if (!gma_encoder)

		return;



	gma_connector = kzalloc(sizeof(struct gma_connector),
@@ -320,7 +313,7 @@ void cdv_hdmi_init(struct drm_device *dev, 


	connector = &gma_connector->base;

	connector->polled = DRM_CONNECTOR_POLL_HPD;

	encoder = &psb_intel_encoder->base;

	encoder = &gma_encoder->base;

	drm_connector_init(dev, connector,

			   &cdv_hdmi_connector_funcs,

			   DRM_MODE_CONNECTOR_DVID);
@@ -328,11 +321,11 @@ void cdv_hdmi_init(struct drm_device *dev, 
	drm_encoder_init(dev, encoder, &psb_intel_lvds_enc_funcs,

			 DRM_MODE_ENCODER_TMDS);



	gma_connector_attach_encoder(gma_connector, psb_intel_encoder);

	psb_intel_encoder->type = INTEL_OUTPUT_HDMI;

	gma_connector_attach_encoder(gma_connector, gma_encoder);

	gma_encoder->type = INTEL_OUTPUT_HDMI;

	hdmi_priv->hdmi_reg = reg;

	hdmi_priv->has_hdmi_sink = false;

	psb_intel_encoder->dev_priv = hdmi_priv;

	gma_encoder->dev_priv = hdmi_priv;



	drm_encoder_helper_add(encoder, &cdv_hdmi_helper_funcs);

	drm_connector_helper_add(connector,
@@ -348,11 +341,11 @@ void cdv_hdmi_init(struct drm_device *dev, 
	switch (reg) {

	case SDVOB:

		ddc_bus = GPIOE;

		psb_intel_encoder->ddi_select = DDI0_SELECT;

		gma_encoder->ddi_select = DDI0_SELECT;

		break;

	case SDVOC:

		ddc_bus = GPIOD;

		psb_intel_encoder->ddi_select = DDI1_SELECT;

		gma_encoder->ddi_select = DDI1_SELECT;

		break;

	default:

		DRM_ERROR("unknown reg 0x%x for HDMI\n", reg);
@@ -360,16 +353,15 @@ void cdv_hdmi_init(struct drm_device *dev, 
		break;

	}



	psb_intel_encoder->i2c_bus = psb_intel_i2c_create(dev,

	gma_encoder->i2c_bus = psb_intel_i2c_create(dev,

				ddc_bus, (reg == SDVOB) ? "HDMIB" : "HDMIC");



	if (!psb_intel_encoder->i2c_bus) {

	if (!gma_encoder->i2c_bus) {

		dev_err(dev->dev, "No ddc adapter available!\n");

		goto failed_ddc;

	}



	hdmi_priv->hdmi_i2c_adapter =

				&(psb_intel_encoder->i2c_bus->adapter);

	hdmi_priv->hdmi_i2c_adapter = &(gma_encoder->i2c_bus->adapter);

	hdmi_priv->dev = dev;

	drm_sysfs_connector_add(connector);

	return;
@@ -380,5 +372,5 @@ void cdv_hdmi_init(struct drm_device *dev, 
err_priv:

	kfree(gma_connector);

err_connector:

	kfree(psb_intel_encoder);

	kfree(gma_encoder);

}

drivers/gpu/drm/gma500/cdv_intel_lvds.c

+24 −26

File changed.

Preview size limit exceeded, changes collapsed.