/* * Copyright © 2013 Intel Corporation * * 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. * * Authors: * Daniel Vetter * Damien Lespiau */ #define _GNU_SOURCE #include #include #include #include #include #include #include #include #include #include #include "drmtest.h" #include "igt_kms.h" #include "igt_aux.h" /* * There hasn't been a release of libdrm containing these #define's yet, so * copy them here to allow compilation to succeed in the mean time. * * We can drop these #define's and just make i-g-t depend on the proper libdrm * version in the future. */ #define DRM_CLIENT_CAP_UNIVERSAL_PLANES 2 #define DRM_PLANE_TYPE_OVERLAY 0 #define DRM_PLANE_TYPE_PRIMARY 1 #define DRM_PLANE_TYPE_CURSOR 2 /** * SECTION:igt_kms * @short_description: Kernel modesetting support library * @title: i-g-t kms * @include: igt_kms.h * * This library provides support to enumerate and set modeset configurations. * * Since this library is very much still a work-in-progress and the interfaces * still in-flux detailed api documentation is currently still missing. * * Note that this library's header pulls in the [i-g-t framebuffer](intel-gpu-tools-i-g-t-framebuffer.html) * library as a dependency. */ const char *kmstest_pipe_str(int pipe) { const char *str[] = { "A", "B", "C" }; if (pipe > 2) return "invalid"; return str[pipe]; } struct type_name { int type; const char *name; }; #define type_name_fn(res) \ const char * kmstest_##res##_str(int type) { \ unsigned int i; \ for (i = 0; i < ARRAY_SIZE(res##_names); i++) { \ if (res##_names[i].type == type) \ return res##_names[i].name; \ } \ return "(invalid)"; \ } struct type_name encoder_type_names[] = { { DRM_MODE_ENCODER_NONE, "none" }, { DRM_MODE_ENCODER_DAC, "DAC" }, { DRM_MODE_ENCODER_TMDS, "TMDS" }, { DRM_MODE_ENCODER_LVDS, "LVDS" }, { DRM_MODE_ENCODER_TVDAC, "TVDAC" }, }; type_name_fn(encoder_type) struct type_name connector_status_names[] = { { DRM_MODE_CONNECTED, "connected" }, { DRM_MODE_DISCONNECTED, "disconnected" }, { DRM_MODE_UNKNOWNCONNECTION, "unknown" }, }; type_name_fn(connector_status) struct type_name connector_type_names[] = { { DRM_MODE_CONNECTOR_Unknown, "unknown" }, { DRM_MODE_CONNECTOR_VGA, "VGA" }, { DRM_MODE_CONNECTOR_DVII, "DVI-I" }, { DRM_MODE_CONNECTOR_DVID, "DVI-D" }, { DRM_MODE_CONNECTOR_DVIA, "DVI-A" }, { DRM_MODE_CONNECTOR_Composite, "composite" }, { DRM_MODE_CONNECTOR_SVIDEO, "s-video" }, { DRM_MODE_CONNECTOR_LVDS, "LVDS" }, { DRM_MODE_CONNECTOR_Component, "component" }, { DRM_MODE_CONNECTOR_9PinDIN, "9-pin DIN" }, { DRM_MODE_CONNECTOR_DisplayPort, "DP" }, { DRM_MODE_CONNECTOR_HDMIA, "HDMI-A" }, { DRM_MODE_CONNECTOR_HDMIB, "HDMI-B" }, { DRM_MODE_CONNECTOR_TV, "TV" }, { DRM_MODE_CONNECTOR_eDP, "eDP" }, }; type_name_fn(connector_type) static const char *mode_stereo_name(const drmModeModeInfo *mode) { switch (mode->flags & DRM_MODE_FLAG_3D_MASK) { case DRM_MODE_FLAG_3D_FRAME_PACKING: return "FP"; case DRM_MODE_FLAG_3D_FIELD_ALTERNATIVE: return "FA"; case DRM_MODE_FLAG_3D_LINE_ALTERNATIVE: return "LA"; case DRM_MODE_FLAG_3D_SIDE_BY_SIDE_FULL: return "SBSF"; case DRM_MODE_FLAG_3D_L_DEPTH: return "LD"; case DRM_MODE_FLAG_3D_L_DEPTH_GFX_GFX_DEPTH: return "LDGFX"; case DRM_MODE_FLAG_3D_TOP_AND_BOTTOM: return "TB"; case DRM_MODE_FLAG_3D_SIDE_BY_SIDE_HALF: return "SBSH"; default: return NULL; } } void kmstest_dump_mode(drmModeModeInfo *mode) { const char *stereo = mode_stereo_name(mode); printf(" %s %d %d %d %d %d %d %d %d %d 0x%x 0x%x %d%s%s%s\n", mode->name, mode->vrefresh, mode->hdisplay, mode->hsync_start, mode->hsync_end, mode->htotal, mode->vdisplay, mode->vsync_start, mode->vsync_end, mode->vtotal, mode->flags, mode->type, mode->clock, stereo ? " (3D:" : "", stereo ? stereo : "", stereo ? ")" : ""); fflush(stdout); } int kmstest_get_pipe_from_crtc_id(int fd, int crtc_id) { struct drm_i915_get_pipe_from_crtc_id pfci; int ret; memset(&pfci, 0, sizeof(pfci)); pfci.crtc_id = crtc_id; ret = drmIoctl(fd, DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID, &pfci); igt_assert(ret == 0); return pfci.pipe; } void kmstest_set_connector_dpms(int fd, drmModeConnector *connector, int mode) { int i, dpms = 0; bool found_it = false; for (i = 0; i < connector->count_props; i++) { struct drm_mode_get_property prop; prop.prop_id = connector->props[i]; prop.count_values = 0; prop.count_enum_blobs = 0; if (drmIoctl(fd, DRM_IOCTL_MODE_GETPROPERTY, &prop)) continue; if (strcmp(prop.name, "DPMS")) continue; dpms = prop.prop_id; found_it = true; break; } igt_assert_f(found_it, "DPMS property not found on %d\n", connector->connector_id); igt_assert(drmModeConnectorSetProperty(fd, connector->connector_id, dpms, mode) == 0); } static signed long set_vt_mode(unsigned long mode) { int fd; unsigned long prev_mode; fd = open("/dev/tty0", O_RDONLY); if (fd < 0) return -errno; prev_mode = 0; if (drmIoctl(fd, KDGETMODE, &prev_mode)) goto err; if (drmIoctl(fd, KDSETMODE, (void *)mode)) goto err; close(fd); return prev_mode; err: close(fd); return -errno; } static unsigned long orig_vt_mode = -1UL; static void restore_vt_mode_at_exit(int sig) { if (orig_vt_mode != -1UL) set_vt_mode(orig_vt_mode); } /* * Set the VT to graphics mode and install an exit handler to restore the * original mode. */ void igt_set_vt_graphics_mode(void) { long ret; igt_install_exit_handler(restore_vt_mode_at_exit); igt_disable_exit_handler(); ret = set_vt_mode(KD_GRAPHICS); igt_enable_exit_handler(); igt_assert(ret >= 0); orig_vt_mode = ret; } int kmstest_get_connector_default_mode(int drm_fd, drmModeConnector *connector, drmModeModeInfo *mode) { drmModeRes *resources; int i; resources = drmModeGetResources(drm_fd); if (!resources) { perror("drmModeGetResources failed"); return -1; } if (!connector->count_modes) { fprintf(stderr, "no modes for connector %d\n", connector->connector_id); drmModeFreeResources(resources); return -1; } for (i = 0; i < connector->count_modes; i++) { if (i == 0 || connector->modes[i].type & DRM_MODE_TYPE_PREFERRED) { *mode = connector->modes[i]; if (mode->type & DRM_MODE_TYPE_PREFERRED) break; } } drmModeFreeResources(resources); return 0; } int kmstest_get_connector_config(int drm_fd, uint32_t connector_id, unsigned long crtc_idx_mask, struct kmstest_connector_config *config) { drmModeRes *resources; drmModeConnector *connector; drmModeEncoder *encoder; int i, j; resources = drmModeGetResources(drm_fd); if (!resources) { perror("drmModeGetResources failed"); goto err1; } /* First, find the connector & mode */ connector = drmModeGetConnector(drm_fd, connector_id); if (!connector) goto err2; if (connector->connection != DRM_MODE_CONNECTED) goto err3; if (!connector->count_modes) { fprintf(stderr, "connector %d has no modes\n", connector_id); goto err3; } if (connector->connector_id != connector_id) { fprintf(stderr, "connector id doesn't match (%d != %d)\n", connector->connector_id, connector_id); goto err3; } /* * Find given CRTC if crtc_id != 0 or else the first CRTC not in use. * In both cases find the first compatible encoder and skip the CRTC * if there is non such. */ encoder = NULL; /* suppress GCC warning */ for (i = 0; i < resources->count_crtcs; i++) { if (!resources->crtcs[i] || !(crtc_idx_mask & (1 << i))) continue; /* Now get a compatible encoder */ for (j = 0; j < connector->count_encoders; j++) { encoder = drmModeGetEncoder(drm_fd, connector->encoders[j]); if (!encoder) { fprintf(stderr, "could not get encoder %d: %s\n", resources->encoders[j], strerror(errno)); continue; } if (encoder->possible_crtcs & (1 << i)) goto found; drmModeFreeEncoder(encoder); } } goto err3; found: if (kmstest_get_connector_default_mode(drm_fd, connector, &config->default_mode) < 0) goto err4; config->connector = connector; config->encoder = encoder; config->crtc = drmModeGetCrtc(drm_fd, resources->crtcs[i]); config->crtc_idx = i; config->pipe = kmstest_get_pipe_from_crtc_id(drm_fd, config->crtc->crtc_id); drmModeFreeResources(resources); return 0; err4: drmModeFreeEncoder(encoder); err3: drmModeFreeConnector(connector); err2: drmModeFreeResources(resources); err1: return -1; } static int get_card_number(int fd) { struct stat buf; /* find the minor number of the device */ fstat(fd, &buf); return minor(buf.st_rdev) & 0x3f; } static char* get_debugfs_connector_path(int drm_fd, drmModeConnector *connector, const char *file) { char *path; asprintf(&path, "/sys/kernel/debug/dri/%d/%s-%d/%s", get_card_number(drm_fd), kmstest_connector_type_str(connector->connector_type), connector->connector_type_id, file); return path; } /** * kmstest_force_connector: * @fd: drm file descriptor * @connector: connector * @state: state to force on @connector * * Force the specified state on the specified connector. */ void kmstest_force_connector(int drm_fd, drmModeConnector *connector, enum kmstest_force_connector_state state) { char *path; const char *value; int debugfs_fd, ret; switch (state) { case FORCE_CONNECTOR_ON: value = "on"; break; case FORCE_CONNECTOR_DIGITAL: value = "digital"; break; case FORCE_CONNECTOR_OFF: value = "off"; break; default: case FORCE_CONNECTOR_UNSPECIFIED: value = "unspecified"; break; } path = get_debugfs_connector_path(drm_fd, connector, "force"); debugfs_fd = open(path, O_WRONLY | O_TRUNC); free(path); igt_assert(debugfs_fd != -1); ret = write(debugfs_fd, value, strlen(value)); close(debugfs_fd); igt_assert(ret != -1); } /** * kmstest_force_edid: * @drm_fd: drm file descriptor * @connector: connector to set @edid on * @edid: An EDID data block * @length: length of the EDID data. #EDID_LENGTH defines the standard EDID * length * * Set the EDID data on @connector to @edid. See #generic_edid and * #kmstest_generic_edid for a set of generic EDID data blocks. * * If @length is zero, the forced EDID will be removed. */ void kmstest_force_edid(int drm_fd, drmModeConnector *connector, const unsigned char *edid, size_t length) { char *path; int debugfs_fd, ret; path = get_debugfs_connector_path(drm_fd, connector, "edid_override"); debugfs_fd = open(path, O_WRONLY | O_TRUNC); free(path); igt_assert(debugfs_fd != -1); if (length == 0) ret = write(debugfs_fd, "reset", 5); else ret = write(debugfs_fd, edid, length); close(debugfs_fd); igt_assert(ret != -1); } void kmstest_free_connector_config(struct kmstest_connector_config *config) { drmModeFreeCrtc(config->crtc); drmModeFreeEncoder(config->encoder); drmModeFreeConnector(config->connector); } const char *plane_name(enum igt_plane p) { static const char *names[] = { [IGT_PLANE_1] = "plane1", [IGT_PLANE_2] = "plane2", [IGT_PLANE_3] = "plane3", [IGT_PLANE_CURSOR] = "cursor", }; igt_assert(p < ARRAY_SIZE(names) && names[p]); return names[p]; } /* * A small modeset API */ #define LOG_SPACES " " #define LOG_N_SPACES (sizeof(LOG_SPACES) - 1) #define LOG_INDENT(d, section) \ do { \ igt_display_log(d, "%s {\n", section); \ igt_display_log_shift(d, 1); \ } while (0) #define LOG_UNINDENT(d) \ do { \ igt_display_log_shift(d, -1); \ igt_display_log(d, "}\n"); \ } while (0) #define LOG(d, fmt, ...) igt_display_log(d, fmt, ## __VA_ARGS__) static void __attribute__((format(printf, 2, 3))) igt_display_log(igt_display_t *display, const char *fmt, ...) { va_list args; int i; va_start(args, fmt); igt_debug("display: "); for (i = 0; i < display->log_shift; i++) igt_debug("%s", LOG_SPACES); igt_vlog(IGT_LOG_DEBUG, fmt, args); va_end(args); } static void igt_display_log_shift(igt_display_t *display, int shift) { display->log_shift += shift; igt_assert(display->log_shift >= 0); } static void igt_output_refresh(igt_output_t *output) { igt_display_t *display = output->display; int ret; unsigned long crtc_idx_mask; /* we mask out the pipes already in use */ crtc_idx_mask = output->pending_crtc_idx_mask & ~display->pipes_in_use; if (output->valid) kmstest_free_connector_config(&output->config); ret = kmstest_get_connector_config(display->drm_fd, output->id, crtc_idx_mask, &output->config); if (ret == 0) output->valid = true; else output->valid = false; if (!output->valid) return; if (!output->name) { drmModeConnector *c = output->config.connector; asprintf(&output->name, "%s-%d", kmstest_connector_type_str(c->connector_type), c->connector_type_id); } LOG(display, "%s: Selecting pipe %c\n", output->name, pipe_name(output->config.pipe)); display->pipes_in_use |= 1 << output->config.pipe; } static bool get_property(igt_display_t *display, uint32_t object_id, uint32_t object_type, const char *name, uint32_t *prop_id /* out */, uint64_t *value /* out */) { drmModeObjectPropertiesPtr proplist; drmModePropertyPtr prop = NULL; bool found = false; int i; proplist = drmModeObjectGetProperties(display->drm_fd, object_id, object_type); for (i = 0; i < proplist->count_props; i++) { drmModeFreeProperty(prop); prop = drmModeGetProperty(display->drm_fd, proplist->props[i]); if (!prop) continue; if (strcmp(prop->name, name) == 0) { found = true; if (prop_id) *prop_id = proplist->props[i]; if (value) *value = proplist->prop_values[i]; goto out; } } out: drmModeFreeProperty(prop); drmModeFreeObjectProperties(proplist); return found; } static bool get_plane_property(igt_display_t *display, uint32_t plane_id, const char *name, uint32_t *prop_id /* out */, uint64_t *value /* out */) { return get_property(display, plane_id, DRM_MODE_OBJECT_PLANE, name, prop_id, value); } static void igt_plane_set_property(igt_plane_t *plane, uint32_t prop_id, uint64_t value) { igt_pipe_t *pipe = plane->pipe; igt_display_t *display = pipe->display; drmModeObjectSetProperty(display->drm_fd, plane->drm_plane->plane_id, DRM_MODE_OBJECT_PLANE, prop_id, value); } /* * Walk a plane's property list to determine its type. If we don't * find a type property, then the kernel doesn't support universal * planes and we know the plane is an overlay/sprite. */ static int get_drm_plane_type(igt_display_t *display, uint32_t plane_id) { uint64_t value; bool has_prop; has_prop = get_plane_property(display, plane_id, "type", NULL /* prop_id */, &value); if (has_prop) return (int)value; return DRM_PLANE_TYPE_OVERLAY; } void igt_display_init(igt_display_t *display, int drm_fd) { drmModeRes *resources; drmModePlaneRes *plane_resources; int i; memset(display, 0, sizeof(igt_display_t)); LOG_INDENT(display, "init"); display->drm_fd = drm_fd; resources = drmModeGetResources(display->drm_fd); igt_assert(resources); /* * We cache the number of pipes, that number is a physical limit of the * hardware and cannot change of time (for now, at least). */ display->n_pipes = resources->count_crtcs; drmSetClientCap(drm_fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1); plane_resources = drmModeGetPlaneResources(display->drm_fd); igt_assert(plane_resources); for (i = 0; i < display->n_pipes; i++) { igt_pipe_t *pipe = &display->pipes[i]; igt_plane_t *plane; int p = IGT_PLANE_2; int j, type; pipe->display = display; pipe->pipe = i; /* add the planes that can be used with that pipe */ for (j = 0; j < plane_resources->count_planes; j++) { drmModePlane *drm_plane; uint64_t prop_value; drm_plane = drmModeGetPlane(display->drm_fd, plane_resources->planes[j]); igt_assert(drm_plane); if (!(drm_plane->possible_crtcs & (1 << i))) { drmModeFreePlane(drm_plane); continue; } type = get_drm_plane_type(display, plane_resources->planes[j]); switch (type) { case DRM_PLANE_TYPE_PRIMARY: plane = &pipe->planes[IGT_PLANE_PRIMARY]; plane->is_primary = 1; plane->index = IGT_PLANE_PRIMARY; display->has_universal_planes = 1; break; case DRM_PLANE_TYPE_CURSOR: /* * Cursor should be the highest index in our * internal list, but we don't know what that * is yet. Just stick it in the last slot * for now and we'll move it later, if * necessary. */ plane = &pipe->planes[IGT_PLANE_CURSOR]; plane->is_cursor = 1; plane->index = IGT_PLANE_CURSOR; display->has_universal_planes = 1; break; default: plane = &pipe->planes[p]; plane->index = p++; break; } plane->pipe = pipe; plane->drm_plane = drm_plane; get_plane_property(display, drm_plane->plane_id, "rotation", &plane->rotation_property, &prop_value); plane->rotation = (igt_rotation_t)prop_value; } if (display->has_universal_planes) { /* * If we have universal planes, we should have both * primary and cursor planes setup now. */ igt_assert(pipe->planes[IGT_PLANE_PRIMARY].drm_plane && pipe->planes[IGT_PLANE_CURSOR].drm_plane); /* * Cursor was put in the last slot. If we have 0 or * only 1 sprite, that's the wrong slot and we need to * move it down. */ if (p != IGT_PLANE_CURSOR) { pipe->planes[p] = pipe->planes[IGT_PLANE_CURSOR]; pipe->planes[p].index = p; memset(&pipe->planes[IGT_PLANE_CURSOR], 0, sizeof *plane); } } else { /* * No universal plane support. Add drm_plane-less * primary and cursor planes. */ plane = &pipe->planes[IGT_PLANE_PRIMARY]; plane->pipe = pipe; plane->index = IGT_PLANE_PRIMARY; plane->is_primary = true; plane = &pipe->planes[p]; plane->pipe = pipe; plane->index = p; plane->is_cursor = true; } /* planes = 1 primary, (p-1) sprites, 1 cursor */ pipe->n_planes = p + 1; /* make sure we don't overflow the plane array */ igt_assert(pipe->n_planes <= IGT_MAX_PLANES); } /* * The number of connectors is set, so we just initialize the outputs * array in _init(). This may change when we need dynamic connectors * (say DisplayPort MST). */ display->n_outputs = resources->count_connectors; display->outputs = calloc(display->n_outputs, sizeof(igt_output_t)); igt_assert(display->outputs); for (i = 0; i < display->n_outputs; i++) { igt_output_t *output = &display->outputs[i]; /* * We're free to select any pipe to drive that output until * a constraint is set with igt_output_set_pipe(). */ output->pending_crtc_idx_mask = -1UL; output->id = resources->connectors[i]; output->display = display; igt_output_refresh(output); } drmModeFreePlaneResources(plane_resources); drmModeFreeResources(resources); LOG_UNINDENT(display); } int igt_display_get_n_pipes(igt_display_t *display) { return display->n_pipes; } static void igt_pipe_fini(igt_pipe_t *pipe) { int i; for (i = 0; i < pipe->n_planes; i++) { igt_plane_t *plane = &pipe->planes[i]; if (plane->drm_plane) { drmModeFreePlane(plane->drm_plane); plane->drm_plane = NULL; } } } static void igt_output_fini(igt_output_t *output) { if (output->valid) kmstest_free_connector_config(&output->config); free(output->name); } void igt_display_fini(igt_display_t *display) { int i; for (i = 0; i < display->n_pipes; i++) igt_pipe_fini(&display->pipes[i]); for (i = 0; i < display->n_outputs; i++) igt_output_fini(&display->outputs[i]); free(display->outputs); display->outputs = NULL; } static void igt_display_refresh(igt_display_t *display) { int i, j; display->pipes_in_use = 0; /* Check that two outputs aren't trying to use the same pipe */ for (i = 0; i < display->n_outputs; i++) { igt_output_t *a = &display->outputs[i]; if (a->pending_crtc_idx_mask == -1UL) continue; for (j = 0; j < display->n_outputs; j++) { igt_output_t *b = &display->outputs[j]; if (i == j) continue; if (b->pending_crtc_idx_mask == -1UL) continue; igt_assert_f(a->pending_crtc_idx_mask != b->pending_crtc_idx_mask, "%s and %s are both trying to use pipe %c\n", igt_output_name(a), igt_output_name(b), pipe_name(ffs(a->pending_crtc_idx_mask) - 1)); } } /* * The pipe allocation has to be done in two phases: * - first, try to satisfy the outputs where a pipe has been specified * - then, allocate the outputs with PIPE_ANY */ for (i = 0; i < display->n_outputs; i++) { igt_output_t *output = &display->outputs[i]; if (output->pending_crtc_idx_mask == -1UL) continue; igt_output_refresh(output); } for (i = 0; i < display->n_outputs; i++) { igt_output_t *output = &display->outputs[i]; if (output->pending_crtc_idx_mask != -1UL) continue; igt_output_refresh(output); } } static igt_pipe_t *igt_output_get_driving_pipe(igt_output_t *output) { igt_display_t *display = output->display; enum pipe pipe; if (output->pending_crtc_idx_mask == -1UL) { /* * The user hasn't specified a pipe to use, take the one * configured by the last refresh() */ pipe = output->config.pipe; } else { /* * Otherwise, return the pending pipe (ie the pipe that should * drive this output after the commit() */ pipe = ffs(output->pending_crtc_idx_mask) - 1; } igt_assert(pipe >= 0 && pipe < display->n_pipes); return &display->pipes[pipe]; } static igt_plane_t *igt_pipe_get_plane(igt_pipe_t *pipe, enum igt_plane plane) { int idx; /* Cursor plane is always the highest index */ if (plane == IGT_PLANE_CURSOR) idx = pipe->n_planes - 1; else { igt_assert_f(plane >= 0 && plane < (pipe->n_planes), "plane=%d\n", plane); idx = plane; } return &pipe->planes[idx]; } static uint32_t igt_plane_get_fb_id(igt_plane_t *plane) { if (plane->fb) return plane->fb->fb_id; else return 0; } static uint32_t igt_plane_get_fb_gem_handle(igt_plane_t *plane) { if (plane->fb) return plane->fb->gem_handle; else return 0; } #define CHECK_RETURN(r, fail) { \ if (r && !fail) \ return r; \ igt_assert(r == 0); \ } /* * Commit position and fb changes to a DRM plane via the SetPlane ioctl; if the * DRM call to program the plane fails, we'll either fail immediately (for * tests that expect the commit to succeed) or return the failure code (for * tests that expect a specific error code). */ static int igt_drm_plane_commit(igt_plane_t *plane, igt_output_t *output, bool fail_on_error) { igt_display_t *display = output->display; uint32_t fb_id, crtc_id; int ret; igt_assert(plane->drm_plane); /* it's an error to try an unsupported feature */ igt_assert(igt_plane_supports_rotation(plane) || !plane->rotation_changed); fb_id = igt_plane_get_fb_id(plane); crtc_id = output->config.crtc->crtc_id; if (plane->fb_changed && fb_id == 0) { LOG(display, "%s: SetPlane pipe %c, plane %d, disabling\n", igt_output_name(output), pipe_name(output->config.pipe), plane->index); ret = drmModeSetPlane(display->drm_fd, plane->drm_plane->plane_id, crtc_id, fb_id, 0, /* flags */ 0, 0, /* crtc_x, crtc_y */ 0, 0, /* crtc_w, crtc_h */ IGT_FIXED(0,0), /* src_x */ IGT_FIXED(0,0), /* src_y */ IGT_FIXED(0,0), /* src_w */ IGT_FIXED(0,0) /* src_h */); CHECK_RETURN(ret, fail_on_error); } else if (plane->fb_changed || plane->position_changed) { LOG(display, "%s: SetPlane %c.%d, fb %u, position (%d, %d)\n", igt_output_name(output), pipe_name(output->config.pipe), plane->index, fb_id, plane->crtc_x, plane->crtc_y); ret = drmModeSetPlane(display->drm_fd, plane->drm_plane->plane_id, crtc_id, fb_id, 0, /* flags */ plane->crtc_x, plane->crtc_y, plane->fb->width, plane->fb->height, IGT_FIXED(0,0), /* src_x */ IGT_FIXED(0,0), /* src_y */ IGT_FIXED(plane->fb->width,0), /* src_w */ IGT_FIXED(plane->fb->height,0) /* src_h */); CHECK_RETURN(ret, fail_on_error); } plane->fb_changed = false; plane->position_changed = false; if (plane->rotation_changed) { igt_plane_set_property(plane, plane->rotation_property, plane->rotation); plane->rotation_changed = false; } return 0; } /* * Commit position and fb changes to a cursor via legacy ioctl's. If commit * fails, we'll either fail immediately (for tests that expect the commit to * succeed) or return the failure code (for tests that expect a specific error * code). */ static int igt_cursor_commit_legacy(igt_plane_t *cursor, igt_output_t *output, bool fail_on_error) { igt_display_t *display = output->display; uint32_t crtc_id = output->config.crtc->crtc_id; int ret; if (cursor->fb_changed) { uint32_t gem_handle = igt_plane_get_fb_gem_handle(cursor); if (gem_handle) { LOG(display, "%s: SetCursor pipe %c, fb %u %dx%d\n", igt_output_name(output), pipe_name(output->config.pipe), gem_handle, cursor->fb->width, cursor->fb->height); ret = drmModeSetCursor(display->drm_fd, crtc_id, gem_handle, cursor->fb->width, cursor->fb->height); } else { LOG(display, "%s: SetCursor pipe %c, disabling\n", igt_output_name(output), pipe_name(output->config.pipe)); ret = drmModeSetCursor(display->drm_fd, crtc_id, 0, 0, 0); } CHECK_RETURN(ret, fail_on_error); cursor->fb_changed = false; } if (cursor->position_changed) { int x = cursor->crtc_x; int y = cursor->crtc_y; LOG(display, "%s: MoveCursor pipe %c, (%d, %d)\n", igt_output_name(output), pipe_name(output->config.pipe), x, y); ret = drmModeMoveCursor(display->drm_fd, crtc_id, x, y); CHECK_RETURN(ret, fail_on_error); cursor->position_changed = false; } return 0; } /* * Commit position and fb changes to a primary plane via the legacy interface * (setmode). */ static int igt_primary_plane_commit_legacy(igt_plane_t *primary, igt_output_t *output, bool fail_on_error) { struct igt_display *display = primary->pipe->display; drmModeModeInfo *mode; uint32_t fb_id, crtc_id; int ret; /* Primary planes can't be windowed when using a legacy commit */ igt_assert((primary->crtc_x == 0 && primary->crtc_y == 0)); /* nor rotated */ igt_assert(!primary->rotation_changed); if (!primary->fb_changed && !primary->position_changed && !primary->panning_changed) return 0; crtc_id = output->config.crtc->crtc_id; fb_id = igt_plane_get_fb_id(primary); if (fb_id) mode = igt_output_get_mode(output); else mode = NULL; if (fb_id) { LOG(display, "%s: SetCrtc pipe %c, fb %u, panning (%d, %d), " "mode %dx%d\n", igt_output_name(output), pipe_name(output->config.pipe), fb_id, primary->pan_x, primary->pan_y, mode->hdisplay, mode->vdisplay); ret = drmModeSetCrtc(display->drm_fd, crtc_id, fb_id, primary->pan_x, primary->pan_y, &output->id, 1, mode); } else { LOG(display, "%s: SetCrtc pipe %c, disabling\n", igt_output_name(output), pipe_name(output->config.pipe)); ret = drmModeSetCrtc(display->drm_fd, crtc_id, fb_id, 0, 0, /* x, y */ NULL, /* connectors */ 0, /* n_connectors */ NULL /* mode */); } CHECK_RETURN(ret, fail_on_error); primary->pipe->enabled = (fb_id != 0); primary->fb_changed = false; primary->position_changed = false; primary->panning_changed = false; return 0; } /* * Commit position and fb changes to a plane. The value of @s will determine * which API is used to do the programming. */ static int igt_plane_commit(igt_plane_t *plane, igt_output_t *output, enum igt_commit_style s, bool fail_on_error) { if (plane->is_cursor && s == COMMIT_LEGACY) { return igt_cursor_commit_legacy(plane, output, fail_on_error); } else if (plane->is_primary && s == COMMIT_LEGACY) { return igt_primary_plane_commit_legacy(plane, output, fail_on_error); } else { return igt_drm_plane_commit(plane, output, fail_on_error); } } /* * Commit all plane changes to an output. Note that if @s is COMMIT_LEGACY, * enabling/disabling the primary plane will also enable/disable the CRTC. * * If @fail_on_error is true, any failure to commit plane state will lead * to subtest failure in the specific function where the failure occurs. * Otherwise, the first error code encountered will be returned and no * further programming will take place, which may result in some changes * taking effect and others not taking effect. */ static int igt_output_commit(igt_output_t *output, enum igt_commit_style s, bool fail_on_error) { igt_display_t *display = output->display; igt_pipe_t *pipe; int i; int ret; bool need_wait_for_vblank = false; pipe = igt_output_get_driving_pipe(output); for (i = 0; i < pipe->n_planes; i++) { igt_plane_t *plane = &pipe->planes[i]; if (plane->fb_changed || plane->position_changed) need_wait_for_vblank = true; ret = igt_plane_commit(plane, output, s, fail_on_error); CHECK_RETURN(ret, fail_on_error); } /* * If the crtc is enabled, wait until the next vblank before returning * if we made changes to any of the planes. */ if (need_wait_for_vblank && pipe->enabled) { igt_wait_for_vblank(display->drm_fd, pipe->pipe); } return 0; } /* * Commit all plane changes across all outputs of the display. * * If @fail_on_error is true, any failure to commit plane state will lead * to subtest failure in the specific function where the failure occurs. * Otherwise, the first error code encountered will be returned and no * further programming will take place, which may result in some changes * taking effect and others not taking effect. */ static int do_display_commit(igt_display_t *display, enum igt_commit_style s, bool fail_on_error) { int i, ret; LOG_INDENT(display, "commit"); igt_display_refresh(display); for (i = 0; i < display->n_outputs; i++) { igt_output_t *output = &display->outputs[i]; if (!output->valid) continue; ret = igt_output_commit(output, s, fail_on_error); CHECK_RETURN(ret, fail_on_error); } LOG_UNINDENT(display); if (getenv("IGT_DISPLAY_WAIT_AT_COMMIT")) igt_wait_for_keypress(); return 0; } /** * igt_display_commit2: * @display: DRM device handle * @s: Commit style * * Commits framebuffer and positioning changes to all planes of each display * pipe, using a specific API to perform the programming. This function should * be used to exercise a specific driver programming API; igt_display_commit * should be used instead if the API used is unimportant to the test being run. * * This function should only be used to commit changes that are expected to * succeed, since any failure during the commit process will cause the IGT * subtest to fail. To commit changes that are expected to fail, use * @igt_try_display_commit2 instead. * * Returns: 0 upon success. This function will never return upon failure * since igt_fail() at lower levels will longjmp out of it. */ int igt_display_commit2(igt_display_t *display, enum igt_commit_style s) { do_display_commit(display, s, true); return 0; } /** * igt_display_try_commit2: * @display: DRM device handle * @s: Commit style * * Attempts to commit framebuffer and positioning changes to all planes of each * display pipe. This function should be used to commit changes that are * expected to fail, so that the error code can be checked for correctness. * For changes that are expected to succeed, use @igt_display_commit instead. * * Note that in non-atomic commit styles, no display programming will be * performed after the first failure is encountered, so only some of the * operations requested by a test may have been completed. Tests that catch * errors returned by this function should take care to restore the display to * a sane state after a failure is detected. * * Returns: 0 upon success, otherwise the error code of the first error * encountered. */ int igt_display_try_commit2(igt_display_t *display, enum igt_commit_style s) { return do_display_commit(display, s, false); } /** * igt_display_commit: * @display: DRM device handle * * Commits framebuffer and positioning changes to all planes of each display * pipe. * * Returns: 0 upon success. This function will never return upon failure * since igt_fail() at lower levels will longjmp out of it. */ int igt_display_commit(igt_display_t *display) { return igt_display_commit2(display, COMMIT_LEGACY); } const char *igt_output_name(igt_output_t *output) { return output->name; } drmModeModeInfo *igt_output_get_mode(igt_output_t *output) { return &output->config.default_mode; } void igt_output_set_pipe(igt_output_t *output, enum pipe pipe) { igt_display_t *display = output->display; if (pipe == PIPE_ANY) { LOG(display, "%s: set_pipe(any)\n", igt_output_name(output)); output->pending_crtc_idx_mask = -1UL; } else { LOG(display, "%s: set_pipe(%c)\n", igt_output_name(output), pipe_name(pipe)); output->pending_crtc_idx_mask = 1 << pipe; } } igt_plane_t *igt_output_get_plane(igt_output_t *output, enum igt_plane plane) { igt_pipe_t *pipe; pipe = igt_output_get_driving_pipe(output); return igt_pipe_get_plane(pipe, plane); } void igt_plane_set_fb(igt_plane_t *plane, struct igt_fb *fb) { igt_pipe_t *pipe = plane->pipe; igt_display_t *display = pipe->display; LOG(display, "%c.%d: plane_set_fb(%d)\n", pipe_name(pipe->pipe), plane->index, fb ? fb->fb_id : 0); plane->fb = fb; plane->fb_changed = true; } void igt_plane_set_position(igt_plane_t *plane, int x, int y) { igt_pipe_t *pipe = plane->pipe; igt_display_t *display = pipe->display; LOG(display, "%c.%d: plane_set_position(%d,%d)\n", pipe_name(pipe->pipe), plane->index, x, y); plane->crtc_x = x; plane->crtc_y = y; plane->position_changed = true; } void igt_plane_set_panning(igt_plane_t *plane, int x, int y) { igt_pipe_t *pipe = plane->pipe; igt_display_t *display = pipe->display; LOG(display, "%c.%d: plane_set_panning(%d,%d)\n", pipe_name(pipe->pipe), plane->index, x, y); plane->pan_x = x; plane->pan_y = y; plane->panning_changed = true; } static const char *rotation_name(igt_rotation_t rotation) { switch (rotation) { case IGT_ROTATION_0: return "0°"; case IGT_ROTATION_90: return "90°"; case IGT_ROTATION_180: return "180°"; case IGT_ROTATION_270: return "270°"; default: igt_assert(0); } } void igt_plane_set_rotation(igt_plane_t *plane, igt_rotation_t rotation) { igt_pipe_t *pipe = plane->pipe; igt_display_t *display = pipe->display; LOG(display, "%c.%d: plane_set_rotation(%s)\n", pipe_name(pipe->pipe), plane->index, rotation_name(rotation)); plane->rotation = rotation; plane->rotation_changed = true; } void igt_wait_for_vblank(int drm_fd, enum pipe pipe) { drmVBlank wait_vbl; memset(&wait_vbl, 0, sizeof(wait_vbl)); wait_vbl.request.type = pipe << DRM_VBLANK_HIGH_CRTC_SHIFT | DRM_VBLANK_RELATIVE; wait_vbl.request.sequence = 1; igt_assert(drmWaitVBlank(drm_fd, &wait_vbl) == 0); } static void reset_connectors_at_exit(int sig) { igt_reset_connectors(); } /** * igt_enable_connectors: * * Force connectors to be enabled where this is known to work well. Use * #igt_reset_connectors to revert the changes. * * An exit handler is installed to ensure connectors are reset when the test * exits. */ void igt_enable_connectors(void) { drmModeRes *res; drmModeConnector *c; int drm_fd; drm_fd = drm_open_any(); res = drmModeGetResources(drm_fd); for (int i = 0; i < res->count_connectors; i++) { c = drmModeGetConnector(drm_fd, res->connectors[i]); /* don't attempt to force connectors that are already connected */ if (c->connection == DRM_MODE_CONNECTED) continue; /* just enable VGA for now */ if (c->connector_type == DRM_MODE_CONNECTOR_VGA) kmstest_force_connector(drm_fd, c, FORCE_CONNECTOR_ON); drmModeFreeConnector(c); } close(drm_fd); igt_install_exit_handler(reset_connectors_at_exit); } /** * igt_reset_connectors: * * Remove any forced state from the connectors. */ void igt_reset_connectors(void) { drmModeRes *res; drmModeConnector *c; int drm_fd; drm_fd = drm_open_any(); res = drmModeGetResources(drm_fd); for (int i = 0; i < res->count_connectors; i++) { c = drmModeGetConnector(drm_fd, res->connectors[i]); kmstest_force_connector(drm_fd, c, FORCE_CONNECTOR_UNSPECIFIED); drmModeFreeConnector(c); } close(drm_fd); }