}
 
 static enum drm_mode_status amdgpu_connector_lvds_mode_valid(struct drm_connector *connector,
-                                            struct drm_display_mode *mode)
+                                            const struct drm_display_mode *mode)
 {
        struct drm_encoder *encoder = amdgpu_connector_best_single_encoder(connector);
 
 }
 
 static enum drm_mode_status amdgpu_connector_vga_mode_valid(struct drm_connector *connector,
-                                           struct drm_display_mode *mode)
+                                           const struct drm_display_mode *mode)
 {
        struct drm_device *dev = connector->dev;
        struct amdgpu_device *adev = drm_to_adev(dev);
 }
 
 static enum drm_mode_status amdgpu_connector_dvi_mode_valid(struct drm_connector *connector,
-                                           struct drm_display_mode *mode)
+                                           const struct drm_display_mode *mode)
 {
        struct drm_device *dev = connector->dev;
        struct amdgpu_device *adev = drm_to_adev(dev);
 }
 
 static enum drm_mode_status amdgpu_connector_dp_mode_valid(struct drm_connector *connector,
-                                          struct drm_display_mode *mode)
+                                          const struct drm_display_mode *mode)
 {
        struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
        struct amdgpu_connector_atom_dig *amdgpu_dig_connector = amdgpu_connector->con_priv;
 
 }
 
 int amdgpu_atombios_dp_mode_valid_helper(struct drm_connector *connector,
-                                 struct drm_display_mode *mode)
+                                 const struct drm_display_mode *mode)
 {
        struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
        struct amdgpu_connector_atom_dig *dig_connector;
 
 void amdgpu_atombios_dp_set_link_config(struct drm_connector *connector,
                                 const struct drm_display_mode *mode);
 int amdgpu_atombios_dp_mode_valid_helper(struct drm_connector *connector,
-                                 struct drm_display_mode *mode);
+                                 const struct drm_display_mode *mode);
 bool amdgpu_atombios_dp_needs_link_train(struct amdgpu_connector *amdgpu_connector);
 void amdgpu_atombios_dp_set_rx_power_state(struct drm_connector *connector,
                                    u8 power_state);
 
 }
 
 enum drm_mode_status amdgpu_dm_connector_mode_valid(struct drm_connector *connector,
-                                  struct drm_display_mode *mode)
+                                  const struct drm_display_mode *mode)
 {
        int result = MODE_ERROR;
        struct dc_sink *dc_sink;
 
                                     int link_index);
 
 enum drm_mode_status amdgpu_dm_connector_mode_valid(struct drm_connector *connector,
-                                  struct drm_display_mode *mode);
+                                  const struct drm_display_mode *mode);
 
 void dm_restore_drm_connector_state(struct drm_device *dev,
                                    struct drm_connector *connector);
 
 
 static enum drm_mode_status
 komeda_wb_connector_mode_valid(struct drm_connector *connector,
-                              struct drm_display_mode *mode)
+                              const struct drm_display_mode *mode)
 {
        struct drm_device *dev = connector->dev;
        struct drm_mode_config *mode_config = &dev->mode_config;
 
 
 static enum drm_mode_status
 malidp_mw_connector_mode_valid(struct drm_connector *connector,
-                              struct drm_display_mode *mode)
+                              const struct drm_display_mode *mode)
 {
        struct drm_device *dev = connector->dev;
        struct drm_mode_config *mode_config = &dev->mode_config;
 
 
 static enum drm_mode_status
 adv7511_connector_mode_valid(struct drm_connector *connector,
-                            struct drm_display_mode *mode)
+                            const struct drm_display_mode *mode)
 {
        struct adv7511 *adv = connector_to_adv7511(connector);
 
 
 
 static
 enum drm_mode_status cdns_mhdp_mode_valid(struct drm_connector *conn,
-                                         struct drm_display_mode *mode)
+                                         const struct drm_display_mode *mode)
 {
        struct cdns_mhdp_device *mhdp = connector_to_mhdp(conn);
 
 
        return num_modes;
 }
 
