drm/i915: Remove dead KMS encoder save/restore code.
Eric Anholt [Fri, 2 Apr 2010 22:24:27 +0000 (15:24 -0700)]
This was brought over from UMS, and used for a while until we decided
that drm_helper_resume_force_mode was easier and more reliable, since
it didn't require duplicating all the code deleted here.  We just
forgot to delete all that junk for a while.

12 files changed:
drivers/gpu/drm/i915/dvo.h
drivers/gpu/drm/i915/dvo_ch7017.c
drivers/gpu/drm/i915/dvo_ch7xxx.c
drivers/gpu/drm/i915/dvo_ivch.c
drivers/gpu/drm/i915/dvo_sil164.c
drivers/gpu/drm/i915/dvo_tfp410.c
drivers/gpu/drm/i915/intel_dp.c
drivers/gpu/drm/i915/intel_dvo.c
drivers/gpu/drm/i915/intel_hdmi.c
drivers/gpu/drm/i915/intel_lvds.c
drivers/gpu/drm/i915/intel_sdvo.c
drivers/gpu/drm/i915/intel_tv.c

index 288fc50..0d6ff64 100644 (file)
@@ -70,16 +70,6 @@ struct intel_dvo_dev_ops {
        void (*dpms)(struct intel_dvo_device *dvo, int mode);
 
        /*
-        * Saves the output's state for restoration on VT switch.
-        */
-       void (*save)(struct intel_dvo_device *dvo);
-
-       /*
-        * Restore's the output's state at VT switch.
-        */
-       void (*restore)(struct intel_dvo_device *dvo);
-
-       /*
         * Callback for testing a video mode for a given output.
         *
         * This function should only check for cases where a mode can't
index 1184c14..14d5980 100644 (file)
 #define CH7017_BANG_LIMIT_CONTROL      0x7f
 
 struct ch7017_priv {
-       uint8_t save_hapi;
-       uint8_t save_vali;
-       uint8_t save_valo;
-       uint8_t save_ailo;
-       uint8_t save_lvds_pll_vco;
-       uint8_t save_feedback_div;
-       uint8_t save_lvds_control_2;
-       uint8_t save_outputs_enable;
-       uint8_t save_lvds_power_down;
-       uint8_t save_power_management;
+       uint8_t dummy;
 };
 
 static void ch7017_dump_regs(struct intel_dvo_device *dvo);
@@ -401,39 +392,6 @@ do {                                                       \
        DUMP(CH7017_LVDS_POWER_DOWN);
 }
 
-static void ch7017_save(struct intel_dvo_device *dvo)
-{
-       struct ch7017_priv *priv = dvo->dev_priv;
-
-       ch7017_read(dvo, CH7017_HORIZONTAL_ACTIVE_PIXEL_INPUT, &priv->save_hapi);
-       ch7017_read(dvo, CH7017_VERTICAL_ACTIVE_LINE_OUTPUT, &priv->save_valo);
-       ch7017_read(dvo, CH7017_ACTIVE_INPUT_LINE_OUTPUT, &priv->save_ailo);
-       ch7017_read(dvo, CH7017_LVDS_PLL_VCO_CONTROL, &priv->save_lvds_pll_vco);
-       ch7017_read(dvo, CH7017_LVDS_PLL_FEEDBACK_DIV, &priv->save_feedback_div);
-       ch7017_read(dvo, CH7017_LVDS_CONTROL_2, &priv->save_lvds_control_2);
-       ch7017_read(dvo, CH7017_OUTPUTS_ENABLE, &priv->save_outputs_enable);
-       ch7017_read(dvo, CH7017_LVDS_POWER_DOWN, &priv->save_lvds_power_down);
-       ch7017_read(dvo, CH7017_POWER_MANAGEMENT, &priv->save_power_management);
-}
-
-static void ch7017_restore(struct intel_dvo_device *dvo)
-{
-       struct ch7017_priv *priv = dvo->dev_priv;
-
-       /* Power down before changing mode */
-       ch7017_dpms(dvo, DRM_MODE_DPMS_OFF);
-
-       ch7017_write(dvo, CH7017_HORIZONTAL_ACTIVE_PIXEL_INPUT, priv->save_hapi);
-       ch7017_write(dvo, CH7017_VERTICAL_ACTIVE_LINE_OUTPUT, priv->save_valo);
-       ch7017_write(dvo, CH7017_ACTIVE_INPUT_LINE_OUTPUT, priv->save_ailo);
-       ch7017_write(dvo, CH7017_LVDS_PLL_VCO_CONTROL, priv->save_lvds_pll_vco);
-       ch7017_write(dvo, CH7017_LVDS_PLL_FEEDBACK_DIV, priv->save_feedback_div);
-       ch7017_write(dvo, CH7017_LVDS_CONTROL_2, priv->save_lvds_control_2);
-       ch7017_write(dvo, CH7017_OUTPUTS_ENABLE, priv->save_outputs_enable);
-       ch7017_write(dvo, CH7017_LVDS_POWER_DOWN, priv->save_lvds_power_down);
-       ch7017_write(dvo, CH7017_POWER_MANAGEMENT, priv->save_power_management);
-}
-
 static void ch7017_destroy(struct intel_dvo_device *dvo)
 {
        struct ch7017_priv *priv = dvo->dev_priv;
@@ -451,7 +409,5 @@ struct intel_dvo_dev_ops ch7017_ops = {
        .mode_set = ch7017_mode_set,
        .dpms = ch7017_dpms,
        .dump_regs = ch7017_dump_regs,
-       .save = ch7017_save,
-       .restore = ch7017_restore,
        .destroy = ch7017_destroy,
 };
index d56ff5c..6f1944b 100644 (file)
@@ -92,21 +92,10 @@ static struct ch7xxx_id_struct {
        { CH7301_VID, "CH7301" },
 };
 
-struct ch7xxx_reg_state {
-    uint8_t regs[CH7xxx_NUM_REGS];
-};
-
 struct ch7xxx_priv {
        bool quiet;
-
-       struct ch7xxx_reg_state save_reg;
-       struct ch7xxx_reg_state mode_reg;
-       uint8_t save_TCTL, save_TPCP, save_TPD, save_TPVT;
-       uint8_t save_TLPF, save_TCT, save_PM, save_IDF;
 };
 
-static void ch7xxx_save(struct intel_dvo_device *dvo);
-
 static char *ch7xxx_get_id(uint8_t vid)
 {
        int i;
@@ -312,42 +301,17 @@ static void ch7xxx_dpms(struct intel_dvo_device *dvo, int mode)
 
 static void ch7xxx_dump_regs(struct intel_dvo_device *dvo)
 {
-       struct ch7xxx_priv *ch7xxx = dvo->dev_priv;
        int i;
 
        for (i = 0; i < CH7xxx_NUM_REGS; i++) {
+               uint8_t val;
                if ((i % 8) == 0 )
                        DRM_LOG_KMS("\n %02X: ", i);
-               DRM_LOG_KMS("%02X ", ch7xxx->mode_reg.regs[i]);
+               ch7xxx_readb(dvo, i, &val);
+               DRM_LOG_KMS("%02X ", val);
        }
 }
 
-static void ch7xxx_save(struct intel_dvo_device *dvo)
-{
-       struct ch7xxx_priv *ch7xxx= dvo->dev_priv;
-
-       ch7xxx_readb(dvo, CH7xxx_TCTL, &ch7xxx->save_TCTL);
-       ch7xxx_readb(dvo, CH7xxx_TPCP, &ch7xxx->save_TPCP);
-       ch7xxx_readb(dvo, CH7xxx_TPD, &ch7xxx->save_TPD);
-       ch7xxx_readb(dvo, CH7xxx_TPVT, &ch7xxx->save_TPVT);
-       ch7xxx_readb(dvo, CH7xxx_TLPF, &ch7xxx->save_TLPF);
-       ch7xxx_readb(dvo, CH7xxx_PM, &ch7xxx->save_PM);
-       ch7xxx_readb(dvo, CH7xxx_IDF, &ch7xxx->save_IDF);
-}
-
-static void ch7xxx_restore(struct intel_dvo_device *dvo)
-{
-       struct ch7xxx_priv *ch7xxx = dvo->dev_priv;
-
-       ch7xxx_writeb(dvo, CH7xxx_TCTL, ch7xxx->save_TCTL);
-       ch7xxx_writeb(dvo, CH7xxx_TPCP, ch7xxx->save_TPCP);
-       ch7xxx_writeb(dvo, CH7xxx_TPD, ch7xxx->save_TPD);
-       ch7xxx_writeb(dvo, CH7xxx_TPVT, ch7xxx->save_TPVT);
-       ch7xxx_writeb(dvo, CH7xxx_TLPF, ch7xxx->save_TLPF);
-       ch7xxx_writeb(dvo, CH7xxx_IDF, ch7xxx->save_IDF);
-       ch7xxx_writeb(dvo, CH7xxx_PM, ch7xxx->save_PM);
-}
-
 static void ch7xxx_destroy(struct intel_dvo_device *dvo)
 {
        struct ch7xxx_priv *ch7xxx = dvo->dev_priv;
@@ -365,7 +329,5 @@ struct intel_dvo_dev_ops ch7xxx_ops = {
        .mode_set = ch7xxx_mode_set,
        .dpms = ch7xxx_dpms,
        .dump_regs = ch7xxx_dump_regs,
-       .save = ch7xxx_save,
-       .restore = ch7xxx_restore,
        .destroy = ch7xxx_destroy,
 };
index 24169e5..a2ec3f4 100644 (file)
@@ -153,9 +153,6 @@ struct ivch_priv {
        bool quiet;
 
        uint16_t width, height;
-
-       uint16_t save_VR01;
-       uint16_t save_VR40;
 };
 
 
@@ -405,22 +402,6 @@ static void ivch_dump_regs(struct intel_dvo_device *dvo)
        DRM_LOG_KMS("VR8F: 0x%04x\n", val);
 }
 
-static void ivch_save(struct intel_dvo_device *dvo)
-{
-       struct ivch_priv *priv = dvo->dev_priv;
-
-       ivch_read(dvo, VR01, &priv->save_VR01);
-       ivch_read(dvo, VR40, &priv->save_VR40);
-}
-
-static void ivch_restore(struct intel_dvo_device *dvo)
-{
-       struct ivch_priv *priv = dvo->dev_priv;
-
-       ivch_write(dvo, VR01, priv->save_VR01);
-       ivch_write(dvo, VR40, priv->save_VR40);
-}
-
 static void ivch_destroy(struct intel_dvo_device *dvo)
 {
        struct ivch_priv *priv = dvo->dev_priv;
@@ -434,8 +415,6 @@ static void ivch_destroy(struct intel_dvo_device *dvo)
 struct intel_dvo_dev_ops ivch_ops= {
        .init = ivch_init,
        .dpms = ivch_dpms,
-       .save = ivch_save,
-       .restore = ivch_restore,
        .mode_valid = ivch_mode_valid,
        .mode_set = ivch_mode_set,
        .detect = ivch_detect,
index 0001c13..9b8e676 100644 (file)
@@ -58,17 +58,9 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #define SIL164_REGC 0x0c
 
-struct sil164_save_rec {
-       uint8_t reg8;
-       uint8_t reg9;
-       uint8_t regc;
-};
-
 struct sil164_priv {
        //I2CDevRec d;
        bool quiet;
-       struct sil164_save_rec save_regs;
-       struct sil164_save_rec mode_regs;
 };
 
 #define SILPTR(d) ((SIL164Ptr)(d->DriverPrivate.ptr))
@@ -252,34 +244,6 @@ static void sil164_dump_regs(struct intel_dvo_device *dvo)
        DRM_LOG_KMS("SIL164_REGC: 0x%02x\n", val);
 }
 
-static void sil164_save(struct intel_dvo_device *dvo)
-{
-       struct sil164_priv *sil= dvo->dev_priv;
-
-       if (!sil164_readb(dvo, SIL164_REG8, &sil->save_regs.reg8))
-               return;
-
-       if (!sil164_readb(dvo, SIL164_REG9, &sil->save_regs.reg9))
-               return;
-
-       if (!sil164_readb(dvo, SIL164_REGC, &sil->save_regs.regc))
-               return;
-
-       return;
-}
-
-static void sil164_restore(struct intel_dvo_device *dvo)
-{
-       struct sil164_priv *sil = dvo->dev_priv;
-
-       /* Restore it powered down initially */
-       sil164_writeb(dvo, SIL164_REG8, sil->save_regs.reg8 & ~0x1);
-
-       sil164_writeb(dvo, SIL164_REG9, sil->save_regs.reg9);
-       sil164_writeb(dvo, SIL164_REGC, sil->save_regs.regc);
-       sil164_writeb(dvo, SIL164_REG8, sil->save_regs.reg8);
-}
-
 static void sil164_destroy(struct intel_dvo_device *dvo)
 {
        struct sil164_priv *sil = dvo->dev_priv;
@@ -297,7 +261,5 @@ struct intel_dvo_dev_ops sil164_ops = {
        .mode_set = sil164_mode_set,
        .dpms = sil164_dpms,
        .dump_regs = sil164_dump_regs,
-       .save = sil164_save,
-       .restore = sil164_restore,
        .destroy = sil164_destroy,
 };
index c7c391b..66c697b 100644 (file)
 #define TFP410_V_RES_LO                0x3C
 #define TFP410_V_RES_HI                0x3D
 
-struct tfp410_save_rec {
-       uint8_t ctl1;
-       uint8_t ctl2;
-};
-
 struct tfp410_priv {
        bool quiet;
-
-       struct tfp410_save_rec saved_reg;
-       struct tfp410_save_rec mode_reg;
 };
 
 static bool tfp410_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
@@ -293,28 +285,6 @@ static void tfp410_dump_regs(struct intel_dvo_device *dvo)
        DRM_LOG_KMS("TFP410_V_RES: 0x%02X%02X\n", val2, val);
 }
 
-static void tfp410_save(struct intel_dvo_device *dvo)
-{
-       struct tfp410_priv *tfp = dvo->dev_priv;
-
-       if (!tfp410_readb(dvo, TFP410_CTL_1, &tfp->saved_reg.ctl1))
-               return;
-
-       if (!tfp410_readb(dvo, TFP410_CTL_2, &tfp->saved_reg.ctl2))
-               return;
-}
-
-static void tfp410_restore(struct intel_dvo_device *dvo)
-{
-       struct tfp410_priv *tfp = dvo->dev_priv;
-
-       /* Restore it powered down initially */
-       tfp410_writeb(dvo, TFP410_CTL_1, tfp->saved_reg.ctl1 & ~0x1);
-
-       tfp410_writeb(dvo, TFP410_CTL_2, tfp->saved_reg.ctl2);
-       tfp410_writeb(dvo, TFP410_CTL_1, tfp->saved_reg.ctl1);
-}
-
 static void tfp410_destroy(struct intel_dvo_device *dvo)
 {
        struct tfp410_priv *tfp = dvo->dev_priv;
@@ -332,7 +302,5 @@ struct intel_dvo_dev_ops tfp410_ops = {
        .mode_set = tfp410_mode_set,
        .dpms = tfp410_dpms,
        .dump_regs = tfp410_dump_regs,
-       .save = tfp410_save,
-       .restore = tfp410_restore,
        .destroy = tfp410_destroy,
 };
index 6064fd7..8f2dd65 100644 (file)
@@ -47,8 +47,6 @@ struct intel_dp_priv {
        uint32_t output_reg;
        uint32_t DP;
        uint8_t  link_configuration[DP_LINK_CONFIGURATION_SIZE];
-       uint32_t save_DP;
-       uint8_t  save_link_configuration[DP_LINK_CONFIGURATION_SIZE];
        bool has_audio;
        int dpms_mode;
        uint8_t link_bw;
@@ -748,20 +746,6 @@ intel_dp_link_status(uint8_t link_status[DP_LINK_STATUS_SIZE],
        return link_status[r - DP_LANE0_1_STATUS];
 }
 
-static void
-intel_dp_save(struct drm_connector *connector)
-{
-       struct intel_encoder *intel_encoder = to_intel_encoder(connector);
-       struct drm_device *dev = intel_encoder->base.dev;
-       struct drm_i915_private *dev_priv = dev->dev_private;
-       struct intel_dp_priv *dp_priv = intel_encoder->dev_priv;
-
-       dp_priv->save_DP = I915_READ(dp_priv->output_reg);
-       intel_dp_aux_native_read(intel_encoder, DP_LINK_BW_SET,
-                                dp_priv->save_link_configuration,
-                                sizeof (dp_priv->save_link_configuration));
-}
-
 static uint8_t
 intel_get_adjust_request_voltage(uint8_t link_status[DP_LINK_STATUS_SIZE],
                                 int lane)
@@ -1101,18 +1085,6 @@ intel_dp_link_down(struct intel_encoder *intel_encoder, uint32_t DP)
        POSTING_READ(dp_priv->output_reg);
 }
 
-static void
-intel_dp_restore(struct drm_connector *connector)
-{
-       struct intel_encoder *intel_encoder = to_intel_encoder(connector);
-       struct intel_dp_priv *dp_priv = intel_encoder->dev_priv;
-
-       if (dp_priv->save_DP & DP_PORT_EN)
-               intel_dp_link_train(intel_encoder, dp_priv->save_DP, dp_priv->save_link_configuration);
-       else
-               intel_dp_link_down(intel_encoder,  dp_priv->save_DP);
-}
-
 /*
  * According to DP spec
  * 5.1.2:
@@ -1267,8 +1239,6 @@ static const struct drm_encoder_helper_funcs intel_dp_helper_funcs = {
 
 static const struct drm_connector_funcs intel_dp_connector_funcs = {
        .dpms = drm_helper_connector_dpms,
-       .save = intel_dp_save,
-       .restore = intel_dp_restore,
        .detect = intel_dp_detect,
        .fill_modes = drm_helper_probe_single_connector_modes,
        .destroy = intel_dp_destroy,
index a3e6efa..1bf6697 100644 (file)
@@ -95,35 +95,6 @@ static void intel_dvo_dpms(struct drm_encoder *encoder, int mode)
        }
 }
 
-static void intel_dvo_save(struct drm_connector *connector)
-{
-       struct drm_i915_private *dev_priv = connector->dev->dev_private;
-       struct intel_encoder *intel_encoder = to_intel_encoder(connector);
-       struct intel_dvo_device *dvo = intel_encoder->dev_priv;
-
-       /* Each output should probably just save the registers it touches,
-        * but for now, use more overkill.
-        */
-       dev_priv->saveDVOA = I915_READ(DVOA);
-       dev_priv->saveDVOB = I915_READ(DVOB);
-       dev_priv->saveDVOC = I915_READ(DVOC);
-
-       dvo->dev_ops->save(dvo);
-}
-
-static void intel_dvo_restore(struct drm_connector *connector)
-{
-       struct drm_i915_private *dev_priv = connector->dev->dev_private;
-       struct intel_encoder *intel_encoder = to_intel_encoder(connector);
-       struct intel_dvo_device *dvo = intel_encoder->dev_priv;
-
-       dvo->dev_ops->restore(dvo);
-
-       I915_WRITE(DVOA, dev_priv->saveDVOA);
-       I915_WRITE(DVOB, dev_priv->saveDVOB);
-       I915_WRITE(DVOC, dev_priv->saveDVOC);
-}
-
 static int intel_dvo_mode_valid(struct drm_connector *connector,
                                struct drm_display_mode *mode)
 {
@@ -317,8 +288,6 @@ static const struct drm_encoder_helper_funcs intel_dvo_helper_funcs = {
 
 static const struct drm_connector_funcs intel_dvo_connector_funcs = {
        .dpms = drm_helper_connector_dpms,
-       .save = intel_dvo_save,
-       .restore = intel_dvo_restore,
        .detect = intel_dvo_detect,
        .destroy = intel_dvo_destroy,
        .fill_modes = drm_helper_probe_single_connector_modes,
index 74823e7..78cb775 100644 (file)
@@ -38,7 +38,6 @@
 
 struct intel_hdmi_priv {
        u32 sdvox_reg;
-       u32 save_SDVOX;
        bool has_hdmi_sink;
 };
 
@@ -105,27 +104,6 @@ static void intel_hdmi_dpms(struct drm_encoder *encoder, int mode)
        }
 }
 
-static void intel_hdmi_save(struct drm_connector *connector)
-{
-       struct drm_device *dev = connector->dev;
-       struct drm_i915_private *dev_priv = dev->dev_private;
-       struct intel_encoder *intel_encoder = to_intel_encoder(connector);
-       struct intel_hdmi_priv *hdmi_priv = intel_encoder->dev_priv;
-
-       hdmi_priv->save_SDVOX = I915_READ(hdmi_priv->sdvox_reg);
-}
-
-static void intel_hdmi_restore(struct drm_connector *connector)
-{
-       struct drm_device *dev = connector->dev;
-       struct drm_i915_private *dev_priv = dev->dev_private;
-       struct intel_encoder *intel_encoder = to_intel_encoder(connector);
-       struct intel_hdmi_priv *hdmi_priv = intel_encoder->dev_priv;
-
-       I915_WRITE(hdmi_priv->sdvox_reg, hdmi_priv->save_SDVOX);
-       POSTING_READ(hdmi_priv->sdvox_reg);
-}
-
 static int intel_hdmi_mode_valid(struct drm_connector *connector,
                                 struct drm_display_mode *mode)
 {
@@ -203,8 +181,6 @@ static const struct drm_encoder_helper_funcs intel_hdmi_helper_funcs = {
 
 static const struct drm_connector_funcs intel_hdmi_connector_funcs = {
        .dpms = drm_helper_connector_dpms,
-       .save = intel_hdmi_save,
-       .restore = intel_hdmi_restore,
        .detect = intel_hdmi_detect,
        .fill_modes = drm_helper_probe_single_connector_modes,
        .destroy = intel_hdmi_destroy,
index a3b8208..bc0ab7d 100644 (file)
@@ -138,75 +138,6 @@ static void intel_lvds_dpms(struct drm_encoder *encoder, int mode)
        /* XXX: We never power down the LVDS pairs. */
 }
 
-static void intel_lvds_save(struct drm_connector *connector)
-{
-       struct drm_device *dev = connector->dev;
-       struct drm_i915_private *dev_priv = dev->dev_private;
-       u32 pp_on_reg, pp_off_reg, pp_ctl_reg, pp_div_reg;
-       u32 pwm_ctl_reg;
-
-       if (HAS_PCH_SPLIT(dev)) {
-               pp_on_reg = PCH_PP_ON_DELAYS;
-               pp_off_reg = PCH_PP_OFF_DELAYS;
-               pp_ctl_reg = PCH_PP_CONTROL;
-               pp_div_reg = PCH_PP_DIVISOR;
-               pwm_ctl_reg = BLC_PWM_CPU_CTL;
-       } else {
-               pp_on_reg = PP_ON_DELAYS;
-               pp_off_reg = PP_OFF_DELAYS;
-               pp_ctl_reg = PP_CONTROL;
-               pp_div_reg = PP_DIVISOR;
-               pwm_ctl_reg = BLC_PWM_CTL;
-       }
-
-       dev_priv->savePP_ON = I915_READ(pp_on_reg);
-       dev_priv->savePP_OFF = I915_READ(pp_off_reg);
-       dev_priv->savePP_CONTROL = I915_READ(pp_ctl_reg);
-       dev_priv->savePP_DIVISOR = I915_READ(pp_div_reg);
-       dev_priv->saveBLC_PWM_CTL = I915_READ(pwm_ctl_reg);
-       dev_priv->backlight_duty_cycle = (dev_priv->saveBLC_PWM_CTL &
-                                      BACKLIGHT_DUTY_CYCLE_MASK);
-
-       /*
-        * If the light is off at server startup, just make it full brightness
-        */
-       if (dev_priv->backlight_duty_cycle == 0)
-               dev_priv->backlight_duty_cycle =
-                       intel_lvds_get_max_backlight(dev);
-}
-
-static void intel_lvds_restore(struct drm_connector *connector)
-{
-       struct drm_device *dev = connector->dev;
-       struct drm_i915_private *dev_priv = dev->dev_private;
-       u32 pp_on_reg, pp_off_reg, pp_ctl_reg, pp_div_reg;
-       u32 pwm_ctl_reg;
-
-       if (HAS_PCH_SPLIT(dev)) {
-               pp_on_reg = PCH_PP_ON_DELAYS;
-               pp_off_reg = PCH_PP_OFF_DELAYS;
-               pp_ctl_reg = PCH_PP_CONTROL;
-               pp_div_reg = PCH_PP_DIVISOR;
-               pwm_ctl_reg = BLC_PWM_CPU_CTL;
-       } else {
-               pp_on_reg = PP_ON_DELAYS;
-               pp_off_reg = PP_OFF_DELAYS;
-               pp_ctl_reg = PP_CONTROL;
-               pp_div_reg = PP_DIVISOR;
-               pwm_ctl_reg = BLC_PWM_CTL;
-       }
-
-       I915_WRITE(pwm_ctl_reg, dev_priv->saveBLC_PWM_CTL);
-       I915_WRITE(pp_on_reg, dev_priv->savePP_ON);
-       I915_WRITE(pp_off_reg, dev_priv->savePP_OFF);
-       I915_WRITE(pp_div_reg, dev_priv->savePP_DIVISOR);
-       I915_WRITE(pp_ctl_reg, dev_priv->savePP_CONTROL);
-       if (dev_priv->savePP_CONTROL & POWER_TARGET_ON)
-               intel_lvds_set_power(dev, true);
-       else
-               intel_lvds_set_power(dev, false);
-}
-
 static int intel_lvds_mode_valid(struct drm_connector *connector,
                                 struct drm_display_mode *mode)
 {
@@ -778,8 +709,6 @@ static const struct drm_connector_helper_funcs intel_lvds_connector_helper_funcs
 
 static const struct drm_connector_funcs intel_lvds_connector_funcs = {
        .dpms = drm_helper_connector_dpms,
-       .save = intel_lvds_save,
-       .restore = intel_lvds_restore,
        .detect = intel_lvds_detect,
        .fill_modes = drm_helper_probe_single_connector_modes,
        .set_property = intel_lvds_set_property,
index 097819c..5534704 100644 (file)
@@ -129,11 +129,6 @@ struct intel_sdvo_priv {
        /* Mac mini hack -- use the same DDC as the analog connector */
        struct i2c_adapter *analog_ddc_bus;
 
-       int save_sdvo_mult;
-       u16 save_active_outputs;
-       struct intel_sdvo_dtd save_input_dtd_1, save_input_dtd_2;
-       struct intel_sdvo_dtd save_output_dtd[16];
-       u32 save_SDVOX;
        /* add the property for the SDVO-TV */
        struct drm_property *left_property;
        struct drm_property *right_property;
@@ -562,17 +557,6 @@ static bool intel_sdvo_get_trained_inputs(struct intel_encoder *intel_encoder, b
        return true;
 }
 
-static bool intel_sdvo_get_active_outputs(struct intel_encoder *intel_encoder,
-                                         u16 *outputs)
-{
-       u8 status;
-
-       intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_ACTIVE_OUTPUTS, NULL, 0);
-       status = intel_sdvo_read_response(intel_encoder, outputs, sizeof(*outputs));
-
-       return (status == SDVO_CMD_STATUS_SUCCESS);
-}
-
 static bool intel_sdvo_set_active_outputs(struct intel_encoder *intel_encoder,
                                          u16 outputs)
 {
@@ -645,40 +629,6 @@ static bool intel_sdvo_set_target_output(struct intel_encoder *intel_encoder,
        return (status == SDVO_CMD_STATUS_SUCCESS);
 }
 
-static bool intel_sdvo_get_timing(struct intel_encoder *intel_encoder, u8 cmd,
-                                 struct intel_sdvo_dtd *dtd)
-{
-       u8 status;
-
-       intel_sdvo_write_cmd(intel_encoder, cmd, NULL, 0);
-       status = intel_sdvo_read_response(intel_encoder, &dtd->part1,
-                                         sizeof(dtd->part1));
-       if (status != SDVO_CMD_STATUS_SUCCESS)
-               return false;
-
-       intel_sdvo_write_cmd(intel_encoder, cmd + 1, NULL, 0);
-       status = intel_sdvo_read_response(intel_encoder, &dtd->part2,
-                                         sizeof(dtd->part2));
-       if (status != SDVO_CMD_STATUS_SUCCESS)
-               return false;
-
-       return true;
-}
-
-static bool intel_sdvo_get_input_timing(struct intel_encoder *intel_encoder,
-                                        struct intel_sdvo_dtd *dtd)
-{
-       return intel_sdvo_get_timing(intel_encoder,
-                                    SDVO_CMD_GET_INPUT_TIMINGS_PART1, dtd);
-}
-
-static bool intel_sdvo_get_output_timing(struct intel_encoder *intel_encoder,
-                                        struct intel_sdvo_dtd *dtd)
-{
-       return intel_sdvo_get_timing(intel_encoder,
-                                    SDVO_CMD_GET_OUTPUT_TIMINGS_PART1, dtd);
-}
-
 static bool intel_sdvo_set_timing(struct intel_encoder *intel_encoder, u8 cmd,
                                  struct intel_sdvo_dtd *dtd)
 {
@@ -766,23 +716,6 @@ static bool intel_sdvo_get_preferred_input_timing(struct intel_encoder *intel_en
        return false;
 }
 
-static int intel_sdvo_get_clock_rate_mult(struct intel_encoder *intel_encoder)
-{
-       u8 response, status;
-
-       intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_CLOCK_RATE_MULT, NULL, 0);
-       status = intel_sdvo_read_response(intel_encoder, &response, 1);
-
-       if (status != SDVO_CMD_STATUS_SUCCESS) {
-               DRM_DEBUG_KMS("Couldn't get SDVO clock rate multiplier\n");
-               return SDVO_CLOCK_RATE_MULT_1X;
-       } else {
-               DRM_DEBUG_KMS("Current clock rate multiplier: %d\n", response);
-       }
-
-       return response;
-}
-
 static bool intel_sdvo_set_clock_rate_mult(struct intel_encoder *intel_encoder, u8 val)
 {
        u8 status;
@@ -1356,98 +1289,6 @@ static void intel_sdvo_dpms(struct drm_encoder *encoder, int mode)
        return;
 }
 
-static void intel_sdvo_save(struct drm_connector *connector)
-{
-       struct drm_device *dev = connector->dev;
-       struct drm_i915_private *dev_priv = dev->dev_private;
-       struct intel_encoder *intel_encoder = to_intel_encoder(connector);
-       struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
-       int o;
-
-       sdvo_priv->save_sdvo_mult = intel_sdvo_get_clock_rate_mult(intel_encoder);
-       intel_sdvo_get_active_outputs(intel_encoder, &sdvo_priv->save_active_outputs);
-
-       if (sdvo_priv->caps.sdvo_inputs_mask & 0x1) {
-               intel_sdvo_set_target_input(intel_encoder, true, false);
-               intel_sdvo_get_input_timing(intel_encoder,
-                                           &sdvo_priv->save_input_dtd_1);
-       }
-
-       if (sdvo_priv->caps.sdvo_inputs_mask & 0x2) {
-               intel_sdvo_set_target_input(intel_encoder, false, true);
-               intel_sdvo_get_input_timing(intel_encoder,
-                                           &sdvo_priv->save_input_dtd_2);
-       }
-
-       for (o = SDVO_OUTPUT_FIRST; o <= SDVO_OUTPUT_LAST; o++)
-       {
-               u16  this_output = (1 << o);
-               if (sdvo_priv->caps.output_flags & this_output)
-               {
-                       intel_sdvo_set_target_output(intel_encoder, this_output);
-                       intel_sdvo_get_output_timing(intel_encoder,
-                                                    &sdvo_priv->save_output_dtd[o]);
-               }
-       }
-       if (sdvo_priv->is_tv) {
-               /* XXX: Save TV format/enhancements. */
-       }
-
-       sdvo_priv->save_SDVOX = I915_READ(sdvo_priv->sdvo_reg);
-}
-
-static void intel_sdvo_restore(struct drm_connector *connector)
-{
-       struct drm_device *dev = connector->dev;
-       struct intel_encoder *intel_encoder = to_intel_encoder(connector);
-       struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
-       int o;
-       int i;
-       bool input1, input2;
-       u8 status;
-
-       intel_sdvo_set_active_outputs(intel_encoder, 0);
-
-       for (o = SDVO_OUTPUT_FIRST; o <= SDVO_OUTPUT_LAST; o++)
-       {
-               u16  this_output = (1 << o);
-               if (sdvo_priv->caps.output_flags & this_output) {
-                       intel_sdvo_set_target_output(intel_encoder, this_output);
-                       intel_sdvo_set_output_timing(intel_encoder, &sdvo_priv->save_output_dtd[o]);
-               }
-       }
-
-       if (sdvo_priv->caps.sdvo_inputs_mask & 0x1) {
-               intel_sdvo_set_target_input(intel_encoder, true, false);
-               intel_sdvo_set_input_timing(intel_encoder, &sdvo_priv->save_input_dtd_1);
-       }
-
-       if (sdvo_priv->caps.sdvo_inputs_mask & 0x2) {
-               intel_sdvo_set_target_input(intel_encoder, false, true);
-               intel_sdvo_set_input_timing(intel_encoder, &sdvo_priv->save_input_dtd_2);
-       }
-
-       intel_sdvo_set_clock_rate_mult(intel_encoder, sdvo_priv->save_sdvo_mult);
-
-       if (sdvo_priv->is_tv) {
-               /* XXX: Restore TV format/enhancements. */
-       }
-
-       intel_sdvo_write_sdvox(intel_encoder, sdvo_priv->save_SDVOX);
-
-       if (sdvo_priv->save_SDVOX & SDVO_ENABLE)
-       {
-               for (i = 0; i < 2; i++)
-                       intel_wait_for_vblank(dev);
-               status = intel_sdvo_get_trained_inputs(intel_encoder, &input1, &input2);
-               if (status == SDVO_CMD_STATUS_SUCCESS && !input1)
-                       DRM_DEBUG_KMS("First %s output reported failure to "
-                                       "sync\n", SDVO_NAME(sdvo_priv));
-       }
-
-       intel_sdvo_set_active_outputs(intel_encoder, sdvo_priv->save_active_outputs);
-}
-
 static int intel_sdvo_mode_valid(struct drm_connector *connector,
                                 struct drm_display_mode *mode)
 {
@@ -2119,8 +1960,6 @@ static const struct drm_encoder_helper_funcs intel_sdvo_helper_funcs = {
 
 static const struct drm_connector_funcs intel_sdvo_connector_funcs = {
        .dpms = drm_helper_connector_dpms,
-       .save = intel_sdvo_save,
-       .restore = intel_sdvo_restore,
        .detect = intel_sdvo_detect,
        .fill_modes = drm_helper_probe_single_connector_modes,
        .set_property = intel_sdvo_set_property,
index dd5e2e8..c8f67bf 100644 (file)
@@ -916,143 +916,6 @@ intel_tv_dpms(struct drm_encoder *encoder, int mode)
        }
 }
 
-static void
-intel_tv_save(struct drm_connector *connector)
-{
-       struct drm_device *dev = connector->dev;
-       struct drm_i915_private *dev_priv = dev->dev_private;
-       struct intel_encoder *intel_encoder = to_intel_encoder(connector);
-       struct intel_tv_priv *tv_priv = intel_encoder->dev_priv;
-       int i;
-
-       tv_priv->save_TV_H_CTL_1 = I915_READ(TV_H_CTL_1);
-       tv_priv->save_TV_H_CTL_2 = I915_READ(TV_H_CTL_2);
-       tv_priv->save_TV_H_CTL_3 = I915_READ(TV_H_CTL_3);
-       tv_priv->save_TV_V_CTL_1 = I915_READ(TV_V_CTL_1);
-       tv_priv->save_TV_V_CTL_2 = I915_READ(TV_V_CTL_2);
-       tv_priv->save_TV_V_CTL_3 = I915_READ(TV_V_CTL_3);
-       tv_priv->save_TV_V_CTL_4 = I915_READ(TV_V_CTL_4);
-       tv_priv->save_TV_V_CTL_5 = I915_READ(TV_V_CTL_5);
-       tv_priv->save_TV_V_CTL_6 = I915_READ(TV_V_CTL_6);
-       tv_priv->save_TV_V_CTL_7 = I915_READ(TV_V_CTL_7);
-       tv_priv->save_TV_SC_CTL_1 = I915_READ(TV_SC_CTL_1);
-       tv_priv->save_TV_SC_CTL_2 = I915_READ(TV_SC_CTL_2);
-       tv_priv->save_TV_SC_CTL_3 = I915_READ(TV_SC_CTL_3);
-
-       tv_priv->save_TV_CSC_Y = I915_READ(TV_CSC_Y);
-       tv_priv->save_TV_CSC_Y2 = I915_READ(TV_CSC_Y2);
-       tv_priv->save_TV_CSC_U = I915_READ(TV_CSC_U);
-       tv_priv->save_TV_CSC_U2 = I915_READ(TV_CSC_U2);
-       tv_priv->save_TV_CSC_V = I915_READ(TV_CSC_V);
-       tv_priv->save_TV_CSC_V2 = I915_READ(TV_CSC_V2);
-       tv_priv->save_TV_CLR_KNOBS = I915_READ(TV_CLR_KNOBS);
-       tv_priv->save_TV_CLR_LEVEL = I915_READ(TV_CLR_LEVEL);
-       tv_priv->save_TV_WIN_POS = I915_READ(TV_WIN_POS);
-       tv_priv->save_TV_WIN_SIZE = I915_READ(TV_WIN_SIZE);
-       tv_priv->save_TV_FILTER_CTL_1 = I915_READ(TV_FILTER_CTL_1);
-       tv_priv->save_TV_FILTER_CTL_2 = I915_READ(TV_FILTER_CTL_2);
-       tv_priv->save_TV_FILTER_CTL_3 = I915_READ(TV_FILTER_CTL_3);
-
-       for (i = 0; i < 60; i++)
-               tv_priv->save_TV_H_LUMA[i] = I915_READ(TV_H_LUMA_0 + (i <<2));
-       for (i = 0; i < 60; i++)
-               tv_priv->save_TV_H_CHROMA[i] = I915_READ(TV_H_CHROMA_0 + (i <<2));
-       for (i = 0; i < 43; i++)
-               tv_priv->save_TV_V_LUMA[i] = I915_READ(TV_V_LUMA_0 + (i <<2));
-       for (i = 0; i < 43; i++)
-               tv_priv->save_TV_V_CHROMA[i] = I915_READ(TV_V_CHROMA_0 + (i <<2));
-
-       tv_priv->save_TV_DAC = I915_READ(TV_DAC);
-       tv_priv->save_TV_CTL = I915_READ(TV_CTL);
-}
-
-static void
-intel_tv_restore(struct drm_connector *connector)
-{
-       struct drm_device *dev = connector->dev;
-       struct drm_i915_private *dev_priv = dev->dev_private;
-       struct intel_encoder *intel_encoder = to_intel_encoder(connector);
-       struct intel_tv_priv *tv_priv = intel_encoder->dev_priv;
-       struct drm_crtc *crtc = connector->encoder->crtc;
-       struct intel_crtc *intel_crtc;
-       int i;
-
-       /* FIXME: No CRTC? */
-       if (!crtc)
-               return;
-
-       intel_crtc = to_intel_crtc(crtc);
-       I915_WRITE(TV_H_CTL_1, tv_priv->save_TV_H_CTL_1);
-       I915_WRITE(TV_H_CTL_2, tv_priv->save_TV_H_CTL_2);
-       I915_WRITE(TV_H_CTL_3, tv_priv->save_TV_H_CTL_3);
-       I915_WRITE(TV_V_CTL_1, tv_priv->save_TV_V_CTL_1);
-       I915_WRITE(TV_V_CTL_2, tv_priv->save_TV_V_CTL_2);
-       I915_WRITE(TV_V_CTL_3, tv_priv->save_TV_V_CTL_3);
-       I915_WRITE(TV_V_CTL_4, tv_priv->save_TV_V_CTL_4);
-       I915_WRITE(TV_V_CTL_5, tv_priv->save_TV_V_CTL_5);
-       I915_WRITE(TV_V_CTL_6, tv_priv->save_TV_V_CTL_6);
-       I915_WRITE(TV_V_CTL_7, tv_priv->save_TV_V_CTL_7);
-       I915_WRITE(TV_SC_CTL_1, tv_priv->save_TV_SC_CTL_1);
-       I915_WRITE(TV_SC_CTL_2, tv_priv->save_TV_SC_CTL_2);
-       I915_WRITE(TV_SC_CTL_3, tv_priv->save_TV_SC_CTL_3);
-
-       I915_WRITE(TV_CSC_Y, tv_priv->save_TV_CSC_Y);
-       I915_WRITE(TV_CSC_Y2, tv_priv->save_TV_CSC_Y2);
-       I915_WRITE(TV_CSC_U, tv_priv->save_TV_CSC_U);
-       I915_WRITE(TV_CSC_U2, tv_priv->save_TV_CSC_U2);
-       I915_WRITE(TV_CSC_V, tv_priv->save_TV_CSC_V);
-       I915_WRITE(TV_CSC_V2, tv_priv->save_TV_CSC_V2);
-       I915_WRITE(TV_CLR_KNOBS, tv_priv->save_TV_CLR_KNOBS);
-       I915_WRITE(TV_CLR_LEVEL, tv_priv->save_TV_CLR_LEVEL);
-
-       {
-               int pipeconf_reg = (intel_crtc->pipe == 0) ?
-                       PIPEACONF : PIPEBCONF;
-               int dspcntr_reg = (intel_crtc->plane == 0) ?
-                       DSPACNTR : DSPBCNTR;
-               int pipeconf = I915_READ(pipeconf_reg);
-               int dspcntr = I915_READ(dspcntr_reg);
-               int dspbase_reg = (intel_crtc->plane == 0) ?
-                       DSPAADDR : DSPBADDR;
-               /* Pipe must be off here */
-               I915_WRITE(dspcntr_reg, dspcntr & ~DISPLAY_PLANE_ENABLE);
-               /* Flush the plane changes */
-               I915_WRITE(dspbase_reg, I915_READ(dspbase_reg));
-
-               if (!IS_I9XX(dev)) {
-                       /* Wait for vblank for the disable to take effect */
-                       intel_wait_for_vblank(dev);
-               }
-
-               I915_WRITE(pipeconf_reg, pipeconf & ~PIPEACONF_ENABLE);
-               /* Wait for vblank for the disable to take effect. */
-               intel_wait_for_vblank(dev);
-
-               /* Filter ctl must be set before TV_WIN_SIZE */
-               I915_WRITE(TV_FILTER_CTL_1, tv_priv->save_TV_FILTER_CTL_1);
-               I915_WRITE(TV_FILTER_CTL_2, tv_priv->save_TV_FILTER_CTL_2);
-               I915_WRITE(TV_FILTER_CTL_3, tv_priv->save_TV_FILTER_CTL_3);
-               I915_WRITE(TV_WIN_POS, tv_priv->save_TV_WIN_POS);
-               I915_WRITE(TV_WIN_SIZE, tv_priv->save_TV_WIN_SIZE);
-               I915_WRITE(pipeconf_reg, pipeconf);
-               I915_WRITE(dspcntr_reg, dspcntr);
-               /* Flush the plane changes */
-               I915_WRITE(dspbase_reg, I915_READ(dspbase_reg));
-       }
-
-       for (i = 0; i < 60; i++)
-               I915_WRITE(TV_H_LUMA_0 + (i <<2), tv_priv->save_TV_H_LUMA[i]);
-       for (i = 0; i < 60; i++)
-               I915_WRITE(TV_H_CHROMA_0 + (i <<2), tv_priv->save_TV_H_CHROMA[i]);
-       for (i = 0; i < 43; i++)
-               I915_WRITE(TV_V_LUMA_0 + (i <<2), tv_priv->save_TV_V_LUMA[i]);
-       for (i = 0; i < 43; i++)
-               I915_WRITE(TV_V_CHROMA_0 + (i <<2), tv_priv->save_TV_V_CHROMA[i]);
-
-       I915_WRITE(TV_DAC, tv_priv->save_TV_DAC);
-       I915_WRITE(TV_CTL, tv_priv->save_TV_CTL);
-}
-
 static const struct tv_mode *
 intel_tv_mode_lookup (char *tv_format)
 {
@@ -1687,8 +1550,6 @@ static const struct drm_encoder_helper_funcs intel_tv_helper_funcs = {
 
 static const struct drm_connector_funcs intel_tv_connector_funcs = {
        .dpms = drm_helper_connector_dpms,
-       .save = intel_tv_save,
-       .restore = intel_tv_restore,
        .detect = intel_tv_detect,
        .destroy = intel_tv_destroy,
        .set_property = intel_tv_set_property,