drm/gma500: Remove dead code (871c6015) · Commits · 戴 / test

drivers/gpu/drm/gma500/cdv_intel_dp.c

+1 −30

Original line number	Diff line number	Diff line
		@@ -1272,37 +1272,8 @@ cdv_intel_get_adjust_request_pre_emphasis(uint8_t link_status[DP_LINK_STATUS_SIZ
		return ((l >> s) & 3) << DP_TRAIN_PRE_EMPHASIS_SHIFT;
		}


		#if 0
		static char *voltage_names[] = {
		"0.4V", "0.6V", "0.8V", "1.2V"
		};
		static char *pre_emph_names[] = {
		"0dB", "3.5dB", "6dB", "9.5dB"
		};
		static char *link_train_names[] = {
		"pattern 1", "pattern 2", "idle", "off"
		};
		#endif

		#define CDV_DP_VOLTAGE_MAX DP_TRAIN_VOLTAGE_SWING_LEVEL_3
		/*
		static uint8_t
		cdv_intel_dp_pre_emphasis_max(uint8_t voltage_swing)
		{
		switch (voltage_swing & DP_TRAIN_VOLTAGE_SWING_MASK) {
		case DP_TRAIN_VOLTAGE_SWING_400:
		return DP_TRAIN_PRE_EMPHASIS_6;
		case DP_TRAIN_VOLTAGE_SWING_600:
		return DP_TRAIN_PRE_EMPHASIS_6;
		case DP_TRAIN_VOLTAGE_SWING_800:
		return DP_TRAIN_PRE_EMPHASIS_3_5;
		case DP_TRAIN_VOLTAGE_SWING_1200:
		default:
		return DP_TRAIN_PRE_EMPHASIS_0;
		}
		}
		*/

		static void
		cdv_intel_get_adjust_train(struct gma_encoder *encoder)
		{

drivers/gpu/drm/gma500/cdv_intel_lvds.c

+0 −83

Original line number	Diff line number	Diff line
		@@ -74,89 +74,6 @@ static u32 cdv_intel_lvds_get_max_backlight(struct drm_device *dev)
		return retval;
		}

		#if 0
		/*
		* Set LVDS backlight level by I2C command
		*/
		static int cdv_lvds_i2c_set_brightness(struct drm_device *dev,
		unsigned int level)
		{
		struct drm_psb_private *dev_priv = dev->dev_private;
		struct psb_intel_i2c_chan *lvds_i2c_bus = dev_priv->lvds_i2c_bus;
		u8 out_buf[2];
		unsigned int blc_i2c_brightness;

		struct i2c_msg msgs[] = {
		{
		.addr = lvds_i2c_bus->slave_addr,
		.flags = 0,
		.len = 2,
		.buf = out_buf,
		}
		};

		blc_i2c_brightness = BRIGHTNESS_MASK & ((unsigned int)level *
		BRIGHTNESS_MASK /
		BRIGHTNESS_MAX_LEVEL);

		if (dev_priv->lvds_bl->pol == BLC_POLARITY_INVERSE)
		blc_i2c_brightness = BRIGHTNESS_MASK - blc_i2c_brightness;

		out_buf[0] = dev_priv->lvds_bl->brightnesscmd;
		out_buf[1] = (u8)blc_i2c_brightness;

		if (i2c_transfer(&lvds_i2c_bus->adapter, msgs, 1) == 1)
		return 0;

		DRM_ERROR("I2C transfer error\n");
		return -1;
		}


		static int cdv_lvds_pwm_set_brightness(struct drm_device *dev, int level)
		{
		struct drm_psb_private *dev_priv = dev->dev_private;

		u32 max_pwm_blc;
		u32 blc_pwm_duty_cycle;

		max_pwm_blc = cdv_intel_lvds_get_max_backlight(dev);

		/BLC_PWM_CTL Should be initiated while backlight device init/
		BUG_ON((max_pwm_blc & PSB_BLC_MAX_PWM_REG_FREQ) == 0);

		blc_pwm_duty_cycle = level * max_pwm_blc / BRIGHTNESS_MAX_LEVEL;

		if (dev_priv->lvds_bl->pol == BLC_POLARITY_INVERSE)
		blc_pwm_duty_cycle = max_pwm_blc - blc_pwm_duty_cycle;

		blc_pwm_duty_cycle &= PSB_BACKLIGHT_PWM_POLARITY_BIT_CLEAR;
		REG_WRITE(BLC_PWM_CTL,
		(max_pwm_blc << PSB_BACKLIGHT_PWM_CTL_SHIFT) \|
		(blc_pwm_duty_cycle));

		return 0;
		}

		/*
		* Set LVDS backlight level either by I2C or PWM
		*/
		void cdv_intel_lvds_set_brightness(struct drm_device *dev, int level)
		{
		struct drm_psb_private *dev_priv = dev->dev_private;

		if (!dev_priv->lvds_bl) {
		DRM_ERROR("NO LVDS Backlight Info\n");
		return;
		}

		if (dev_priv->lvds_bl->type == BLC_I2C_TYPE)
		cdv_lvds_i2c_set_brightness(dev, level);
		else
		cdv_lvds_pwm_set_brightness(dev, level);
		}
		#endif

		/**
		* Sets the backlight level.
		*

drivers/gpu/drm/gma500/mdfld_intel_display.c

+0 −31

Original line number	Diff line number	Diff line
		@@ -658,16 +658,6 @@ static int mdfld_crtc_mode_set(struct drm_crtc *crtc,

		dev_dbg(dev->dev, "pipe = 0x%x\n", pipe);

		#if 0
		if (pipe == 1) {
		if (!gma_power_begin(dev, true))
		return 0;
		android_hdmi_crtc_mode_set(crtc, mode, adjusted_mode,
		x, y, old_fb);
		goto mrst_crtc_mode_set_exit;
		}
		#endif

		ret = check_fb(crtc->primary->fb);
		if (ret)
		return ret;
		@@ -918,14 +908,6 @@ static int mdfld_crtc_mode_set(struct drm_crtc *crtc,
		}
		dpll = 0;

		#if 0 /* FIXME revisit later */
		if (ksel == KSEL_CRYSTAL_19 \|\| ksel == KSEL_BYPASS_19 \|\|
		ksel == KSEL_BYPASS_25)
		dpll &= ~MDFLD_INPUT_REF_SEL;
		else if (ksel == KSEL_BYPASS_83_100)
		dpll \|= MDFLD_INPUT_REF_SEL;
		#endif /* FIXME revisit later */

		if (is_hdmi)
		dpll \|= MDFLD_VCO_SEL;

		@@ -935,20 +917,7 @@ static int mdfld_crtc_mode_set(struct drm_crtc *crtc,
		/* compute bitmask from p1 value */
		dpll \|= (1 << (clock.p1 - 2)) << 17;

		#if 0 /* 1080p30 & 720p */
		dpll = 0x00050000;
		fp = 0x000001be;
		#endif
		#if 0 /* 480p */
		dpll = 0x02010000;
		fp = 0x000000d2;
		#endif
		} else {
		#if 0 /DBI_TPO_480x864/
		dpll = 0x00020000;
		fp = 0x00000156;
		#endif /* DBI_TPO_480x864 / / get from spec. */

		dpll = 0x00800000;
		fp = 0x000000c1;
		}

drivers/gpu/drm/gma500/psb_intel_sdvo.c

+0 −99

Original line number	Diff line number	Diff line
		@@ -864,36 +864,6 @@ static bool psb_intel_sdvo_set_avi_infoframe(struct psb_intel_sdvo *psb_intel_sd
		DRM_INFO("HDMI is not supported yet");

		return false;
		#if 0
		struct dip_infoframe avi_if = {
		.type = DIP_TYPE_AVI,
		.ver = DIP_VERSION_AVI,
		.len = DIP_LEN_AVI,
		};
		uint8_t tx_rate = SDVO_HBUF_TX_VSYNC;
		uint8_t set_buf_index[2] = { 1, 0 };
		uint64_t data = (uint64_t )&avi_if;
		unsigned i;

		intel_dip_infoframe_csum(&avi_if);

		if (!psb_intel_sdvo_set_value(psb_intel_sdvo,
		SDVO_CMD_SET_HBUF_INDEX,
		set_buf_index, 2))
		return false;

		for (i = 0; i < sizeof(avi_if); i += 8) {
		if (!psb_intel_sdvo_set_value(psb_intel_sdvo,
		SDVO_CMD_SET_HBUF_DATA,
		data, 8))
		return false;
		data++;
		}

		return psb_intel_sdvo_set_value(psb_intel_sdvo,
		SDVO_CMD_SET_HBUF_TXRATE,
		&tx_rate, 1);
		#endif
		}

		static bool psb_intel_sdvo_set_tv_format(struct psb_intel_sdvo *psb_intel_sdvo)
		@@ -1227,75 +1197,6 @@ static bool psb_intel_sdvo_get_capabilities(struct psb_intel_sdvo *psb_intel_sdv
		return true;
		}

		/* No use! */
		#if 0
		struct drm_connector* psb_intel_sdvo_find(struct drm_device *dev, int sdvoB)
		{
		struct drm_connector *connector = NULL;
		struct psb_intel_sdvo *iout = NULL;
		struct psb_intel_sdvo *sdvo;

		/* find the sdvo connector */
		list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		iout = to_psb_intel_sdvo(connector);

		if (iout->type != INTEL_OUTPUT_SDVO)
		continue;

		sdvo = iout->dev_priv;

		if (sdvo->sdvo_reg == SDVOB && sdvoB)
		return connector;

		if (sdvo->sdvo_reg == SDVOC && !sdvoB)
		return connector;

		}

		return NULL;
		}

		int psb_intel_sdvo_supports_hotplug(struct drm_connector *connector)
		{
		u8 response[2];
		u8 status;
		struct psb_intel_sdvo *psb_intel_sdvo;
		DRM_DEBUG_KMS("\n");

		if (!connector)
		return 0;

		psb_intel_sdvo = to_psb_intel_sdvo(connector);

		return psb_intel_sdvo_get_value(psb_intel_sdvo, SDVO_CMD_GET_HOT_PLUG_SUPPORT,
		&response, 2) && response[0];
		}

		void psb_intel_sdvo_set_hotplug(struct drm_connector *connector, int on)
		{
		u8 response[2];
		u8 status;
		struct psb_intel_sdvo *psb_intel_sdvo = to_psb_intel_sdvo(connector);

		psb_intel_sdvo_write_cmd(psb_intel_sdvo, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0);
		psb_intel_sdvo_read_response(psb_intel_sdvo, &response, 2);

		if (on) {
		psb_intel_sdvo_write_cmd(psb_intel_sdvo, SDVO_CMD_GET_HOT_PLUG_SUPPORT, NULL, 0);
		status = psb_intel_sdvo_read_response(psb_intel_sdvo, &response, 2);

		psb_intel_sdvo_write_cmd(psb_intel_sdvo, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2);
		} else {
		response[0] = 0;
		response[1] = 0;
		psb_intel_sdvo_write_cmd(psb_intel_sdvo, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2);
		}

		psb_intel_sdvo_write_cmd(psb_intel_sdvo, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0);
		psb_intel_sdvo_read_response(psb_intel_sdvo, &response, 2);
		}
		#endif

		static bool
		psb_intel_sdvo_multifunc_encoder(struct psb_intel_sdvo *psb_intel_sdvo)
		{

Admin message