weston/libweston/backend-drm/modes.c
Michael Tretter deebfd99e3 backend-drm: get the drm device from the output
If we have multiple drm devices, we cannot use the drm device from the backend,
because we would only get the primary device and not the device of the output.

Signed-off-by: Michael Tretter <m.tretter@pengutronix.de>
2022-06-03 09:17:49 +02:00

836 lines
23 KiB
C

/*
* Copyright © 2008-2011 Kristian Høgsberg
* Copyright © 2011 Intel Corporation
* Copyright © 2017, 2018 Collabora, Ltd.
* Copyright © 2017, 2018 General Electric Company
* Copyright (c) 2018 DisplayLink (UK) Ltd.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial
* portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include "config.h"
#include <xf86drm.h>
#include <xf86drmMode.h>
#include "drm-internal.h"
#include "shared/weston-drm-fourcc.h"
static const char *const aspect_ratio_as_string[] = {
[WESTON_MODE_PIC_AR_NONE] = "",
[WESTON_MODE_PIC_AR_4_3] = " 4:3",
[WESTON_MODE_PIC_AR_16_9] = " 16:9",
[WESTON_MODE_PIC_AR_64_27] = " 64:27",
[WESTON_MODE_PIC_AR_256_135] = " 256:135",
};
/*
* Get the aspect-ratio from drmModeModeInfo mode flags.
*
* @param drm_mode_flags- flags from drmModeModeInfo structure.
* @returns aspect-ratio as encoded in enum 'weston_mode_aspect_ratio'.
*/
static enum weston_mode_aspect_ratio
drm_to_weston_mode_aspect_ratio(uint32_t drm_mode_flags)
{
switch (drm_mode_flags & DRM_MODE_FLAG_PIC_AR_MASK) {
case DRM_MODE_FLAG_PIC_AR_4_3:
return WESTON_MODE_PIC_AR_4_3;
case DRM_MODE_FLAG_PIC_AR_16_9:
return WESTON_MODE_PIC_AR_16_9;
case DRM_MODE_FLAG_PIC_AR_64_27:
return WESTON_MODE_PIC_AR_64_27;
case DRM_MODE_FLAG_PIC_AR_256_135:
return WESTON_MODE_PIC_AR_256_135;
case DRM_MODE_FLAG_PIC_AR_NONE:
default:
return WESTON_MODE_PIC_AR_NONE;
}
}
static const char *
aspect_ratio_to_string(enum weston_mode_aspect_ratio ratio)
{
if (ratio < 0 || ratio >= ARRAY_LENGTH(aspect_ratio_as_string) ||
!aspect_ratio_as_string[ratio])
return " (unknown aspect ratio)";
return aspect_ratio_as_string[ratio];
}
static int
drm_subpixel_to_wayland(int drm_value)
{
switch (drm_value) {
default:
case DRM_MODE_SUBPIXEL_UNKNOWN:
return WL_OUTPUT_SUBPIXEL_UNKNOWN;
case DRM_MODE_SUBPIXEL_NONE:
return WL_OUTPUT_SUBPIXEL_NONE;
case DRM_MODE_SUBPIXEL_HORIZONTAL_RGB:
return WL_OUTPUT_SUBPIXEL_HORIZONTAL_RGB;
case DRM_MODE_SUBPIXEL_HORIZONTAL_BGR:
return WL_OUTPUT_SUBPIXEL_HORIZONTAL_BGR;
case DRM_MODE_SUBPIXEL_VERTICAL_RGB:
return WL_OUTPUT_SUBPIXEL_VERTICAL_RGB;
case DRM_MODE_SUBPIXEL_VERTICAL_BGR:
return WL_OUTPUT_SUBPIXEL_VERTICAL_BGR;
}
}
int
drm_mode_ensure_blob(struct drm_device *device, struct drm_mode *mode)
{
struct drm_backend *backend = device->backend;
int ret;
if (mode->blob_id)
return 0;
ret = drmModeCreatePropertyBlob(device->drm.fd,
&mode->mode_info,
sizeof(mode->mode_info),
&mode->blob_id);
if (ret != 0)
weston_log("failed to create mode property blob: %s\n",
strerror(errno));
drm_debug(backend, "\t\t\t[atomic] created new mode blob %lu for %s\n",
(unsigned long) mode->blob_id, mode->mode_info.name);
return ret;
}
static bool
check_non_desktop(struct drm_connector *connector, drmModeObjectPropertiesPtr props)
{
struct drm_property_info *non_desktop_info =
&connector->props[WDRM_CONNECTOR_NON_DESKTOP];
return drm_property_get_value(non_desktop_info, props, 0);
}
static uint32_t
get_panel_orientation(struct drm_connector *connector, drmModeObjectPropertiesPtr props)
{
struct drm_property_info *orientation =
&connector->props[WDRM_CONNECTOR_PANEL_ORIENTATION];
uint64_t kms_val =
drm_property_get_value(orientation, props,
WDRM_PANEL_ORIENTATION_NORMAL);
switch (kms_val) {
case WDRM_PANEL_ORIENTATION_NORMAL:
return WL_OUTPUT_TRANSFORM_NORMAL;
case WDRM_PANEL_ORIENTATION_UPSIDE_DOWN:
return WL_OUTPUT_TRANSFORM_180;
case WDRM_PANEL_ORIENTATION_LEFT_SIDE_UP:
return WL_OUTPUT_TRANSFORM_90;
case WDRM_PANEL_ORIENTATION_RIGHT_SIDE_UP:
return WL_OUTPUT_TRANSFORM_270;
default:
assert(!"unknown property value in get_panel_orientation");
}
}
static int
parse_modeline(const char *s, drmModeModeInfo *mode)
{
char hsync[16];
char vsync[16];
float fclock;
memset(mode, 0, sizeof *mode);
mode->type = DRM_MODE_TYPE_USERDEF;
mode->hskew = 0;
mode->vscan = 0;
mode->vrefresh = 0;
mode->flags = 0;
if (sscanf(s, "%f %hd %hd %hd %hd %hd %hd %hd %hd %15s %15s",
&fclock,
&mode->hdisplay,
&mode->hsync_start,
&mode->hsync_end,
&mode->htotal,
&mode->vdisplay,
&mode->vsync_start,
&mode->vsync_end,
&mode->vtotal, hsync, vsync) != 11)
return -1;
mode->clock = fclock * 1000;
if (strcasecmp(hsync, "+hsync") == 0)
mode->flags |= DRM_MODE_FLAG_PHSYNC;
else if (strcasecmp(hsync, "-hsync") == 0)
mode->flags |= DRM_MODE_FLAG_NHSYNC;
else
return -1;
if (strcasecmp(vsync, "+vsync") == 0)
mode->flags |= DRM_MODE_FLAG_PVSYNC;
else if (strcasecmp(vsync, "-vsync") == 0)
mode->flags |= DRM_MODE_FLAG_NVSYNC;
else
return -1;
snprintf(mode->name, sizeof mode->name, "%dx%d@%.3f",
mode->hdisplay, mode->vdisplay, fclock);
return 0;
}
static void
edid_parse_string(const uint8_t *data, char text[])
{
int i;
int replaced = 0;
/* this is always 12 bytes, but we can't guarantee it's null
* terminated or not junk. */
strncpy(text, (const char *) data, 12);
/* guarantee our new string is null-terminated */
text[12] = '\0';
/* remove insane chars */
for (i = 0; text[i] != '\0'; i++) {
if (text[i] == '\n' ||
text[i] == '\r') {
text[i] = '\0';
break;
}
}
/* ensure string is printable */
for (i = 0; text[i] != '\0'; i++) {
if (!isprint(text[i])) {
text[i] = '-';
replaced++;
}
}
/* if the string is random junk, ignore the string */
if (replaced > 4)
text[0] = '\0';
}
#define EDID_DESCRIPTOR_ALPHANUMERIC_DATA_STRING 0xfe
#define EDID_DESCRIPTOR_DISPLAY_PRODUCT_NAME 0xfc
#define EDID_DESCRIPTOR_DISPLAY_PRODUCT_SERIAL_NUMBER 0xff
#define EDID_OFFSET_DATA_BLOCKS 0x36
#define EDID_OFFSET_LAST_BLOCK 0x6c
#define EDID_OFFSET_PNPID 0x08
#define EDID_OFFSET_SERIAL 0x0c
static int
edid_parse(struct drm_edid *edid, const uint8_t *data, size_t length)
{
int i;
uint32_t serial_number;
/* check header */
if (length < 128)
return -1;
if (data[0] != 0x00 || data[1] != 0xff)
return -1;
/* decode the PNP ID from three 5 bit words packed into 2 bytes
* /--08--\/--09--\
* 7654321076543210
* |\---/\---/\---/
* R C1 C2 C3 */
edid->pnp_id[0] = 'A' + ((data[EDID_OFFSET_PNPID + 0] & 0x7c) / 4) - 1;
edid->pnp_id[1] = 'A' + ((data[EDID_OFFSET_PNPID + 0] & 0x3) * 8) + ((data[EDID_OFFSET_PNPID + 1] & 0xe0) / 32) - 1;
edid->pnp_id[2] = 'A' + (data[EDID_OFFSET_PNPID + 1] & 0x1f) - 1;
edid->pnp_id[3] = '\0';
/* maybe there isn't a ASCII serial number descriptor, so use this instead */
serial_number = (uint32_t) data[EDID_OFFSET_SERIAL + 0];
serial_number += (uint32_t) data[EDID_OFFSET_SERIAL + 1] * 0x100;
serial_number += (uint32_t) data[EDID_OFFSET_SERIAL + 2] * 0x10000;
serial_number += (uint32_t) data[EDID_OFFSET_SERIAL + 3] * 0x1000000;
if (serial_number > 0)
sprintf(edid->serial_number, "%lu", (unsigned long) serial_number);
/* parse EDID data */
for (i = EDID_OFFSET_DATA_BLOCKS;
i <= EDID_OFFSET_LAST_BLOCK;
i += 18) {
/* ignore pixel clock data */
if (data[i] != 0)
continue;
if (data[i+2] != 0)
continue;
/* any useful blocks? */
if (data[i+3] == EDID_DESCRIPTOR_DISPLAY_PRODUCT_NAME) {
edid_parse_string(&data[i+5],
edid->monitor_name);
} else if (data[i+3] == EDID_DESCRIPTOR_DISPLAY_PRODUCT_SERIAL_NUMBER) {
edid_parse_string(&data[i+5],
edid->serial_number);
} else if (data[i+3] == EDID_DESCRIPTOR_ALPHANUMERIC_DATA_STRING) {
edid_parse_string(&data[i+5],
edid->eisa_id);
}
}
return 0;
}
/** Parse monitor make, model and serial from EDID
*
* \param head The head whose \c drm_edid to fill in.
* \param props The DRM connector properties to get the EDID from.
* \param[out] make The monitor make (PNP ID).
* \param[out] model The monitor model (name).
* \param[out] serial_number The monitor serial number.
* \param[out] eotf_mask The monitor supported EOTF modes, combination of
* enum weston_eotf_mode bits.
*
* Each of \c *make, \c *model and \c *serial_number are set only if the
* information is found in the EDID. The pointers they are set to must not
* be free()'d explicitly, instead they get implicitly freed when the
* \c drm_head is destroyed.
*/
static void
find_and_parse_output_edid(struct drm_head *head,
drmModeObjectPropertiesPtr props,
const char **make,
const char **model,
const char **serial_number,
uint32_t *eotf_mask)
{
struct drm_device *device = head->connector.device;
drmModePropertyBlobPtr edid_blob = NULL;
uint32_t blob_id;
int rc;
blob_id =
drm_property_get_value(
&head->connector.props[WDRM_CONNECTOR_EDID],
props, 0);
if (!blob_id)
return;
edid_blob = drmModeGetPropertyBlob(device->drm.fd, blob_id);
if (!edid_blob)
return;
rc = edid_parse(&head->edid,
edid_blob->data,
edid_blob->length);
if (!rc) {
if (head->edid.pnp_id[0] != '\0')
*make = head->edid.pnp_id;
if (head->edid.monitor_name[0] != '\0')
*model = head->edid.monitor_name;
if (head->edid.serial_number[0] != '\0')
*serial_number = head->edid.serial_number;
}
drmModeFreePropertyBlob(edid_blob);
/* TODO: parse this from EDID */
*eotf_mask = WESTON_EOTF_MODE_ALL_MASK;
}
static void
prune_eotf_modes_by_kms_support(struct drm_head *head, uint32_t *eotf_mask)
{
const struct drm_property_info *info;
/* Without the KMS property, cannot do anything but SDR. */
info = &head->connector.props[WDRM_CONNECTOR_HDR_OUTPUT_METADATA];
if (!head->connector.device->atomic_modeset || info->prop_id == 0)
*eotf_mask = WESTON_EOTF_MODE_SDR;
}
static uint32_t
drm_refresh_rate_mHz(const drmModeModeInfo *info)
{
uint64_t refresh;
/* Calculate higher precision (mHz) refresh rate */
refresh = (info->clock * 1000000LL / info->htotal +
info->vtotal / 2) / info->vtotal;
if (info->flags & DRM_MODE_FLAG_INTERLACE)
refresh *= 2;
if (info->flags & DRM_MODE_FLAG_DBLSCAN)
refresh /= 2;
if (info->vscan > 1)
refresh /= info->vscan;
return refresh;
}
/**
* Add a mode to output's mode list
*
* Copy the supplied DRM mode into a Weston mode structure, and add it to the
* output's mode list.
*
* @param output DRM output to add mode to
* @param info DRM mode structure to add
* @returns Newly-allocated Weston/DRM mode structure
*/
static struct drm_mode *
drm_output_add_mode(struct drm_output *output, const drmModeModeInfo *info)
{
struct drm_mode *mode;
mode = malloc(sizeof *mode);
if (mode == NULL)
return NULL;
mode->base.flags = 0;
mode->base.width = info->hdisplay;
mode->base.height = info->vdisplay;
mode->base.refresh = drm_refresh_rate_mHz(info);
mode->mode_info = *info;
mode->blob_id = 0;
if (info->type & DRM_MODE_TYPE_PREFERRED)
mode->base.flags |= WL_OUTPUT_MODE_PREFERRED;
mode->base.aspect_ratio = drm_to_weston_mode_aspect_ratio(info->flags);
wl_list_insert(output->base.mode_list.prev, &mode->base.link);
return mode;
}
/**
* Destroys a mode, and removes it from the list.
*/
static void
drm_output_destroy_mode(struct drm_device *device, struct drm_mode *mode)
{
if (mode->blob_id)
drmModeDestroyPropertyBlob(device->drm.fd, mode->blob_id);
wl_list_remove(&mode->base.link);
free(mode);
}
/** Destroy a list of drm_modes
*
* @param device The device for releasing mode property blobs.
* @param mode_list The list linked by drm_mode::base.link.
*/
void
drm_mode_list_destroy(struct drm_device *device, struct wl_list *mode_list)
{
struct drm_mode *mode, *next;
wl_list_for_each_safe(mode, next, mode_list, base.link)
drm_output_destroy_mode(device, mode);
}
void
drm_output_print_modes(struct drm_output *output)
{
struct weston_mode *m;
struct drm_mode *dm;
const char *aspect_ratio;
wl_list_for_each(m, &output->base.mode_list, link) {
dm = to_drm_mode(m);
aspect_ratio = aspect_ratio_to_string(m->aspect_ratio);
weston_log_continue(STAMP_SPACE "%dx%d@%.1f%s%s%s, %.1f MHz\n",
m->width, m->height, m->refresh / 1000.0,
aspect_ratio,
m->flags & WL_OUTPUT_MODE_PREFERRED ?
", preferred" : "",
m->flags & WL_OUTPUT_MODE_CURRENT ?
", current" : "",
dm->mode_info.clock / 1000.0);
}
}
/**
* Find the closest-matching mode for a given target
*
* Given a target mode, find the most suitable mode amongst the output's
* current mode list to use, preferring the current mode if possible, to
* avoid an expensive mode switch.
*
* @param output DRM output
* @param target_mode Mode to attempt to match
* @returns Pointer to a mode from the output's mode list
*/
struct drm_mode *
drm_output_choose_mode(struct drm_output *output,
struct weston_mode *target_mode)
{
struct drm_mode *tmp_mode = NULL, *mode_fall_back = NULL, *mode;
enum weston_mode_aspect_ratio src_aspect = WESTON_MODE_PIC_AR_NONE;
enum weston_mode_aspect_ratio target_aspect = WESTON_MODE_PIC_AR_NONE;
struct drm_device *device;
device = output->device;
target_aspect = target_mode->aspect_ratio;
src_aspect = output->base.current_mode->aspect_ratio;
if (output->base.current_mode->width == target_mode->width &&
output->base.current_mode->height == target_mode->height &&
(output->base.current_mode->refresh == target_mode->refresh ||
target_mode->refresh == 0)) {
if (!device->aspect_ratio_supported || src_aspect == target_aspect)
return to_drm_mode(output->base.current_mode);
}
wl_list_for_each(mode, &output->base.mode_list, base.link) {
src_aspect = mode->base.aspect_ratio;
if (mode->mode_info.hdisplay == target_mode->width &&
mode->mode_info.vdisplay == target_mode->height) {
if (mode->base.refresh == target_mode->refresh ||
target_mode->refresh == 0) {
if (!device->aspect_ratio_supported ||
src_aspect == target_aspect)
return mode;
else if (!mode_fall_back)
mode_fall_back = mode;
} else if (!tmp_mode) {
tmp_mode = mode;
}
}
}
if (mode_fall_back)
return mode_fall_back;
return tmp_mode;
}
void
update_head_from_connector(struct drm_head *head)
{
struct drm_connector *connector = &head->connector;
drmModeObjectProperties *props = connector->props_drm;
drmModeConnector *conn = connector->conn;
const char *make = "unknown";
const char *model = "unknown";
const char *serial_number = "unknown";
uint32_t eotf_mask = WESTON_EOTF_MODE_SDR;
find_and_parse_output_edid(head, props, &make, &model, &serial_number, &eotf_mask);
weston_head_set_monitor_strings(&head->base, make, model, serial_number);
prune_eotf_modes_by_kms_support(head, &eotf_mask);
weston_head_set_supported_eotf_mask(&head->base, eotf_mask);
weston_head_set_non_desktop(&head->base,
check_non_desktop(connector, props));
weston_head_set_subpixel(&head->base,
drm_subpixel_to_wayland(conn->subpixel));
weston_head_set_physical_size(&head->base, conn->mmWidth, conn->mmHeight);
weston_head_set_transform(&head->base,
get_panel_orientation(connector, props));
/* Unknown connection status is assumed disconnected. */
weston_head_set_connection_status(&head->base,
conn->connection == DRM_MODE_CONNECTED);
}
/**
* Choose suitable mode for an output
*
* Find the most suitable mode to use for initial setup (or reconfiguration on
* hotplug etc) for a DRM output.
*
* @param device the DRM device
* @param output DRM output to choose mode for
* @param mode Strategy and preference to use when choosing mode
* @param modeline Manually-entered mode (may be NULL)
* @param current_mode Mode currently being displayed on this output
* @returns A mode from the output's mode list, or NULL if none available
*/
static struct drm_mode *
drm_output_choose_initial_mode(struct drm_device *device,
struct drm_output *output,
enum weston_drm_backend_output_mode mode,
const char *modeline,
const drmModeModeInfo *current_mode)
{
struct drm_mode *preferred = NULL;
struct drm_mode *current = NULL;
struct drm_mode *configured = NULL;
struct drm_mode *config_fall_back = NULL;
struct drm_mode *best = NULL;
struct drm_mode *drm_mode;
drmModeModeInfo drm_modeline;
int32_t width = 0;
int32_t height = 0;
uint32_t refresh = 0;
uint32_t aspect_width = 0;
uint32_t aspect_height = 0;
enum weston_mode_aspect_ratio aspect_ratio = WESTON_MODE_PIC_AR_NONE;
int n;
if (mode == WESTON_DRM_BACKEND_OUTPUT_PREFERRED && modeline) {
n = sscanf(modeline, "%dx%d@%d %u:%u", &width, &height,
&refresh, &aspect_width, &aspect_height);
if (device->aspect_ratio_supported && n == 5) {
if (aspect_width == 4 && aspect_height == 3)
aspect_ratio = WESTON_MODE_PIC_AR_4_3;
else if (aspect_width == 16 && aspect_height == 9)
aspect_ratio = WESTON_MODE_PIC_AR_16_9;
else if (aspect_width == 64 && aspect_height == 27)
aspect_ratio = WESTON_MODE_PIC_AR_64_27;
else if (aspect_width == 256 && aspect_height == 135)
aspect_ratio = WESTON_MODE_PIC_AR_256_135;
else
weston_log("Invalid modeline \"%s\" for output %s\n",
modeline, output->base.name);
}
if (n != 2 && n != 3 && n != 5) {
width = -1;
if (parse_modeline(modeline, &drm_modeline) == 0) {
configured = drm_output_add_mode(output, &drm_modeline);
if (!configured)
return NULL;
} else {
weston_log("Invalid modeline \"%s\" for output %s\n",
modeline, output->base.name);
}
}
}
wl_list_for_each_reverse(drm_mode, &output->base.mode_list, base.link) {
if (width == drm_mode->base.width &&
height == drm_mode->base.height &&
(refresh == 0 || refresh == drm_mode->mode_info.vrefresh)) {
if (!device->aspect_ratio_supported ||
aspect_ratio == drm_mode->base.aspect_ratio)
configured = drm_mode;
else
config_fall_back = drm_mode;
}
if (memcmp(current_mode, &drm_mode->mode_info,
sizeof *current_mode) == 0)
current = drm_mode;
if (drm_mode->base.flags & WL_OUTPUT_MODE_PREFERRED)
preferred = drm_mode;
best = drm_mode;
}
if (current == NULL && current_mode->clock != 0) {
current = drm_output_add_mode(output, current_mode);
if (!current)
return NULL;
}
if (mode == WESTON_DRM_BACKEND_OUTPUT_CURRENT)
configured = current;
if (configured)
return configured;
if (config_fall_back)
return config_fall_back;
if (preferred)
return preferred;
if (current)
return current;
if (best)
return best;
weston_log("no available modes for %s\n", output->base.name);
return NULL;
}
static uint32_t
u32distance(uint32_t a, uint32_t b)
{
if (a < b)
return b - a;
else
return a - b;
}
/** Choose equivalent mode
*
* If the two modes are not equivalent, return NULL.
* Otherwise return the mode that is more likely to work in place of both.
*
* None of the fuzzy matching criteria in this function have any justification.
*
* typedef struct _drmModeModeInfo {
* uint32_t clock;
* uint16_t hdisplay, hsync_start, hsync_end, htotal, hskew;
* uint16_t vdisplay, vsync_start, vsync_end, vtotal, vscan;
*
* uint32_t vrefresh;
*
* uint32_t flags;
* uint32_t type;
* char name[DRM_DISPLAY_MODE_LEN];
* } drmModeModeInfo, *drmModeModeInfoPtr;
*/
static const drmModeModeInfo *
drm_mode_pick_equivalent(const drmModeModeInfo *a, const drmModeModeInfo *b)
{
uint32_t refresh_a, refresh_b;
if (a->hdisplay != b->hdisplay || a->vdisplay != b->vdisplay)
return NULL;
if (a->flags != b->flags)
return NULL;
/* kHz */
if (u32distance(a->clock, b->clock) > 500)
return NULL;
refresh_a = drm_refresh_rate_mHz(a);
refresh_b = drm_refresh_rate_mHz(b);
if (u32distance(refresh_a, refresh_b) > 50)
return NULL;
if ((a->type ^ b->type) & DRM_MODE_TYPE_PREFERRED) {
if (a->type & DRM_MODE_TYPE_PREFERRED)
return a;
else
return b;
}
return a;
}
/* If the given mode info is not already in the list, add it.
* If it is in the list, either keep the existing or replace it,
* depending on which one is "better".
*/
static int
drm_output_try_add_mode(struct drm_output *output, const drmModeModeInfo *info)
{
struct weston_mode *base;
struct drm_mode *mode = NULL;
struct drm_device *device = output->device;
const drmModeModeInfo *chosen = NULL;
assert(info);
wl_list_for_each(base, &output->base.mode_list, link) {
mode = to_drm_mode(base);
chosen = drm_mode_pick_equivalent(&mode->mode_info, info);
if (chosen)
break;
}
if (chosen == info) {
assert(mode);
drm_output_destroy_mode(device, mode);
chosen = NULL;
}
if (!chosen) {
mode = drm_output_add_mode(output, info);
if (!mode)
return -1;
}
/* else { the equivalent mode is already in the list } */
return 0;
}
/** Rewrite the output's mode list
*
* @param output The output.
* @return 0 on success, -1 on failure.
*
* Destroy all existing modes in the list, and reconstruct a new list from
* scratch, based on the currently attached heads.
*
* On failure the output's mode list may contain some modes.
*/
static int
drm_output_update_modelist_from_heads(struct drm_output *output)
{
struct drm_device *device = output->device;
struct weston_head *head_base;
struct drm_head *head;
drmModeConnector *conn;
int i;
int ret;
assert(!output->base.enabled);
drm_mode_list_destroy(device, &output->base.mode_list);
wl_list_for_each(head_base, &output->base.head_list, output_link) {
head = to_drm_head(head_base);
conn = head->connector.conn;
for (i = 0; i < conn->count_modes; i++) {
ret = drm_output_try_add_mode(output, &conn->modes[i]);
if (ret < 0)
return -1;
}
}
return 0;
}
int
drm_output_set_mode(struct weston_output *base,
enum weston_drm_backend_output_mode mode,
const char *modeline)
{
struct drm_output *output = to_drm_output(base);
struct drm_device *device = output->device;
struct drm_head *head = to_drm_head(weston_output_get_first_head(base));
struct drm_mode *current;
if (output->virtual)
return -1;
if (drm_output_update_modelist_from_heads(output) < 0)
return -1;
current = drm_output_choose_initial_mode(device, output, mode, modeline,
&head->inherited_mode);
if (!current)
return -1;
output->base.current_mode = &current->base;
output->base.current_mode->flags |= WL_OUTPUT_MODE_CURRENT;
/* Set native_ fields, so weston_output_mode_switch_to_native() works */
output->base.native_mode = output->base.current_mode;
output->base.native_scale = output->base.current_scale;
return 0;
}