-static enum drm_mode_status ge_b850v3_lvds_mode_valid(
-               struct drm_connector *connector, struct drm_display_mode *mode)
-{
-       return MODE_OK;
-}
-
 static const struct
 drm_connector_helper_funcs ge_b850v3_lvds_connector_helper_funcs = {
        .get_modes = ge_b850v3_lvds_get_modes,
-       .mode_valid = ge_b850v3_lvds_mode_valid,
 };
 
 static enum drm_connector_status ge_b850v3_lvds_bridge_detect(struct drm_bridge *bridge)
 
 
 static enum drm_mode_status
 drm_bridge_connector_mode_valid(struct drm_connector *connector,
-                               struct drm_display_mode *mode)
+                               const struct drm_display_mode *mode)
 {
        struct drm_bridge_connector *bridge_connector =
                to_drm_bridge_connector(connector);
 
  */
 enum drm_mode_status
 drm_hdmi_connector_mode_valid(struct drm_connector *connector,
-                             struct drm_display_mode *mode)
+                             const struct drm_display_mode *mode)
 {
        unsigned long long clock;
 
 
                                            const struct drm_display_mode *mode);
 int
 drm_connector_mode_valid(struct drm_connector *connector,
-                        struct drm_display_mode *mode,
+                        const struct drm_display_mode *mode,
                         struct drm_modeset_acquire_ctx *ctx,
                         enum drm_mode_status *status);
 
 
 
 int
 drm_connector_mode_valid(struct drm_connector *connector,
-                        struct drm_display_mode *mode,
+                        const struct drm_display_mode *mode,
                         struct drm_modeset_acquire_ctx *ctx,
                         enum drm_mode_status *status)
 {
 
 }
 
 static enum drm_mode_status hdmi_mode_valid(struct drm_connector *connector,
-                                           struct drm_display_mode *mode)
+                                           const struct drm_display_mode *mode)
 {
        struct hdmi_context *hdata = connector_to_hdmi(connector);
        int ret;
 
 
 static enum drm_mode_status
 fsl_dcu_drm_connector_mode_valid(struct drm_connector *connector,
-                                struct drm_display_mode *mode)
+                                const struct drm_display_mode *mode)
 {
        if (mode->hdisplay & 0xf)
                return MODE_ERROR;
 
 }
 
 static enum drm_mode_status cdv_intel_crt_mode_valid(struct drm_connector *connector,
-                               struct drm_display_mode *mode)
+                               const struct drm_display_mode *mode)
 {
        if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
                return MODE_NO_DBLESCAN;
 
 
 static enum drm_mode_status
 cdv_intel_dp_mode_valid(struct drm_connector *connector,
-                   struct drm_display_mode *mode)
+                   const struct drm_display_mode *mode)
 {
        struct gma_encoder *encoder = gma_attached_encoder(connector);
        struct cdv_intel_dp *intel_dp = encoder->dev_priv;
 
 }
 
 static enum drm_mode_status cdv_hdmi_mode_valid(struct drm_connector *connector,
-                                struct drm_display_mode *mode)
+                                const struct drm_display_mode *mode)
 {
        if (mode->clock > 165000)
                return MODE_CLOCK_HIGH;
 
 }
 
 static enum drm_mode_status cdv_intel_lvds_mode_valid(struct drm_connector *connector,
-                             struct drm_display_mode *mode)
+                             const struct drm_display_mode *mode)
 {
        struct drm_device *dev = connector->dev;
        struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
 
 }
 
 static enum drm_mode_status oaktrail_hdmi_mode_valid(struct drm_connector *connector,
-                               struct drm_display_mode *mode)
+                               const struct drm_display_mode *mode)
 {
        if (mode->clock > 165000)
                return MODE_CLOCK_HIGH;
 
                                      const struct drm_display_mode *mode,
                                      struct drm_display_mode *adjusted_mode);
 extern enum drm_mode_status psb_intel_lvds_mode_valid(struct drm_connector *connector,
-                                    struct drm_display_mode *mode);
+                                    const struct drm_display_mode *mode);
 extern int psb_intel_lvds_set_property(struct drm_connector *connector,
                                        struct drm_property *property,
                                        uint64_t value);
 
 }
 
 enum drm_mode_status psb_intel_lvds_mode_valid(struct drm_connector *connector,
-                                struct drm_display_mode *mode)
+                                const struct drm_display_mode *mode)
 {
        struct drm_psb_private *dev_priv = to_drm_psb_private(connector->dev);
        struct gma_encoder *gma_encoder = gma_attached_encoder(connector);
 
 }
 
 static enum drm_mode_status psb_intel_sdvo_mode_valid(struct drm_connector *connector,
-                                struct drm_display_mode *mode)
+                                const struct drm_display_mode *mode)
 {
        struct psb_intel_sdvo *psb_intel_sdvo = intel_attached_sdvo(connector);
 
 
 }
 
 static enum drm_mode_status ch7017_mode_valid(struct intel_dvo_device *dvo,
-                                             struct drm_display_mode *mode)
+                                             const struct drm_display_mode *mode)
 {
        if (mode->clock > 160000)
                return MODE_CLOCK_HIGH;
 
 }
 
 static enum drm_mode_status ch7xxx_mode_valid(struct intel_dvo_device *dvo,
-                                             struct drm_display_mode *mode)
+                                             const struct drm_display_mode *mode)
 {
        if (mode->clock > 165000)
                return MODE_CLOCK_HIGH;
 
 }
 
 static enum drm_mode_status ivch_mode_valid(struct intel_dvo_device *dvo,
-                                           struct drm_display_mode *mode)
+                                           const struct drm_display_mode *mode)
 {
        if (mode->clock > 112000)
                return MODE_CLOCK_HIGH;
 
 }
 
 static enum drm_mode_status ns2501_mode_valid(struct intel_dvo_device *dvo,
-                                             struct drm_display_mode *mode)
+                                             const struct drm_display_mode *mode)
 {
        DRM_DEBUG_KMS
            ("is mode valid (hdisplay=%d,htotal=%d,vdisplay=%d,vtotal=%d)\n",
 
 }
 
 static enum drm_mode_status sil164_mode_valid(struct intel_dvo_device *dvo,
-                                             struct drm_display_mode *mode)
+                                             const struct drm_display_mode *mode)
 {
        return MODE_OK;
 }
 
 }
 
 static enum drm_mode_status tfp410_mode_valid(struct intel_dvo_device *dvo,
-                                             struct drm_display_mode *mode)
+                                             const struct drm_display_mode *mode)
 {
        return MODE_OK;
 }
 
 }
 
 static enum drm_mode_status gen11_dsi_mode_valid(struct drm_connector *connector,
-                                                struct drm_display_mode *mode)
+                                                const struct drm_display_mode *mode)
 {
        struct drm_i915_private *i915 = to_i915(connector->dev);
        enum drm_mode_status status;
 
 
 static enum drm_mode_status
 intel_crt_mode_valid(struct drm_connector *connector,
-                    struct drm_display_mode *mode)
+                    const struct drm_display_mode *mode)
 {
        struct intel_display *display = to_intel_display(connector->dev);
        struct drm_device *dev = connector->dev;
 
 
 static enum drm_mode_status
 intel_dp_mode_valid(struct drm_connector *_connector,
-                   struct drm_display_mode *mode)
+                   const struct drm_display_mode *mode)
 {
        struct intel_connector *connector = to_intel_connector(_connector);
        struct intel_dp *intel_dp = intel_attached_dp(connector);
 
 }
 
 enum drm_mode_status intel_dsi_mode_valid(struct drm_connector *connector,
-                                         struct drm_display_mode *mode)
+                                         const struct drm_display_mode *mode)
 {
        struct drm_i915_private *dev_priv = to_i915(connector->dev);
        struct intel_connector *intel_connector = to_intel_connector(connector);
 
 intel_dsi_get_panel_orientation(struct intel_connector *connector);
 int intel_dsi_get_modes(struct drm_connector *connector);
 enum drm_mode_status intel_dsi_mode_valid(struct drm_connector *connector,
-                                         struct drm_display_mode *mode);
+                                         const struct drm_display_mode *mode);
 struct intel_dsi_host *intel_dsi_host_init(struct intel_dsi *intel_dsi,
                                           const struct mipi_dsi_host_ops *funcs,
                                           enum port port);
 
 
 static enum drm_mode_status
 intel_dvo_mode_valid(struct drm_connector *_connector,
-                    struct drm_display_mode *mode)
+                    const struct drm_display_mode *mode)
 {
        struct intel_connector *connector = to_intel_connector(_connector);
        struct drm_i915_private *i915 = to_i915(connector->base.dev);
 
         * \return MODE_OK if the mode is valid, or another MODE_* otherwise.
         */
        enum drm_mode_status (*mode_valid)(struct intel_dvo_device *dvo,
-                                          struct drm_display_mode *mode);
+                                          const struct drm_display_mode *mode);
 
        /*
         * Callback for setting up a video mode after fixups have been made.
 
 
 static enum drm_mode_status
 intel_hdmi_mode_valid(struct drm_connector *connector,
-                     struct drm_display_mode *mode)
+                     const struct drm_display_mode *mode)
 {
        struct intel_display *display = to_intel_display(connector->dev);
        struct intel_hdmi *hdmi = intel_attached_hdmi(to_intel_connector(connector));
 
 
 static enum drm_mode_status
 intel_lvds_mode_valid(struct drm_connector *_connector,
-                     struct drm_display_mode *mode)
+                     const struct drm_display_mode *mode)
 {
        struct intel_connector *connector = to_intel_connector(_connector);
        struct drm_i915_private *i915 = to_i915(connector->base.dev);
 
 
 static enum drm_mode_status
 intel_sdvo_mode_valid(struct drm_connector *connector,
-                     struct drm_display_mode *mode)
+                     const struct drm_display_mode *mode)
 {
        struct drm_i915_private *i915 = to_i915(connector->dev);
        struct intel_sdvo *intel_sdvo = intel_attached_sdvo(to_intel_connector(connector));
 
 
 static enum drm_mode_status
 intel_tv_mode_valid(struct drm_connector *connector,
-                   struct drm_display_mode *mode)
+                   const struct drm_display_mode *mode)
 {
        struct intel_display *display = to_intel_display(connector->dev);
        struct drm_i915_private *i915 = to_i915(connector->dev);
 
 };
 
 static enum drm_mode_status vlv_dsi_mode_valid(struct drm_connector *connector,
-                                              struct drm_display_mode *mode)
+                                              const struct drm_display_mode *mode)
 {
        struct drm_i915_private *i915 = to_i915(connector->dev);
 
 
 
 static enum drm_mode_status
 imx_tve_connector_mode_valid(struct drm_connector *connector,
-                            struct drm_display_mode *mode)
+                            const struct drm_display_mode *mode)
 {
        struct imx_tve *tve = con_to_tve(connector);
        unsigned long rate;
 
 
 static enum drm_mode_status
 mdp4_lvds_connector_mode_valid(struct drm_connector *connector,
-                              struct drm_display_mode *mode)
+                              const struct drm_display_mode *mode)
 {
        struct mdp4_lvds_connector *mdp4_lvds_connector =
                        to_mdp4_lvds_connector(connector);
 
 
 static enum drm_mode_status
 nv50_mstc_mode_valid(struct drm_connector *connector,
-                    struct drm_display_mode *mode)
+                    const struct drm_display_mode *mode)
 {
        struct nv50_mstc *mstc = nv50_mstc(connector);
        struct nouveau_encoder *outp = mstc->mstm->outp;
 
 
 static enum drm_mode_status
 nouveau_connector_mode_valid(struct drm_connector *connector,
-                            struct drm_display_mode *mode)
+                            const struct drm_display_mode *mode)
 {
        struct nouveau_connector *nv_connector = nouveau_connector(connector);
        struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
 
 }
 
 static enum drm_mode_status qxl_conn_mode_valid(struct drm_connector *connector,
-                              struct drm_display_mode *mode)
+                              const struct drm_display_mode *mode)
 {
        struct drm_device *ddev = connector->dev;
        struct qxl_device *qdev = to_qxl(ddev);
 
 }
 
 int radeon_dp_mode_valid_helper(struct drm_connector *connector,
-                               struct drm_display_mode *mode)
+                               const struct drm_display_mode *mode)
 {
        struct radeon_connector *radeon_connector = to_radeon_connector(connector);
        struct radeon_connector_atom_dig *dig_connector;
 
 }
 
 static enum drm_mode_status radeon_lvds_mode_valid(struct drm_connector *connector,
-                                 struct drm_display_mode *mode)
+                                 const struct drm_display_mode *mode)
 {
        struct drm_encoder *encoder = radeon_best_single_encoder(connector);
 
 }
 
 static enum drm_mode_status radeon_vga_mode_valid(struct drm_connector *connector,
-                                 struct drm_display_mode *mode)
+                                 const struct drm_display_mode *mode)
 {
        struct drm_device *dev = connector->dev;
        struct radeon_device *rdev = dev->dev_private;
 }
 
 static enum drm_mode_status radeon_tv_mode_valid(struct drm_connector *connector,
-                               struct drm_display_mode *mode)
+                               const struct drm_display_mode *mode)
 {
        if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
                return MODE_CLOCK_RANGE;
 }
 
 static enum drm_mode_status radeon_dvi_mode_valid(struct drm_connector *connector,
-                                 struct drm_display_mode *mode)
+                                 const struct drm_display_mode *mode)
 {
        struct drm_device *dev = connector->dev;
        struct radeon_device *rdev = dev->dev_private;
 }
 
 static enum drm_mode_status radeon_dp_mode_valid(struct drm_connector *connector,
-                                 struct drm_display_mode *mode)
+                                 const struct drm_display_mode *mode)
 {
        struct drm_device *dev = connector->dev;
        struct radeon_device *rdev = dev->dev_private;
 
 
 extern void radeon_connector_hotplug(struct drm_connector *connector);
 extern int radeon_dp_mode_valid_helper(struct drm_connector *connector,
-                                      struct drm_display_mode *mode);
+                                      const struct drm_display_mode *mode);
 extern void radeon_dp_set_link_config(struct drm_connector *connector,
                                      const struct drm_display_mode *mode);
 extern void radeon_dp_link_train(struct drm_encoder *encoder,
 
 
 static enum drm_mode_status
 cdn_dp_connector_mode_valid(struct drm_connector *connector,
-                           struct drm_display_mode *mode)
+                           const struct drm_display_mode *mode)
 {
        struct cdn_dp_device *dp = connector_to_dp(connector);
        struct drm_display_info *display_info = &dp->connector.display_info;
 
 }
 
 static enum drm_mode_status inno_hdmi_display_mode_valid(struct inno_hdmi *hdmi,
-                                                        struct drm_display_mode *mode)
+                                                        const struct drm_display_mode *mode)
 {
        unsigned long mpixelclk, max_tolerance;
        long rounded_refclk;
 
 static enum drm_mode_status
 inno_hdmi_connector_mode_valid(struct drm_connector *connector,
-                              struct drm_display_mode *mode)
+                              const struct drm_display_mode *mode)
 {
        struct inno_hdmi *hdmi = connector_to_inno_hdmi(connector);
 
 
 
 static enum drm_mode_status
 rk3066_hdmi_connector_mode_valid(struct drm_connector *connector,
-                                struct drm_display_mode *mode)
+                                const struct drm_display_mode *mode)
 {
        u32 vic = drm_match_cea_mode(mode);
 
 
 
 static enum drm_mode_status
 sti_dvo_connector_mode_valid(struct drm_connector *connector,
-                            struct drm_display_mode *mode)
+                            const struct drm_display_mode *mode)
 {
        int target = mode->clock * 1000;
        int target_min = target - CLK_TOLERANCE_HZ;
 
 
 static enum drm_mode_status
 sti_hda_connector_mode_valid(struct drm_connector *connector,
-                            struct drm_display_mode *mode)
+                            const struct drm_display_mode *mode)
 {
        int target = mode->clock * 1000;
        int target_min = target - CLK_TOLERANCE_HZ;
 
 
 static enum drm_mode_status
 sti_hdmi_connector_mode_valid(struct drm_connector *connector,
-                             struct drm_display_mode *mode)
+                             const struct drm_display_mode *mode)
 {
        int target = mode->clock * 1000;
        int target_min = target - CLK_TOLERANCE_HZ;
 
 
 static enum drm_mode_status
 tegra_dsi_connector_mode_valid(struct drm_connector *connector,
-                              struct drm_display_mode *mode)
+                              const struct drm_display_mode *mode)
 {
        return MODE_OK;
 }
 
 
 static enum drm_mode_status
 tegra_hdmi_connector_mode_valid(struct drm_connector *connector,
-                               struct drm_display_mode *mode)
+                               const struct drm_display_mode *mode)
 {
        struct tegra_output *output = connector_to_output(connector);
        struct tegra_hdmi *hdmi = to_hdmi(output);
 
 
 static enum drm_mode_status
 tegra_sor_connector_mode_valid(struct drm_connector *connector,
-                              struct drm_display_mode *mode)
+                              const struct drm_display_mode *mode)
 {
        return MODE_OK;
 }
 
 
 static enum drm_mode_status
 vc4_txp_connector_mode_valid(struct drm_connector *connector,
-                            struct drm_display_mode *mode)
+                            const struct drm_display_mode *mode)
 {
        struct drm_device *dev = connector->dev;
        struct drm_mode_config *mode_config = &dev->mode_config;
 
 }
 
 static enum drm_mode_status virtio_gpu_conn_mode_valid(struct drm_connector *connector,
-                                     struct drm_display_mode *mode)
+                                     const struct drm_display_mode *mode)
 {
        struct virtio_gpu_output *output =
                drm_connector_to_virtio_gpu_output(connector);
 
  * Returns MODE_OK on success, or a drm_mode_status error code.
  */
 enum drm_mode_status vmw_connector_mode_valid(struct drm_connector *connector,
-                                             struct drm_display_mode *mode)
+                                             const struct drm_display_mode *mode)
 {
        enum drm_mode_status ret;
        struct drm_device *dev = connector->dev;
 
                         int increment,
                         struct vmw_kms_dirty *dirty);
 enum drm_mode_status vmw_connector_mode_valid(struct drm_connector *connector,
-                                             struct drm_display_mode *mode);
+                                             const struct drm_display_mode *mode);
 int vmw_connector_get_modes(struct drm_connector *connector);
 
 void vmw_kms_helper_validation_finish(struct vmw_private *dev_priv,
 
 
 static enum drm_mode_status
 vmw_stdu_connector_mode_valid(struct drm_connector *connector,
-                             struct drm_display_mode *mode)
+                             const struct drm_display_mode *mode)
 {
        enum drm_mode_status ret;
        struct drm_device *dev = connector->dev;
 
 
 enum drm_mode_status
 drm_hdmi_connector_mode_valid(struct drm_connector *connector,
-                             struct drm_display_mode *mode);
+                             const struct drm_display_mode *mode);
 
 #endif // DRM_HDMI_STATE_HELPER_H_
 
         * drm_mode_status.
         */
        enum drm_mode_status (*mode_valid)(struct drm_connector *connector,
-                                          struct drm_display_mode *mode);
+                                          const struct drm_display_mode *mode);
 
        /**
         * @mode_valid_ctx: