}
 
                if (funcs->atomic_check)
-                       ret = funcs->atomic_check(connector, new_connector_state);
+                       ret = funcs->atomic_check(connector, state);
                if (ret)
                        return ret;
 
                        continue;
 
                if (funcs->atomic_check)
-                       ret = funcs->atomic_check(connector, new_connector_state);
+                       ret = funcs->atomic_check(connector, state);
                if (ret)
                        return ret;
        }
 
 }
 
 int intel_digital_connector_atomic_check(struct drm_connector *conn,
-                                        struct drm_connector_state *new_state)
+                                        struct drm_atomic_state *state)
 {
+       struct drm_connector_state *new_state =
+               drm_atomic_get_new_connector_state(state, conn);
        struct intel_digital_connector_state *new_conn_state =
                to_intel_digital_connector_state(new_state);
        struct drm_connector_state *old_state =
-               drm_atomic_get_old_connector_state(new_state->state, conn);
+               drm_atomic_get_old_connector_state(state, conn);
        struct intel_digital_connector_state *old_conn_state =
                to_intel_digital_connector_state(old_state);
        struct drm_crtc_state *crtc_state;
        if (!new_state->crtc)
                return 0;
 
-       crtc_state = drm_atomic_get_new_crtc_state(new_state->state, new_state->crtc);
+       crtc_state = drm_atomic_get_new_crtc_state(state, new_state->crtc);
 
        /*
         * These properties are handled by fastset, and might not end
 
                                                struct drm_property *property,
                                                u64 val);
 int intel_digital_connector_atomic_check(struct drm_connector *conn,
-                                        struct drm_connector_state *new_state);
+                                        struct drm_atomic_state *state);
 struct drm_connector_state *
 intel_digital_connector_duplicate_state(struct drm_connector *connector);
 
 
 
 static int
 intel_dp_mst_atomic_check(struct drm_connector *connector,
-                         struct drm_connector_state *new_conn_state)
+                         struct drm_atomic_state *state)
 {
-       struct drm_atomic_state *state = new_conn_state->state;
+       struct drm_connector_state *new_conn_state =
+               drm_atomic_get_new_connector_state(state, connector);
        struct drm_connector_state *old_conn_state =
                drm_atomic_get_old_connector_state(state, connector);
        struct intel_connector *intel_connector =
        struct drm_dp_mst_topology_mgr *mgr;
        int ret;
 
-       ret = intel_digital_connector_atomic_check(connector, new_conn_state);
+       ret = intel_digital_connector_atomic_check(connector, state);
        if (ret)
                return ret;
 
 
 };
 
 static int intel_sdvo_atomic_check(struct drm_connector *conn,
-                                  struct drm_connector_state *new_conn_state)
+                                  struct drm_atomic_state *state)
 {
-       struct drm_atomic_state *state = new_conn_state->state;
+       struct drm_connector_state *new_conn_state =
+               drm_atomic_get_new_connector_state(state, conn);
        struct drm_connector_state *old_conn_state =
                drm_atomic_get_old_connector_state(state, conn);
        struct intel_sdvo_connector_state *old_state =
            (memcmp(&old_state->tv, &new_state->tv, sizeof(old_state->tv)) ||
             memcmp(&old_conn_state->tv, &new_conn_state->tv, sizeof(old_conn_state->tv)))) {
                struct drm_crtc_state *crtc_state =
-                       drm_atomic_get_new_crtc_state(new_conn_state->state,
+                       drm_atomic_get_new_crtc_state(state,
                                                      new_conn_state->crtc);
 
                crtc_state->connectors_changed = true;
        }
 
-       return intel_digital_connector_atomic_check(conn, new_conn_state);
+       return intel_digital_connector_atomic_check(conn, state);
 }
 
 static const struct drm_connector_helper_funcs intel_sdvo_connector_helper_funcs = {
 
 };
 
 static int intel_tv_atomic_check(struct drm_connector *connector,
-                                struct drm_connector_state *new_state)
+                                struct drm_atomic_state *state)
 {
+       struct drm_connector_state *new_state;
        struct drm_crtc_state *new_crtc_state;
        struct drm_connector_state *old_state;
 
+       new_state = drm_atomic_get_new_connector_state(state, connector);
        if (!new_state->crtc)
                return 0;
 
-       old_state = drm_atomic_get_old_connector_state(new_state->state, connector);
-       new_crtc_state = drm_atomic_get_new_crtc_state(new_state->state, new_state->crtc);
+       old_state = drm_atomic_get_old_connector_state(state, connector);
+       new_crtc_state = drm_atomic_get_new_crtc_state(state, new_state->crtc);
 
        if (old_state->tv.mode != new_state->tv.mode ||
            old_state->tv.margins.left != new_state->tv.margins.left ||
 
 
 static int
 nv50_mstc_atomic_check(struct drm_connector *connector,
-                      struct drm_connector_state *new_conn_state)
+                      struct drm_atomic_state *state)
 {
-       struct drm_atomic_state *state = new_conn_state->state;
        struct nv50_mstc *mstc = nv50_mstc(connector);
        struct drm_dp_mst_topology_mgr *mgr = &mstc->mstm->mgr;
+       struct drm_connector_state *new_conn_state =
+               drm_atomic_get_new_connector_state(state, connector);
        struct drm_connector_state *old_conn_state =
                drm_atomic_get_old_connector_state(state, connector);
        struct drm_crtc_state *crtc_state;
 
 }
 
 static int rcar_lvds_connector_atomic_check(struct drm_connector *connector,
-                                           struct drm_connector_state *state)
+                                           struct drm_atomic_state *state)
 {
        struct rcar_lvds *lvds = connector_to_rcar_lvds(connector);
        const struct drm_display_mode *panel_mode;
+       struct drm_connector_state *conn_state;
        struct drm_crtc_state *crtc_state;
 
-       if (!state->crtc)
+       conn_state = drm_atomic_get_new_connector_state(state, connector);
+       if (!conn_state->crtc)
                return 0;
 
        if (list_empty(&connector->modes)) {
                                      struct drm_display_mode, head);
 
        /* We're not allowed to modify the resolution. */
-       crtc_state = drm_atomic_get_crtc_state(state->state, state->crtc);
-       if (IS_ERR(crtc_state))
-               return PTR_ERR(crtc_state);
+       crtc_state = drm_atomic_get_crtc_state(state, conn_state->crtc);
+       if (!crtc_state)
+               return -EINVAL;
 
        if (crtc_state->mode.hdisplay != panel_mode->hdisplay ||
            crtc_state->mode.vdisplay != panel_mode->vdisplay)
 
 };
 
 static int vc4_txp_connector_atomic_check(struct drm_connector *conn,
-                                       struct drm_connector_state *conn_state)
+                                         struct drm_atomic_state *state)
 {
+       struct drm_connector_state *conn_state;
        struct drm_crtc_state *crtc_state;
        struct drm_framebuffer *fb;
        int i;
 
+       conn_state = drm_atomic_get_new_connector_state(state, conn);
        if (!conn_state->writeback_job || !conn_state->writeback_job->fb)
                return 0;
 
-       crtc_state = drm_atomic_get_new_crtc_state(conn_state->state,
-                                                  conn_state->crtc);
+       crtc_state = drm_atomic_get_new_crtc_state(state, conn_state->crtc);
 
        fb = conn_state->writeback_job->fb;
        if (fb->width != crtc_state->mode.hdisplay ||
 
         * deadlock.
         */
        int (*atomic_check)(struct drm_connector *connector,
-                           struct drm_connector_state *state);
+                           struct drm_atomic_state *state);
 
        /**
         * @atomic_commit: