ARCPGU_CTRL_ENABLE_MASK);
 }
 
-static void arc_pgu_crtc_disable(struct drm_crtc *crtc)
+static void arc_pgu_crtc_atomic_disable(struct drm_crtc *crtc,
+                                       struct drm_crtc_state *old_state)
 {
        struct arcpgu_drm_private *arcpgu = crtc_to_arcpgu_priv(crtc);
 
        .mode_set       = drm_helper_crtc_mode_set,
        .mode_set_base  = drm_helper_crtc_mode_set_base,
        .mode_set_nofb  = arc_pgu_crtc_mode_set_nofb,
-       .disable        = arc_pgu_crtc_disable,
        .atomic_begin   = arc_pgu_crtc_atomic_begin,
        .atomic_enable  = arc_pgu_crtc_atomic_enable,
+       .atomic_disable = arc_pgu_crtc_atomic_disable,
 };
 
 static void arc_pgu_plane_atomic_update(struct drm_plane *plane,
 
        drm_crtc_vblank_on(crtc);
 }
 
-static void hdlcd_crtc_disable(struct drm_crtc *crtc)
+static void hdlcd_crtc_atomic_disable(struct drm_crtc *crtc,
+                                     struct drm_crtc_state *old_state)
 {
        struct hdlcd_drm_private *hdlcd = crtc_to_hdlcd_priv(crtc);
 
 }
 
 static const struct drm_crtc_helper_funcs hdlcd_crtc_helper_funcs = {
-       .disable        = hdlcd_crtc_disable,
        .atomic_check   = hdlcd_crtc_atomic_check,
        .atomic_begin   = hdlcd_crtc_atomic_begin,
        .atomic_enable  = hdlcd_crtc_atomic_enable,
+       .atomic_disable = hdlcd_crtc_atomic_disable,
 };
 
 static int hdlcd_plane_atomic_check(struct drm_plane *plane,
 
        drm_crtc_vblank_on(crtc);
 }
 
-static void malidp_crtc_disable(struct drm_crtc *crtc)
+static void malidp_crtc_atomic_disable(struct drm_crtc *crtc,
+                                      struct drm_crtc_state *old_state)
 {
        struct malidp_drm *malidp = crtc_to_malidp_device(crtc);
        struct malidp_hw_device *hwdev = malidp->dev;
 
 static const struct drm_crtc_helper_funcs malidp_crtc_helper_funcs = {
        .mode_valid = malidp_crtc_mode_valid,
-       .disable = malidp_crtc_disable,
        .atomic_check = malidp_crtc_atomic_check,
        .atomic_enable = malidp_crtc_atomic_enable,
+       .atomic_disable = malidp_crtc_atomic_disable,
 };
 
 static struct drm_crtc_state *malidp_crtc_duplicate_state(struct drm_crtc *crtc)
 
        return atmel_hlcdc_dc_mode_valid(crtc->dc, mode);
 }
 
-static void atmel_hlcdc_crtc_disable(struct drm_crtc *c)
+static void atmel_hlcdc_crtc_atomic_disable(struct drm_crtc *c,
+                                           struct drm_crtc_state *old_state)
 {
        struct drm_device *dev = c->dev;
        struct atmel_hlcdc_crtc *crtc = drm_crtc_to_atmel_hlcdc_crtc(c);
        .mode_set = drm_helper_crtc_mode_set,
        .mode_set_nofb = atmel_hlcdc_crtc_mode_set_nofb,
        .mode_set_base = drm_helper_crtc_mode_set_base,
-       .disable = atmel_hlcdc_crtc_disable,
        .atomic_check = atmel_hlcdc_crtc_atomic_check,
        .atomic_begin = atmel_hlcdc_crtc_atomic_begin,
        .atomic_flush = atmel_hlcdc_crtc_atomic_flush,
        .atomic_enable = atmel_hlcdc_crtc_atomic_enable,
+       .atomic_disable = atmel_hlcdc_crtc_atomic_disable,
 };
 
 static void atmel_hlcdc_crtc_destroy(struct drm_crtc *c)
 
        pipe->funcs->enable(pipe, crtc->state);
 }
 
