mirrors/wlroots
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/wlroots/wlroots.git synced 2026-04-17 06:46:39 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'vt-switch-enable-atomic' into 'master'

Browse source 
Draft: backend/drm: use a single commit to restore state after VT switch

See merge request wlroots/wlroots!4554
This commit is contained in:
Simon Ser 2024-02-21 10:32:39 +00:00
commit d6cf4a2594
6 changed files with 487 additions and 354 deletions
Download patch file Download diff file Expand all files Collapse all files

259
backend/drm/atomic.c
View file

@ -61,8 +61,8 @@ static void atomic_begin(struct atomic *atom) {
} }
static bool atomic_commit(struct atomic *atom, struct wlr_drm_backend *drm, static bool atomic_commit(struct atomic *atom, struct wlr_drm_backend *drm,
struct wlr_drm_connector *conn, struct wlr_drm_page_flip *page_flip, const struct wlr_drm_device_state *state,
uint32_t flags) { struct wlr_drm_page_flip *page_flip, uint32_t flags) {
if (atom->failed) { if (atom->failed) {
return false; return false;
} }
@ -74,12 +74,12 @@ static bool atomic_commit(struct atomic *atom, struct wlr_drm_backend *drm,
log_level = WLR_DEBUG; 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"); wlr_drm_conn_log_errno(conn, log_level, "Atomic commit failed");
} else { } else {
wlr_log_errno(log_level, "Atomic commit failed"); wlr_log_errno(log_level, "Atomic commit failed");
} }
char *flags_str = atomic_commit_flags_str(flags); char *flags_str = atomic_commit_flags_str(flags);
wlr_log(WLR_DEBUG, "(Atomic commit flags: %s)", wlr_log(WLR_DEBUG, "(Atomic commit flags: %s)",
flags_str ? flags_str : "<error>"); 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) { const struct wlr_drm_connector_state *state, uint32_t *blob_id) {
if (!state->active) { if (!state->active) {
*blob_id = 0; *blob_id = 0;
@ -117,7 +117,7 @@ bool create_mode_blob(struct wlr_drm_connector *conn,
return true; 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) { size_t size, const uint16_t *lut, uint32_t *blob_id) {
if (size == 0) { if (size == 0) {
*blob_id = 0; *blob_id = 0;
@ -233,51 +233,12 @@ static void rollback_blob(struct wlr_drm_backend *drm,
destroy_blob(drm, next); destroy_blob(drm, next);
} }
static void plane_disable(struct atomic *atom, struct wlr_drm_plane *plane) { bool drm_atomic_connector_prepare(struct wlr_drm_connector_state *state, bool modeset) {
uint32_t id = plane->id; struct wlr_drm_connector *conn = state->connector;
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) {
struct wlr_drm_backend *drm = conn->backend; struct wlr_drm_backend *drm = conn->backend;
struct wlr_output *output = &conn->output; struct wlr_output *output = &conn->output;
struct wlr_drm_crtc *crtc = conn->crtc; struct wlr_drm_crtc *crtc = conn->crtc;
bool modeset = state->modeset;
bool active = state->active;
uint32_t mode_id = crtc->mode_id; uint32_t mode_id = crtc->mode_id;
if (modeset) { if (modeset) {
if (!create_mode_blob(conn, state, &mode_id)) { 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; 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) { if (test_only) {
flags |= DRM_MODE_ATOMIC_TEST_ONLY; flags |= DRM_MODE_ATOMIC_TEST_ONLY;
} }
if (modeset) { if (state->modeset) {
flags |= DRM_MODE_ATOMIC_ALLOW_MODESET; flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
} }
if (!test_only && state->nonblock) { if (!test_only && state->nonblock) {
flags |= DRM_MODE_ATOMIC_NONBLOCK; flags |= DRM_MODE_ATOMIC_NONBLOCK;
} }
struct atomic atom; ok = atomic_commit(&atom, drm, state, page_flip, flags);
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);
atomic_finish(&atom); atomic_finish(&atom);
if (ok && !test_only) { out:
commit_blob(drm, &crtc->mode_id, mode_id); for (size_t i = 0; i < state->connectors_len; i++) {
commit_blob(drm, &crtc->gamma_lut, gamma_lut); struct wlr_drm_connector_state *conn_state = &state->connectors[i];
if (ok && !test_only) {
if (vrr_enabled != prev_vrr_enabled) { drm_atomic_connector_apply_commit(conn_state);
output->adaptive_sync_status = vrr_enabled ? } else {
WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED : drm_atomic_connector_rollback_commit(conn_state);
WLR_OUTPUT_ADAPTIVE_SYNC_DISABLED;
wlr_drm_conn_log(conn, WLR_DEBUG, "VRR %s",
vrr_enabled ? "enabled" : "disabled");
} }
} 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; return ok;
} }
@ -425,6 +466,6 @@ bool drm_atomic_reset(struct wlr_drm_backend *drm) {
} }
const struct wlr_drm_interface atomic_iface = { const struct wlr_drm_interface atomic_iface = {
.crtc_commit = atomic_crtc_commit, .commit = atomic_device_commit,
.reset = drm_atomic_reset, .reset = drm_atomic_reset,
}; };

239
backend/drm/drm.c
View file

@ -425,82 +425,139 @@ static struct wlr_drm_layer *get_or_create_layer(struct wlr_drm_backend *drm,
return layer; 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) { void drm_page_flip_destroy(struct wlr_drm_page_flip *page_flip) {
if (!page_flip) { if (!page_flip) {
return; return;
} }
wl_list_remove(&page_flip->link); wl_list_remove(&page_flip->link);
free(page_flip->connectors);
free(page_flip); 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)); struct wlr_drm_page_flip *page_flip = calloc(1, sizeof(*page_flip));
if (page_flip == NULL) { if (page_flip == NULL) {
return NULL; return NULL;
} }
page_flip->conn = conn; page_flip->connectors_len = state->connectors_len;
wl_list_insert(&conn->backend->page_flips, &page_flip->link); 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; return page_flip;
} }
static bool drm_crtc_commit(struct wlr_drm_connector *conn, static struct wlr_drm_connector *drm_page_flip_pop(
const struct wlr_drm_connector_state *state, 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) { uint32_t flags, bool test_only) {
// Disallow atomic-only flags // Disallow atomic-only flags
assert((flags & ~DRM_MODE_PAGE_FLIP_FLAGS) == 0); assert((flags & ~DRM_MODE_PAGE_FLIP_FLAGS) == 0);
struct wlr_drm_page_flip *page_flip = NULL; struct wlr_drm_page_flip *page_flip = NULL;
if (flags & DRM_MODE_PAGE_FLIP_EVENT) { 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) { if (page_flip == NULL) {
return false; return false;
} }
} }
struct wlr_drm_backend *drm = conn->backend; bool ok = drm->iface->commit(drm, state, page_flip, flags, test_only);
struct wlr_drm_crtc *crtc = conn->crtc;
bool ok = drm->iface->crtc_commit(conn, state, page_flip, flags, test_only);
if (ok && !test_only) { if (ok && !test_only) {
drm_fb_clear(&crtc->primary->queued_fb); for (size_t i = 0; i < state->connectors_len; i++) {
if (state->primary_fb != NULL) { drm_connector_apply_commit(&state->connectors[i], page_flip);
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);
} }
} else { } else {
// The set_cursor() hook is a bit special: it's not really synchronized for (size_t i = 0; i < state->connectors_len; i++) {
// to commit() or test(). Once set_cursor() returns true, the new drm_connector_rollback_commit(&state->connectors[i]);
// 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);
} }
drm_page_flip_destroy(page_flip); drm_page_flip_destroy(page_flip);
} }
return ok; return ok;
@ -510,17 +567,10 @@ static void drm_connector_state_init(struct wlr_drm_connector_state *state,
struct wlr_drm_connector *conn, struct wlr_drm_connector *conn,
const struct wlr_output_state *base) { const struct wlr_output_state *base) {
*state = (struct wlr_drm_connector_state){ *state = (struct wlr_drm_connector_state){
.connector = conn,
.base = base, .base = base,
.modeset = base->allow_reconfiguration,
.active = (base->committed & WLR_OUTPUT_STATE_ENABLED) ? .active = (base->committed & WLR_OUTPUT_STATE_ENABLED) ?
base->enabled : conn->output.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; 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) { static void drm_connector_state_finish(struct wlr_drm_connector_state *state) {
drm_fb_clear(&state->primary_fb); drm_fb_clear(&state->primary_fb);
} }
@ -679,6 +745,8 @@ static bool drm_connector_test(struct wlr_output *output,
bool ok = false; bool ok = false;
struct wlr_drm_connector_state pending = {0}; struct wlr_drm_connector_state pending = {0};
drm_connector_state_init(&pending, conn, state); 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 (pending.active) {
if ((state->committed & 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: out:
drm_connector_state_finish(&pending); drm_connector_state_finish(&pending);
@ -776,6 +844,8 @@ static bool drm_connector_commit_state(struct wlr_drm_connector *conn,
bool ok = false; bool ok = false;
struct wlr_drm_connector_state pending = {0}; struct wlr_drm_connector_state pending = {0};
drm_connector_state_init(&pending, conn, base); 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) { if (!pending.active && conn->crtc == NULL) {
// Disabling an already-disabled connector // 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) { if (pending.active) {
wlr_drm_conn_log(conn, WLR_INFO, "Modesetting with %dx%d @ %.3f Hz", wlr_drm_conn_log(conn, WLR_INFO, "Modesetting with %dx%d @ %.3f Hz",
pending.mode.hdisplay, pending.mode.vdisplay, 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 // 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 // we'll wait for all queued page-flips to complete, so we don't need this
// safeguard. // 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: " wlr_drm_conn_log(conn, WLR_ERROR, "Failed to page-flip output: "
"a page-flip is already pending"); "a page-flip is already pending");
goto out; goto out;
@ -830,7 +900,7 @@ static bool drm_connector_commit_state(struct wlr_drm_connector *conn,
flags |= DRM_MODE_PAGE_FLIP_ASYNC; flags |= DRM_MODE_PAGE_FLIP_ASYNC;
} }
ok = drm_crtc_commit(conn, &pending, flags, false); ok = drm_commit(drm, &pending_dev, flags, false);
if (!ok) { if (!ok) {
goto out; 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, static void build_current_connector_state(struct wlr_output_state *state,
struct wlr_drm_connector *conn) { struct wlr_drm_connector *conn) {
bool enabled = conn->status != DRM_MODE_DISCONNECTED && conn->output.enabled;
wlr_output_state_init(state); wlr_output_state_init(state);
wlr_output_state_set_enabled(state, enabled); wlr_output_state_set_enabled(state, conn->output.enabled);
if (!enabled) { if (!conn->output.enabled) {
return; return;
} }
@ -1759,6 +1827,12 @@ static bool skip_reset_for_restore(struct wlr_drm_backend *drm) {
if (crtc != NULL && conn->crtc != crtc) { if (crtc != NULL && conn->crtc != crtc) {
return false; 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++) { 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"); 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; struct wlr_drm_connector *conn;
wl_list_for_each(conn, &drm->connectors, link) { wl_list_for_each(conn, &drm->connectors, link) {
struct wlr_output_state state; if (conn->status == DRM_MODE_DISCONNECTED || !conn->output.enabled) {
build_current_connector_state(&state, conn); continue; // already disabled above
if (!drm_connector_commit_state(conn, &state)) {
wlr_drm_conn_log(conn, WLR_ERROR, "Failed to restore state after VT switch");
} }
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) { 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) { unsigned tv_sec, unsigned tv_usec, unsigned crtc_id, void *data) {
struct wlr_drm_page_flip *page_flip = 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) { if (conn != NULL) {
conn->pending_page_flip = 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) { if (conn == NULL) {
return; return;

50
backend/drm/legacy.c
View file

@ -34,11 +34,12 @@ static bool legacy_fb_props_match(struct wlr_drm_fb *fb1,
return true; return true;
} }
static bool legacy_crtc_test(struct wlr_drm_connector *conn, static bool legacy_crtc_test(const struct wlr_drm_connector_state *state,
const struct wlr_drm_connector_state *state) { bool modeset) {
struct wlr_drm_connector *conn = state->connector;
struct wlr_drm_crtc *crtc = conn->crtc; 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 *pending_fb = state->primary_fb;
struct wlr_drm_fb *prev_fb = crtc->primary->queued_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; return true;
} }
static bool legacy_crtc_commit(struct wlr_drm_connector *conn, static bool legacy_crtc_commit(const struct wlr_drm_connector_state *state,
const struct wlr_drm_connector_state *state, struct wlr_drm_page_flip *page_flip, uint32_t flags, bool modeset) {
struct wlr_drm_page_flip *page_flip, uint32_t flags, bool test_only) { struct wlr_drm_connector *conn = state->connector;
if (!legacy_crtc_test(conn, state)) {
return false;
}
if (test_only) {
return true;
}
struct wlr_drm_backend *drm = conn->backend; struct wlr_drm_backend *drm = conn->backend;
struct wlr_output *output = &conn->output; struct wlr_output *output = &conn->output;
struct wlr_drm_crtc *crtc = conn->crtc; 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; fb_id = state->primary_fb->id;
} }
if (state->modeset) { if (modeset) {
uint32_t *conns = NULL; uint32_t *conns = NULL;
size_t conns_len = 0; size_t conns_len = 0;
drmModeModeInfo *mode = NULL; drmModeModeInfo *mode = NULL;
@ -185,6 +179,32 @@ static bool legacy_crtc_commit(struct wlr_drm_connector *conn,
return true; 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, static void fill_empty_gamma_table(size_t size,
uint16_t *r, uint16_t *g, uint16_t *b) { uint16_t *r, uint16_t *g, uint16_t *b) {
assert(0xFFFF < UINT64_MAX / (size - 1)); 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 = { const struct wlr_drm_interface legacy_iface = {
.crtc_commit = legacy_crtc_commit, .commit = legacy_commit,
.reset = legacy_reset, .reset = legacy_reset,
}; };

253
backend/drm/libliftoff.c
View file

@ -1,5 +1,6 @@
#include <fcntl.h> #include <fcntl.h>
#include <libliftoff.h> #include <libliftoff.h>
#include <stdlib.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <unistd.h> #include <unistd.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
@ -126,27 +127,6 @@ static bool add_prop(drmModeAtomicReq *req, uint32_t obj,
return true; 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, 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) { struct liftoff_layer *layer, struct wlr_drm_fb *fb, int32_t x, int32_t y, uint64_t zpos) {
if (fb == NULL) { if (fb == NULL) {
@ -300,86 +280,16 @@ static void update_layer_feedback(struct wlr_drm_backend *drm,
wlr_drm_format_set_finish(&formats); 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, const struct wlr_drm_connector_state *state,
struct wlr_drm_page_flip *page_flip, uint32_t flags, bool test_only) { bool modeset, struct wl_array *fb_damage_clips_arr) {
struct wlr_drm_backend *drm = conn->backend; struct wlr_drm_connector *conn = state->connector;
struct wlr_output *output = &conn->output;
struct wlr_drm_crtc *crtc = conn->crtc; struct wlr_drm_crtc *crtc = conn->crtc;
struct wlr_drm_backend *drm = conn->backend;
bool modeset = state->modeset;
bool active = state->active; bool active = state->active;
bool ok = true;
if (modeset && !register_planes_for_crtc(drm, crtc)) { ok = ok && add_prop(req, conn->id, conn->props.crtc_id,
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,
active ? crtc->id : 0); active ? crtc->id : 0);
if (modeset && active && conn->props.link_status != 0) { if (modeset && active && conn->props.link_status != 0) {
ok = ok && add_prop(req, conn->id, conn->props.link_status, 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" // TODO: set "max bpc"
ok = ok && 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); add_prop(req, crtc->id, crtc->props.active, active);
if (active) { if (active) {
if (crtc->props.gamma_lut != 0) { 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) { 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 && ok = ok &&
set_plane_props(crtc->primary, crtc->primary->liftoff_layer, state->primary_fb, 0, 0, 0) && 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); set_plane_props(crtc->primary, crtc->liftoff_composition_layer, state->primary_fb, 0, 0, 0);
liftoff_layer_set_property(crtc->primary->liftoff_layer, 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, 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) { if (state->base->committed & WLR_OUTPUT_STATE_LAYERS) {
for (size_t i = 0; i < state->base->layers_len; i++) { for (size_t i = 0; i < state->base->layers_len; i++) {
const struct wlr_output_layer_state *layer_state = &state->base->layers[i]; const struct wlr_output_layer_state *layer_state = &state->base->layers[i];
ok = ok && set_layer_props(drm, layer_state, i + 1, 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) { return ok;
goto out; }
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); for (size_t i = 0; i < state->base->layers_len; i++) {
if (ret != 0) { struct wlr_output_layer_state *layer_state = &state->base->layers[i];
wlr_drm_conn_log(conn, test_only ? WLR_DEBUG : WLR_ERROR, struct wlr_drm_layer *layer = get_drm_layer(drm, layer_state->layer);
"liftoff_output_apply failed: %s", strerror(-ret)); layer_state->accepted =
ok = false; !liftoff_layer_needs_composition(layer->liftoff);
goto out; if (!layer_state->accepted) {
} update_layer_feedback(drm, layer);
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);
}
} }
} }
}
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: out:
drmModeAtomicFree(req); drmModeAtomicFree(req);
for (size_t i = 0; i < state->connectors_len; i++) {
if (ok && !test_only) { struct wlr_drm_connector_state *conn_state = &state->connectors[i];
commit_blob(drm, &crtc->mode_id, mode_id); if (ok && !test_only) {
commit_blob(drm, &crtc->gamma_lut, gamma_lut); drm_atomic_connector_apply_commit(conn_state);
connector_update_layers_feedback(conn_state);
if (vrr_enabled != prev_vrr_enabled) { } else {
output->adaptive_sync_status = vrr_enabled ? drm_atomic_connector_rollback_commit(conn_state);
WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED :
WLR_OUTPUT_ADAPTIVE_SYNC_DISABLED;
wlr_drm_conn_log(conn, WLR_DEBUG, "VRR %s",
vrr_enabled ? "enabled" : "disabled");
} }
} else {
rollback_blob(drm, &crtc->mode_id, mode_id);
rollback_blob(drm, &crtc->gamma_lut, gamma_lut);
} }
uint32_t *fb_damage_clips_ptr; uint32_t *fb_damage_clips_ptr;
@ -504,6 +453,6 @@ out:
const struct wlr_drm_interface liftoff_iface = { const struct wlr_drm_interface liftoff_iface = {
.init = init, .init = init,
.finish = finish, .finish = finish,
.crtc_commit = crtc_commit, .commit = commit,
.reset = drm_atomic_reset, .reset = drm_atomic_reset,
}; };

25
include/backend/drm/drm.h
View file

@ -121,13 +121,26 @@ struct wlr_drm_mode {
drmModeModeInfo drm_mode; drmModeModeInfo drm_mode;
}; };
struct wlr_drm_connector_state { struct wlr_drm_device_state {
const struct wlr_output_state *base;
bool modeset; bool modeset;
bool nonblock; 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; bool active;
drmModeModeInfo mode; drmModeModeInfo mode;
struct wlr_drm_fb *primary_fb; 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 wlr_drm_page_flip {
struct wl_list link; // wlr_drm_connector.page_flips 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 { struct wlr_drm_connector {

15
include/backend/drm/iface.h
View file

@ -10,6 +10,7 @@
struct wlr_drm_backend; struct wlr_drm_backend;
struct wlr_drm_connector; struct wlr_drm_connector;
struct wlr_drm_crtc; struct wlr_drm_crtc;
struct wlr_drm_device_state;
struct wlr_drm_connector_state; struct wlr_drm_connector_state;
struct wlr_drm_fb; struct wlr_drm_fb;
struct wlr_drm_page_flip; struct wlr_drm_page_flip;
@ -18,9 +19,8 @@ struct wlr_drm_page_flip;
struct wlr_drm_interface { struct wlr_drm_interface {
bool (*init)(struct wlr_drm_backend *drm); bool (*init)(struct wlr_drm_backend *drm);
void (*finish)(struct wlr_drm_backend *drm); void (*finish)(struct wlr_drm_backend *drm);
// Commit all pending changes on a CRTC. bool (*commit)(struct wlr_drm_backend *drm,
bool (*crtc_commit)(struct wlr_drm_connector *conn, const struct wlr_drm_device_state *state,
const struct wlr_drm_connector_state *state,
struct wlr_drm_page_flip *page_flip, uint32_t flags, bool test_only); struct wlr_drm_page_flip *page_flip, uint32_t flags, bool test_only);
// Turn off everything // Turn off everything
bool (*reset)(struct wlr_drm_backend *drm); 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, bool drm_legacy_crtc_set_gamma(struct wlr_drm_backend *drm,
struct wlr_drm_crtc *crtc, size_t size, uint16_t *lut); 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, bool create_fb_damage_clips_blob(struct wlr_drm_backend *drm,
int width, int height, const pixman_region32_t *damage, uint32_t *blob_id); 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_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 #endif