wlroots-hyprland/backend/drm/util.c

269 lines
6.3 KiB
C
Raw Normal View History

#define _POSIX_C_SOURCE 200809L
#include <assert.h>
#include <drm_fourcc.h>
2017-08-05 07:56:22 +02:00
#include <drm_mode.h>
2018-02-12 21:29:23 +01:00
#include <drm.h>
#include <libudev.h>
2018-02-12 21:29:23 +01:00
#include <stdio.h>
#include <stdlib.h>
2018-02-12 21:29:23 +01:00
#include <string.h>
2017-08-09 10:43:01 +02:00
#include <wlr/util/log.h>
#include "backend/drm/drm.h"
2018-02-12 21:29:23 +01:00
#include "backend/drm/util.h"
2017-08-05 07:56:22 +02:00
int32_t calculate_refresh_rate(const drmModeModeInfo *mode) {
2017-08-05 07:56:22 +02:00
int32_t refresh = (mode->clock * 1000000LL / mode->htotal +
mode->vtotal / 2) / mode->vtotal;
if (mode->flags & DRM_MODE_FLAG_INTERLACE) {
refresh *= 2;
}
if (mode->flags & DRM_MODE_FLAG_DBLSCAN) {
refresh /= 2;
}
if (mode->vscan > 1) {
refresh /= mode->vscan;
}
return refresh;
}
static const char *get_manufacturer(struct udev_hwdb *hwdb, uint16_t code) {
static char pnp_id[4];
// The ASCII 3-letter manufacturer PnP ID is encoded in 5-bit codes
pnp_id[0] = ((code >> 10) & 0x1F) + '@';
pnp_id[1] = ((code >> 5) & 0x1F) + '@';
pnp_id[2] = ((code >> 0) & 0x1F) + '@';
pnp_id[3] = '\0';
if (hwdb == NULL) {
return pnp_id;
}
char query[32];
snprintf(query, sizeof(query), "acpi:%s:", pnp_id);
struct udev_list_entry *acpi_entry =
udev_hwdb_get_properties_list_entry(hwdb, query, 0);
if (acpi_entry == NULL) {
return pnp_id;
2017-08-05 07:56:22 +02:00
}
struct udev_list_entry *vendor_entry =
udev_list_entry_get_by_name(acpi_entry, "ID_VENDOR_FROM_DATABASE");
if (vendor_entry == NULL) {
return pnp_id;
}
return udev_list_entry_get_value(vendor_entry);
2017-08-05 07:56:22 +02:00
}
/* See https://en.wikipedia.org/wiki/Extended_Display_Identification_Data for layout of EDID data.
* We don't parse the EDID properly. We just expect to receive valid data.
*/
void parse_edid(struct wlr_drm_connector *conn, size_t len, const uint8_t *data) {
struct wlr_output *output = &conn->output;
free(output->make);
free(output->model);
free(output->serial);
output->make = NULL;
output->model = NULL;
output->serial = NULL;
2017-08-05 07:56:22 +02:00
if (!data || len < 128) {
return;
}
uint16_t id = (data[8] << 8) | data[9];
output->make = strdup(get_manufacturer(conn->backend->hwdb, id));
2017-08-05 07:56:22 +02:00
uint16_t model = data[10] | (data[11] << 8);
char model_str[32];
snprintf(model_str, sizeof(model_str), "0x%04" PRIX16, model);
uint32_t serial = data[12] | (data[13] << 8) | (data[14] << 8) | (data[15] << 8);
char serial_str[32];
if (serial != 0) {
snprintf(serial_str, sizeof(serial_str), "0x%08" PRIX32, serial);
} else {
serial_str[0] = '\0';
}
2017-08-05 07:56:22 +02:00
for (size_t i = 72; i <= 108; i += 18) {
uint16_t flag = (data[i] << 8) | data[i + 1];
if (flag == 0 && data[i + 3] == 0xFC) {
snprintf(model_str, sizeof(model_str), "%.13s", &data[i + 5]);
2017-08-05 07:56:22 +02:00
// Monitor names are terminated by newline if they're too short
char *nl = strchr(model_str, '\n');
2017-08-05 07:56:22 +02:00
if (nl) {
*nl = '\0';
}
2017-11-11 19:09:34 +01:00
} else if (flag == 0 && data[i + 3] == 0xFF) {
snprintf(serial_str, sizeof(serial_str), "%.13s", &data[i + 5]);
2017-08-05 07:56:22 +02:00
2017-11-11 19:09:34 +01:00
// Monitor serial numbers are terminated by newline if they're too
// short
char* nl = strchr(serial_str, '\n');
2017-11-11 19:09:34 +01:00
if (nl) {
*nl = '\0';
}
2017-08-05 07:56:22 +02:00
}
}
output->model = strdup(model_str);
if (serial_str[0] != '\0') {
output->serial = strdup(serial_str);
}
2017-08-05 07:56:22 +02:00
}
static bool is_taken(size_t n, const uint32_t arr[static n], uint32_t key) {
2017-08-05 07:56:22 +02:00
for (size_t i = 0; i < n; ++i) {
if (arr[i] == key) {
return true;
}
}
return false;
}
/*
* Store all of the non-recursive state in a struct, so we aren't literally
* passing 12 arguments to a function.
*/
struct match_state {
const size_t num_objs;
const uint32_t *restrict objs;
const size_t num_res;
size_t score;
size_t replaced;
uint32_t *restrict res;
uint32_t *restrict best;
const uint32_t *restrict orig;
bool exit_early;
};
/*
* skips: The number of SKIP elements encountered so far.
* score: The number of resources we've matched so far.
* replaced: The number of changes from the original solution.
* i: The index of the current element.
*
* This tries to match a solution as close to st->orig as it can.
*
* Returns whether we've set a new best element with this solution.
*/
static bool match_obj_(struct match_state *st, size_t skips, size_t score, size_t replaced, size_t i) {
// Finished
if (i >= st->num_res) {
backend/drm: steal CRTCs from disabled outputs This commit allows outputs that need a CRTC to steal it from user-disabled outputs. Note that in the case there are enough CRTCs, disabled outputs don't loose it (so there's no modeset and plane initialization needed after DPMS). CRTC allocation still prefers to keep the old configuration, even if that means allocating an extra CRTC to a disabled output. CRTC reallocation now happen when enabling/disabling an output as well as when trying to modeset. When enabling an output without a CRTC, we realloc to try to steal a CRTC from a disabled output (that doesn't really need the CRTC). When disabling an output, we try to give our CRTC to an output that needs one. Modesetting is similar to enabling. A new DRM connector field has been added: `desired_enabled`. Outputs without CRTCs get automatically disabled. This field keeps track of the state desired by the user, allowing to automatically re-enable outputs when a CRTC becomes free. This required some changes to the allocation algorithm. Previously, the algorithm tried to keep the previous configuration even if a new configuration with a better score was possible (it only changed configuration when the old one didn't work anymore). This is now changed and the old configuration (still preferred) is only retained without considering new possibilities when it's perfect (all outputs have CRTCs). User-disabled outputs now have `possible_crtcs` set to 0, meaning they can only retain a previous CRTC (not acquire a new one). The allocation algorithm has been updated to do not bump the score when assigning a CRTC to a disabled output.
2018-09-10 23:35:22 +02:00
if (score > st->score ||
(score == st->score && replaced < st->replaced)) {
2017-08-05 07:56:22 +02:00
st->score = score;
st->replaced = replaced;
memcpy(st->best, st->res, sizeof(st->best[0]) * st->num_res);
2017-08-05 07:56:22 +02:00
st->exit_early = (st->score == st->num_res - skips
|| st->score == st->num_objs)
&& st->replaced == 0;
return true;
} else {
return false;
}
}
if (st->orig[i] == SKIP) {
st->res[i] = SKIP;
return match_obj_(st, skips + 1, score, replaced, i + 1);
}
backend/drm: steal CRTCs from disabled outputs This commit allows outputs that need a CRTC to steal it from user-disabled outputs. Note that in the case there are enough CRTCs, disabled outputs don't loose it (so there's no modeset and plane initialization needed after DPMS). CRTC allocation still prefers to keep the old configuration, even if that means allocating an extra CRTC to a disabled output. CRTC reallocation now happen when enabling/disabling an output as well as when trying to modeset. When enabling an output without a CRTC, we realloc to try to steal a CRTC from a disabled output (that doesn't really need the CRTC). When disabling an output, we try to give our CRTC to an output that needs one. Modesetting is similar to enabling. A new DRM connector field has been added: `desired_enabled`. Outputs without CRTCs get automatically disabled. This field keeps track of the state desired by the user, allowing to automatically re-enable outputs when a CRTC becomes free. This required some changes to the allocation algorithm. Previously, the algorithm tried to keep the previous configuration even if a new configuration with a better score was possible (it only changed configuration when the old one didn't work anymore). This is now changed and the old configuration (still preferred) is only retained without considering new possibilities when it's perfect (all outputs have CRTCs). User-disabled outputs now have `possible_crtcs` set to 0, meaning they can only retain a previous CRTC (not acquire a new one). The allocation algorithm has been updated to do not bump the score when assigning a CRTC to a disabled output.
2018-09-10 23:35:22 +02:00
bool has_best = false;
2017-08-05 07:56:22 +02:00
/*
* Attempt to use the current solution first, to try and avoid
* recalculating everything
*/
if (st->orig[i] != UNMATCHED && !is_taken(i, st->res, st->orig[i])) {
st->res[i] = st->orig[i];
backend/drm: steal CRTCs from disabled outputs This commit allows outputs that need a CRTC to steal it from user-disabled outputs. Note that in the case there are enough CRTCs, disabled outputs don't loose it (so there's no modeset and plane initialization needed after DPMS). CRTC allocation still prefers to keep the old configuration, even if that means allocating an extra CRTC to a disabled output. CRTC reallocation now happen when enabling/disabling an output as well as when trying to modeset. When enabling an output without a CRTC, we realloc to try to steal a CRTC from a disabled output (that doesn't really need the CRTC). When disabling an output, we try to give our CRTC to an output that needs one. Modesetting is similar to enabling. A new DRM connector field has been added: `desired_enabled`. Outputs without CRTCs get automatically disabled. This field keeps track of the state desired by the user, allowing to automatically re-enable outputs when a CRTC becomes free. This required some changes to the allocation algorithm. Previously, the algorithm tried to keep the previous configuration even if a new configuration with a better score was possible (it only changed configuration when the old one didn't work anymore). This is now changed and the old configuration (still preferred) is only retained without considering new possibilities when it's perfect (all outputs have CRTCs). User-disabled outputs now have `possible_crtcs` set to 0, meaning they can only retain a previous CRTC (not acquire a new one). The allocation algorithm has been updated to do not bump the score when assigning a CRTC to a disabled output.
2018-09-10 23:35:22 +02:00
size_t obj_score = st->objs[st->res[i]] != 0 ? 1 : 0;
if (match_obj_(st, skips, score + obj_score, replaced, i + 1)) {
has_best = true;
2017-08-05 07:56:22 +02:00
}
}
if (st->orig[i] == UNMATCHED) {
st->res[i] = UNMATCHED;
backend/drm: steal CRTCs from disabled outputs This commit allows outputs that need a CRTC to steal it from user-disabled outputs. Note that in the case there are enough CRTCs, disabled outputs don't loose it (so there's no modeset and plane initialization needed after DPMS). CRTC allocation still prefers to keep the old configuration, even if that means allocating an extra CRTC to a disabled output. CRTC reallocation now happen when enabling/disabling an output as well as when trying to modeset. When enabling an output without a CRTC, we realloc to try to steal a CRTC from a disabled output (that doesn't really need the CRTC). When disabling an output, we try to give our CRTC to an output that needs one. Modesetting is similar to enabling. A new DRM connector field has been added: `desired_enabled`. Outputs without CRTCs get automatically disabled. This field keeps track of the state desired by the user, allowing to automatically re-enable outputs when a CRTC becomes free. This required some changes to the allocation algorithm. Previously, the algorithm tried to keep the previous configuration even if a new configuration with a better score was possible (it only changed configuration when the old one didn't work anymore). This is now changed and the old configuration (still preferred) is only retained without considering new possibilities when it's perfect (all outputs have CRTCs). User-disabled outputs now have `possible_crtcs` set to 0, meaning they can only retain a previous CRTC (not acquire a new one). The allocation algorithm has been updated to do not bump the score when assigning a CRTC to a disabled output.
2018-09-10 23:35:22 +02:00
if (match_obj_(st, skips, score, replaced, i + 1)) {
has_best = true;
}
}
backend/drm: steal CRTCs from disabled outputs This commit allows outputs that need a CRTC to steal it from user-disabled outputs. Note that in the case there are enough CRTCs, disabled outputs don't loose it (so there's no modeset and plane initialization needed after DPMS). CRTC allocation still prefers to keep the old configuration, even if that means allocating an extra CRTC to a disabled output. CRTC reallocation now happen when enabling/disabling an output as well as when trying to modeset. When enabling an output without a CRTC, we realloc to try to steal a CRTC from a disabled output (that doesn't really need the CRTC). When disabling an output, we try to give our CRTC to an output that needs one. Modesetting is similar to enabling. A new DRM connector field has been added: `desired_enabled`. Outputs without CRTCs get automatically disabled. This field keeps track of the state desired by the user, allowing to automatically re-enable outputs when a CRTC becomes free. This required some changes to the allocation algorithm. Previously, the algorithm tried to keep the previous configuration even if a new configuration with a better score was possible (it only changed configuration when the old one didn't work anymore). This is now changed and the old configuration (still preferred) is only retained without considering new possibilities when it's perfect (all outputs have CRTCs). User-disabled outputs now have `possible_crtcs` set to 0, meaning they can only retain a previous CRTC (not acquire a new one). The allocation algorithm has been updated to do not bump the score when assigning a CRTC to a disabled output.
2018-09-10 23:35:22 +02:00
if (st->exit_early) {
return true;
}
2017-08-05 07:56:22 +02:00
if (st->orig[i] != UNMATCHED) {
++replaced;
}
2018-09-04 23:08:45 +02:00
for (size_t candidate = 0; candidate < st->num_objs; ++candidate) {
2017-08-05 07:56:22 +02:00
// We tried this earlier
2018-09-04 23:08:45 +02:00
if (candidate == st->orig[i]) {
2017-08-05 07:56:22 +02:00
continue;
}
2018-05-03 22:59:43 +02:00
// Not compatible
2018-09-04 23:08:45 +02:00
if (!(st->objs[candidate] & (1 << i))) {
2017-08-05 07:56:22 +02:00
continue;
}
// Already taken
2018-09-04 23:08:45 +02:00
if (is_taken(i, st->res, candidate)) {
2017-08-05 07:56:22 +02:00
continue;
}
2018-09-04 23:08:45 +02:00
st->res[i] = candidate;
backend/drm: steal CRTCs from disabled outputs This commit allows outputs that need a CRTC to steal it from user-disabled outputs. Note that in the case there are enough CRTCs, disabled outputs don't loose it (so there's no modeset and plane initialization needed after DPMS). CRTC allocation still prefers to keep the old configuration, even if that means allocating an extra CRTC to a disabled output. CRTC reallocation now happen when enabling/disabling an output as well as when trying to modeset. When enabling an output without a CRTC, we realloc to try to steal a CRTC from a disabled output (that doesn't really need the CRTC). When disabling an output, we try to give our CRTC to an output that needs one. Modesetting is similar to enabling. A new DRM connector field has been added: `desired_enabled`. Outputs without CRTCs get automatically disabled. This field keeps track of the state desired by the user, allowing to automatically re-enable outputs when a CRTC becomes free. This required some changes to the allocation algorithm. Previously, the algorithm tried to keep the previous configuration even if a new configuration with a better score was possible (it only changed configuration when the old one didn't work anymore). This is now changed and the old configuration (still preferred) is only retained without considering new possibilities when it's perfect (all outputs have CRTCs). User-disabled outputs now have `possible_crtcs` set to 0, meaning they can only retain a previous CRTC (not acquire a new one). The allocation algorithm has been updated to do not bump the score when assigning a CRTC to a disabled output.
2018-09-10 23:35:22 +02:00
size_t obj_score = st->objs[candidate] != 0 ? 1 : 0;
if (match_obj_(st, skips, score + obj_score, replaced, i + 1)) {
2018-09-04 23:08:45 +02:00
has_best = true;
2017-08-05 07:56:22 +02:00
}
if (st->exit_early) {
return true;
}
}
2018-09-04 23:08:45 +02:00
if (has_best) {
2017-08-05 07:56:22 +02:00
return true;
}
// Maybe this resource can't be matched
st->res[i] = UNMATCHED;
return match_obj_(st, skips, score, replaced, i + 1);
}
size_t match_obj(size_t num_objs, const uint32_t objs[static restrict num_objs],
size_t num_res, const uint32_t res[static restrict num_res],
uint32_t out[static restrict num_res]) {
uint32_t solution[num_res];
for (size_t i = 0; i < num_res; ++i) {
solution[i] = UNMATCHED;
}
2017-08-05 07:56:22 +02:00
struct match_state st = {
.num_objs = num_objs,
.num_res = num_res,
.score = 0,
.replaced = SIZE_MAX,
.objs = objs,
.res = solution,
.best = out,
.orig = res,
.exit_early = false,
};
match_obj_(&st, 0, 0, 0, 0);
return st.score;
}