-static void drm_simple_kms_crtc_disable(struct drm_crtc *crtc)
+static void drm_simple_kms_crtc_disable(struct drm_crtc *crtc,
+                                       struct drm_crtc_state *old_state)
 {
        struct drm_simple_display_pipe *pipe;
 
 static const struct drm_crtc_helper_funcs drm_simple_kms_crtc_helper_funcs = {
        .atomic_check = drm_simple_kms_crtc_check,
        .atomic_enable = drm_simple_kms_crtc_enable,
-       .disable = drm_simple_kms_crtc_disable,
+       .atomic_disable = drm_simple_kms_crtc_disable,
 };
 
 static const struct drm_crtc_funcs drm_simple_kms_crtc_funcs = {
 
        drm_crtc_vblank_on(crtc);
 }
 
-static void exynos_drm_crtc_disable(struct drm_crtc *crtc)
+static void exynos_drm_crtc_atomic_disable(struct drm_crtc *crtc,
+                                          struct drm_crtc_state *old_state)
 {
        struct exynos_drm_crtc *exynos_crtc = to_exynos_crtc(crtc);
 
 }
 
 static const struct drm_crtc_helper_funcs exynos_crtc_helper_funcs = {
-       .disable        = exynos_drm_crtc_disable,
        .atomic_check   = exynos_crtc_atomic_check,
        .atomic_begin   = exynos_crtc_atomic_begin,
        .atomic_flush   = exynos_crtc_atomic_flush,
        .atomic_enable  = exynos_drm_crtc_atomic_enable,
+       .atomic_disable = exynos_drm_crtc_atomic_disable,
 };
 
 void exynos_crtc_handle_event(struct exynos_drm_crtc *exynos_crtc)
 
        drm_crtc_vblank_on(crtc);
 }
 
-static void hibmc_crtc_disable(struct drm_crtc *crtc)
+static void hibmc_crtc_atomic_disable(struct drm_crtc *crtc,
+                                     struct drm_crtc_state *old_state)
 {
        unsigned int reg;
        struct hibmc_drm_private *priv = crtc->dev->dev_private;
 };
 
 static const struct drm_crtc_helper_funcs hibmc_crtc_helper_funcs = {
-       .disable        = hibmc_crtc_disable,
        .mode_set_nofb  = hibmc_crtc_mode_set_nofb,
        .atomic_begin   = hibmc_crtc_atomic_begin,
        .atomic_flush   = hibmc_crtc_atomic_flush,
        .atomic_enable  = hibmc_crtc_atomic_enable,
+       .atomic_disable = hibmc_crtc_atomic_disable,
 };
 
 int hibmc_de_init(struct hibmc_drm_private *priv)
 
        acrtc->enable = true;
 }
 
-static void ade_crtc_disable(struct drm_crtc *crtc)
+static void ade_crtc_atomic_disable(struct drm_crtc *crtc,
+                                   struct drm_crtc_state *old_state)
 {
        struct ade_crtc *acrtc = to_ade_crtc(crtc);
        struct ade_hw_ctx *ctx = acrtc->ctx;
 }
 
 static const struct drm_crtc_helper_funcs ade_crtc_helper_funcs = {
-       .disable        = ade_crtc_disable,
        .mode_set_nofb  = ade_crtc_mode_set_nofb,
        .atomic_begin   = ade_crtc_atomic_begin,
        .atomic_flush   = ade_crtc_atomic_flush,
        .atomic_enable  = ade_crtc_atomic_enable,
+       .atomic_disable = ade_crtc_atomic_disable,
 };
 
 static const struct drm_crtc_funcs ade_crtc_funcs = {
 
        mtk_crtc->enabled = true;
 }
 
