| /* |
| * Copyright 2017 The Chromium OS Authors. All rights reserved. |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| /* |
| * This file performs some sanity checks on the DRM atomic API. To run a test, please run the |
| * following command: |
| * |
| * atomictest <testname> |
| * |
| * To get a list of possible tests, run: |
| * |
| * atomictest |
| */ |
| |
| #include <errno.h> |
| #include <getopt.h> |
| #include <inttypes.h> |
| #include <pthread.h> |
| #include <string.h> |
| #include <sync/sync.h> |
| |
| #include "bs_drm.h" |
| |
| #define CHECK(cond) \ |
| do { \ |
| if (!(cond)) { \ |
| bs_debug_error("check %s failed", #cond); \ |
| return -1; \ |
| } \ |
| } while (0) |
| |
| #define CHECK_RESULT(ret) \ |
| do { \ |
| if ((ret) < 0) { \ |
| bs_debug_error("failed with error: %d", ret); \ |
| return -1; \ |
| } \ |
| } while (0) |
| |
| #define MAX(a, b) ((a) > (b) ? (a) : (b)) |
| |
| #define CURSOR_SIZE 64 |
| |
| // TODO(dcastagna): Remove these declarations once they're exported in a libsync header. |
| int sw_sync_timeline_create(void); |
| int sw_sync_timeline_inc(int fd, unsigned count); |
| int sw_sync_fence_create(int fd, const char *name, unsigned value); |
| |
| // TODO(gsingh) This is defined in upstream libdrm -- remove when CROS libdrm is updated. |
| #ifndef DRM_ROTATE_0 |
| #define DRM_ROTATE_0 (1UL << 0) |
| #endif |
| |
| #ifndef DRM_REFLECT_Y |
| #define DRM_REFLECT_Y (1UL << 5) |
| #endif |
| |
| #define TEST_COMMIT_FAIL 1 |
| |
| #define GAMMA_MAX_VALUE ((1 << 16) - 1) |
| |
| static const uint32_t yuv_formats[] = { |
| DRM_FORMAT_NV12, |
| DRM_FORMAT_YVU420, |
| }; |
| |
| /* |
| * The blob for the CTM propery is a drm_color_ctm. |
| * drm_color_ctm contains a 3x3 u64 matrix. Every element is represented as |
| * sign and U31.32. The sign is the MSB. |
| */ |
| // clang-format off |
| static int64_t identity_ctm[9] = { |
| 0x100000000, 0x0, 0x0, |
| 0x0, 0x100000000, 0x0, |
| 0x0, 0x0, 0x100000000 |
| }; |
| static int64_t red_shift_ctm[9] = { |
| 0x140000000, 0x0, 0x0, |
| 0x0, 0xC0000000, 0x0, |
| 0x0, 0x0, 0xC0000000 |
| }; |
| // clang-format on |
| |
| static bool automatic = false; |
| static struct gbm_device *gbm = NULL; |
| |
| static void page_flip_handler(int fd, unsigned int sequence, unsigned int tv_sec, |
| unsigned int tv_usec, void *user_data) |
| { |
| // Nothing to do. |
| } |
| |
| struct atomictest_property { |
| uint32_t pid; |
| uint64_t value; |
| }; |
| |
| struct atomictest_plane { |
| drmModePlane drm_plane; |
| struct gbm_bo *bo; |
| |
| uint32_t format_idx; |
| |
| /* Properties. */ |
| struct atomictest_property crtc_id; |
| struct atomictest_property crtc_x; |
| struct atomictest_property crtc_y; |
| struct atomictest_property crtc_w; |
| struct atomictest_property crtc_h; |
| struct atomictest_property fb_id; |
| struct atomictest_property src_x; |
| struct atomictest_property src_y; |
| struct atomictest_property src_w; |
| struct atomictest_property src_h; |
| struct atomictest_property type; |
| struct atomictest_property in_fence_fd; |
| struct atomictest_property rotation; |
| struct atomictest_property ctm; |
| struct atomictest_property alpha; |
| }; |
| |
| struct atomictest_connector { |
| uint32_t connector_id; |
| struct atomictest_property crtc_id; |
| struct atomictest_property edid; |
| struct atomictest_property dpms; |
| }; |
| |
| struct atomictest_crtc { |
| uint32_t crtc_id; |
| uint32_t width; |
| uint32_t height; |
| uint32_t *primary_idx; |
| uint32_t *cursor_idx; |
| uint32_t *overlay_idx; |
| uint32_t num_primary; |
| uint32_t num_cursor; |
| uint32_t num_overlay; |
| |
| struct atomictest_plane *planes; |
| struct atomictest_property mode_id; |
| struct atomictest_property active; |
| struct atomictest_property out_fence_ptr; |
| struct atomictest_property ctm; |
| struct atomictest_property gamma_lut; |
| struct atomictest_property gamma_lut_size; |
| struct atomictest_property background_color; |
| }; |
| |
| struct atomictest_mode { |
| uint32_t height; |
| uint32_t width; |
| uint32_t id; |
| }; |
| |
| struct atomictest_context { |
| int fd; |
| uint32_t num_crtcs; |
| uint32_t num_connectors; |
| uint32_t num_modes; |
| |
| struct atomictest_connector *connectors; |
| struct atomictest_crtc *crtcs; |
| struct atomictest_mode *modes; |
| drmModeAtomicReqPtr pset; |
| drmModeResPtr res; |
| drmEventContext drm_event_ctx; |
| |
| struct bs_mapper *mapper; |
| |
| uint64_t modifier; |
| }; |
| |
| typedef int (*test_function)(struct atomictest_context *ctx, struct atomictest_crtc *crtc); |
| |
| struct atomictest_testcase { |
| const char *name; |
| test_function test_func; |
| }; |
| |
| // clang-format off |
| enum draw_format_type { |
| DRAW_NONE = 0, |
| DRAW_STRIPE = 1, |
| DRAW_TRANSPARENT_HOLE = 2, |
| DRAW_ELLIPSE = 3, |
| DRAW_CURSOR = 4, |
| DRAW_LINES = 5, |
| }; |
| // clang-format on |
| |
| static int drmModeCreatePropertyBlob64(int fd, const void *data, size_t length, uint64_t *id) |
| { |
| uint32_t ctm_blob_id = 0; |
| int ret = drmModeCreatePropertyBlob(fd, data, length, &ctm_blob_id); |
| *id = ctm_blob_id; |
| return ret; |
| } |
| |
| static int drmModeDestroyPropertyBlob64(int fd, uint64_t id) |
| { |
| CHECK(id < (1ull << 32)); |
| return drmModeDestroyPropertyBlob(fd, (uint32_t)id); |
| } |
| |
| static int32_t get_format_idx(struct atomictest_plane *plane, uint32_t format) |
| { |
| for (int32_t i = 0; i < plane->drm_plane.count_formats; i++) |
| if (plane->drm_plane.formats[i] == format) |
| return i; |
| return -1; |
| } |
| |
| static void copy_drm_plane(drmModePlane *dest, drmModePlane *src) |
| { |
| memcpy(dest, src, sizeof(drmModePlane)); |
| dest->formats = calloc(src->count_formats, sizeof(uint32_t)); |
| memcpy(dest->formats, src->formats, src->count_formats * sizeof(uint32_t)); |
| } |
| |
| static struct atomictest_plane *get_plane(struct atomictest_crtc *crtc, uint32_t idx, uint64_t type) |
| { |
| uint32_t index; |
| switch (type) { |
| case DRM_PLANE_TYPE_OVERLAY: |
| index = crtc->overlay_idx[idx]; |
| break; |
| case DRM_PLANE_TYPE_PRIMARY: |
| index = crtc->primary_idx[idx]; |
| break; |
| case DRM_PLANE_TYPE_CURSOR: |
| index = crtc->cursor_idx[idx]; |
| break; |
| default: |
| bs_debug_error("invalid plane type returned"); |
| return NULL; |
| } |
| |
| return &crtc->planes[index]; |
| } |
| |
| static int draw_to_plane(struct bs_mapper *mapper, struct atomictest_plane *plane, |
| enum draw_format_type pattern) |
| { |
| struct gbm_bo *bo = plane->bo; |
| uint32_t format = gbm_bo_get_format(bo); |
| const struct bs_draw_format *draw_format = bs_get_draw_format(format); |
| |
| if (draw_format && pattern) { |
| switch (pattern) { |
| case DRAW_STRIPE: |
| CHECK(bs_draw_stripe(mapper, bo, draw_format)); |
| break; |
| case DRAW_TRANSPARENT_HOLE: |
| CHECK(bs_draw_transparent_hole(mapper, bo, draw_format)); |
| break; |
| case DRAW_ELLIPSE: |
| CHECK(bs_draw_ellipse(mapper, bo, draw_format, 0)); |
| break; |
| case DRAW_CURSOR: |
| CHECK(bs_draw_cursor(mapper, bo, draw_format)); |
| break; |
| case DRAW_LINES: |
| CHECK(bs_draw_lines(mapper, bo, draw_format)); |
| break; |
| default: |
| bs_debug_error("invalid draw type"); |
| return -1; |
| } |
| } else { |
| // DRM_FORMAT_RGB565 --> red, DRM_FORMAT_BGR565 --> blue, |
| // everything else --> something |
| void *map_data; |
| uint16_t value = 0xF800; |
| uint32_t stride; |
| void *addr = bs_mapper_map(mapper, bo, 0, &map_data, &stride); |
| uint32_t num_shorts = stride * gbm_bo_get_height(bo) / sizeof(uint16_t); |
| uint16_t *pixel = (uint16_t *)addr; |
| |
| CHECK(addr); |
| for (uint32_t i = 0; i < num_shorts; i++) |
| pixel[i] = value; |
| |
| bs_mapper_unmap(mapper, bo, map_data); |
| } |
| |
| return 0; |
| } |
| |
| static int get_prop(int fd, drmModeObjectPropertiesPtr props, const char *name, |
| struct atomictest_property *bs_prop) |
| { |
| /* Property ID should always be > 0. */ |
| bs_prop->pid = 0; |
| drmModePropertyPtr prop; |
| for (uint32_t i = 0; i < props->count_props; i++) { |
| if (bs_prop->pid) |
| break; |
| |
| prop = drmModeGetProperty(fd, props->props[i]); |
| if (prop) { |
| if (!strcmp(prop->name, name)) { |
| bs_prop->pid = prop->prop_id; |
| bs_prop->value = props->prop_values[i]; |
| } |
| drmModeFreeProperty(prop); |
| } |
| } |
| |
| return (bs_prop->pid == 0) ? -1 : 0; |
| } |
| |
| static int get_connector_props(int fd, struct atomictest_connector *connector, |
| drmModeObjectPropertiesPtr props) |
| { |
| CHECK_RESULT(get_prop(fd, props, "CRTC_ID", &connector->crtc_id)); |
| CHECK_RESULT(get_prop(fd, props, "EDID", &connector->edid)); |
| CHECK_RESULT(get_prop(fd, props, "DPMS", &connector->dpms)); |
| return 0; |
| } |
| |
| static int get_crtc_props(int fd, struct atomictest_crtc *crtc, drmModeObjectPropertiesPtr props) |
| { |
| CHECK_RESULT(get_prop(fd, props, "MODE_ID", &crtc->mode_id)); |
| CHECK_RESULT(get_prop(fd, props, "ACTIVE", &crtc->active)); |
| CHECK_RESULT(get_prop(fd, props, "OUT_FENCE_PTR", &crtc->out_fence_ptr)); |
| |
| /* |
| * The atomic API makes no guarantee a property is present in object. This test |
| * requires the above common properties since a plane is undefined without them. |
| * Other properties (i.e: ctm) are optional. |
| */ |
| get_prop(fd, props, "CTM", &crtc->ctm); |
| get_prop(fd, props, "GAMMA_LUT", &crtc->gamma_lut); |
| get_prop(fd, props, "GAMMA_LUT_SIZE", &crtc->gamma_lut_size); |
| get_prop(fd, props, "BACKGROUND_COLOR", &crtc->background_color); |
| |
| return 0; |
| } |
| |
| static int get_plane_props(int fd, struct atomictest_plane *plane, drmModeObjectPropertiesPtr props) |
| { |
| CHECK_RESULT(get_prop(fd, props, "CRTC_ID", &plane->crtc_id)); |
| CHECK_RESULT(get_prop(fd, props, "FB_ID", &plane->fb_id)); |
| CHECK_RESULT(get_prop(fd, props, "CRTC_X", &plane->crtc_x)); |
| CHECK_RESULT(get_prop(fd, props, "CRTC_Y", &plane->crtc_y)); |
| CHECK_RESULT(get_prop(fd, props, "CRTC_W", &plane->crtc_w)); |
| CHECK_RESULT(get_prop(fd, props, "CRTC_H", &plane->crtc_h)); |
| CHECK_RESULT(get_prop(fd, props, "SRC_X", &plane->src_x)); |
| CHECK_RESULT(get_prop(fd, props, "SRC_Y", &plane->src_y)); |
| CHECK_RESULT(get_prop(fd, props, "SRC_W", &plane->src_w)); |
| CHECK_RESULT(get_prop(fd, props, "SRC_H", &plane->src_h)); |
| CHECK_RESULT(get_prop(fd, props, "type", &plane->type)); |
| CHECK_RESULT(get_prop(fd, props, "IN_FENCE_FD", &plane->in_fence_fd)); |
| |
| /* |
| * The atomic API makes no guarantee a property is present in object. This test |
| * requires the above common properties since a plane is undefined without them. |
| * Other properties (i.e: rotation and ctm) are optional. |
| */ |
| get_prop(fd, props, "rotation", &plane->rotation); |
| get_prop(fd, props, "PLANE_CTM", &plane->ctm); |
| get_prop(fd, props, "alpha", &plane->alpha); |
| return 0; |
| } |
| |
| static int set_connector_props(struct atomictest_connector *conn, drmModeAtomicReqPtr pset) |
| { |
| uint32_t id = conn->connector_id; |
| CHECK_RESULT(drmModeAtomicAddProperty(pset, id, conn->crtc_id.pid, conn->crtc_id.value)); |
| return 0; |
| } |
| |
| static int set_crtc_props(struct atomictest_crtc *crtc, drmModeAtomicReqPtr pset) |
| { |
| uint32_t id = crtc->crtc_id; |
| CHECK_RESULT(drmModeAtomicAddProperty(pset, id, crtc->mode_id.pid, crtc->mode_id.value)); |
| CHECK_RESULT(drmModeAtomicAddProperty(pset, id, crtc->active.pid, crtc->active.value)); |
| if (crtc->out_fence_ptr.value) |
| CHECK_RESULT(drmModeAtomicAddProperty(pset, id, crtc->out_fence_ptr.pid, |
| crtc->out_fence_ptr.value)); |
| if (crtc->ctm.pid) |
| CHECK_RESULT(drmModeAtomicAddProperty(pset, id, crtc->ctm.pid, crtc->ctm.value)); |
| if (crtc->gamma_lut.pid) |
| CHECK_RESULT( |
| drmModeAtomicAddProperty(pset, id, crtc->gamma_lut.pid, crtc->gamma_lut.value)); |
| if (crtc->background_color.pid) { |
| CHECK_RESULT(drmModeAtomicAddProperty(pset, id, crtc->background_color.pid, |
| crtc->background_color.value)); |
| } |
| |
| return 0; |
| } |
| |
| static int set_plane_props(struct atomictest_plane *plane, drmModeAtomicReqPtr pset) |
| { |
| uint32_t id = plane->drm_plane.plane_id; |
| CHECK_RESULT(drmModeAtomicAddProperty(pset, id, plane->crtc_id.pid, plane->crtc_id.value)); |
| CHECK_RESULT(drmModeAtomicAddProperty(pset, id, plane->fb_id.pid, plane->fb_id.value)); |
| CHECK_RESULT(drmModeAtomicAddProperty(pset, id, plane->crtc_x.pid, plane->crtc_x.value)); |
| CHECK_RESULT(drmModeAtomicAddProperty(pset, id, plane->crtc_y.pid, plane->crtc_y.value)); |
| CHECK_RESULT(drmModeAtomicAddProperty(pset, id, plane->crtc_w.pid, plane->crtc_w.value)); |
| CHECK_RESULT(drmModeAtomicAddProperty(pset, id, plane->crtc_h.pid, plane->crtc_h.value)); |
| CHECK_RESULT(drmModeAtomicAddProperty(pset, id, plane->src_x.pid, plane->src_x.value)); |
| CHECK_RESULT(drmModeAtomicAddProperty(pset, id, plane->src_y.pid, plane->src_y.value)); |
| CHECK_RESULT(drmModeAtomicAddProperty(pset, id, plane->src_w.pid, plane->src_w.value)); |
| CHECK_RESULT(drmModeAtomicAddProperty(pset, id, plane->src_h.pid, plane->src_h.value)); |
| CHECK_RESULT( |
| drmModeAtomicAddProperty(pset, id, plane->in_fence_fd.pid, plane->in_fence_fd.value)); |
| if (plane->rotation.pid) |
| CHECK_RESULT( |
| drmModeAtomicAddProperty(pset, id, plane->rotation.pid, plane->rotation.value)); |
| if (plane->ctm.pid) |
| CHECK_RESULT(drmModeAtomicAddProperty(pset, id, plane->ctm.pid, plane->ctm.value)); |
| if (plane->alpha.pid) { |
| CHECK_RESULT( |
| drmModeAtomicAddProperty(pset, id, plane->alpha.pid, plane->alpha.value)); |
| } |
| |
| return 0; |
| } |
| |
| static int remove_plane_fb(struct atomictest_context *ctx, struct atomictest_plane *plane) |
| { |
| if (plane->bo && plane->fb_id.value) { |
| CHECK_RESULT(drmModeRmFB(ctx->fd, plane->fb_id.value)); |
| gbm_bo_destroy(plane->bo); |
| plane->bo = NULL; |
| plane->fb_id.value = 0; |
| } |
| |
| return 0; |
| } |
| |
| static int add_plane_fb(struct atomictest_context *ctx, struct atomictest_plane *plane) |
| { |
| if (plane->format_idx < plane->drm_plane.count_formats) { |
| CHECK_RESULT(remove_plane_fb(ctx, plane)); |
| uint32_t flags = (plane->type.value == DRM_PLANE_TYPE_CURSOR) ? GBM_BO_USE_CURSOR |
| : GBM_BO_USE_SCANOUT; |
| flags |= GBM_BO_USE_LINEAR; |
| if (ctx->modifier != DRM_FORMAT_MOD_INVALID) { |
| plane->bo = gbm_bo_create_with_modifiers( |
| gbm, plane->crtc_w.value, plane->crtc_h.value, |
| plane->drm_plane.formats[plane->format_idx], &(ctx->modifier), 1); |
| } else { |
| plane->bo = |
| gbm_bo_create(gbm, plane->crtc_w.value, plane->crtc_h.value, |
| plane->drm_plane.formats[plane->format_idx], flags); |
| } |
| |
| CHECK(plane->bo); |
| plane->fb_id.value = bs_drm_fb_create_gbm(plane->bo); |
| CHECK(plane->fb_id.value); |
| CHECK_RESULT(set_plane_props(plane, ctx->pset)); |
| } |
| |
| return 0; |
| } |
| |
| static int init_plane(struct atomictest_context *ctx, struct atomictest_plane *plane, |
| uint32_t format, uint32_t x, uint32_t y, uint32_t w, uint32_t h, |
| uint32_t crtc_id) |
| { |
| int32_t idx = get_format_idx(plane, format); |
| if (idx < 0) |
| return -EINVAL; |
| |
| plane->format_idx = idx; |
| plane->crtc_x.value = x; |
| plane->crtc_y.value = y; |
| plane->crtc_w.value = w; |
| plane->crtc_h.value = h; |
| plane->src_w.value = plane->crtc_w.value << 16; |
| plane->src_h.value = plane->crtc_h.value << 16; |
| plane->crtc_id.value = crtc_id; |
| |
| CHECK_RESULT(add_plane_fb(ctx, plane)); |
| return 0; |
| } |
| |
| static int init_plane_any_format(struct atomictest_context *ctx, struct atomictest_plane *plane, |
| uint32_t x, uint32_t y, uint32_t w, uint32_t h, uint32_t crtc_id, |
| bool yuv) |
| { |
| if (yuv) { |
| uint32_t i; |
| for (i = 0; i < BS_ARRAY_LEN(yuv_formats); i++) |
| if (!init_plane(ctx, plane, yuv_formats[i], x, y, w, h, crtc_id)) |
| return 0; |
| } else { |
| // XRGB888 works well with our draw code, so try that first. |
| if (!init_plane(ctx, plane, DRM_FORMAT_XRGB8888, x, y, w, h, crtc_id)) |
| return 0; |
| |
| for (uint32_t format_idx = 0; format_idx < plane->drm_plane.count_formats; |
| format_idx++) { |
| if (!gbm_device_is_format_supported(gbm, |
| plane->drm_plane.formats[format_idx], |
| GBM_BO_USE_SCANOUT | GBM_BO_USE_LINEAR)) |
| continue; |
| |
| if (!init_plane(ctx, plane, plane->drm_plane.formats[format_idx], x, y, w, |
| h, crtc_id)) |
| return 0; |
| } |
| } |
| |
| return -EINVAL; |
| } |
| |
| static int disable_plane(struct atomictest_context *ctx, struct atomictest_plane *plane) |
| { |
| plane->format_idx = 0; |
| plane->crtc_x.value = 0; |
| plane->crtc_y.value = 0; |
| plane->crtc_w.value = 0; |
| plane->crtc_h.value = 0; |
| plane->src_w.value = 0; |
| plane->src_h.value = 0; |
| plane->crtc_id.value = 0; |
| plane->in_fence_fd.value = -1; |
| |
| if (plane->rotation.pid) |
| plane->rotation.value = DRM_ROTATE_0; |
| if (plane->ctm.pid) |
| plane->ctm.value = 0; |
| |
| CHECK_RESULT(remove_plane_fb(ctx, plane)); |
| CHECK_RESULT(set_plane_props(plane, ctx->pset)); |
| return 0; |
| } |
| |
| static int move_plane(struct atomictest_context *ctx, struct atomictest_crtc *crtc, |
| struct atomictest_plane *plane, uint32_t dx, uint32_t dy) |
| { |
| if (plane->crtc_x.value < (crtc->width - plane->crtc_w.value) && |
| plane->crtc_y.value < (crtc->height - plane->crtc_h.value)) { |
| plane->crtc_x.value += dx; |
| plane->crtc_y.value += dy; |
| CHECK_RESULT(set_plane_props(plane, ctx->pset)); |
| return 0; |
| } |
| |
| return -1; |
| } |
| |
| static int scale_plane(struct atomictest_context *ctx, struct atomictest_crtc *crtc, |
| struct atomictest_plane *plane, float dw, float dh) |
| { |
| int32_t plane_w = (int32_t)plane->crtc_w.value + dw * plane->crtc_w.value; |
| int32_t plane_h = (int32_t)plane->crtc_h.value + dh * plane->crtc_h.value; |
| if (plane_w > 0 && plane_h > 0 && (plane->crtc_x.value + plane_w < crtc->width) && |
| (plane->crtc_h.value + plane_h < crtc->height)) { |
| plane->crtc_w.value = BS_ALIGN((uint32_t)plane_w, 2); |
| plane->crtc_h.value = BS_ALIGN((uint32_t)plane_h, 2); |
| CHECK_RESULT(set_plane_props(plane, ctx->pset)); |
| return 0; |
| } |
| |
| return -1; |
| } |
| |
| static void log(struct atomictest_context *ctx) |
| { |
| printf("Committing the following configuration: \n"); |
| for (uint32_t i = 0; i < ctx->num_crtcs; i++) { |
| struct atomictest_plane *plane; |
| struct atomictest_crtc *crtc = &ctx->crtcs[i]; |
| uint32_t num_planes = crtc->num_primary + crtc->num_cursor + crtc->num_overlay; |
| if (!crtc->active.value) |
| continue; |
| |
| printf("----- [CRTC: %u] -----\n", crtc->crtc_id); |
| for (uint32_t j = 0; j < num_planes; j++) { |
| plane = &crtc->planes[j]; |
| if (plane->crtc_id.value == crtc->crtc_id && plane->fb_id.value) { |
| uint32_t format = gbm_bo_get_format(plane->bo); |
| char *fourcc = (char *)&format; |
| printf("\t{Plane ID: %u, ", plane->drm_plane.plane_id); |
| printf("Plane format: %c%c%c%c, ", fourcc[0], fourcc[1], fourcc[2], |
| fourcc[3]); |
| printf("Plane type: "); |
| switch (plane->type.value) { |
| case DRM_PLANE_TYPE_OVERLAY: |
| printf("overlay, "); |
| break; |
| case DRM_PLANE_TYPE_PRIMARY: |
| printf("primary, "); |
| break; |
| case DRM_PLANE_TYPE_CURSOR: |
| printf("cursor, "); |
| break; |
| } |
| |
| printf("CRTC_X: %" PRIu64 ", CRTC_Y: %" PRIu64 ", CRTC_W: %" PRIu64 |
| ", CRTC_H: %" PRIu64 "}\n", |
| plane->crtc_x.value, plane->crtc_y.value, |
| plane->crtc_w.value, plane->crtc_h.value); |
| } |
| } |
| } |
| } |
| |
| static int test_commit(struct atomictest_context *ctx) |
| { |
| return drmModeAtomicCommit(ctx->fd, ctx->pset, |
| DRM_MODE_ATOMIC_ALLOW_MODESET | DRM_MODE_ATOMIC_TEST_ONLY, NULL); |
| } |
| |
| static int commit(struct atomictest_context *ctx) |
| { |
| int ret; |
| fd_set fds; |
| FD_ZERO(&fds); |
| FD_SET(ctx->fd, &fds); |
| |
| log(ctx); |
| ret = drmModeAtomicCommit(ctx->fd, ctx->pset, |
| DRM_MODE_PAGE_FLIP_EVENT | DRM_MODE_ATOMIC_ALLOW_MODESET, NULL); |
| CHECK_RESULT(ret); |
| do { |
| ret = select(ctx->fd + 1, &fds, NULL, NULL, NULL); |
| } while (ret == -1 && errno == EINTR); |
| |
| CHECK_RESULT(ret); |
| if (FD_ISSET(ctx->fd, &fds)) |
| drmHandleEvent(ctx->fd, &ctx->drm_event_ctx); |
| |
| return 0; |
| } |
| |
| static int test_and_commit(struct atomictest_context *ctx, uint32_t sleep_micro_secs) |
| { |
| sleep_micro_secs = automatic ? 0 : sleep_micro_secs; |
| if (!test_commit(ctx)) { |
| CHECK_RESULT(commit(ctx)); |
| usleep(sleep_micro_secs); |
| } else { |
| return TEST_COMMIT_FAIL; |
| } |
| |
| return 0; |
| } |
| |
| static int pageflip_formats(struct atomictest_context *ctx, struct atomictest_crtc *crtc, |
| struct atomictest_plane *plane) |
| { |
| int ret = 0; |
| uint32_t flags; |
| for (uint32_t i = 0; i < plane->drm_plane.count_formats; i++) { |
| flags = (plane->type.value == DRM_PLANE_TYPE_CURSOR) ? GBM_BO_USE_CURSOR |
| : GBM_BO_USE_SCANOUT; |
| |
| flags |= GBM_BO_USE_LINEAR; |
| if (!gbm_device_is_format_supported(gbm, plane->drm_plane.formats[i], flags)) |
| continue; |
| |
| CHECK_RESULT(init_plane(ctx, plane, plane->drm_plane.formats[i], 0, 0, crtc->width, |
| crtc->height, crtc->crtc_id)); |
| CHECK_RESULT(draw_to_plane(ctx->mapper, plane, DRAW_ELLIPSE)); |
| ret |= test_and_commit(ctx, 1e6); |
| |
| // disable, but don't commit, since we can't have an active CRTC without any planes. |
| CHECK_RESULT(disable_plane(ctx, plane)); |
| } |
| |
| return ret; |
| } |
| |
| static uint32_t get_connection(struct atomictest_crtc *crtc, uint32_t crtc_index) |
| { |
| uint32_t connector_id = 0; |
| uint32_t crtc_mask = 1u << crtc_index; |
| struct bs_drm_pipe pipe = { 0 }; |
| struct bs_drm_pipe_plumber *plumber = bs_drm_pipe_plumber_new(); |
| bs_drm_pipe_plumber_crtc_mask(plumber, crtc_mask); |
| if (bs_drm_pipe_plumber_make(plumber, &pipe)) |
| connector_id = pipe.connector_id; |
| |
| bs_drm_pipe_plumber_destroy(&plumber); |
| return connector_id; |
| } |
| |
| static int enable_crtc(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| drmModeAtomicSetCursor(ctx->pset, 0); |
| |
| for (uint32_t i = 0; i < ctx->num_connectors; i++) { |
| ctx->connectors[i].crtc_id.value = 0; |
| set_connector_props(&ctx->connectors[i], ctx->pset); |
| } |
| |
| for (uint32_t i = 0; i < ctx->num_crtcs; i++) { |
| if (&ctx->crtcs[i] == crtc) { |
| uint32_t connector_id = get_connection(crtc, i); |
| CHECK(connector_id); |
| for (uint32_t j = 0; j < ctx->num_connectors; j++) { |
| if (connector_id == ctx->connectors[j].connector_id) { |
| ctx->connectors[j].crtc_id.value = crtc->crtc_id; |
| set_connector_props(&ctx->connectors[j], ctx->pset); |
| break; |
| } |
| } |
| |
| break; |
| } |
| } |
| |
| int ret = -EINVAL; |
| int cursor = drmModeAtomicGetCursor(ctx->pset); |
| |
| for (uint32_t i = 0; i < ctx->num_modes; i++) { |
| struct atomictest_mode *mode = &ctx->modes[i]; |
| drmModeAtomicSetCursor(ctx->pset, cursor); |
| |
| crtc->mode_id.value = mode->id; |
| crtc->active.value = 1; |
| crtc->width = mode->width; |
| crtc->height = mode->height; |
| |
| set_crtc_props(crtc, ctx->pset); |
| ret = drmModeAtomicCommit(ctx->fd, ctx->pset, |
| DRM_MODE_ATOMIC_TEST_ONLY | DRM_MODE_ATOMIC_ALLOW_MODESET, |
| NULL); |
| if (!ret) |
| return 0; |
| } |
| |
| bs_debug_error("[CRTC:%d]: failed to find mode: %s", crtc->crtc_id, strerror(errno)); |
| return ret; |
| } |
| |
| static int disable_crtcs(struct atomictest_context *ctx, uint32_t crtc_mask) |
| { |
| for (uint32_t i = 0; i < ctx->num_connectors; i++) { |
| ctx->connectors[i].crtc_id.value = 0; |
| set_connector_props(&ctx->connectors[i], ctx->pset); |
| } |
| |
| struct atomictest_crtc *crtc; |
| for (uint32_t crtc_index = 0; crtc_index < ctx->num_crtcs; crtc_index++) { |
| if (!((1 << crtc_index) & crtc_mask)) |
| continue; |
| |
| crtc = &ctx->crtcs[crtc_index]; |
| crtc->mode_id.value = 0; |
| crtc->active.value = 0; |
| if (crtc->ctm.pid) |
| crtc->ctm.value = 0; |
| if (crtc->gamma_lut.pid) |
| crtc->gamma_lut.value = 0; |
| if (crtc->background_color.pid) |
| crtc->background_color.value = 0; |
| |
| set_crtc_props(crtc, ctx->pset); |
| } |
| |
| int ret = drmModeAtomicCommit(ctx->fd, ctx->pset, DRM_MODE_ATOMIC_ALLOW_MODESET, NULL); |
| CHECK_RESULT(ret); |
| return ret; |
| } |
| |
| static int disable_crtc(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| for (uint32_t i = 0; i < ctx->num_crtcs; i++) |
| if (&ctx->crtcs[i] == crtc) |
| return disable_crtcs(ctx, 1 << i); |
| CHECK(false); // We shouldn't get here. |
| } |
| |
| static struct atomictest_context *new_context(uint32_t num_connectors, uint32_t num_crtcs, |
| uint32_t num_planes) |
| { |
| struct atomictest_context *ctx = calloc(1, sizeof(*ctx)); |
| |
| ctx->mapper = bs_mapper_gem_new(); |
| if (ctx->mapper == NULL) { |
| bs_debug_error("failed to create mapper object"); |
| free(ctx); |
| return NULL; |
| } |
| |
| ctx->connectors = calloc(num_connectors, sizeof(*ctx->connectors)); |
| ctx->crtcs = calloc(num_crtcs, sizeof(*ctx->crtcs)); |
| for (uint32_t i = 0; i < num_crtcs; i++) { |
| ctx->crtcs[i].planes = calloc(num_planes, sizeof(*ctx->crtcs[i].planes)); |
| ctx->crtcs[i].overlay_idx = calloc(num_planes, sizeof(uint32_t)); |
| ctx->crtcs[i].primary_idx = calloc(num_planes, sizeof(uint32_t)); |
| ctx->crtcs[i].cursor_idx = calloc(num_planes, sizeof(uint32_t)); |
| } |
| |
| ctx->num_connectors = num_connectors; |
| ctx->num_crtcs = num_crtcs; |
| ctx->num_modes = 0; |
| ctx->modes = NULL; |
| ctx->pset = drmModeAtomicAlloc(); |
| ctx->drm_event_ctx.version = DRM_EVENT_CONTEXT_VERSION; |
| ctx->drm_event_ctx.page_flip_handler = page_flip_handler; |
| |
| return ctx; |
| } |
| |
| static void free_context(struct atomictest_context *ctx) |
| { |
| for (uint32_t i = 0; i < ctx->num_crtcs; i++) { |
| uint32_t num_planes = ctx->crtcs[i].num_primary + ctx->crtcs[i].num_cursor + |
| ctx->crtcs[i].num_overlay; |
| |
| for (uint32_t j = 0; j < num_planes; j++) { |
| remove_plane_fb(ctx, &ctx->crtcs[i].planes[j]); |
| free(ctx->crtcs[i].planes[j].drm_plane.formats); |
| } |
| |
| free(ctx->crtcs[i].planes); |
| free(ctx->crtcs[i].overlay_idx); |
| free(ctx->crtcs[i].cursor_idx); |
| free(ctx->crtcs[i].primary_idx); |
| } |
| |
| drmModeAtomicFree(ctx->pset); |
| drmModeFreeResources(ctx->res); |
| free(ctx->modes); |
| free(ctx->crtcs); |
| free(ctx->connectors); |
| bs_mapper_destroy(ctx->mapper); |
| free(ctx); |
| } |
| |
| static struct atomictest_context *query_kms(int fd) |
| { |
| drmModeResPtr res = drmModeGetResources(fd); |
| if (res == NULL) { |
| bs_debug_error("failed to get drm resources"); |
| return false; |
| } |
| |
| drmModePlaneRes *plane_res = drmModeGetPlaneResources(fd); |
| if (plane_res == NULL) { |
| bs_debug_error("failed to get plane resources"); |
| drmModeFreeResources(res); |
| return NULL; |
| } |
| |
| struct atomictest_context *ctx = |
| new_context(res->count_connectors, res->count_crtcs, plane_res->count_planes); |
| if (ctx == NULL) { |
| bs_debug_error("failed to allocate atomic context"); |
| drmModeFreePlaneResources(plane_res); |
| drmModeFreeResources(res); |
| return NULL; |
| } |
| |
| ctx->fd = fd; |
| ctx->res = res; |
| drmModeObjectPropertiesPtr props = NULL; |
| |
| for (uint32_t conn_index = 0; conn_index < res->count_connectors; conn_index++) { |
| uint32_t conn_id = res->connectors[conn_index]; |
| ctx->connectors[conn_index].connector_id = conn_id; |
| props = drmModeObjectGetProperties(fd, conn_id, DRM_MODE_OBJECT_CONNECTOR); |
| get_connector_props(fd, &ctx->connectors[conn_index], props); |
| |
| drmModeConnector *connector = drmModeGetConnector(fd, conn_id); |
| for (uint32_t mode_index = 0; mode_index < connector->count_modes; mode_index++) { |
| ctx->modes = |
| realloc(ctx->modes, (ctx->num_modes + 1) * sizeof(*ctx->modes)); |
| drmModeCreatePropertyBlob(fd, &connector->modes[mode_index], |
| sizeof(drmModeModeInfo), |
| &ctx->modes[ctx->num_modes].id); |
| ctx->modes[ctx->num_modes].width = connector->modes[mode_index].hdisplay; |
| ctx->modes[ctx->num_modes].height = connector->modes[mode_index].vdisplay; |
| ctx->num_modes++; |
| } |
| |
| drmModeFreeConnector(connector); |
| drmModeFreeObjectProperties(props); |
| props = NULL; |
| } |
| |
| uint32_t crtc_index; |
| for (crtc_index = 0; crtc_index < res->count_crtcs; crtc_index++) { |
| ctx->crtcs[crtc_index].crtc_id = res->crtcs[crtc_index]; |
| props = |
| drmModeObjectGetProperties(fd, res->crtcs[crtc_index], DRM_MODE_OBJECT_CRTC); |
| get_crtc_props(fd, &ctx->crtcs[crtc_index], props); |
| |
| drmModeFreeObjectProperties(props); |
| props = NULL; |
| } |
| |
| uint32_t overlay_idx, primary_idx, cursor_idx, idx; |
| |
| for (uint32_t plane_index = 0; plane_index < plane_res->count_planes; plane_index++) { |
| drmModePlane *plane = drmModeGetPlane(fd, plane_res->planes[plane_index]); |
| if (plane == NULL) { |
| bs_debug_error("failed to get plane id %u", plane_res->planes[plane_index]); |
| continue; |
| } |
| |
| uint32_t crtc_mask = 0; |
| |
| drmModeObjectPropertiesPtr props = drmModeObjectGetProperties( |
| fd, plane_res->planes[plane_index], DRM_MODE_OBJECT_PLANE); |
| |
| for (crtc_index = 0; crtc_index < res->count_crtcs; crtc_index++) { |
| crtc_mask = (1 << crtc_index); |
| if (plane->possible_crtcs & crtc_mask) { |
| struct atomictest_crtc *crtc = &ctx->crtcs[crtc_index]; |
| cursor_idx = crtc->num_cursor; |
| primary_idx = crtc->num_primary; |
| overlay_idx = crtc->num_overlay; |
| idx = cursor_idx + primary_idx + overlay_idx; |
| copy_drm_plane(&crtc->planes[idx].drm_plane, plane); |
| get_plane_props(fd, &crtc->planes[idx], props); |
| switch (crtc->planes[idx].type.value) { |
| case DRM_PLANE_TYPE_OVERLAY: |
| crtc->overlay_idx[overlay_idx] = idx; |
| crtc->num_overlay++; |
| break; |
| case DRM_PLANE_TYPE_PRIMARY: |
| crtc->primary_idx[primary_idx] = idx; |
| crtc->num_primary++; |
| break; |
| case DRM_PLANE_TYPE_CURSOR: |
| crtc->cursor_idx[cursor_idx] = idx; |
| crtc->num_cursor++; |
| break; |
| default: |
| bs_debug_error("invalid plane type returned"); |
| return NULL; |
| } |
| |
| /* |
| * The DRM UAPI states that cursor and overlay framebuffers may be |
| * present after a CRTC disable, so zero this out so we can get a |
| * clean slate. |
| */ |
| crtc->planes[idx].fb_id.value = 0; |
| } |
| } |
| |
| drmModeFreePlane(plane); |
| drmModeFreeObjectProperties(props); |
| props = NULL; |
| } |
| |
| drmModeFreePlaneResources(plane_res); |
| return ctx; |
| } |
| |
| static int test_multiple_planes(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| int ret = 0; |
| struct atomictest_plane *primary, *overlay, *cursor; |
| for (uint32_t i = 0; i < crtc->num_primary; i++) { |
| bool video = true; |
| uint32_t x, y; |
| for (uint32_t j = 0; j < crtc->num_overlay; j++) { |
| overlay = get_plane(crtc, j, DRM_PLANE_TYPE_OVERLAY); |
| x = crtc->width >> (j + 2); |
| y = crtc->height >> (j + 2); |
| x = MAX(x, ctx->res->min_width); |
| y = MAX(y, ctx->res->min_height); |
| // drmModeAddFB2 requires the height and width are even for sub-sampled YUV |
| // formats. |
| x = BS_ALIGN(x, 2); |
| y = BS_ALIGN(y, 2); |
| if (video && |
| !init_plane_any_format(ctx, overlay, x, y, x, y, crtc->crtc_id, true)) { |
| CHECK_RESULT(draw_to_plane(ctx->mapper, overlay, DRAW_STRIPE)); |
| video = false; |
| } else { |
| CHECK_RESULT(init_plane_any_format(ctx, overlay, x, y, x, y, |
| crtc->crtc_id, false)); |
| CHECK_RESULT(draw_to_plane(ctx->mapper, overlay, DRAW_LINES)); |
| } |
| } |
| |
| for (uint32_t j = 0; j < crtc->num_cursor; j++) { |
| x = crtc->width >> (j + 2); |
| y = crtc->height >> (j + 2); |
| cursor = get_plane(crtc, j, DRM_PLANE_TYPE_CURSOR); |
| CHECK_RESULT(init_plane(ctx, cursor, DRM_FORMAT_ARGB8888, x, y, CURSOR_SIZE, |
| CURSOR_SIZE, crtc->crtc_id)); |
| CHECK_RESULT(draw_to_plane(ctx->mapper, cursor, DRAW_CURSOR)); |
| } |
| |
| primary = get_plane(crtc, i, DRM_PLANE_TYPE_PRIMARY); |
| CHECK_RESULT(init_plane_any_format(ctx, primary, 0, 0, crtc->width, crtc->height, |
| crtc->crtc_id, false)); |
| CHECK_RESULT(draw_to_plane(ctx->mapper, primary, DRAW_ELLIPSE)); |
| |
| uint32_t num_planes = crtc->num_primary + crtc->num_cursor + crtc->num_overlay; |
| int done = 0; |
| struct atomictest_plane *plane; |
| while (!done) { |
| done = 1; |
| for (uint32_t j = 0; j < num_planes; j++) { |
| plane = &crtc->planes[j]; |
| if (plane->type.value != DRM_PLANE_TYPE_PRIMARY) |
| done &= move_plane(ctx, crtc, plane, 40, 40); |
| } |
| |
| ret |= test_and_commit(ctx, 1e6 / 60); |
| } |
| |
| ret |= test_and_commit(ctx, 1e6); |
| |
| /* Disable primary plane and verify overlays show up. */ |
| CHECK_RESULT(disable_plane(ctx, primary)); |
| ret |= test_and_commit(ctx, 1e6); |
| |
| for (uint32_t j = 0; j < crtc->num_cursor; j++) { |
| cursor = get_plane(crtc, j, DRM_PLANE_TYPE_CURSOR); |
| CHECK_RESULT(disable_plane(ctx, cursor)); |
| } |
| } |
| |
| return ret; |
| } |
| |
| static int test_video_overlay(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| int ret = 0; |
| struct atomictest_plane *overlay; |
| for (uint32_t i = 0; i < crtc->num_overlay; i++) { |
| overlay = get_plane(crtc, i, DRM_PLANE_TYPE_OVERLAY); |
| if (init_plane_any_format(ctx, overlay, 0, 0, 800, 800, crtc->crtc_id, true)) |
| continue; |
| |
| CHECK_RESULT(draw_to_plane(ctx->mapper, overlay, DRAW_STRIPE)); |
| while (!move_plane(ctx, crtc, overlay, 40, 40)) |
| ret |= test_and_commit(ctx, 1e6 / 60); |
| } |
| |
| return ret; |
| } |
| |
| static int prop_contains_value(drmModePropertyPtr prop, uint64_t value) |
| { |
| for (uint32_t i = 0; i < prop->count_values; i++) { |
| if (prop->values[i] == value) |
| return 1; |
| } |
| return 0; |
| } |
| |
| static int test_orientation(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| int ret = 0; |
| struct atomictest_plane *primary, *overlay; |
| drmModePropertyPtr rotation_prop; |
| for (uint32_t i = 0; i < crtc->num_overlay; i++) { |
| overlay = get_plane(crtc, i, DRM_PLANE_TYPE_OVERLAY); |
| if (!overlay->rotation.pid) |
| continue; |
| |
| rotation_prop = drmModeGetProperty(ctx->fd, overlay->rotation.pid); |
| CHECK(rotation_prop); |
| CHECK_RESULT(init_plane_any_format(ctx, overlay, 0, 0, crtc->width, crtc->height, |
| crtc->crtc_id, false)); |
| CHECK(prop_contains_value(rotation_prop, DRM_ROTATE_0)); |
| overlay->rotation.value = DRM_ROTATE_0; |
| set_plane_props(overlay, ctx->pset); |
| CHECK_RESULT(draw_to_plane(ctx->mapper, overlay, DRAW_LINES)); |
| ret |= test_and_commit(ctx, 1e6); |
| |
| if (prop_contains_value(rotation_prop, DRM_REFLECT_Y)) { |
| overlay->rotation.value = DRM_REFLECT_Y; |
| set_plane_props(overlay, ctx->pset); |
| ret |= test_and_commit(ctx, 1e6); |
| |
| CHECK_RESULT(disable_plane(ctx, overlay)); |
| } |
| drmModeFreeProperty(rotation_prop); |
| rotation_prop = NULL; |
| } |
| |
| for (uint32_t i = 0; i < crtc->num_primary; i++) { |
| primary = get_plane(crtc, i, DRM_PLANE_TYPE_PRIMARY); |
| if (!primary->rotation.pid) |
| continue; |
| |
| rotation_prop = drmModeGetProperty(ctx->fd, primary->rotation.pid); |
| CHECK(rotation_prop); |
| CHECK_RESULT(init_plane_any_format(ctx, primary, 0, 0, crtc->width, crtc->height, |
| crtc->crtc_id, false)); |
| CHECK(prop_contains_value(rotation_prop, DRM_ROTATE_0)); |
| primary->rotation.value = DRM_ROTATE_0; |
| set_plane_props(primary, ctx->pset); |
| CHECK_RESULT(draw_to_plane(ctx->mapper, primary, DRAW_LINES)); |
| ret |= test_and_commit(ctx, 1e6); |
| |
| if (prop_contains_value(rotation_prop, DRM_REFLECT_Y)) { |
| primary->rotation.value = DRM_REFLECT_Y; |
| set_plane_props(primary, ctx->pset); |
| ret |= test_and_commit(ctx, 1e6); |
| } |
| |
| CHECK_RESULT(disable_plane(ctx, primary)); |
| drmModeFreeProperty(rotation_prop); |
| rotation_prop = NULL; |
| } |
| |
| return ret; |
| } |
| |
| static int test_plane_alpha(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| int ret = 0; |
| struct atomictest_plane *primary, *overlay; |
| int offset_x = crtc->width / 5, offset_y = crtc->height / 5; |
| |
| for (uint32_t i = 0; i < crtc->num_primary; i++) { |
| primary = get_plane(crtc, i, DRM_PLANE_TYPE_PRIMARY); |
| if (!primary->alpha.pid) |
| return 0; |
| |
| CHECK_RESULT(init_plane_any_format(ctx, primary, 0, 0, crtc->width, crtc->height, |
| crtc->crtc_id, false)); |
| CHECK_RESULT(draw_to_plane(ctx->mapper, primary, DRAW_ELLIPSE)); |
| primary->alpha.value = 0xffff; |
| set_plane_props(primary, ctx->pset); |
| ret |= test_and_commit(ctx, 1e6 / 2); |
| |
| for (uint32_t j = 0; j < crtc->num_overlay; j++) { |
| overlay = get_plane(crtc, j, DRM_PLANE_TYPE_OVERLAY); |
| if (!overlay->alpha.pid) |
| return 0; |
| |
| CHECK_RESULT(init_plane_any_format( |
| ctx, overlay, offset_x, offset_y, crtc->width - offset_x * 2, |
| crtc->height - offset_y * 2, crtc->crtc_id, false)); |
| CHECK_RESULT(draw_to_plane(ctx->mapper, overlay, DRAW_STRIPE)); |
| ret |= test_and_commit(ctx, 1e6 / 2); |
| |
| for (uint32_t a = 0xffff; a > 0; a = a >> 1) { |
| overlay->alpha.value = a; |
| set_plane_props(overlay, ctx->pset); |
| ret |= test_and_commit(ctx, 1e6 / 5); |
| } |
| overlay->alpha.value = 0xffff; |
| set_plane_props(overlay, ctx->pset); |
| } |
| |
| for (uint32_t a = 0xffff; a > 0; a = a >> 1) { |
| primary->alpha.value = a; |
| set_plane_props(primary, ctx->pset); |
| ret |= test_and_commit(ctx, 1e6 / 5); |
| } |
| } |
| |
| return ret; |
| } |
| |
| static void *inc_timeline(void *user_data) |
| { |
| int timeline_fd = *(int *)user_data; |
| uint32_t sleep_micro_secs = automatic ? 1e3 : 1e5; |
| usleep(sleep_micro_secs); |
| sw_sync_timeline_inc(timeline_fd, 1); |
| return NULL; |
| } |
| |
| static int test_in_fence(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| int ret = 0; |
| pthread_t inc_timeline_thread; |
| struct atomictest_plane *primary = NULL; |
| |
| for (uint32_t i = 0; i < crtc->num_primary; i++) { |
| primary = get_plane(crtc, i, DRM_PLANE_TYPE_PRIMARY); |
| CHECK_RESULT(init_plane_any_format(ctx, primary, 0, 0, crtc->width, crtc->height, |
| crtc->crtc_id, false)); |
| break; |
| } |
| |
| int timeline = sw_sync_timeline_create(); |
| CHECK(fcntl(timeline, F_GETFD, 0) >= 0); |
| int in_fence = sw_sync_fence_create(timeline, "test_in_fence", 1); |
| CHECK(fcntl(in_fence, F_GETFD, 0) >= 0); |
| |
| CHECK_RESULT(draw_to_plane(ctx->mapper, primary, DRAW_LINES)); |
| |
| primary->in_fence_fd.value = in_fence; |
| set_plane_props(primary, ctx->pset); |
| set_crtc_props(crtc, ctx->pset); |
| |
| CHECK(!pthread_create(&inc_timeline_thread, NULL, inc_timeline, &timeline)); |
| |
| ret |= test_and_commit(ctx, 1e6); |
| CHECK(!pthread_join(inc_timeline_thread, NULL)); |
| |
| ret |= test_and_commit(ctx, 1e6); |
| close(in_fence); |
| close(timeline); |
| |
| return ret; |
| } |
| |
| static int test_out_fence(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| int ret = 0; |
| struct atomictest_plane *primary = NULL; |
| |
| for (uint32_t i = 0; i < crtc->num_primary; i++) { |
| primary = get_plane(crtc, i, DRM_PLANE_TYPE_PRIMARY); |
| CHECK_RESULT(init_plane_any_format(ctx, primary, 0, 0, crtc->width, crtc->height, |
| crtc->crtc_id, false)); |
| break; |
| } |
| |
| CHECK_RESULT(draw_to_plane(ctx->mapper, primary, DRAW_LINES)); |
| set_plane_props(primary, ctx->pset); |
| int out_fence_fd = 0; |
| crtc->out_fence_ptr.value = (uint64_t)&out_fence_fd; |
| set_crtc_props(crtc, ctx->pset); |
| ret |= test_and_commit(ctx, 1e6); |
| CHECK(out_fence_fd); |
| // |out_fence_fd| will signal when the currently scanned out buffers are replaced. |
| // In this case we're waiting with a timeout of 0 only to check that |out_fence_fd| |
| // is a valid fence. |
| CHECK(!sync_wait(out_fence_fd, 0)); |
| close(out_fence_fd); |
| return ret; |
| } |
| |
| static int test_plane_ctm(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| int ret = 0; |
| struct atomictest_plane *primary, *overlay; |
| |
| for (uint32_t i = 0; i < crtc->num_overlay; i++) { |
| overlay = get_plane(crtc, i, DRM_PLANE_TYPE_OVERLAY); |
| if (!overlay->ctm.pid) |
| continue; |
| |
| CHECK_RESULT(init_plane(ctx, overlay, DRM_FORMAT_XRGB8888, 0, 0, crtc->width, |
| crtc->height, crtc->crtc_id)); |
| |
| CHECK_RESULT(drmModeCreatePropertyBlob64( |
| ctx->fd, identity_ctm, sizeof(identity_ctm), &overlay->ctm.value)); |
| set_plane_props(overlay, ctx->pset); |
| CHECK_RESULT(draw_to_plane(ctx->mapper, overlay, DRAW_LINES)); |
| ret |= test_and_commit(ctx, 1e6); |
| CHECK_RESULT(drmModeDestroyPropertyBlob64(ctx->fd, overlay->ctm.value)); |
| |
| CHECK_RESULT(drmModeCreatePropertyBlob64( |
| ctx->fd, red_shift_ctm, sizeof(red_shift_ctm), &overlay->ctm.value)); |
| set_plane_props(overlay, ctx->pset); |
| ret |= test_and_commit(ctx, 1e6); |
| CHECK_RESULT(drmModeDestroyPropertyBlob64(ctx->fd, overlay->ctm.value)); |
| |
| CHECK_RESULT(disable_plane(ctx, overlay)); |
| } |
| |
| for (uint32_t i = 0; i < crtc->num_primary; i++) { |
| primary = get_plane(crtc, i, DRM_PLANE_TYPE_PRIMARY); |
| if (!primary->ctm.pid) |
| continue; |
| |
| CHECK_RESULT(init_plane_any_format(ctx, primary, 0, 0, crtc->width, crtc->height, |
| crtc->crtc_id, false)); |
| CHECK_RESULT(drmModeCreatePropertyBlob64( |
| ctx->fd, identity_ctm, sizeof(identity_ctm), &primary->ctm.value)); |
| set_plane_props(primary, ctx->pset); |
| CHECK_RESULT(draw_to_plane(ctx->mapper, primary, DRAW_LINES)); |
| ret |= test_and_commit(ctx, 1e6); |
| CHECK_RESULT(drmModeDestroyPropertyBlob64(ctx->fd, primary->ctm.value)); |
| |
| CHECK_RESULT(drmModeCreatePropertyBlob64( |
| ctx->fd, red_shift_ctm, sizeof(red_shift_ctm), &primary->ctm.value)); |
| set_plane_props(primary, ctx->pset); |
| ret |= test_and_commit(ctx, 1e6); |
| CHECK_RESULT(drmModeDestroyPropertyBlob64(ctx->fd, primary->ctm.value)); |
| |
| CHECK_RESULT(disable_plane(ctx, primary)); |
| } |
| |
| return ret; |
| } |
| |
| static int test_video_underlay(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| int ret = 0; |
| int i = 0; |
| struct atomictest_plane *underlay = 0; |
| struct atomictest_plane *primary = 0; |
| |
| for (; i < crtc->num_primary + crtc->num_overlay; ++i) { |
| if (crtc->planes[i].type.value != DRM_PLANE_TYPE_CURSOR) { |
| if (!underlay) { |
| underlay = &crtc->planes[i]; |
| } else { |
| primary = &crtc->planes[i]; |
| break; |
| } |
| } |
| } |
| if (!underlay || !primary) |
| return 0; |
| |
| if (init_plane_any_format(ctx, underlay, 0, 0, crtc->width >> 2, crtc->height >> 2, |
| crtc->crtc_id, true)) { |
| // Fall back to a non YUV format. |
| CHECK_RESULT(init_plane_any_format(ctx, underlay, 0, 0, crtc->width >> 2, |
| crtc->height >> 2, crtc->crtc_id, false)); |
| } |
| |
| CHECK_RESULT(draw_to_plane(ctx->mapper, underlay, DRAW_LINES)); |
| |
| CHECK_RESULT(init_plane(ctx, primary, DRM_FORMAT_ARGB8888, 0, 0, crtc->width, crtc->height, |
| crtc->crtc_id)); |
| CHECK_RESULT(draw_to_plane(ctx->mapper, primary, DRAW_TRANSPARENT_HOLE)); |
| |
| while (!move_plane(ctx, crtc, underlay, 50, 20)) |
| ret |= test_and_commit(ctx, 1e6 / 60); |
| |
| return ret; |
| } |
| |
| static int test_fullscreen_video(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| int ret = 0; |
| struct atomictest_plane *primary; |
| for (uint32_t i = 0; i < crtc->num_primary; i++) { |
| primary = get_plane(crtc, i, DRM_PLANE_TYPE_PRIMARY); |
| if (init_plane_any_format(ctx, primary, 0, 0, crtc->width, crtc->height, |
| crtc->crtc_id, true)) |
| continue; |
| |
| CHECK_RESULT(draw_to_plane(ctx->mapper, primary, DRAW_STRIPE)); |
| ret |= test_and_commit(ctx, 1e6); |
| } |
| |
| return ret; |
| } |
| |
| static int test_disable_primary(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| int ret = 0; |
| struct atomictest_plane *primary, *overlay; |
| for (uint32_t i = 0; i < crtc->num_primary; i++) { |
| for (uint32_t j = 0; j < crtc->num_overlay; j++) { |
| overlay = get_plane(crtc, j, DRM_PLANE_TYPE_OVERLAY); |
| uint32_t x = crtc->width >> (j + 2); |
| uint32_t y = crtc->height >> (j + 2); |
| x = MAX(x, ctx->res->min_width); |
| y = MAX(y, ctx->res->min_height); |
| CHECK_RESULT( |
| init_plane_any_format(ctx, overlay, x, y, x, y, crtc->crtc_id, false)); |
| CHECK_RESULT(draw_to_plane(ctx->mapper, overlay, DRAW_LINES)); |
| } |
| |
| primary = get_plane(crtc, i, DRM_PLANE_TYPE_PRIMARY); |
| CHECK_RESULT(init_plane_any_format(ctx, primary, 0, 0, crtc->width, crtc->height, |
| crtc->crtc_id, false)); |
| CHECK_RESULT(draw_to_plane(ctx->mapper, primary, DRAW_ELLIPSE)); |
| ret |= test_and_commit(ctx, 1e6); |
| |
| /* Disable primary plane. */ |
| disable_plane(ctx, primary); |
| ret |= test_and_commit(ctx, 1e6); |
| } |
| |
| return ret; |
| } |
| |
| static int test_rgba_primary(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| int ret = 0; |
| struct atomictest_plane *primary; |
| for (uint32_t i = 0; i < crtc->num_primary; i++) { |
| primary = get_plane(crtc, i, DRM_PLANE_TYPE_PRIMARY); |
| bool has_argb = false; |
| for (uint32_t i = 0; i < primary->drm_plane.count_formats; ++i) { |
| if (primary->drm_plane.formats[i] == DRM_FORMAT_ARGB8888) { |
| has_argb = true; |
| break; |
| } |
| } |
| if (!has_argb) |
| return 0; |
| |
| CHECK_RESULT(init_plane(ctx, primary, DRM_FORMAT_ARGB8888, 0, 0, crtc->width, |
| crtc->height, crtc->crtc_id)); |
| |
| CHECK_RESULT(draw_to_plane(ctx->mapper, primary, DRAW_LINES)); |
| |
| ret |= test_and_commit(ctx, 1e6); |
| } |
| |
| return ret; |
| } |
| |
| static int test_overlay_pageflip(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| struct atomictest_plane *overlay; |
| for (uint32_t i = 0; i < crtc->num_overlay; i++) { |
| overlay = get_plane(crtc, i, DRM_PLANE_TYPE_OVERLAY); |
| CHECK_RESULT(pageflip_formats(ctx, crtc, overlay)); |
| } |
| |
| return 0; |
| } |
| |
| static int test_overlay_downscaling(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| int ret = 0; |
| struct atomictest_plane *overlay; |
| uint32_t w = BS_ALIGN(crtc->width / 2, 2); |
| uint32_t h = BS_ALIGN(crtc->height / 2, 2); |
| for (uint32_t i = 0; i < crtc->num_overlay; i++) { |
| overlay = get_plane(crtc, i, DRM_PLANE_TYPE_OVERLAY); |
| if (init_plane_any_format(ctx, overlay, 0, 0, w, h, crtc->crtc_id, true)) |
| CHECK_RESULT(init_plane(ctx, overlay, DRM_FORMAT_XRGB8888, 0, 0, w, h, |
| crtc->crtc_id)); |
| CHECK_RESULT(draw_to_plane(ctx->mapper, overlay, DRAW_LINES)); |
| ret |= test_and_commit(ctx, 1e6); |
| |
| while (!scale_plane(ctx, crtc, overlay, -.1f, -.1f) && !test_commit(ctx)) { |
| CHECK_RESULT(commit(ctx)); |
| usleep(1e6); |
| } |
| |
| disable_plane(ctx, overlay); |
| } |
| |
| return ret; |
| } |
| |
| static int test_overlay_upscaling(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| int ret = 0; |
| struct atomictest_plane *overlay; |
| uint32_t w = BS_ALIGN(crtc->width / 4, 2); |
| uint32_t h = BS_ALIGN(crtc->height / 4, 2); |
| for (uint32_t i = 0; i < crtc->num_overlay; i++) { |
| overlay = get_plane(crtc, i, DRM_PLANE_TYPE_OVERLAY); |
| if (init_plane_any_format(ctx, overlay, 0, 0, w, h, crtc->crtc_id, true)) |
| CHECK_RESULT(init_plane(ctx, overlay, DRM_FORMAT_XRGB8888, 0, 0, w, h, |
| crtc->crtc_id)); |
| CHECK_RESULT(draw_to_plane(ctx->mapper, overlay, DRAW_LINES)); |
| ret |= test_and_commit(ctx, 1e6); |
| |
| while (!scale_plane(ctx, crtc, overlay, .1f, .1f) && !test_commit(ctx)) { |
| CHECK_RESULT(commit(ctx)); |
| usleep(1e6); |
| } |
| |
| disable_plane(ctx, overlay); |
| } |
| |
| return ret; |
| } |
| |
| static int test_primary_pageflip(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| struct atomictest_plane *primary; |
| for (uint32_t i = 0; i < crtc->num_primary; i++) { |
| primary = get_plane(crtc, i, DRM_PLANE_TYPE_PRIMARY); |
| CHECK_RESULT(pageflip_formats(ctx, crtc, primary)); |
| } |
| |
| return 0; |
| } |
| |
| static int test_crtc_ctm(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| int ret = 0; |
| struct atomictest_plane *primary; |
| if (!crtc->ctm.pid) |
| return 0; |
| |
| CHECK_RESULT(drmModeCreatePropertyBlob64(ctx->fd, identity_ctm, sizeof(identity_ctm), |
| &crtc->ctm.value)); |
| set_crtc_props(crtc, ctx->pset); |
| for (uint32_t i = 0; i < crtc->num_primary; i++) { |
| primary = get_plane(crtc, i, DRM_PLANE_TYPE_PRIMARY); |
| |
| CHECK_RESULT(init_plane(ctx, primary, DRM_FORMAT_XRGB8888, 0, 0, crtc->width, |
| crtc->height, crtc->crtc_id)); |
| CHECK_RESULT(draw_to_plane(ctx->mapper, primary, DRAW_LINES)); |
| ret |= test_and_commit(ctx, 1e6); |
| |
| primary->crtc_id.value = 0; |
| CHECK_RESULT(set_plane_props(primary, ctx->pset)); |
| } |
| |
| CHECK_RESULT(drmModeDestroyPropertyBlob64(ctx->fd, crtc->ctm.value)); |
| |
| CHECK_RESULT(drmModeCreatePropertyBlob64(ctx->fd, red_shift_ctm, sizeof(red_shift_ctm), |
| &crtc->ctm.value)); |
| set_crtc_props(crtc, ctx->pset); |
| for (uint32_t i = 0; i < crtc->num_primary; i++) { |
| primary = get_plane(crtc, i, DRM_PLANE_TYPE_PRIMARY); |
| primary->crtc_id.value = crtc->crtc_id; |
| CHECK_RESULT(set_plane_props(primary, ctx->pset)); |
| |
| ret |= test_and_commit(ctx, 1e6); |
| |
| primary->crtc_id.value = 0; |
| CHECK_RESULT(disable_plane(ctx, primary)); |
| } |
| |
| CHECK_RESULT(drmModeDestroyPropertyBlob64(ctx->fd, crtc->ctm.value)); |
| |
| return ret; |
| } |
| |
| static void gamma_linear(struct drm_color_lut *table, int size) |
| { |
| for (int i = 0; i < size; i++) { |
| float v = (float)(i) / (float)(size - 1); |
| v *= (float)GAMMA_MAX_VALUE; |
| table[i].red = (uint16_t)v; |
| table[i].green = (uint16_t)v; |
| table[i].blue = (uint16_t)v; |
| } |
| } |
| |
| static void gamma_step(struct drm_color_lut *table, int size) |
| { |
| for (int i = 0; i < size; i++) { |
| float v = (i < size / 2) ? 0 : GAMMA_MAX_VALUE; |
| table[i].red = (uint16_t)v; |
| table[i].green = (uint16_t)v; |
| table[i].blue = (uint16_t)v; |
| } |
| } |
| |
| static int test_crtc_gamma(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| int ret = 0; |
| struct atomictest_plane *primary; |
| if (!crtc->gamma_lut.pid || !crtc->gamma_lut_size.pid) |
| return 0; |
| |
| if (crtc->gamma_lut_size.value == 0) |
| return 0; |
| |
| struct drm_color_lut *gamma_table = |
| calloc(crtc->gamma_lut_size.value, sizeof(*gamma_table)); |
| |
| gamma_linear(gamma_table, crtc->gamma_lut_size.value); |
| CHECK_RESULT(drmModeCreatePropertyBlob64( |
| ctx->fd, gamma_table, sizeof(struct drm_color_lut) * crtc->gamma_lut_size.value, |
| &crtc->gamma_lut.value)); |
| set_crtc_props(crtc, ctx->pset); |
| |
| for (uint32_t i = 0; i < crtc->num_primary; i++) { |
| primary = get_plane(crtc, i, DRM_PLANE_TYPE_PRIMARY); |
| |
| CHECK_RESULT(init_plane(ctx, primary, DRM_FORMAT_XRGB8888, 0, 0, crtc->width, |
| crtc->height, crtc->crtc_id)); |
| |
| CHECK_RESULT(draw_to_plane(ctx->mapper, primary, DRAW_STRIPE)); |
| ret |= test_and_commit(ctx, 1e6); |
| |
| CHECK_RESULT(disable_plane(ctx, primary)); |
| } |
| |
| CHECK_RESULT(drmModeDestroyPropertyBlob(ctx->fd, crtc->gamma_lut.value)); |
| |
| gamma_step(gamma_table, crtc->gamma_lut_size.value); |
| CHECK_RESULT(drmModeCreatePropertyBlob64( |
| ctx->fd, gamma_table, sizeof(struct drm_color_lut) * crtc->gamma_lut_size.value, |
| &crtc->gamma_lut.value)); |
| set_crtc_props(crtc, ctx->pset); |
| |
| for (uint32_t i = 0; i < crtc->num_primary; i++) { |
| primary = get_plane(crtc, i, DRM_PLANE_TYPE_PRIMARY); |
| |
| CHECK_RESULT(init_plane(ctx, primary, DRM_FORMAT_XRGB8888, 0, 0, crtc->width, |
| crtc->height, crtc->crtc_id)); |
| |
| CHECK_RESULT(draw_to_plane(ctx->mapper, primary, DRAW_STRIPE)); |
| ret |= test_and_commit(ctx, 1e6); |
| |
| CHECK_RESULT(disable_plane(ctx, primary)); |
| } |
| |
| CHECK_RESULT(drmModeDestroyPropertyBlob(ctx->fd, crtc->gamma_lut.value)); |
| free(gamma_table); |
| |
| return ret; |
| } |
| |
| static inline uint64_t pack_rgba_64(uint64_t red, uint64_t green, uint64_t blue, uint64_t alpha) |
| { |
| return alpha << 48 | blue << 32 | green << 16 | red; |
| } |
| |
| static int test_crtc_background_color(struct atomictest_context *ctx, struct atomictest_crtc *crtc) |
| { |
| int ret = 0; |
| |
| if (!crtc->background_color.pid) |
| return 0; |
| |
| struct crtc_background_color { |
| const char *name; |
| uint64_t rgba_value; |
| }; |
| |
| const struct crtc_background_color colors[] = { |
| { "black", pack_rgba_64(0, 0, 0, 0xffff) }, |
| { "red", pack_rgba_64(0xffff, 0, 0, 0xffff) }, |
| { "green", pack_rgba_64(0, 0xffff, 0, 0xffff) }, |
| { "blue", pack_rgba_64(0, 0, 0xffff, 0xffff) }, |
| }; |
| |
| for (int i = 0; i < BS_ARRAY_LEN(colors); i++) { |
| crtc->background_color.value = colors[i].rgba_value; |
| set_crtc_props(crtc, ctx->pset); |
| ret |= test_and_commit(ctx, 1e6); |
| } |
| |
| return ret; |
| } |
| |
| static const struct atomictest_testcase cases[] = { |
| { "disable_primary", test_disable_primary }, |
| { "rgba_primary", test_rgba_primary }, |
| { "fullscreen_video", test_fullscreen_video }, |
| { "multiple_planes", test_multiple_planes }, |
| { "overlay_pageflip", test_overlay_pageflip }, |
| { "overlay_downscaling", test_overlay_downscaling }, |
| { "overlay_upscaling", test_overlay_upscaling }, |
| { "primary_pageflip", test_primary_pageflip }, |
| { "video_overlay", test_video_overlay }, |
| { "orientation", test_orientation }, |
| { "video_underlay", test_video_underlay }, |
| { "in_fence", test_in_fence }, |
| { "out_fence", test_out_fence }, |
| /* CTM stands for Color Transform Matrix. */ |
| { "plane_ctm", test_plane_ctm }, |
| { "plane_alpha", test_plane_alpha }, |
| { "crtc_ctm", test_crtc_ctm }, |
| { "crtc_gamma", test_crtc_gamma }, |
| { "crtc_background_color", test_crtc_background_color }, |
| }; |
| |
| static int run_testcase(struct atomictest_context *ctx, struct atomictest_crtc *crtc, |
| test_function func) |
| { |
| int cursor = drmModeAtomicGetCursor(ctx->pset); |
| uint32_t num_planes = crtc->num_primary + crtc->num_cursor + crtc->num_overlay; |
| |
| int ret = func(ctx, crtc); |
| |
| for (uint32_t i = 0; i < num_planes; i++) |
| disable_plane(ctx, &crtc->planes[i]); |
| |
| drmModeAtomicSetCursor(ctx->pset, cursor); |
| |
| CHECK_RESULT(commit(ctx)); |
| usleep(1e6 / 60); |
| |
| return ret; |
| } |
| |
| static int run_atomictest(const char *name, uint32_t crtc_mask, uint64_t modifier) |
| { |
| int ret = 0; |
| uint32_t num_run = 0; |
| int fd = bs_drm_open_main_display(); |
| CHECK_RESULT(fd); |
| |
| gbm = gbm_create_device(fd); |
| if (!gbm) { |
| bs_debug_error("failed to create gbm device"); |
| ret = -1; |
| goto destroy_fd; |
| } |
| |
| ret = drmSetClientCap(fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1); |
| if (ret) { |
| bs_debug_error("failed to enable DRM_CLIENT_CAP_UNIVERSAL_PLANES"); |
| ret = -1; |
| goto destroy_gbm_device; |
| } |
| |
| ret = drmSetClientCap(fd, DRM_CLIENT_CAP_ATOMIC, 1); |
| if (ret) { |
| bs_debug_warning("failed to enable DRM_CLIENT_CAP_ATOMIC"); |
| /* We want to allow per-board disabling of atomic */ |
| ret = 0; |
| goto destroy_gbm_device; |
| } |
| |
| struct atomictest_context *ctx = query_kms(fd); |
| if (!ctx) { |
| bs_debug_error("querying atomictest failed."); |
| ret = -1; |
| goto destroy_gbm_device; |
| } |
| |
| ctx->modifier = modifier; |
| struct atomictest_crtc *crtc; |
| /* Disable all CRTCs first, in case there are any dangling connections. */ |
| disable_crtcs(ctx, ~0); |
| for (uint32_t crtc_index = 0; crtc_index < ctx->num_crtcs; crtc_index++) { |
| crtc = &ctx->crtcs[crtc_index]; |
| if (!((1 << crtc_index) & crtc_mask)) |
| continue; |
| |
| for (uint32_t i = 0; i < BS_ARRAY_LEN(cases); i++) { |
| if (strcmp(cases[i].name, name) && strcmp("all", name)) |
| continue; |
| |
| num_run++; |
| ret = enable_crtc(ctx, crtc); |
| if (ret) |
| continue; |
| |
| ret = run_testcase(ctx, crtc, cases[i].test_func); |
| if (ret < 0) |
| goto out; |
| else if (ret == TEST_COMMIT_FAIL) |
| bs_debug_warning("%s failed test commit, testcase not run.", |
| cases[i].name); |
| |
| ret = disable_crtc(ctx, crtc); |
| if (ret) |
| goto out; |
| } |
| } |
| |
| ret = (num_run == 0); |
| |
| out: |
| free_context(ctx); |
| destroy_gbm_device: |
| gbm_device_destroy(gbm); |
| destroy_fd: |
| close(fd); |
| |
| return ret; |
| } |
| |
| static const struct option longopts[] = { |
| { "crtc", required_argument, NULL, 'c' }, { "test_name", required_argument, NULL, 't' }, |
| { "help", no_argument, NULL, 'h' }, { "automatic", no_argument, NULL, 'a' }, |
| { "modifier", required_argument, NULL, 'm' }, { 0, 0, 0, 0 }, |
| }; |
| |
| static void print_help(const char *argv0) |
| { |
| printf("usage: %s [OPTIONS]\n", argv0); |
| printf(" -t, --test_name <test_name> name of test to run.\n"); |
| printf(" -c, --crtc <crtc_index> index of crtc to run against.\n"); |
| printf(" -a, --automatic don't sleep between tests.\n"); |
| printf(" -m, --modifier <modifier> pass modifiers.\n"); |
| printf(" <test_name> is one the following:\n"); |
| for (uint32_t i = 0; i < BS_ARRAY_LEN(cases); i++) |
| printf(" %s\n", cases[i].name); |
| printf(" all\n"); |
| |
| int fd = bs_drm_open_main_display(); |
| if (fd) { |
| printf(" <modifier> must be one of "); |
| bs_print_supported_modifiers(fd); |
| close(fd); |
| } else { |
| printf("unable to show supported modifiers\n"); |
| } |
| } |
| |
| int main(int argc, char **argv) |
| { |
| int c; |
| char *name = NULL; |
| int32_t crtc_idx = -1; |
| uint32_t crtc_mask = ~0; |
| uint64_t modifier = DRM_FORMAT_MOD_INVALID; |
| while ((c = getopt_long(argc, argv, "c:t:h:am:", longopts, NULL)) != -1) { |
| switch (c) { |
| case 'a': |
| automatic = true; |
| break; |
| case 'c': |
| if (sscanf(optarg, "%d", &crtc_idx) != 1) |
| goto print; |
| break; |
| case 't': |
| if (name) { |
| free(name); |
| name = NULL; |
| } |
| |
| name = strdup(optarg); |
| break; |
| case 'm': |
| modifier = bs_string_to_modifier(optarg); |
| if (modifier == -1) { |
| bs_debug_error("unsupported modifier: %s", optarg); |
| goto print; |
| } |
| break; |
| case 'h': |
| goto print; |
| default: |
| goto print; |
| } |
| } |
| |
| if (!name) |
| goto print; |
| |
| if (crtc_idx >= 0) |
| crtc_mask = 1 << crtc_idx; |
| |
| int ret = run_atomictest(name, crtc_mask, modifier); |
| if (ret == 0) |
| printf("[ PASSED ] atomictest.%s\n", name); |
| else if (ret < 0) |
| printf("[ FAILED ] atomictest.%s\n", name); |
| |
| free(name); |
| |
| if (ret > 0) |
| goto print; |
| |
| return ret; |
| |
| print: |
| print_help(argv[0]); |
| return 0; |
| } |