diff --git a/backend/drm/atomic.c b/backend/drm/atomic.c
index bbbd064e6..637f28727 100644
--- a/backend/drm/atomic.c
+++ b/backend/drm/atomic.c
@@ -61,8 +61,8 @@ static void atomic_begin(struct atomic *atom) {
 }
 
 static bool atomic_commit(struct atomic *atom, struct wlr_drm_backend *drm,
-		struct wlr_drm_connector *conn, struct wlr_drm_page_flip *page_flip,
-		uint32_t flags) {
+		const struct wlr_drm_device_state *state,
+		struct wlr_drm_page_flip *page_flip, uint32_t flags) {
 	if (atom->failed) {
 		return false;
 	}
@@ -74,12 +74,12 @@ static bool atomic_commit(struct atomic *atom, struct wlr_drm_backend *drm,
 			log_level = WLR_DEBUG;
 		}
 
-		if (conn != NULL) {
+		if (state->connectors_len == 1) {
+			struct wlr_drm_connector *conn = state->connectors[0].connector;
 			wlr_drm_conn_log_errno(conn, log_level, "Atomic commit failed");
 		} else {
 			wlr_log_errno(log_level, "Atomic commit failed");
 		}
-
 		char *flags_str = atomic_commit_flags_str(flags);
 		wlr_log(WLR_DEBUG, "(Atomic commit flags: %s)",
 			flags_str ? flags_str : "<error>");
@@ -101,7 +101,7 @@ static void atomic_add(struct atomic *atom, uint32_t id, uint32_t prop, uint64_t
 	}
 }
 
-bool create_mode_blob(struct wlr_drm_connector *conn,
+static bool create_mode_blob(struct wlr_drm_connector *conn,
 		const struct wlr_drm_connector_state *state, uint32_t *blob_id) {
 	if (!state->active) {
 		*blob_id = 0;
@@ -117,7 +117,7 @@ bool create_mode_blob(struct wlr_drm_connector *conn,
 	return true;
 }
 
-bool create_gamma_lut_blob(struct wlr_drm_backend *drm,
+static bool create_gamma_lut_blob(struct wlr_drm_backend *drm,
 		size_t size, const uint16_t *lut, uint32_t *blob_id) {
 	if (size == 0) {
 		*blob_id = 0;
@@ -233,51 +233,12 @@ static void rollback_blob(struct wlr_drm_backend *drm,
 	destroy_blob(drm, next);
 }
 
-static void plane_disable(struct atomic *atom, struct wlr_drm_plane *plane) {
-	uint32_t id = plane->id;
-	const union wlr_drm_plane_props *props = &plane->props;
-	atomic_add(atom, id, props->fb_id, 0);
-	atomic_add(atom, id, props->crtc_id, 0);
-}
-
-static void set_plane_props(struct atomic *atom, struct wlr_drm_backend *drm,
-		struct wlr_drm_plane *plane, struct wlr_drm_fb *fb, uint32_t crtc_id,
-		int32_t x, int32_t y) {
-	uint32_t id = plane->id;
-	const union wlr_drm_plane_props *props = &plane->props;
-
-	if (fb == NULL) {
-		wlr_log(WLR_ERROR, "Failed to acquire FB for plane %"PRIu32, plane->id);
-		atom->failed = true;
-		return;
-	}
-
-	uint32_t width = fb->wlr_buf->width;
-	uint32_t height = fb->wlr_buf->height;
-
-	// The src_* properties are in 16.16 fixed point
-	atomic_add(atom, id, props->src_x, 0);
-	atomic_add(atom, id, props->src_y, 0);
-	atomic_add(atom, id, props->src_w, (uint64_t)width << 16);
-	atomic_add(atom, id, props->src_h, (uint64_t)height << 16);
-	atomic_add(atom, id, props->crtc_w, width);
-	atomic_add(atom, id, props->crtc_h, height);
-	atomic_add(atom, id, props->fb_id, fb->id);
-	atomic_add(atom, id, props->crtc_id, crtc_id);
-	atomic_add(atom, id, props->crtc_x, (uint64_t)x);
-	atomic_add(atom, id, props->crtc_y, (uint64_t)y);
-}
-
-static bool atomic_crtc_commit(struct wlr_drm_connector *conn,
-		const struct wlr_drm_connector_state *state,
-		struct wlr_drm_page_flip *page_flip, uint32_t flags, bool test_only) {
+bool drm_atomic_connector_prepare(struct wlr_drm_connector_state *state, bool modeset) {
+	struct wlr_drm_connector *conn = state->connector;
 	struct wlr_drm_backend *drm = conn->backend;
 	struct wlr_output *output = &conn->output;
 	struct wlr_drm_crtc *crtc = conn->crtc;
 
-	bool modeset = state->modeset;
-	bool active = state->active;
-
 	uint32_t mode_id = crtc->mode_id;
 	if (modeset) {
 		if (!create_mode_blob(conn, state, &mode_id)) {
@@ -321,80 +282,160 @@ static bool atomic_crtc_commit(struct wlr_drm_connector *conn,
 		vrr_enabled = state->base->adaptive_sync_enabled;
 	}
 
+	state->mode_id = mode_id;
+	state->gamma_lut = gamma_lut;
+	state->fb_damage_clips = fb_damage_clips;
+	state->vrr_enabled = vrr_enabled;
+	return true;
+}
+
+void drm_atomic_connector_apply_commit(struct wlr_drm_connector_state *state) {
+	struct wlr_drm_connector *conn = state->connector;
+	struct wlr_drm_crtc *crtc = conn->crtc;
+	struct wlr_drm_backend *drm = conn->backend;
+
+	commit_blob(drm, &crtc->mode_id, state->mode_id);
+	commit_blob(drm, &crtc->gamma_lut, state->gamma_lut);
+
+	destroy_blob(drm, state->fb_damage_clips);
+}
+
+void drm_atomic_connector_rollback_commit(struct wlr_drm_connector_state *state) {
+	struct wlr_drm_connector *conn = state->connector;
+	struct wlr_drm_crtc *crtc = conn->crtc;
+	struct wlr_drm_backend *drm = conn->backend;
+
+	rollback_blob(drm, &crtc->mode_id, state->mode_id);
+	rollback_blob(drm, &crtc->gamma_lut, state->gamma_lut);
+
+	destroy_blob(drm, state->fb_damage_clips);
+}
+
+static void plane_disable(struct atomic *atom, struct wlr_drm_plane *plane) {
+	uint32_t id = plane->id;
+	const union wlr_drm_plane_props *props = &plane->props;
+	atomic_add(atom, id, props->fb_id, 0);
+	atomic_add(atom, id, props->crtc_id, 0);
+}
+
+static void set_plane_props(struct atomic *atom, struct wlr_drm_backend *drm,
+		struct wlr_drm_plane *plane, struct wlr_drm_fb *fb, uint32_t crtc_id,
+		int32_t x, int32_t y) {
+	uint32_t id = plane->id;
+	const union wlr_drm_plane_props *props = &plane->props;
+
+	if (fb == NULL) {
+		wlr_log(WLR_ERROR, "Failed to acquire FB for plane %"PRIu32, plane->id);
+		atom->failed = true;
+		return;
+	}
+
+	uint32_t width = fb->wlr_buf->width;
+	uint32_t height = fb->wlr_buf->height;
+
+	// The src_* properties are in 16.16 fixed point
+	atomic_add(atom, id, props->src_x, 0);
+	atomic_add(atom, id, props->src_y, 0);
+	atomic_add(atom, id, props->src_w, (uint64_t)width << 16);
+	atomic_add(atom, id, props->src_h, (uint64_t)height << 16);
+	atomic_add(atom, id, props->crtc_w, width);
+	atomic_add(atom, id, props->crtc_h, height);
+	atomic_add(atom, id, props->fb_id, fb->id);
+	atomic_add(atom, id, props->crtc_id, crtc_id);
+	atomic_add(atom, id, props->crtc_x, (uint64_t)x);
+	atomic_add(atom, id, props->crtc_y, (uint64_t)y);
+}
+
+static void atomic_connector_add(struct atomic *atom,
+		const struct wlr_drm_connector_state *state, bool modeset) {
+	struct wlr_drm_connector *conn = state->connector;
+	struct wlr_drm_backend *drm = conn->backend;
+	struct wlr_drm_crtc *crtc = conn->crtc;
+	bool active = state->active;
+
+	atomic_add(atom, conn->id, conn->props.crtc_id, active ? crtc->id : 0);
+	if (modeset && active && conn->props.link_status != 0) {
+		atomic_add(atom, conn->id, conn->props.link_status,
+			DRM_MODE_LINK_STATUS_GOOD);
+	}
+	if (active && conn->props.content_type != 0) {
+		atomic_add(atom, conn->id, conn->props.content_type,
+			DRM_MODE_CONTENT_TYPE_GRAPHICS);
+	}
+	if (modeset && active && conn->props.max_bpc != 0 && conn->max_bpc_bounds[1] != 0) {
+		atomic_add(atom, conn->id, conn->props.max_bpc, pick_max_bpc(conn, state->primary_fb));
+	}
+	atomic_add(atom, crtc->id, crtc->props.mode_id, state->mode_id);
+	atomic_add(atom, crtc->id, crtc->props.active, active);
+	if (active) {
+		if (crtc->props.gamma_lut != 0) {
+			atomic_add(atom, crtc->id, crtc->props.gamma_lut, state->gamma_lut);
+		}
+		if (crtc->props.vrr_enabled != 0) {
+			atomic_add(atom, crtc->id, crtc->props.vrr_enabled, state->vrr_enabled);
+		}
+		set_plane_props(atom, drm, crtc->primary, state->primary_fb, crtc->id,
+			0, 0);
+		if (crtc->primary->props.fb_damage_clips != 0) {
+			atomic_add(atom, crtc->primary->id,
+				crtc->primary->props.fb_damage_clips, state->fb_damage_clips);
+		}
+		if (crtc->cursor) {
+			if (drm_connector_is_cursor_visible(conn)) {
+				set_plane_props(atom, drm, crtc->cursor, get_next_cursor_fb(conn),
+					crtc->id, conn->cursor_x, conn->cursor_y);
+			} else {
+				plane_disable(atom, crtc->cursor);
+			}
+		}
+	} else {
+		plane_disable(atom, crtc->primary);
+		if (crtc->cursor) {
+			plane_disable(atom, crtc->cursor);
+		}
+	}
+}
+
+static bool atomic_device_commit(struct wlr_drm_backend *drm,
+		const struct wlr_drm_device_state *state,
+		struct wlr_drm_page_flip *page_flip, uint32_t flags, bool test_only) {
+	bool ok = false;
+
+	for (size_t i = 0; i < state->connectors_len; i++) {
+		if (!drm_atomic_connector_prepare(&state->connectors[i], state->modeset)) {
+			goto out;
+		}
+	}
+
+	struct atomic atom;
+	atomic_begin(&atom);
+
+	for (size_t i = 0; i < state->connectors_len; i++) {
+		atomic_connector_add(&atom, &state->connectors[i], state->modeset);
+	}
+
 	if (test_only) {
 		flags |= DRM_MODE_ATOMIC_TEST_ONLY;
 	}
-	if (modeset) {
+	if (state->modeset) {
 		flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
 	}
 	if (!test_only && state->nonblock) {
 		flags |= DRM_MODE_ATOMIC_NONBLOCK;
 	}
 
-	struct atomic atom;
-	atomic_begin(&atom);
-	atomic_add(&atom, conn->id, conn->props.crtc_id, active ? crtc->id : 0);
-	if (modeset && active && conn->props.link_status != 0) {
-		atomic_add(&atom, conn->id, conn->props.link_status,
-			DRM_MODE_LINK_STATUS_GOOD);
-	}
-	if (active && conn->props.content_type != 0) {
-		atomic_add(&atom, conn->id, conn->props.content_type,
-			DRM_MODE_CONTENT_TYPE_GRAPHICS);
-	}
-	if (modeset && active && conn->props.max_bpc != 0 && conn->max_bpc_bounds[1] != 0) {
-		atomic_add(&atom, conn->id, conn->props.max_bpc, pick_max_bpc(conn, state->primary_fb));
-	}
-	atomic_add(&atom, crtc->id, crtc->props.mode_id, mode_id);
-	atomic_add(&atom, crtc->id, crtc->props.active, active);
-	if (active) {
-		if (crtc->props.gamma_lut != 0) {
-			atomic_add(&atom, crtc->id, crtc->props.gamma_lut, gamma_lut);
-		}
-		if (crtc->props.vrr_enabled != 0) {
-			atomic_add(&atom, crtc->id, crtc->props.vrr_enabled, vrr_enabled);
-		}
-		set_plane_props(&atom, drm, crtc->primary, state->primary_fb, crtc->id,
-			0, 0);
-		if (crtc->primary->props.fb_damage_clips != 0) {
-			atomic_add(&atom, crtc->primary->id,
-				crtc->primary->props.fb_damage_clips, fb_damage_clips);
-		}
-		if (crtc->cursor) {
-			if (drm_connector_is_cursor_visible(conn)) {
-				set_plane_props(&atom, drm, crtc->cursor, get_next_cursor_fb(conn),
-					crtc->id, conn->cursor_x, conn->cursor_y);
-			} else {
-				plane_disable(&atom, crtc->cursor);
-			}
-		}
-	} else {
-		plane_disable(&atom, crtc->primary);
-		if (crtc->cursor) {
-			plane_disable(&atom, crtc->cursor);
-		}
-	}
-
-	bool ok = atomic_commit(&atom, drm, conn, page_flip, flags);
+	ok = atomic_commit(&atom, drm, state, page_flip, flags);
 	atomic_finish(&atom);
 
-	if (ok && !test_only) {
-		commit_blob(drm, &crtc->mode_id, mode_id);
-		commit_blob(drm, &crtc->gamma_lut, gamma_lut);
-
-		if (vrr_enabled != prev_vrr_enabled) {
-			output->adaptive_sync_status = vrr_enabled ?
-				WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED :
-				WLR_OUTPUT_ADAPTIVE_SYNC_DISABLED;
-			wlr_drm_conn_log(conn, WLR_DEBUG, "VRR %s",
-				vrr_enabled ? "enabled" : "disabled");
+out:
+	for (size_t i = 0; i < state->connectors_len; i++) {
+		struct wlr_drm_connector_state *conn_state = &state->connectors[i];
+		if (ok && !test_only) {
+			drm_atomic_connector_apply_commit(conn_state);
+		} else {
+			drm_atomic_connector_rollback_commit(conn_state);
 		}
-	} else {
-		rollback_blob(drm, &crtc->mode_id, mode_id);
-		rollback_blob(drm, &crtc->gamma_lut, gamma_lut);
 	}
-	destroy_blob(drm, fb_damage_clips);
-
 	return ok;
 }
 
@@ -425,6 +466,6 @@ bool drm_atomic_reset(struct wlr_drm_backend *drm) {
 }
 
 const struct wlr_drm_interface atomic_iface = {
-	.crtc_commit = atomic_crtc_commit,
+	.commit = atomic_device_commit,
 	.reset = drm_atomic_reset,
 };
diff --git a/backend/drm/drm.c b/backend/drm/drm.c
index d92b41d36..6dd22e3cc 100644
--- a/backend/drm/drm.c
+++ b/backend/drm/drm.c
@@ -425,82 +425,139 @@ static struct wlr_drm_layer *get_or_create_layer(struct wlr_drm_backend *drm,
 	return layer;
 }
 
-static void drm_connector_set_pending_page_flip(struct wlr_drm_connector *conn,
-		struct wlr_drm_page_flip *page_flip) {
-	if (conn->pending_page_flip != NULL) {
-		conn->pending_page_flip->conn = NULL;
-	}
-	conn->pending_page_flip = page_flip;
-}
-
 void drm_page_flip_destroy(struct wlr_drm_page_flip *page_flip) {
 	if (!page_flip) {
 		return;
 	}
 
 	wl_list_remove(&page_flip->link);
+	free(page_flip->connectors);
 	free(page_flip);
 }
 
-static struct wlr_drm_page_flip *drm_page_flip_create(struct wlr_drm_connector *conn) {
+static struct wlr_drm_page_flip *drm_page_flip_create(struct wlr_drm_backend *drm,
+		const struct wlr_drm_device_state *state) {
 	struct wlr_drm_page_flip *page_flip = calloc(1, sizeof(*page_flip));
 	if (page_flip == NULL) {
 		return NULL;
 	}
-	page_flip->conn = conn;
-	wl_list_insert(&conn->backend->page_flips, &page_flip->link);
+	page_flip->connectors_len = state->connectors_len;
+	page_flip->connectors =
+		calloc(page_flip->connectors_len, sizeof(page_flip->connectors[0]));
+	if (page_flip->connectors == NULL) {
+		free(page_flip);
+		return NULL;
+	}
+	for (size_t i = 0; i < state->connectors_len; i++) {
+		struct wlr_drm_connector *conn = state->connectors[i].connector;
+		page_flip->connectors[0] = (struct wlr_drm_page_flip_connector){
+			.connector = conn,
+			.crtc_id = conn->crtc->id,
+		};
+	}
+	wl_list_insert(&drm->page_flips, &page_flip->link);
 	return page_flip;
 }
 
-static bool drm_crtc_commit(struct wlr_drm_connector *conn,
-		const struct wlr_drm_connector_state *state,
+static struct wlr_drm_connector *drm_page_flip_pop(
+		struct wlr_drm_page_flip *page_flip, uint32_t crtc_id) {
+	bool found = false;
+	size_t i;
+	for (i = 0; i < page_flip->connectors_len; i++) {
+		if (page_flip->connectors[i].crtc_id == crtc_id) {
+			found = true;
+			break;
+		}
+	}
+	if (!found) {
+		return NULL;
+	}
+
+	struct wlr_drm_connector *conn = page_flip->connectors[i].connector;
+	if (i != page_flip->connectors_len - 1) {
+		page_flip->connectors[i] = page_flip->connectors[page_flip->connectors_len - 1];
+	}
+	page_flip->connectors_len--;
+	return conn;
+}
+
+static void drm_connector_set_pending_page_flip(struct wlr_drm_connector *conn,
+		struct wlr_drm_page_flip *page_flip) {
+	if (conn->pending_page_flip != NULL) {
+		struct wlr_drm_page_flip *page_flip = conn->pending_page_flip;
+		for (size_t i = 0; i < page_flip->connectors_len; i++) {
+			if (page_flip->connectors[i].connector == conn) {
+				page_flip->connectors[i].connector = NULL;
+			}
+		}
+	}
+	conn->pending_page_flip = page_flip;
+}
+
+static void drm_connector_apply_commit(const struct wlr_drm_connector_state *state,
+		struct wlr_drm_page_flip *page_flip) {
+	struct wlr_drm_connector *conn = state->connector;
+	struct wlr_drm_crtc *crtc = conn->crtc;
+
+	drm_fb_clear(&crtc->primary->queued_fb);
+	if (state->primary_fb != NULL) {
+		crtc->primary->queued_fb = drm_fb_lock(state->primary_fb);
+	}
+	if (crtc->cursor != NULL) {
+		drm_fb_move(&crtc->cursor->queued_fb, &conn->cursor_pending_fb);
+	}
+
+	struct wlr_drm_layer *layer;
+	wl_list_for_each(layer, &crtc->layers, link) {
+		drm_fb_move(&layer->queued_fb, &layer->pending_fb);
+	}
+
+	drm_connector_set_pending_page_flip(conn, page_flip);
+
+	if (state->base->committed & WLR_OUTPUT_STATE_MODE) {
+		conn->refresh = calculate_refresh_rate(&state->mode);
+	}
+}
+
+static void drm_connector_rollback_commit(const struct wlr_drm_connector_state *state) {
+	struct wlr_drm_crtc *crtc = state->connector->crtc;
+
+	// The set_cursor() hook is a bit special: it's not really synchronized
+	// to commit() or test(). Once set_cursor() returns true, the new
+	// cursor is effectively committed. So don't roll it back here, or we
+	// risk ending up in a state where we don't have a cursor FB but
+	// wlr_drm_connector.cursor_enabled is true.
+	// TODO: fix our output interface to avoid this issue.
+
+	struct wlr_drm_layer *layer;
+	wl_list_for_each(layer, &crtc->layers, link) {
+		drm_fb_clear(&layer->pending_fb);
+	}
+}
+
+static bool drm_commit(struct wlr_drm_backend *drm,
+		const struct wlr_drm_device_state *state,
 		uint32_t flags, bool test_only) {
 	// Disallow atomic-only flags
 	assert((flags & ~DRM_MODE_PAGE_FLIP_FLAGS) == 0);
 
 	struct wlr_drm_page_flip *page_flip = NULL;
 	if (flags & DRM_MODE_PAGE_FLIP_EVENT) {
-		page_flip = drm_page_flip_create(conn);
+		page_flip = drm_page_flip_create(drm, state);
 		if (page_flip == NULL) {
 			return false;
 		}
 	}
 
-	struct wlr_drm_backend *drm = conn->backend;
-	struct wlr_drm_crtc *crtc = conn->crtc;
-	bool ok = drm->iface->crtc_commit(conn, state, page_flip, flags, test_only);
+	bool ok = drm->iface->commit(drm, state, page_flip, flags, test_only);
 	if (ok && !test_only) {
-		drm_fb_clear(&crtc->primary->queued_fb);
-		if (state->primary_fb != NULL) {
-			crtc->primary->queued_fb = drm_fb_lock(state->primary_fb);
-		}
-		if (crtc->cursor != NULL) {
-			drm_fb_move(&crtc->cursor->queued_fb, &conn->cursor_pending_fb);
-		}
-
-		struct wlr_drm_layer *layer;
-		wl_list_for_each(layer, &crtc->layers, link) {
-			drm_fb_move(&layer->queued_fb, &layer->pending_fb);
-		}
-
-		drm_connector_set_pending_page_flip(conn, page_flip);
-
-		if (state->base->committed & WLR_OUTPUT_STATE_MODE) {
-			conn->refresh = calculate_refresh_rate(&state->mode);
+		for (size_t i = 0; i < state->connectors_len; i++) {
+			drm_connector_apply_commit(&state->connectors[i], page_flip);
 		}
 	} else {
-		// The set_cursor() hook is a bit special: it's not really synchronized
-		// to commit() or test(). Once set_cursor() returns true, the new
-		// cursor is effectively committed. So don't roll it back here, or we
-		// risk ending up in a state where we don't have a cursor FB but
-		// wlr_drm_connector.cursor_enabled is true.
-		// TODO: fix our output interface to avoid this issue.
-
-		struct wlr_drm_layer *layer;
-		wl_list_for_each(layer, &crtc->layers, link) {
-			drm_fb_clear(&layer->pending_fb);
+		for (size_t i = 0; i < state->connectors_len; i++) {
+			drm_connector_rollback_commit(&state->connectors[i]);
 		}
-
 		drm_page_flip_destroy(page_flip);
 	}
 	return ok;
@@ -510,17 +567,10 @@ static void drm_connector_state_init(struct wlr_drm_connector_state *state,
 		struct wlr_drm_connector *conn,
 		const struct wlr_output_state *base) {
 	*state = (struct wlr_drm_connector_state){
+		.connector = conn,
 		.base = base,
-		.modeset = base->allow_reconfiguration,
 		.active = (base->committed & WLR_OUTPUT_STATE_ENABLED) ?
 			base->enabled : conn->output.enabled,
-		// The wlr_output API requires non-modeset commits with a new buffer to
-		// wait for the frame event. However compositors often perform
-		// non-modesets commits without a new buffer without waiting for the
-		// frame event. In that case we need to make the KMS commit blocking,
-		// otherwise the kernel will error out with EBUSY.
-		.nonblock = !base->allow_reconfiguration &&
-			(base->committed & WLR_OUTPUT_STATE_BUFFER),
 	};
 
 	struct wlr_output_mode *mode = conn->output.current_mode;
@@ -560,6 +610,22 @@ static void drm_connector_state_init(struct wlr_drm_connector_state *state,
 	}
 }
 
+static void drm_device_state_init_single(struct wlr_drm_device_state *dev_state,
+		struct wlr_drm_connector_state *conn_state) {
+	*dev_state = (struct wlr_drm_device_state){
+		.modeset = conn_state->base->allow_reconfiguration,
+		// The wlr_output API requires non-modeset commits with a new buffer to
+		// wait for the frame event. However compositors often perform
+		// non-modesets commits without a new buffer without waiting for the
+		// frame event. In that case we need to make the KMS commit blocking,
+		// otherwise the kernel will error out with EBUSY.
+		.nonblock = !conn_state->base->allow_reconfiguration &&
+			(conn_state->base->committed & WLR_OUTPUT_STATE_BUFFER),
+		.connectors = conn_state,
+		.connectors_len = 1,
+	};
+}
+
 static void drm_connector_state_finish(struct wlr_drm_connector_state *state) {
 	drm_fb_clear(&state->primary_fb);
 }
@@ -679,6 +745,8 @@ static bool drm_connector_test(struct wlr_output *output,
 	bool ok = false;
 	struct wlr_drm_connector_state pending = {0};
 	drm_connector_state_init(&pending, conn, state);
+	struct wlr_drm_device_state pending_dev = {0};
+	drm_device_state_init_single(&pending_dev, &pending);
 
 	if (pending.active) {
 		if ((state->committed &
@@ -732,7 +800,7 @@ static bool drm_connector_test(struct wlr_output *output,
 		}
 	}
 
-	ok = drm_crtc_commit(conn, &pending, 0, true);
+	ok = drm_commit(conn->backend, &pending_dev, 0, true);
 
 out:
 	drm_connector_state_finish(&pending);
@@ -776,6 +844,8 @@ static bool drm_connector_commit_state(struct wlr_drm_connector *conn,
 	bool ok = false;
 	struct wlr_drm_connector_state pending = {0};
 	drm_connector_state_init(&pending, conn, base);
+	struct wlr_drm_device_state pending_dev = {0};
+	drm_device_state_init_single(&pending_dev, &pending);
 
 	if (!pending.active && conn->crtc == NULL) {
 		// Disabling an already-disabled connector
@@ -802,7 +872,7 @@ static bool drm_connector_commit_state(struct wlr_drm_connector *conn,
 		}
 	}
 
-	if (pending.modeset) {
+	if (pending_dev.modeset) {
 		if (pending.active) {
 			wlr_drm_conn_log(conn, WLR_INFO, "Modesetting with %dx%d @ %.3f Hz",
 				pending.mode.hdisplay, pending.mode.vdisplay,
@@ -816,7 +886,7 @@ static bool drm_connector_commit_state(struct wlr_drm_connector *conn,
 	// page-flip, either a blocking modeset. When performing a blocking modeset
 	// we'll wait for all queued page-flips to complete, so we don't need this
 	// safeguard.
-	if (pending.nonblock && conn->pending_page_flip != NULL) {
+	if (pending_dev.nonblock && conn->pending_page_flip != NULL) {
 		wlr_drm_conn_log(conn, WLR_ERROR, "Failed to page-flip output: "
 			"a page-flip is already pending");
 		goto out;
@@ -830,7 +900,7 @@ static bool drm_connector_commit_state(struct wlr_drm_connector *conn,
 		flags |= DRM_MODE_PAGE_FLIP_ASYNC;
 	}
 
-	ok = drm_crtc_commit(conn, &pending, flags, false);
+	ok = drm_commit(drm, &pending_dev, flags, false);
 	if (!ok) {
 		goto out;
 	}
@@ -1721,11 +1791,9 @@ void scan_drm_leases(struct wlr_drm_backend *drm) {
 
 static void build_current_connector_state(struct wlr_output_state *state,
 		struct wlr_drm_connector *conn) {
-	bool enabled = conn->status != DRM_MODE_DISCONNECTED && conn->output.enabled;
-
 	wlr_output_state_init(state);
-	wlr_output_state_set_enabled(state, enabled);
-	if (!enabled) {
+	wlr_output_state_set_enabled(state, conn->output.enabled);
+	if (!conn->output.enabled) {
 		return;
 	}
 
@@ -1759,6 +1827,12 @@ static bool skip_reset_for_restore(struct wlr_drm_backend *drm) {
 		if (crtc != NULL && conn->crtc != crtc) {
 			return false;
 		}
+		if (!conn->output.enabled && crtc != NULL) {
+			return false;
+		}
+		if (conn->output.enabled && conn->status == DRM_MODE_DISCONNECTED) {
+			return false;
+		}
 	}
 
 	for (size_t i = 0; i < drm->num_planes; i++) {
@@ -1810,15 +1884,42 @@ void restore_drm_device(struct wlr_drm_backend *drm) {
 		wlr_log(WLR_ERROR, "Failed to reset state after VT switch");
 	}
 
+	size_t states_cap = wl_list_length(&drm->connectors);
+	struct wlr_output_state *output_states = calloc(states_cap, sizeof(output_states[0]));
+	struct wlr_drm_connector_state *conn_states = calloc(states_cap, sizeof(conn_states[0]));
+	if (output_states == NULL || conn_states == NULL) {
+		goto out_states;
+	}
+
+	size_t states_len = 0;
 	struct wlr_drm_connector *conn;
 	wl_list_for_each(conn, &drm->connectors, link) {
-		struct wlr_output_state state;
-		build_current_connector_state(&state, conn);
-		if (!drm_connector_commit_state(conn, &state)) {
-			wlr_drm_conn_log(conn, WLR_ERROR, "Failed to restore state after VT switch");
+		if (conn->status == DRM_MODE_DISCONNECTED || !conn->output.enabled) {
+			continue; // already disabled above
 		}
-		wlr_output_state_finish(&state);
+
+		build_current_connector_state(&output_states[states_len], conn);
+		drm_connector_state_init(&conn_states[states_len], conn, &output_states[states_len]);
+		states_len++;
 	}
+
+	struct wlr_drm_device_state dev_state = {
+		.modeset = true,
+		.connectors = conn_states,
+		.connectors_len = states_len,
+	};
+	if (!drm_commit(drm, &dev_state, DRM_MODE_PAGE_FLIP_EVENT, false)) {
+		wlr_log(WLR_ERROR, "Failed to restore state after VT switch");
+	}
+
+	for (size_t i = 0; i < states_len; i++) {
+		drm_connector_state_finish(&conn_states[i]);
+		wlr_output_state_finish(&output_states[i]);
+	}
+
+out_states:
+	free(output_states);
+	free(conn_states);
 }
 
 static int mhz_to_nsec(int mhz) {
@@ -1829,11 +1930,13 @@ static void handle_page_flip(int fd, unsigned seq,
 		unsigned tv_sec, unsigned tv_usec, unsigned crtc_id, void *data) {
 	struct wlr_drm_page_flip *page_flip = data;
 
-	struct wlr_drm_connector *conn = page_flip->conn;
+	struct wlr_drm_connector *conn = drm_page_flip_pop(page_flip, crtc_id);
 	if (conn != NULL) {
 		conn->pending_page_flip = NULL;
 	}
-	drm_page_flip_destroy(page_flip);
+	if (page_flip->connectors_len == 0) {
+		drm_page_flip_destroy(page_flip);
+	}
 
 	if (conn == NULL) {
 		return;
diff --git a/backend/drm/legacy.c b/backend/drm/legacy.c
index 1e62f61f7..3fe3d1107 100644
--- a/backend/drm/legacy.c
+++ b/backend/drm/legacy.c
@@ -34,11 +34,12 @@ static bool legacy_fb_props_match(struct wlr_drm_fb *fb1,
 	return true;
 }
 
-static bool legacy_crtc_test(struct wlr_drm_connector *conn,
-		const struct wlr_drm_connector_state *state) {
+static bool legacy_crtc_test(const struct wlr_drm_connector_state *state,
+		bool modeset) {
+	struct wlr_drm_connector *conn = state->connector;
 	struct wlr_drm_crtc *crtc = conn->crtc;
 
-	if ((state->base->committed & WLR_OUTPUT_STATE_BUFFER) && !state->modeset) {
+	if ((state->base->committed & WLR_OUTPUT_STATE_BUFFER) && !modeset) {
 		struct wlr_drm_fb *pending_fb = state->primary_fb;
 
 		struct wlr_drm_fb *prev_fb = crtc->primary->queued_fb;
@@ -58,16 +59,9 @@ static bool legacy_crtc_test(struct wlr_drm_connector *conn,
 	return true;
 }
 
-static bool legacy_crtc_commit(struct wlr_drm_connector *conn,
-		const struct wlr_drm_connector_state *state,
-		struct wlr_drm_page_flip *page_flip, uint32_t flags, bool test_only) {
-	if (!legacy_crtc_test(conn, state)) {
-		return false;
-	}
-	if (test_only) {
-		return true;
-	}
-
+static bool legacy_crtc_commit(const struct wlr_drm_connector_state *state,
+		struct wlr_drm_page_flip *page_flip, uint32_t flags, bool modeset) {
+	struct wlr_drm_connector *conn = state->connector;
 	struct wlr_drm_backend *drm = conn->backend;
 	struct wlr_output *output = &conn->output;
 	struct wlr_drm_crtc *crtc = conn->crtc;
@@ -83,7 +77,7 @@ static bool legacy_crtc_commit(struct wlr_drm_connector *conn,
 		fb_id = state->primary_fb->id;
 	}
 
-	if (state->modeset) {
+	if (modeset) {
 		uint32_t *conns = NULL;
 		size_t conns_len = 0;
 		drmModeModeInfo *mode = NULL;
@@ -185,6 +179,32 @@ static bool legacy_crtc_commit(struct wlr_drm_connector *conn,
 	return true;
 }
 
+static bool legacy_commit(struct wlr_drm_backend *drm,
+		const struct wlr_drm_device_state *state,
+		struct wlr_drm_page_flip *page_flip, uint32_t flags,
+		bool test_only) {
+	for (size_t i = 0; i < state->connectors_len; i++) {
+		const struct wlr_drm_connector_state *conn_state = &state->connectors[i];
+		if (!legacy_crtc_test(conn_state, state->modeset)) {
+			return false;
+		}
+	}
+
+	if (test_only) {
+		return true;
+	}
+
+	for (size_t i = 0; i < state->connectors_len; i++) {
+		const struct wlr_drm_connector_state *conn_state = &state->connectors[i];
+		if (!legacy_crtc_commit(conn_state, page_flip, flags,
+				state->modeset)) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
 static void fill_empty_gamma_table(size_t size,
 		uint16_t *r, uint16_t *g, uint16_t *b) {
 	assert(0xFFFF < UINT64_MAX / (size - 1));
@@ -241,6 +261,6 @@ static bool legacy_reset(struct wlr_drm_backend *drm) {
 }
 
 const struct wlr_drm_interface legacy_iface = {
-	.crtc_commit = legacy_crtc_commit,
+	.commit = legacy_commit,
 	.reset = legacy_reset,
 };
diff --git a/backend/drm/libliftoff.c b/backend/drm/libliftoff.c
index 334a660c2..56ed78d84 100644
--- a/backend/drm/libliftoff.c
+++ b/backend/drm/libliftoff.c
@@ -1,5 +1,6 @@
 #include <fcntl.h>
 #include <libliftoff.h>
+#include <stdlib.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <wlr/util/log.h>
@@ -126,27 +127,6 @@ static bool add_prop(drmModeAtomicReq *req, uint32_t obj,
 	return true;
 }
 
-static void commit_blob(struct wlr_drm_backend *drm,
-		uint32_t *current, uint32_t next) {
-	if (*current == next) {
-		return;
-	}
-	if (*current != 0) {
-		drmModeDestroyPropertyBlob(drm->fd, *current);
-	}
-	*current = next;
-}
-
-static void rollback_blob(struct wlr_drm_backend *drm,
-		uint32_t *current, uint32_t next) {
-	if (*current == next) {
-		return;
-	}
-	if (next != 0) {
-		drmModeDestroyPropertyBlob(drm->fd, next);
-	}
-}
-
 static bool set_plane_props(struct wlr_drm_plane *plane,
 		struct liftoff_layer *layer, struct wlr_drm_fb *fb, int32_t x, int32_t y, uint64_t zpos) {
 	if (fb == NULL) {
@@ -300,86 +280,16 @@ static void update_layer_feedback(struct wlr_drm_backend *drm,
 	wlr_drm_format_set_finish(&formats);
 }
 
-static bool crtc_commit(struct wlr_drm_connector *conn,
+static bool add_connector(drmModeAtomicReq *req,
 		const struct wlr_drm_connector_state *state,
-		struct wlr_drm_page_flip *page_flip, uint32_t flags, bool test_only) {
-	struct wlr_drm_backend *drm = conn->backend;
-	struct wlr_output *output = &conn->output;
+		bool modeset, struct wl_array *fb_damage_clips_arr) {
+	struct wlr_drm_connector *conn = state->connector;
 	struct wlr_drm_crtc *crtc = conn->crtc;
-
-	bool modeset = state->modeset;
+	struct wlr_drm_backend *drm = conn->backend;
 	bool active = state->active;
+	bool ok = true;
 
-	if (modeset && !register_planes_for_crtc(drm, crtc)) {
-		return false;
-	}
-
-	uint32_t mode_id = crtc->mode_id;
-	if (modeset) {
-		if (!create_mode_blob(conn, state, &mode_id)) {
-			return false;
-		}
-	}
-
-	uint32_t gamma_lut = crtc->gamma_lut;
-	if (state->base->committed & WLR_OUTPUT_STATE_GAMMA_LUT) {
-		// Fallback to legacy gamma interface when gamma properties are not
-		// available (can happen on older Intel GPUs that support gamma but not
-		// degamma).
-		if (crtc->props.gamma_lut == 0) {
-			if (!drm_legacy_crtc_set_gamma(drm, crtc,
-					state->base->gamma_lut_size,
-					state->base->gamma_lut)) {
-				return false;
-			}
-		} else {
-			if (!create_gamma_lut_blob(drm, state->base->gamma_lut_size,
-					state->base->gamma_lut, &gamma_lut)) {
-				return false;
-			}
-		}
-	}
-
-	struct wl_array fb_damage_clips_arr = {0};
-
-	uint32_t primary_fb_damage_clips = 0;
-	if ((state->base->committed & WLR_OUTPUT_STATE_DAMAGE) &&
-			crtc->primary->props.fb_damage_clips != 0) {
-		uint32_t *ptr = wl_array_add(&fb_damage_clips_arr, sizeof(primary_fb_damage_clips));
-		if (ptr == NULL) {
-			return false;
-		}
-		create_fb_damage_clips_blob(drm, state->primary_fb->wlr_buf->width,
-			state->primary_fb->wlr_buf->height, &state->base->damage,
-			&primary_fb_damage_clips);
-		*ptr = primary_fb_damage_clips;
-	}
-
-	bool prev_vrr_enabled =
-		output->adaptive_sync_status == WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED;
-	bool vrr_enabled = prev_vrr_enabled;
-	if ((state->base->committed & WLR_OUTPUT_STATE_ADAPTIVE_SYNC_ENABLED) &&
-			drm_connector_supports_vrr(conn)) {
-		vrr_enabled = state->base->adaptive_sync_enabled;
-	}
-
-	if (test_only) {
-		flags |= DRM_MODE_ATOMIC_TEST_ONLY;
-	}
-	if (modeset) {
-		flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
-	}
-	if (!test_only && state->nonblock) {
-		flags |= DRM_MODE_ATOMIC_NONBLOCK;
-	}
-
-	drmModeAtomicReq *req = drmModeAtomicAlloc();
-	if (req == NULL) {
-		wlr_log(WLR_ERROR, "drmModeAtomicAlloc failed");
-		return false;
-	}
-
-	bool ok = add_prop(req, conn->id, conn->props.crtc_id,
+	ok = ok && add_prop(req, conn->id, conn->props.crtc_id,
 		active ? crtc->id : 0);
 	if (modeset && active && conn->props.link_status != 0) {
 		ok = ok && add_prop(req, conn->id, conn->props.link_status,
@@ -391,28 +301,28 @@ static bool crtc_commit(struct wlr_drm_connector *conn,
 	}
 	// TODO: set "max bpc"
 	ok = ok &&
-		add_prop(req, crtc->id, crtc->props.mode_id, mode_id) &&
+		add_prop(req, crtc->id, crtc->props.mode_id, state->mode_id) &&
 		add_prop(req, crtc->id, crtc->props.active, active);
 	if (active) {
 		if (crtc->props.gamma_lut != 0) {
-			ok = ok && add_prop(req, crtc->id, crtc->props.gamma_lut, gamma_lut);
+			ok = ok && add_prop(req, crtc->id, crtc->props.gamma_lut, state->gamma_lut);
 		}
 		if (crtc->props.vrr_enabled != 0) {
-			ok = ok && add_prop(req, crtc->id, crtc->props.vrr_enabled, vrr_enabled);
+			ok = ok && add_prop(req, crtc->id, crtc->props.vrr_enabled, state->vrr_enabled);
 		}
 		ok = ok &&
 			set_plane_props(crtc->primary, crtc->primary->liftoff_layer, state->primary_fb, 0, 0, 0) &&
 			set_plane_props(crtc->primary, crtc->liftoff_composition_layer, state->primary_fb, 0, 0, 0);
 		liftoff_layer_set_property(crtc->primary->liftoff_layer,
-			"FB_DAMAGE_CLIPS", primary_fb_damage_clips);
+			"FB_DAMAGE_CLIPS", state->fb_damage_clips);
 		liftoff_layer_set_property(crtc->liftoff_composition_layer,
-			"FB_DAMAGE_CLIPS", primary_fb_damage_clips);
+			"FB_DAMAGE_CLIPS", state->fb_damage_clips);
 
 		if (state->base->committed & WLR_OUTPUT_STATE_LAYERS) {
 			for (size_t i = 0; i < state->base->layers_len; i++) {
 				const struct wlr_output_layer_state *layer_state = &state->base->layers[i];
 				ok = ok && set_layer_props(drm, layer_state, i + 1,
-					&fb_damage_clips_arr);
+					fb_damage_clips_arr);
 			}
 		}
 
@@ -432,62 +342,101 @@ static bool crtc_commit(struct wlr_drm_connector *conn,
 		}
 	}
 
-	if (!ok) {
-		goto out;
+	return ok;
+}
+
+static void connector_update_layers_feedback(const struct wlr_drm_connector_state *state) {
+	struct wlr_drm_backend *drm = state->connector->backend;
+
+	if (!(state->base->committed & WLR_OUTPUT_STATE_LAYERS)) {
+		return;
 	}
 
-	int ret = liftoff_output_apply(crtc->liftoff, req, flags);
-	if (ret != 0) {
-		wlr_drm_conn_log(conn, test_only ? WLR_DEBUG : WLR_ERROR,
-			"liftoff_output_apply failed: %s", strerror(-ret));
-		ok = false;
-		goto out;
-	}
-
-	if (crtc->cursor &&
-			liftoff_layer_needs_composition(crtc->cursor->liftoff_layer)) {
-		wlr_drm_conn_log(conn, WLR_DEBUG, "Failed to scan-out cursor plane");
-		ok = false;
-		goto out;
-	}
-
-	ret = drmModeAtomicCommit(drm->fd, req, flags, page_flip);
-	if (ret != 0) {
-		wlr_drm_conn_log_errno(conn, test_only ? WLR_DEBUG : WLR_ERROR,
-			"Atomic commit failed");
-		ok = false;
-		goto out;
-	}
-
-	if (state->base->committed & WLR_OUTPUT_STATE_LAYERS) {
-		for (size_t i = 0; i < state->base->layers_len; i++) {
-			struct wlr_output_layer_state *layer_state = &state->base->layers[i];
-			struct wlr_drm_layer *layer = get_drm_layer(drm, layer_state->layer);
-			layer_state->accepted =
-				!liftoff_layer_needs_composition(layer->liftoff);
-			if (!test_only && !layer_state->accepted) {
-				update_layer_feedback(drm, layer);
-			}
+	for (size_t i = 0; i < state->base->layers_len; i++) {
+		struct wlr_output_layer_state *layer_state = &state->base->layers[i];
+		struct wlr_drm_layer *layer = get_drm_layer(drm, layer_state->layer);
+		layer_state->accepted =
+			!liftoff_layer_needs_composition(layer->liftoff);
+		if (!layer_state->accepted) {
+			update_layer_feedback(drm, layer);
 		}
 	}
+}
+
+static bool commit(struct wlr_drm_backend *drm,
+		const struct wlr_drm_device_state *state,
+		struct wlr_drm_page_flip *page_flip, uint32_t flags, bool test_only) {
+	bool ok = false;
+	struct wl_array fb_damage_clips_arr = {0};
+	drmModeAtomicReq *req = NULL;
+
+	if (test_only) {
+		flags |= DRM_MODE_ATOMIC_TEST_ONLY;
+	}
+	if (state->modeset) {
+		flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
+	}
+	if (!test_only && state->nonblock) {
+		flags |= DRM_MODE_ATOMIC_NONBLOCK;
+	}
+
+	for (size_t i = 0; i < state->connectors_len; i++) {
+		struct wlr_drm_connector_state *conn_state = &state->connectors[i];
+		struct wlr_drm_connector *conn = conn_state->connector;
+		if (state->modeset && !register_planes_for_crtc(drm, conn->crtc)) {
+			goto out;
+		}
+		if (!drm_atomic_connector_prepare(conn_state, state->modeset)) {
+			goto out;
+		}
+	}
+
+	req = drmModeAtomicAlloc();
+	if (req == NULL) {
+		wlr_log(WLR_ERROR, "drmModeAtomicAlloc failed");
+		goto out;
+	}
+
+	for (size_t i = 0; i < state->connectors_len; i++) {
+		if (!add_connector(req, &state->connectors[i], state->modeset, &fb_damage_clips_arr)) {
+			goto out;
+		}
+	}
+
+	for (size_t i = 0; i < state->connectors_len; i++) {
+		struct wlr_drm_connector *conn = state->connectors[i].connector;
+		struct wlr_drm_crtc *crtc = conn->crtc;
+
+		int ret = liftoff_output_apply(crtc->liftoff, req, flags);
+		if (ret != 0) {
+			wlr_drm_conn_log(conn, test_only ? WLR_DEBUG : WLR_ERROR,
+				"liftoff_output_apply failed: %s", strerror(-ret));
+			goto out;
+		}
+
+		if (crtc->cursor &&
+				liftoff_layer_needs_composition(crtc->cursor->liftoff_layer)) {
+			wlr_drm_conn_log(conn, WLR_DEBUG, "Failed to scan-out cursor plane");
+			goto out;
+		}
+	}
+
+	ok = drmModeAtomicCommit(drm->fd, req, flags, page_flip) == 0;
+	if (!ok) {
+		wlr_log_errno(test_only ? WLR_DEBUG : WLR_ERROR,
+			"Atomic commit failed");
+	}
 
 out:
 	drmModeAtomicFree(req);
-
-	if (ok && !test_only) {
-		commit_blob(drm, &crtc->mode_id, mode_id);
-		commit_blob(drm, &crtc->gamma_lut, gamma_lut);
-
-		if (vrr_enabled != prev_vrr_enabled) {
-			output->adaptive_sync_status = vrr_enabled ?
-				WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED :
-				WLR_OUTPUT_ADAPTIVE_SYNC_DISABLED;
-			wlr_drm_conn_log(conn, WLR_DEBUG, "VRR %s",
-				vrr_enabled ? "enabled" : "disabled");
+	for (size_t i = 0; i < state->connectors_len; i++) {
+		struct wlr_drm_connector_state *conn_state = &state->connectors[i];
+		if (ok && !test_only) {
+			drm_atomic_connector_apply_commit(conn_state);
+			connector_update_layers_feedback(conn_state);
+		} else {
+			drm_atomic_connector_rollback_commit(conn_state);
 		}
-	} else {
-		rollback_blob(drm, &crtc->mode_id, mode_id);
-		rollback_blob(drm, &crtc->gamma_lut, gamma_lut);
 	}
 
 	uint32_t *fb_damage_clips_ptr;
@@ -504,6 +453,6 @@ out:
 const struct wlr_drm_interface liftoff_iface = {
 	.init = init,
 	.finish = finish,
-	.crtc_commit = crtc_commit,
+	.commit = commit,
 	.reset = drm_atomic_reset,
 };
diff --git a/include/backend/drm/drm.h b/include/backend/drm/drm.h
index e2c74a9f5..941e9b1ee 100644
--- a/include/backend/drm/drm.h
+++ b/include/backend/drm/drm.h
@@ -121,13 +121,26 @@ struct wlr_drm_mode {
 	drmModeModeInfo drm_mode;
 };
 
-struct wlr_drm_connector_state {
-	const struct wlr_output_state *base;
+struct wlr_drm_device_state {
 	bool modeset;
 	bool nonblock;
+
+	struct wlr_drm_connector_state *connectors;
+	size_t connectors_len;
+};
+
+struct wlr_drm_connector_state {
+	struct wlr_drm_connector *connector;
+	const struct wlr_output_state *base;
 	bool active;
 	drmModeModeInfo mode;
 	struct wlr_drm_fb *primary_fb;
+
+	// used by atomic
+	uint32_t mode_id;
+	uint32_t gamma_lut;
+	uint32_t fb_damage_clips;
+	bool vrr_enabled;
 };
 
 /**
@@ -144,7 +157,13 @@ struct wlr_drm_connector_state {
  */
 struct wlr_drm_page_flip {
 	struct wl_list link; // wlr_drm_connector.page_flips
-	struct wlr_drm_connector *conn;
+	struct wlr_drm_page_flip_connector *connectors;
+	size_t connectors_len;
+};
+
+struct wlr_drm_page_flip_connector {
+	uint32_t crtc_id;
+	struct wlr_drm_connector *connector; // may be NULL
 };
 
 struct wlr_drm_connector {
diff --git a/include/backend/drm/iface.h b/include/backend/drm/iface.h
index 6408c440a..1ac1095a8 100644
--- a/include/backend/drm/iface.h
+++ b/include/backend/drm/iface.h
@@ -10,6 +10,7 @@
 struct wlr_drm_backend;
 struct wlr_drm_connector;
 struct wlr_drm_crtc;
+struct wlr_drm_device_state;
 struct wlr_drm_connector_state;
 struct wlr_drm_fb;
 struct wlr_drm_page_flip;
@@ -18,9 +19,8 @@ struct wlr_drm_page_flip;
 struct wlr_drm_interface {
 	bool (*init)(struct wlr_drm_backend *drm);
 	void (*finish)(struct wlr_drm_backend *drm);
-	// Commit all pending changes on a CRTC.
-	bool (*crtc_commit)(struct wlr_drm_connector *conn,
-		const struct wlr_drm_connector_state *state,
+	bool (*commit)(struct wlr_drm_backend *drm,
+		const struct wlr_drm_device_state *state,
 		struct wlr_drm_page_flip *page_flip, uint32_t flags, bool test_only);
 	// Turn off everything
 	bool (*reset)(struct wlr_drm_backend *drm);
@@ -33,12 +33,13 @@ extern const struct wlr_drm_interface liftoff_iface;
 bool drm_legacy_crtc_set_gamma(struct wlr_drm_backend *drm,
 	struct wlr_drm_crtc *crtc, size_t size, uint16_t *lut);
 
-bool create_mode_blob(struct wlr_drm_connector *conn,
-	const struct wlr_drm_connector_state *state, uint32_t *blob_id);
-bool create_gamma_lut_blob(struct wlr_drm_backend *drm,
-	size_t size, const uint16_t *lut, uint32_t *blob_id);
 bool create_fb_damage_clips_blob(struct wlr_drm_backend *drm,
 	int width, int height, const pixman_region32_t *damage, uint32_t *blob_id);
 bool drm_atomic_reset(struct wlr_drm_backend *drm);
 
+bool drm_atomic_connector_prepare(struct wlr_drm_connector_state *state,
+	bool modeset);
+void drm_atomic_connector_apply_commit(struct wlr_drm_connector_state *state);
+void drm_atomic_connector_rollback_commit(struct wlr_drm_connector_state *state);
+
 #endif