-static void mtk_drm_crtc_disable(struct drm_crtc *crtc)
+static void mtk_drm_crtc_atomic_disable(struct drm_crtc *crtc,
+                                       struct drm_crtc_state *old_state)
 {
        struct mtk_drm_crtc *mtk_crtc = to_mtk_crtc(crtc);
        struct mtk_ddp_comp *ovl = mtk_crtc->ddp_comp[0];
 static const struct drm_crtc_helper_funcs mtk_crtc_helper_funcs = {
        .mode_fixup     = mtk_drm_crtc_mode_fixup,
        .mode_set_nofb  = mtk_drm_crtc_mode_set_nofb,
-       .disable        = mtk_drm_crtc_disable,
        .atomic_begin   = mtk_drm_crtc_atomic_begin,
        .atomic_flush   = mtk_drm_crtc_atomic_flush,
        .atomic_enable  = mtk_drm_crtc_atomic_enable,
+       .atomic_disable = mtk_drm_crtc_atomic_disable,
 };
 
 static int mtk_drm_crtc_init(struct drm_device *drm,
 
        priv->viu.osd1_enabled = true;
 }
 
-static void meson_crtc_disable(struct drm_crtc *crtc)
+static void meson_crtc_atomic_disable(struct drm_crtc *crtc,
+                                     struct drm_crtc_state *old_state)
 {
        struct meson_crtc *meson_crtc = to_meson_crtc(crtc);
        struct meson_drm *priv = meson_crtc->priv;
 }
 
 static const struct drm_crtc_helper_funcs meson_crtc_helper_funcs = {
-       .disable        = meson_crtc_disable,
        .atomic_begin   = meson_crtc_atomic_begin,
        .atomic_flush   = meson_crtc_atomic_flush,
        .atomic_enable  = meson_crtc_atomic_enable,
+       .atomic_disable = meson_crtc_atomic_disable,
 };
 
 void meson_crtc_irq(struct meson_drm *priv)
 
        }
 }
 
-static void mdp4_crtc_disable(struct drm_crtc *crtc)
+static void mdp4_crtc_atomic_disable(struct drm_crtc *crtc,
+                                    struct drm_crtc_state *old_state)
 {
        struct mdp4_crtc *mdp4_crtc = to_mdp4_crtc(crtc);
        struct mdp4_kms *mdp4_kms = get_kms(crtc);
 
 static const struct drm_crtc_helper_funcs mdp4_crtc_helper_funcs = {
        .mode_set_nofb = mdp4_crtc_mode_set_nofb,
-       .disable = mdp4_crtc_disable,
        .atomic_check = mdp4_crtc_atomic_check,
        .atomic_begin = mdp4_crtc_atomic_begin,
        .atomic_flush = mdp4_crtc_atomic_flush,
        .atomic_enable = mdp4_crtc_atomic_enable,
+       .atomic_disable = mdp4_crtc_atomic_disable,
 };
 
 static void mdp4_crtc_vblank_irq(struct mdp_irq *irq, uint32_t irqstatus)
 
        spin_unlock_irqrestore(&mdp5_crtc->lm_lock, flags);
 }
 
-static void mdp5_crtc_disable(struct drm_crtc *crtc)
+static void mdp5_crtc_atomic_disable(struct drm_crtc *crtc,
+                                    struct drm_crtc_state *old_state)
 {
        struct mdp5_crtc *mdp5_crtc = to_mdp5_crtc(crtc);
        struct mdp5_crtc_state *mdp5_cstate = to_mdp5_crtc_state(crtc->state);
 
 static const struct drm_crtc_helper_funcs mdp5_crtc_helper_funcs = {
        .mode_set_nofb = mdp5_crtc_mode_set_nofb,
-       .disable = mdp5_crtc_disable,
        .atomic_check = mdp5_crtc_atomic_check,
        .atomic_begin = mdp5_crtc_atomic_begin,
        .atomic_flush = mdp5_crtc_atomic_flush,
        .atomic_enable = mdp5_crtc_atomic_enable,
+       .atomic_disable = mdp5_crtc_atomic_disable,
 };
 
 static void mdp5_crtc_vblank_irq(struct mdp_irq *irq, uint32_t irqstatus)
 
        spin_unlock_irq(&crtc->dev->event_lock);
 }
 
-static void omap_crtc_disable(struct drm_crtc *crtc)
+static void omap_crtc_atomic_disable(struct drm_crtc *crtc,
+                                    struct drm_crtc_state *old_state)
 {
        struct omap_crtc *omap_crtc = to_omap_crtc(crtc);
 
 
 static const struct drm_crtc_helper_funcs omap_crtc_helper_funcs = {
        .mode_set_nofb = omap_crtc_mode_set_nofb,
-       .disable = omap_crtc_disable,
        .atomic_check = omap_crtc_atomic_check,
        .atomic_begin = omap_crtc_atomic_begin,
        .atomic_flush = omap_crtc_atomic_flush,
        .atomic_enable = omap_crtc_atomic_enable,
+       .atomic_disable = omap_crtc_atomic_disable,
 };
 
 /* -----------------------------------------------------------------------------
 
        DRM_DEBUG("\n");
 }
 
-static void qxl_crtc_disable(struct drm_crtc *crtc)
+static void qxl_crtc_atomic_disable(struct drm_crtc *crtc,
+                                   struct drm_crtc_state *old_state)
 {
        struct qxl_crtc *qcrtc = to_qxl_crtc(crtc);
        struct qxl_device *qdev = crtc->dev->dev_private;
 }
 
 static const struct drm_crtc_helper_funcs qxl_crtc_helper_funcs = {
-       .disable = qxl_crtc_disable,
        .mode_fixup = qxl_crtc_mode_fixup,
        .mode_set_nofb = qxl_mode_set_nofb,
        .atomic_flush = qxl_crtc_atomic_flush,
        .atomic_enable = qxl_crtc_atomic_enable,
+       .atomic_disable = qxl_crtc_atomic_disable,
 };
 
 static int qxl_primary_atomic_check(struct drm_plane *plane,
 
        rcar_du_crtc_start(rcrtc);
 }
 
-static void rcar_du_crtc_disable(struct drm_crtc *crtc)
+static void rcar_du_crtc_atomic_disable(struct drm_crtc *crtc,
+                                       struct drm_crtc_state *old_state)
 {
        struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc);
 
 }
 
 static const struct drm_crtc_helper_funcs crtc_helper_funcs = {
-       .disable = rcar_du_crtc_disable,
        .atomic_begin = rcar_du_crtc_atomic_begin,
        .atomic_flush = rcar_du_crtc_atomic_flush,
        .atomic_enable = rcar_du_crtc_atomic_enable,
+       .atomic_disable = rcar_du_crtc_atomic_disable,
 };
 
 static int rcar_du_crtc_enable_vblank(struct drm_crtc *crtc)
 
        return ret;
 }
 
-static void vop_crtc_disable(struct drm_crtc *crtc)
+static void vop_crtc_atomic_disable(struct drm_crtc *crtc,
+                                   struct drm_crtc_state *old_state)
 {
        struct vop *vop = to_vop(crtc);
        int i;
 }
 
 static const struct drm_crtc_helper_funcs vop_crtc_helper_funcs = {
-       .disable = vop_crtc_disable,
        .mode_fixup = vop_crtc_mode_fixup,
        .atomic_flush = vop_crtc_atomic_flush,
        .atomic_begin = vop_crtc_atomic_begin,
        .atomic_enable = vop_crtc_atomic_enable,
+       .atomic_disable = vop_crtc_atomic_disable,
 };
 
 static void vop_crtc_destroy(struct drm_crtc *crtc)
 
        drm_crtc_vblank_on(crtc);
 }
 
-static void sti_crtc_disabling(struct drm_crtc *crtc)
+static void sti_crtc_atomic_disable(struct drm_crtc *crtc,
+                                   struct drm_crtc_state *old_state)
 {
        struct sti_mixer *mixer = to_sti_mixer(crtc);
 
 }
 
 static const struct drm_crtc_helper_funcs sti_crtc_helper_funcs = {
-       .disable = sti_crtc_disabling,
        .mode_set_nofb = sti_crtc_mode_set_nofb,
        .atomic_flush = sti_crtc_atomic_flush,
        .atomic_enable = sti_crtc_atomic_enable,
+       .atomic_disable = sti_crtc_atomic_disable,
 };
 
 static void sti_crtc_destroy(struct drm_crtc *crtc)
 
        drm_crtc_vblank_on(crtc);
 }
 
-static void ltdc_crtc_disable(struct drm_crtc *crtc)
+static void ltdc_crtc_atomic_disable(struct drm_crtc *crtc,
+                                    struct drm_crtc_state *old_state)
 {
        struct ltdc_device *ldev = crtc_to_ltdc(crtc);
 
 
 static struct drm_crtc_helper_funcs ltdc_crtc_helper_funcs = {
        .load_lut = ltdc_crtc_load_lut,
-       .disable = ltdc_crtc_disable,
        .mode_set_nofb = ltdc_crtc_mode_set_nofb,
        .atomic_flush = ltdc_crtc_atomic_flush,
        .atomic_enable = ltdc_crtc_atomic_enable,
+       .atomic_disable = ltdc_crtc_atomic_disable,
 };
 
 int ltdc_crtc_enable_vblank(struct drm_device *ddev, unsigned int pipe)
 
        }
 }
 
-static void sun4i_crtc_disable(struct drm_crtc *crtc)
+static void sun4i_crtc_atomic_disable(struct drm_crtc *crtc,
+                                     struct drm_crtc_state *old_state)
 {
        struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
 
        .atomic_begin   = sun4i_crtc_atomic_begin,
        .atomic_flush   = sun4i_crtc_atomic_flush,
        .atomic_enable  = sun4i_crtc_atomic_enable,
-       .disable        = sun4i_crtc_disable,
+       .atomic_disable = sun4i_crtc_atomic_disable,
 };
 
 static int sun4i_crtc_enable_vblank(struct drm_crtc *crtc)
 
        return -ETIMEDOUT;
 }
 
-static void tegra_crtc_disable(struct drm_crtc *crtc)
+static void tegra_crtc_atomic_disable(struct drm_crtc *crtc,
+                                     struct drm_crtc_state *old_state)
 {
        struct tegra_dc *dc = to_tegra_dc(crtc);
        u32 value;
 }
 
 static const struct drm_crtc_helper_funcs tegra_crtc_helper_funcs = {
-       .disable = tegra_crtc_disable,
        .atomic_check = tegra_crtc_atomic_check,
        .atomic_begin = tegra_crtc_atomic_begin,
        .atomic_flush = tegra_crtc_atomic_flush,
        .atomic_enable = tegra_crtc_atomic_enable,
+       .atomic_disable = tegra_crtc_atomic_disable,
 };
 
 static irqreturn_t tegra_dc_irq(int irq, void *data)
 
        tilcdc_crtc_off(crtc, false);
 }
 
+static void tilcdc_crtc_atomic_disable(struct drm_crtc *crtc,
+                                      struct drm_crtc_state *old_state)
+{
+       tilcdc_crtc_disable(crtc);
+}
+
 void tilcdc_crtc_shutdown(struct drm_crtc *crtc)
 {
        tilcdc_crtc_off(crtc, true);
 
 static const struct drm_crtc_helper_funcs tilcdc_crtc_helper_funcs = {
                .mode_fixup     = tilcdc_crtc_mode_fixup,
-               .disable        = tilcdc_crtc_disable,
                .atomic_check   = tilcdc_crtc_atomic_check,
                .atomic_enable  = tilcdc_crtc_atomic_enable,
+               .atomic_disable = tilcdc_crtc_atomic_disable,
 };
 
 int tilcdc_crtc_max_width(struct drm_crtc *crtc)
 
                     SCALER_DISPCTRL_ENABLE);
 }
 
-static void vc4_crtc_disable(struct drm_crtc *crtc)
+static void vc4_crtc_atomic_disable(struct drm_crtc *crtc,
+                                   struct drm_crtc_state *old_state)
 {
        struct drm_device *dev = crtc->dev;
        struct vc4_dev *vc4 = to_vc4_dev(dev);
 
 static const struct drm_crtc_helper_funcs vc4_crtc_helper_funcs = {
        .mode_set_nofb = vc4_crtc_mode_set_nofb,
-       .disable = vc4_crtc_disable,
        .mode_valid = vc4_crtc_mode_valid,
        .atomic_check = vc4_crtc_atomic_check,
        .atomic_flush = vc4_crtc_atomic_flush,
        .atomic_enable = vc4_crtc_atomic_enable,
+       .atomic_disable = vc4_crtc_atomic_disable,
 };
 
 static const struct vc4_crtc_data pv0_data = {
 
 {
 }
 
-static void virtio_gpu_crtc_disable(struct drm_crtc *crtc)
+static void virtio_gpu_crtc_atomic_disable(struct drm_crtc *crtc,
+                                          struct drm_crtc_state *old_state)
 {
        struct drm_device *dev = crtc->dev;
        struct virtio_gpu_device *vgdev = dev->dev_private;
 }
 
 static const struct drm_crtc_helper_funcs virtio_gpu_crtc_helper_funcs = {
-       .disable       = virtio_gpu_crtc_disable,
        .mode_set_nofb = virtio_gpu_crtc_mode_set_nofb,
        .atomic_check  = virtio_gpu_crtc_atomic_check,
        .atomic_flush  = virtio_gpu_crtc_atomic_flush,
        .atomic_enable = virtio_gpu_crtc_atomic_enable,
+       .atomic_disable = virtio_gpu_crtc_atomic_disable,
 };
 
 static void virtio_gpu_enc_mode_set(struct drm_encoder *encoder,
 
 }
 
 /**
- * vmw_ldu_crtc_helper_disable - Turns off CRTC
+ * vmw_ldu_crtc_atomic_disable - Turns off CRTC
  *
  * @crtc: CRTC to be turned off
  */
-static void vmw_ldu_crtc_helper_disable(struct drm_crtc *crtc)
+static void vmw_ldu_crtc_atomic_disable(struct drm_crtc *crtc,
+                                       struct drm_crtc_state *old_state)
 {
 }
 
 };
 
 static const struct drm_crtc_helper_funcs vmw_ldu_crtc_helper_funcs = {
-       .disable = vmw_ldu_crtc_helper_disable,
        .mode_set_nofb = vmw_ldu_crtc_mode_set_nofb,
        .atomic_check = vmw_du_crtc_atomic_check,
        .atomic_begin = vmw_du_crtc_atomic_begin,
        .atomic_flush = vmw_du_crtc_atomic_flush,
        .atomic_enable = vmw_ldu_crtc_atomic_enable,
+       .atomic_disable = vmw_ldu_crtc_atomic_disable,
 };
 
 
 
 }
 
 /**
- * vmw_sou_crtc_helper_disable - Turns off CRTC
+ * vmw_sou_crtc_atomic_disable - Turns off CRTC
  *
  * @crtc: CRTC to be turned off
  */
