2020-05-14 18:27:02 +02:00
|
|
|
#include <assert.h>
|
2017-08-09 10:43:01 +02:00
|
|
|
#include <gbm.h>
|
2020-05-14 18:27:02 +02:00
|
|
|
#include <stdlib.h>
|
2018-02-12 21:29:23 +01:00
|
|
|
#include <wlr/util/log.h>
|
2017-08-09 10:43:01 +02:00
|
|
|
#include <xf86drm.h>
|
|
|
|
#include <xf86drmMode.h>
|
2017-09-30 08:03:34 +02:00
|
|
|
#include "backend/drm/drm.h"
|
2017-09-30 08:11:41 +02:00
|
|
|
#include "backend/drm/iface.h"
|
2017-09-30 08:03:34 +02:00
|
|
|
#include "backend/drm/util.h"
|
2017-08-09 10:43:01 +02:00
|
|
|
|
2020-05-07 19:20:56 +02:00
|
|
|
static bool legacy_crtc_commit(struct wlr_drm_backend *drm,
|
2021-04-06 16:32:01 +02:00
|
|
|
struct wlr_drm_connector *conn, const struct wlr_output_state *state,
|
|
|
|
uint32_t flags) {
|
2020-05-14 18:27:02 +02:00
|
|
|
struct wlr_output *output = &conn->output;
|
2020-02-12 09:25:40 +01:00
|
|
|
struct wlr_drm_crtc *crtc = conn->crtc;
|
2020-05-07 16:17:18 +02:00
|
|
|
struct wlr_drm_plane *cursor = crtc->cursor;
|
|
|
|
|
2021-04-06 17:14:17 +02:00
|
|
|
bool active = drm_connector_state_active(conn, state);
|
|
|
|
|
2020-05-07 21:11:43 +02:00
|
|
|
uint32_t fb_id = 0;
|
2021-04-06 17:14:17 +02:00
|
|
|
if (active) {
|
2020-05-07 21:11:43 +02:00
|
|
|
struct wlr_drm_fb *fb = plane_get_next_fb(crtc->primary);
|
2020-12-22 17:07:29 +01:00
|
|
|
if (fb == NULL) {
|
2020-12-15 12:21:40 +01:00
|
|
|
wlr_log(WLR_ERROR, "%s: failed to acquire primary FB",
|
|
|
|
conn->output.name);
|
2020-05-07 21:11:43 +02:00
|
|
|
return false;
|
|
|
|
}
|
2020-12-15 12:21:40 +01:00
|
|
|
fb_id = fb->id;
|
2020-02-12 09:25:40 +01:00
|
|
|
}
|
|
|
|
|
2021-04-06 17:06:37 +02:00
|
|
|
if (drm_connector_state_is_modeset(state)) {
|
2020-05-07 21:11:43 +02:00
|
|
|
uint32_t *conns = NULL;
|
|
|
|
size_t conns_len = 0;
|
|
|
|
drmModeModeInfo *mode = NULL;
|
2021-04-06 17:14:17 +02:00
|
|
|
if (active) {
|
2020-05-07 21:11:43 +02:00
|
|
|
conns = &conn->id;
|
|
|
|
conns_len = 1;
|
2020-05-18 14:27:42 +02:00
|
|
|
mode = &crtc->pending.mode->drm_mode;
|
2020-05-07 21:11:43 +02:00
|
|
|
}
|
|
|
|
|
2021-04-06 17:14:17 +02:00
|
|
|
uint32_t dpms = active ? DRM_MODE_DPMS_ON : DRM_MODE_DPMS_OFF;
|
2020-05-07 21:11:43 +02:00
|
|
|
if (drmModeConnectorSetProperty(drm->fd, conn->id, conn->props.dpms,
|
2020-05-18 14:27:42 +02:00
|
|
|
dpms) != 0) {
|
2020-12-09 14:50:39 +01:00
|
|
|
wlr_drm_conn_log_errno(conn, WLR_ERROR,
|
|
|
|
"Failed to set DPMS property");
|
2020-05-07 21:11:43 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-09-30 11:22:26 +02:00
|
|
|
if (drmModeSetCrtc(drm->fd, crtc->id, fb_id, 0, 0,
|
2020-05-07 21:11:43 +02:00
|
|
|
conns, conns_len, mode)) {
|
2020-12-09 14:50:39 +01:00
|
|
|
wlr_drm_conn_log_errno(conn, WLR_ERROR, "Failed to set CRTC");
|
2017-09-24 01:19:49 +02:00
|
|
|
return false;
|
|
|
|
}
|
2017-08-09 10:43:01 +02:00
|
|
|
}
|
|
|
|
|
2021-04-06 16:32:01 +02:00
|
|
|
if (state->committed & WLR_OUTPUT_STATE_GAMMA_LUT) {
|
2020-05-14 18:27:02 +02:00
|
|
|
if (!drm_legacy_crtc_set_gamma(drm, crtc,
|
2021-04-06 16:32:01 +02:00
|
|
|
state->gamma_lut_size, state->gamma_lut)) {
|
2020-05-07 17:50:40 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-06 16:32:01 +02:00
|
|
|
if ((state->committed & WLR_OUTPUT_STATE_ADAPTIVE_SYNC_ENABLED) &&
|
2020-05-27 16:43:19 +02:00
|
|
|
drm_connector_supports_vrr(conn)) {
|
|
|
|
if (drmModeObjectSetProperty(drm->fd, crtc->id, DRM_MODE_OBJECT_CRTC,
|
|
|
|
crtc->props.vrr_enabled,
|
2021-04-06 16:32:01 +02:00
|
|
|
state->adaptive_sync_enabled) != 0) {
|
2020-12-09 14:50:39 +01:00
|
|
|
wlr_drm_conn_log_errno(conn, WLR_ERROR,
|
2020-05-27 16:43:19 +02:00
|
|
|
"drmModeObjectSetProperty(VRR_ENABLED) failed");
|
|
|
|
return false;
|
|
|
|
}
|
2021-04-06 16:32:01 +02:00
|
|
|
output->adaptive_sync_status = state->adaptive_sync_enabled ?
|
2020-05-27 16:43:19 +02:00
|
|
|
WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED :
|
|
|
|
WLR_OUTPUT_ADAPTIVE_SYNC_DISABLED;
|
2020-12-09 14:50:39 +01:00
|
|
|
wlr_drm_conn_log(conn, WLR_DEBUG, "VRR %s",
|
2021-04-06 16:32:01 +02:00
|
|
|
state->adaptive_sync_enabled ? "enabled" : "disabled");
|
2020-05-27 16:43:19 +02:00
|
|
|
}
|
|
|
|
|
2020-05-27 18:16:03 +02:00
|
|
|
if (cursor != NULL && drm_connector_is_cursor_visible(conn)) {
|
2020-05-07 21:28:42 +02:00
|
|
|
struct wlr_drm_fb *cursor_fb = plane_get_next_fb(cursor);
|
2020-12-22 17:07:29 +01:00
|
|
|
if (cursor_fb == NULL) {
|
2021-01-07 16:53:20 +01:00
|
|
|
wlr_drm_conn_log(conn, WLR_DEBUG, "Failed to acquire cursor FB");
|
2020-05-07 19:20:56 +02:00
|
|
|
return false;
|
|
|
|
}
|
2017-08-09 10:43:01 +02:00
|
|
|
|
2020-12-18 16:24:36 +01:00
|
|
|
uint32_t cursor_handle = gbm_bo_get_handle(cursor_fb->bo).u32;
|
|
|
|
uint32_t cursor_width = gbm_bo_get_width(cursor_fb->bo);
|
|
|
|
uint32_t cursor_height = gbm_bo_get_height(cursor_fb->bo);
|
|
|
|
if (drmModeSetCursor(drm->fd, crtc->id, cursor_handle,
|
|
|
|
cursor_width, cursor_height)) {
|
2020-12-09 14:50:39 +01:00
|
|
|
wlr_drm_conn_log_errno(conn, WLR_DEBUG, "drmModeSetCursor failed");
|
2020-05-07 21:28:42 +02:00
|
|
|
return false;
|
|
|
|
}
|
2017-08-09 10:43:01 +02:00
|
|
|
|
2020-05-07 21:28:42 +02:00
|
|
|
if (drmModeMoveCursor(drm->fd,
|
|
|
|
crtc->id, conn->cursor_x, conn->cursor_y) != 0) {
|
2020-12-09 14:50:39 +01:00
|
|
|
wlr_drm_conn_log_errno(conn, WLR_ERROR, "drmModeMoveCursor failed");
|
2020-05-07 21:28:42 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
} else {
|
2018-09-10 17:30:26 +02:00
|
|
|
if (drmModeSetCursor(drm->fd, crtc->id, 0, 0, 0)) {
|
2020-12-09 14:50:39 +01:00
|
|
|
wlr_drm_conn_log_errno(conn, WLR_DEBUG, "drmModeSetCursor failed");
|
2018-09-10 17:30:26 +02:00
|
|
|
return false;
|
|
|
|
}
|
2017-08-09 10:43:01 +02:00
|
|
|
}
|
|
|
|
|
2020-05-07 21:28:42 +02:00
|
|
|
if (flags & DRM_MODE_PAGE_FLIP_EVENT) {
|
|
|
|
if (drmModePageFlip(drm->fd, crtc->id, fb_id,
|
|
|
|
DRM_MODE_PAGE_FLIP_EVENT, drm)) {
|
2020-12-09 14:50:39 +01:00
|
|
|
wlr_drm_conn_log_errno(conn, WLR_ERROR, "drmModePageFlip failed");
|
2020-05-07 21:28:42 +02:00
|
|
|
return false;
|
|
|
|
}
|
2017-08-09 10:43:01 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-05-14 18:27:02 +02:00
|
|
|
static void fill_empty_gamma_table(size_t size,
|
|
|
|
uint16_t *r, uint16_t *g, uint16_t *b) {
|
|
|
|
assert(0xFFFF < UINT64_MAX / (size - 1));
|
|
|
|
for (uint32_t i = 0; i < size; ++i) {
|
|
|
|
uint16_t val = (uint64_t)0xFFFF * i / (size - 1);
|
|
|
|
r[i] = g[i] = b[i] = val;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-07 17:50:40 +02:00
|
|
|
bool drm_legacy_crtc_set_gamma(struct wlr_drm_backend *drm,
|
2020-05-14 18:27:02 +02:00
|
|
|
struct wlr_drm_crtc *crtc, size_t size, uint16_t *lut) {
|
|
|
|
uint16_t *linear_lut = NULL;
|
|
|
|
if (size == 0) {
|
|
|
|
// The legacy interface doesn't offer a way to reset the gamma LUT
|
|
|
|
size = drm_crtc_get_gamma_lut_size(drm, crtc);
|
|
|
|
if (size == 0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
linear_lut = malloc(3 * size * sizeof(uint16_t));
|
|
|
|
if (linear_lut == NULL) {
|
|
|
|
wlr_log_errno(WLR_ERROR, "Allocation failed");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
fill_empty_gamma_table(size, linear_lut, linear_lut + size,
|
|
|
|
linear_lut + 2 * size);
|
|
|
|
|
|
|
|
lut = linear_lut;
|
2020-05-07 17:50:40 +02:00
|
|
|
}
|
|
|
|
|
2020-05-14 18:27:02 +02:00
|
|
|
uint16_t *r = lut, *g = lut + size, *b = lut + 2 * size;
|
2020-05-07 17:50:40 +02:00
|
|
|
if (drmModeCrtcSetGamma(drm->fd, crtc->id, size, r, g, b) != 0) {
|
|
|
|
wlr_log_errno(WLR_ERROR, "Failed to set gamma LUT on CRTC %"PRIu32,
|
|
|
|
crtc->id);
|
|
|
|
return false;
|
|
|
|
}
|
2020-05-14 18:27:02 +02:00
|
|
|
|
|
|
|
free(linear_lut);
|
2020-05-07 17:50:40 +02:00
|
|
|
return true;
|
2018-02-01 20:27:35 +01:00
|
|
|
}
|
|
|
|
|
2017-10-02 10:44:33 +02:00
|
|
|
const struct wlr_drm_interface legacy_iface = {
|
2020-05-07 19:20:56 +02:00
|
|
|
.crtc_commit = legacy_crtc_commit,
|
2017-08-09 10:43:01 +02:00
|
|
|
};
|