-static void vmw_sou_crtc_helper_disable(struct drm_crtc *crtc)
+static void vmw_sou_crtc_atomic_disable(struct drm_crtc *crtc,
+                                       struct drm_crtc_state *old_state)
 {
        struct vmw_private *dev_priv;
        struct vmw_screen_object_unit *sou;
 
 static const struct drm_crtc_helper_funcs vmw_sou_crtc_helper_funcs = {
        .prepare = vmw_sou_crtc_helper_prepare,
-       .disable = vmw_sou_crtc_helper_disable,
        .mode_set_nofb = vmw_sou_crtc_mode_set_nofb,
        .atomic_check = vmw_du_crtc_atomic_check,
        .atomic_begin = vmw_du_crtc_atomic_begin,
        .atomic_flush = vmw_du_crtc_atomic_flush,
        .atomic_enable = vmw_sou_crtc_atomic_enable,
+       .atomic_disable = vmw_sou_crtc_atomic_disable,
 };
 
 
 
                vmw_kms_del_active(dev_priv, &stdu->base);
 }
 
-static void vmw_stdu_crtc_helper_disable(struct drm_crtc *crtc)
+static void vmw_stdu_crtc_atomic_disable(struct drm_crtc *crtc,
+                                        struct drm_crtc_state *old_state)
 {
        struct vmw_private *dev_priv;
        struct vmw_screen_target_display_unit *stdu;
 
 static const struct drm_crtc_helper_funcs vmw_stdu_crtc_helper_funcs = {
        .prepare = vmw_stdu_crtc_helper_prepare,
-       .disable = vmw_stdu_crtc_helper_disable,
        .mode_set_nofb = vmw_stdu_crtc_mode_set_nofb,
        .atomic_check = vmw_du_crtc_atomic_check,
        .atomic_begin = vmw_du_crtc_atomic_begin,
        .atomic_flush = vmw_du_crtc_atomic_flush,
        .atomic_enable = vmw_stdu_crtc_atomic_enable,
+       .atomic_disable = vmw_stdu_crtc_atomic_disable,
 };
 
 
 
                DRM_DEV_ERROR(vou->dev, "failed to enable pixclk: %d\n", ret);
 }
 
-static void zx_crtc_disable(struct drm_crtc *crtc)
+static void zx_crtc_atomic_disable(struct drm_crtc *crtc,
+                                  struct drm_crtc_state *old_state)
 {
        struct zx_crtc *zcrtc = to_zx_crtc(crtc);
        const struct zx_crtc_bits *bits = zcrtc->bits;
 }
 
 static const struct drm_crtc_helper_funcs zx_crtc_helper_funcs = {
-       .disable = zx_crtc_disable,
        .atomic_flush = zx_crtc_atomic_flush,
        .atomic_enable = zx_crtc_atomic_enable,
+       .atomic_disable = zx_crtc_atomic_disable,
 };
 
 static int zx_vou_enable_vblank(struct drm_crtc *crtc)