Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Copyright © 2016 Intel Corporation |
| 3 | * |
| 4 | * Permission is hereby granted, free of charge, to any person obtaining a |
| 5 | * copy of this software and associated documentation files (the "Software"), |
| 6 | * to deal in the Software without restriction, including without limitation |
| 7 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 8 | * and/or sell copies of the Software, and to permit persons to whom the |
| 9 | * Software is furnished to do so, subject to the following conditions: |
| 10 | * |
| 11 | * The above copyright notice and this permission notice (including the next |
| 12 | * paragraph) shall be included in all copies or substantial portions of the |
| 13 | * Software. |
| 14 | * |
| 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 18 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| 20 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| 21 | * IN THE SOFTWARE. |
| 22 | * |
| 23 | */ |
| 24 | |
| 25 | #include "igt.h" |
| 26 | #include "drmtest.h" |
| 27 | #include <errno.h> |
| 28 | #include <stdbool.h> |
| 29 | #include <stdio.h> |
| 30 | #include <string.h> |
| 31 | #include <time.h> |
| 32 | |
| 33 | IGT_TEST_DESCRIPTION("Test atomic mode setting with multiple planes "); |
| 34 | |
Mika Kahola | 834bea0 | 2017-01-16 14:39:19 +0200 | [diff] [blame] | 35 | #define MAX_CRCS 2 |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 36 | #define SIZE_PLANE 256 |
| 37 | #define SIZE_CURSOR 128 |
| 38 | #define LOOP_FOREVER -1 |
| 39 | |
| 40 | typedef struct { |
| 41 | float red; |
| 42 | float green; |
| 43 | float blue; |
| 44 | } color_t; |
| 45 | |
| 46 | typedef struct { |
| 47 | int drm_fd; |
| 48 | igt_display_t display; |
| 49 | igt_pipe_crc_t *pipe_crc; |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 50 | igt_plane_t **plane; |
| 51 | struct igt_fb *fb; |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 52 | } data_t; |
| 53 | |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 54 | /* Command line parameters. */ |
| 55 | struct { |
| 56 | int iterations; |
| 57 | bool user_seed; |
| 58 | int seed; |
| 59 | } opt = { |
Mika Kahola | 04cd372 | 2017-01-12 12:52:49 +0200 | [diff] [blame] | 60 | .iterations = 1, |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 61 | .user_seed = false, |
| 62 | .seed = 1, |
| 63 | }; |
| 64 | |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 65 | /* |
| 66 | * Common code across all tests, acting on data_t |
| 67 | */ |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 68 | static void test_init(data_t *data, enum pipe pipe, int n_planes) |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 69 | { |
Chris Wilson | 83884e9 | 2017-03-21 17:16:03 +0000 | [diff] [blame] | 70 | data->pipe_crc = igt_pipe_crc_new(data->drm_fd, pipe, INTEL_PIPE_CRC_SOURCE_AUTO); |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 71 | |
| 72 | data->plane = calloc(n_planes, sizeof(data->plane)); |
| 73 | igt_assert_f(data->plane != NULL, "Failed to allocate memory for planes\n"); |
| 74 | |
| 75 | data->fb = calloc(n_planes, sizeof(struct igt_fb)); |
| 76 | igt_assert_f(data->fb != NULL, "Failed to allocate memory for FBs\n"); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 77 | } |
| 78 | |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 79 | static void test_fini(data_t *data, igt_output_t *output, int n_planes) |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 80 | { |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 81 | for (int i = 0; i < n_planes; i++) { |
| 82 | igt_plane_t *plane = data->plane[i]; |
| 83 | if (!plane) |
| 84 | continue; |
| 85 | if (plane->type == DRM_PLANE_TYPE_PRIMARY) |
| 86 | continue; |
| 87 | igt_plane_set_fb(plane, NULL); |
| 88 | data->plane[i] = NULL; |
| 89 | } |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 90 | |
| 91 | /* reset the constraint on the pipe */ |
| 92 | igt_output_set_pipe(output, PIPE_ANY); |
| 93 | |
| 94 | igt_pipe_crc_free(data->pipe_crc); |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 95 | |
| 96 | free(data->plane); |
| 97 | data->plane = NULL; |
| 98 | free(data->fb); |
| 99 | data->fb = NULL; |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 100 | } |
| 101 | |
| 102 | static void |
| 103 | test_grab_crc(data_t *data, igt_output_t *output, enum pipe pipe, bool atomic, |
Mika Kahola | 8d4ddae | 2017-08-02 16:20:55 +0300 | [diff] [blame] | 104 | color_t *color, uint64_t tiling, igt_crc_t **crc /* out */) |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 105 | { |
| 106 | drmModeModeInfo *mode; |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 107 | igt_plane_t *primary; |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 108 | int ret, n; |
| 109 | |
| 110 | igt_output_set_pipe(output, pipe); |
| 111 | |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 112 | primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY); |
| 113 | data->plane[primary->index] = primary; |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 114 | |
| 115 | mode = igt_output_get_mode(output); |
| 116 | |
| 117 | igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay, |
| 118 | DRM_FORMAT_XRGB8888, |
| 119 | LOCAL_DRM_FORMAT_MOD_NONE, |
| 120 | color->red, color->green, color->blue, |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 121 | &data->fb[primary->index]); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 122 | |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 123 | igt_plane_set_fb(data->plane[primary->index], &data->fb[primary->index]); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 124 | |
| 125 | ret = igt_display_try_commit2(&data->display, |
| 126 | atomic ? COMMIT_ATOMIC : COMMIT_LEGACY); |
| 127 | igt_skip_on(ret != 0); |
| 128 | |
| 129 | igt_pipe_crc_start(data->pipe_crc); |
Mika Kahola | 8d4ddae | 2017-08-02 16:20:55 +0300 | [diff] [blame] | 130 | n = igt_pipe_crc_get_crcs(data->pipe_crc, 1, crc); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 131 | igt_assert_eq(n, 1); |
| 132 | } |
| 133 | |
| 134 | /* |
| 135 | * Multiple plane position test. |
| 136 | * - We start by grabbing a reference CRC of a full blue fb being scanned |
| 137 | * out on the primary plane |
| 138 | * - Then we scannout number of planes: |
| 139 | * * the primary plane uses a blue fb with a black rectangle hole |
| 140 | * * planes, on top of the primary plane, with a blue fb that is set-up |
| 141 | * to cover the black rectangles of the primary plane fb |
| 142 | * The resulting CRC should be identical to the reference CRC |
| 143 | */ |
| 144 | |
| 145 | static void |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 146 | create_fb_for_mode_position(data_t *data, igt_output_t *output, drmModeModeInfo *mode, |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 147 | color_t *color, int *rect_x, int *rect_y, |
| 148 | int *rect_w, int *rect_h, uint64_t tiling, |
| 149 | int max_planes) |
| 150 | { |
| 151 | unsigned int fb_id; |
| 152 | cairo_t *cr; |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 153 | igt_plane_t *primary; |
| 154 | |
| 155 | primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 156 | |
| 157 | fb_id = igt_create_fb(data->drm_fd, |
| 158 | mode->hdisplay, mode->vdisplay, |
| 159 | DRM_FORMAT_XRGB8888, |
| 160 | tiling, |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 161 | &data->fb[primary->index]); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 162 | igt_assert(fb_id); |
| 163 | |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 164 | cr = igt_get_cairo_ctx(data->drm_fd, &data->fb[primary->index]); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 165 | igt_paint_color(cr, rect_x[0], rect_y[0], |
| 166 | mode->hdisplay, mode->vdisplay, |
| 167 | color->red, color->green, color->blue); |
| 168 | |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 169 | for (int i = 0; i < max_planes; i++) { |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 170 | if (data->plane[i]->type == DRM_PLANE_TYPE_PRIMARY) |
| 171 | continue; |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 172 | igt_paint_color(cr, rect_x[i], rect_y[i], |
| 173 | rect_w[i], rect_h[i], 0.0, 0.0, 0.0); |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 174 | } |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 175 | |
Maarten Lankhorst | be2f6fc | 2018-02-01 12:48:45 +0100 | [diff] [blame^] | 176 | igt_put_cairo_ctx(data->drm_fd, &data->fb[primary->index], cr); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 177 | } |
| 178 | |
| 179 | |
| 180 | static void |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 181 | prepare_planes(data_t *data, enum pipe pipe_id, color_t *color, |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 182 | uint64_t tiling, int max_planes, igt_output_t *output) |
| 183 | { |
| 184 | drmModeModeInfo *mode; |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 185 | igt_pipe_t *pipe; |
| 186 | igt_plane_t *primary; |
| 187 | int *x; |
| 188 | int *y; |
| 189 | int *size; |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 190 | int i; |
| 191 | |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 192 | igt_output_set_pipe(output, pipe_id); |
| 193 | primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY); |
| 194 | pipe = primary->pipe; |
| 195 | |
| 196 | x = malloc(pipe->n_planes * sizeof(*x)); |
| 197 | igt_assert_f(x, "Failed to allocate %ld bytes for variable x\n", (long int) (pipe->n_planes * sizeof(*x))); |
| 198 | y = malloc(pipe->n_planes * sizeof(*y)); |
| 199 | igt_assert_f(y, "Failed to allocate %ld bytes for variable y\n", (long int) (pipe->n_planes * sizeof(*y))); |
| 200 | size = malloc(pipe->n_planes * sizeof(*size)); |
| 201 | igt_assert_f(size, "Failed to allocate %ld bytes for variable size\n", (long int) (pipe->n_planes * sizeof(*size))); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 202 | |
| 203 | mode = igt_output_get_mode(output); |
| 204 | |
| 205 | /* planes with random positions */ |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 206 | x[primary->index] = 0; |
| 207 | y[primary->index] = 0; |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 208 | for (i = 0; i < max_planes; i++) { |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 209 | igt_plane_t *plane = igt_output_get_plane(output, i); |
| 210 | |
| 211 | if (plane->type == DRM_PLANE_TYPE_PRIMARY) |
| 212 | continue; |
| 213 | else if (plane->type == DRM_PLANE_TYPE_CURSOR) |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 214 | size[i] = SIZE_CURSOR; |
| 215 | else |
| 216 | size[i] = SIZE_PLANE; |
| 217 | |
| 218 | x[i] = rand() % (mode->hdisplay - size[i]); |
| 219 | y[i] = rand() % (mode->vdisplay - size[i]); |
| 220 | |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 221 | data->plane[i] = plane; |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 222 | |
| 223 | igt_create_color_fb(data->drm_fd, |
| 224 | size[i], size[i], |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 225 | data->plane[i]->type == DRM_PLANE_TYPE_CURSOR ? DRM_FORMAT_ARGB8888 : DRM_FORMAT_XRGB8888, |
| 226 | data->plane[i]->type == DRM_PLANE_TYPE_CURSOR ? LOCAL_DRM_FORMAT_MOD_NONE : tiling, |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 227 | color->red, color->green, color->blue, |
| 228 | &data->fb[i]); |
| 229 | |
| 230 | igt_plane_set_position(data->plane[i], x[i], y[i]); |
| 231 | igt_plane_set_fb(data->plane[i], &data->fb[i]); |
| 232 | } |
| 233 | |
| 234 | /* primary plane */ |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 235 | data->plane[primary->index] = primary; |
| 236 | create_fb_for_mode_position(data, output, mode, color, x, y, |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 237 | size, size, tiling, max_planes); |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 238 | igt_plane_set_fb(data->plane[primary->index], &data->fb[primary->index]); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 239 | } |
| 240 | |
| 241 | static void |
| 242 | test_atomic_plane_position_with_output(data_t *data, enum pipe pipe, |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 243 | igt_output_t *output, int n_planes, |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 244 | uint64_t tiling) |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 245 | { |
| 246 | char buf[256]; |
| 247 | struct drm_event *e = (void *)buf; |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 248 | color_t blue = { 0.0f, 0.0f, 1.0f }; |
Mika Kahola | 8d4ddae | 2017-08-02 16:20:55 +0300 | [diff] [blame] | 249 | igt_crc_t *ref = NULL; |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 250 | igt_crc_t *crc = NULL; |
Mika Kahola | 834bea0 | 2017-01-16 14:39:19 +0200 | [diff] [blame] | 251 | unsigned int vblank_start, vblank_stop; |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 252 | int i, n, ret; |
| 253 | int iterations = opt.iterations < 1 ? 1 : opt.iterations; |
| 254 | bool loop_forever; |
| 255 | char info[256]; |
| 256 | |
| 257 | if (opt.iterations == LOOP_FOREVER) { |
| 258 | loop_forever = true; |
| 259 | sprintf(info, "forever"); |
| 260 | } else { |
| 261 | loop_forever = false; |
| 262 | sprintf(info, "for %d %s", |
| 263 | iterations, iterations > 1 ? "iterations" : "iteration"); |
| 264 | } |
| 265 | |
| 266 | igt_info("Testing connector %s using pipe %s with %d planes %s with seed %d\n", |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 267 | igt_output_name(output), kmstest_pipe_name(pipe), n_planes, |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 268 | info, opt.seed); |
| 269 | |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 270 | test_init(data, pipe, n_planes); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 271 | |
Mika Kahola | 8d4ddae | 2017-08-02 16:20:55 +0300 | [diff] [blame] | 272 | test_grab_crc(data, output, pipe, true, &blue, tiling, &ref); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 273 | |
| 274 | i = 0; |
| 275 | while (i < iterations || loop_forever) { |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 276 | prepare_planes(data, pipe, &blue, tiling, n_planes, output); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 277 | |
Mika Kahola | 8d14370 | 2017-01-16 13:53:40 +0200 | [diff] [blame] | 278 | vblank_start = kmstest_get_vblank(data->display.drm_fd, pipe, |
| 279 | DRM_VBLANK_NEXTONMISS); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 280 | |
| 281 | igt_display_commit_atomic(&data->display, |
| 282 | DRM_MODE_PAGE_FLIP_EVENT, |
| 283 | &data->display); |
| 284 | |
| 285 | igt_set_timeout(1, "Stuck on page flip"); |
| 286 | |
| 287 | ret = read(data->display.drm_fd, buf, sizeof(buf)); |
| 288 | igt_assert(ret >= 0); |
| 289 | |
Mika Kahola | 8d14370 | 2017-01-16 13:53:40 +0200 | [diff] [blame] | 290 | vblank_stop = kmstest_get_vblank(data->display.drm_fd, pipe, 0); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 291 | igt_assert_eq(e->type, DRM_EVENT_FLIP_COMPLETE); |
| 292 | igt_reset_timeout(); |
| 293 | |
Mika Kahola | 834bea0 | 2017-01-16 14:39:19 +0200 | [diff] [blame] | 294 | n = igt_pipe_crc_get_crcs(data->pipe_crc, vblank_stop - vblank_start, &crc); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 295 | |
Mika Kahola | 834bea0 | 2017-01-16 14:39:19 +0200 | [diff] [blame] | 296 | igt_assert(vblank_stop - vblank_start <= MAX_CRCS); |
| 297 | igt_assert_eq(n, vblank_stop - vblank_start); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 298 | |
Mika Kahola | 8d4ddae | 2017-08-02 16:20:55 +0300 | [diff] [blame] | 299 | igt_assert_crc_equal(ref, crc); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 300 | |
| 301 | i++; |
| 302 | } |
| 303 | |
| 304 | igt_pipe_crc_stop(data->pipe_crc); |
| 305 | |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 306 | test_fini(data, output, n_planes); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 307 | } |
| 308 | |
| 309 | static void |
| 310 | test_legacy_plane_position_with_output(data_t *data, enum pipe pipe, |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 311 | igt_output_t *output, int n_planes, |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 312 | uint64_t tiling) |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 313 | { |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 314 | color_t blue = { 0.0f, 0.0f, 1.0f }; |
Mika Kahola | 8d4ddae | 2017-08-02 16:20:55 +0300 | [diff] [blame] | 315 | igt_crc_t *ref = NULL; |
| 316 | igt_crc_t *crc = NULL; |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 317 | int i, n; |
| 318 | int iterations = opt.iterations < 1 ? 1 : opt.iterations; |
| 319 | bool loop_forever; |
| 320 | char info[256]; |
| 321 | |
| 322 | if (opt.iterations == LOOP_FOREVER) { |
| 323 | loop_forever = true; |
| 324 | sprintf(info, "forever"); |
| 325 | } else { |
| 326 | loop_forever = false; |
| 327 | sprintf(info, "for %d %s", |
| 328 | iterations, iterations > 1 ? "iterations" : "iteration"); |
| 329 | } |
| 330 | |
| 331 | igt_info("Testing connector %s using pipe %s with %d planes %s with seed %d\n", |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 332 | igt_output_name(output), kmstest_pipe_name(pipe), n_planes, |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 333 | info, opt.seed); |
| 334 | |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 335 | test_init(data, pipe, n_planes); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 336 | |
Mika Kahola | 8d4ddae | 2017-08-02 16:20:55 +0300 | [diff] [blame] | 337 | test_grab_crc(data, output, pipe, false, &blue, tiling, &ref); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 338 | |
| 339 | i = 0; |
| 340 | while (i < iterations || loop_forever) { |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 341 | prepare_planes(data, pipe, &blue, tiling, n_planes, output); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 342 | |
| 343 | igt_display_commit2(&data->display, COMMIT_LEGACY); |
| 344 | |
| 345 | n = igt_pipe_crc_get_crcs(data->pipe_crc, MAX_CRCS, &crc); |
| 346 | |
| 347 | igt_assert_eq(n, MAX_CRCS); |
| 348 | |
Mika Kahola | 8d4ddae | 2017-08-02 16:20:55 +0300 | [diff] [blame] | 349 | igt_assert_crc_equal(ref, crc); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 350 | |
| 351 | i++; |
| 352 | } |
| 353 | |
| 354 | igt_pipe_crc_stop(data->pipe_crc); |
| 355 | |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 356 | test_fini(data, output, n_planes); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 357 | } |
| 358 | |
| 359 | static void |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 360 | test_plane_position(data_t *data, enum pipe pipe, bool atomic, uint64_t tiling) |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 361 | { |
| 362 | igt_output_t *output; |
| 363 | int connected_outs; |
Mika Kahola | 3e2a753 | 2016-11-29 15:45:23 +0200 | [diff] [blame] | 364 | int devid = intel_get_drm_devid(data->drm_fd); |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 365 | int n_planes = data->display.pipes[pipe].n_planes; |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 366 | |
| 367 | if (atomic) |
| 368 | igt_require(data->display.is_atomic); |
| 369 | |
Mika Kahola | 3e2a753 | 2016-11-29 15:45:23 +0200 | [diff] [blame] | 370 | if ((tiling == LOCAL_I915_FORMAT_MOD_Y_TILED || |
| 371 | tiling == LOCAL_I915_FORMAT_MOD_Yf_TILED)) |
| 372 | igt_require(AT_LEAST_GEN(devid, 9)); |
| 373 | |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 374 | if (!opt.user_seed) |
| 375 | opt.seed = time(NULL); |
| 376 | |
| 377 | srand(opt.seed); |
| 378 | |
| 379 | connected_outs = 0; |
Maarten Lankhorst | dea85f6 | 2017-01-12 13:51:14 +0100 | [diff] [blame] | 380 | for_each_valid_output_on_pipe(&data->display, pipe, output) { |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 381 | if (atomic) |
| 382 | test_atomic_plane_position_with_output(data, pipe, |
| 383 | output, |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 384 | n_planes, |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 385 | tiling); |
| 386 | else |
| 387 | test_legacy_plane_position_with_output(data, pipe, |
| 388 | output, |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 389 | n_planes, |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 390 | tiling); |
| 391 | |
| 392 | connected_outs++; |
| 393 | } |
| 394 | |
| 395 | igt_skip_on(connected_outs == 0); |
| 396 | |
| 397 | } |
| 398 | |
| 399 | static void |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 400 | run_tests_for_pipe(data_t *data, enum pipe pipe) |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 401 | { |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 402 | igt_output_t *output; |
| 403 | |
| 404 | igt_fixture { |
| 405 | int valid_tests = 0; |
| 406 | |
| 407 | igt_skip_on(pipe >= data->display.n_pipes); |
| 408 | |
| 409 | for_each_valid_output_on_pipe(&data->display, pipe, output) |
| 410 | valid_tests++; |
| 411 | |
| 412 | igt_require_f(valid_tests, "no valid crtc/connector combinations found\n"); |
| 413 | igt_require(data->display.pipes[pipe].n_planes > 0); |
Robert Foss | 0239e15 | 2017-01-10 20:10:43 -0500 | [diff] [blame] | 414 | } |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 415 | |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 416 | |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 417 | igt_subtest_f("legacy-pipe-%s-tiling-none", |
| 418 | kmstest_pipe_name(pipe)) |
| 419 | for_each_valid_output_on_pipe(&data->display, pipe, output) |
| 420 | test_plane_position(data, pipe, false, LOCAL_DRM_FORMAT_MOD_NONE); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 421 | |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 422 | igt_subtest_f("atomic-pipe-%s-tiling-none", |
| 423 | kmstest_pipe_name(pipe)) |
| 424 | for_each_valid_output_on_pipe(&data->display, pipe, output) |
| 425 | test_plane_position(data, pipe, true, LOCAL_I915_FORMAT_MOD_X_TILED); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 426 | |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 427 | igt_subtest_f("legacy-pipe-%s-tiling-x", |
| 428 | kmstest_pipe_name(pipe)) |
| 429 | for_each_valid_output_on_pipe(&data->display, pipe, output) |
| 430 | test_plane_position(data, pipe, false, LOCAL_I915_FORMAT_MOD_X_TILED); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 431 | |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 432 | igt_subtest_f("atomic-pipe-%s-tiling-x", |
| 433 | kmstest_pipe_name(pipe)) |
| 434 | for_each_valid_output_on_pipe(&data->display, pipe, output) |
| 435 | test_plane_position(data, pipe, true, LOCAL_I915_FORMAT_MOD_X_TILED); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 436 | |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 437 | igt_subtest_f("legacy-pipe-%s-tiling-y", |
| 438 | kmstest_pipe_name(pipe)) |
| 439 | for_each_valid_output_on_pipe(&data->display, pipe, output) |
| 440 | test_plane_position(data, pipe, false, LOCAL_I915_FORMAT_MOD_Y_TILED); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 441 | |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 442 | igt_subtest_f("atomic-pipe-%s-tiling-y", |
| 443 | kmstest_pipe_name(pipe)) |
| 444 | for_each_valid_output_on_pipe(&data->display, pipe, output) |
| 445 | test_plane_position(data, pipe, true, LOCAL_I915_FORMAT_MOD_Y_TILED); |
| 446 | |
| 447 | igt_subtest_f("legacy-pipe-%s-tiling-yf", |
| 448 | kmstest_pipe_name(pipe)) |
| 449 | for_each_valid_output_on_pipe(&data->display, pipe, output) |
| 450 | test_plane_position(data, pipe, false, LOCAL_I915_FORMAT_MOD_Yf_TILED); |
| 451 | |
| 452 | igt_subtest_f("atomic-pipe-%s-tiling-yf", |
| 453 | kmstest_pipe_name(pipe)) |
| 454 | for_each_valid_output_on_pipe(&data->display, pipe, output) |
| 455 | test_plane_position(data, pipe, true, LOCAL_I915_FORMAT_MOD_Yf_TILED); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 456 | } |
| 457 | |
| 458 | static data_t data; |
| 459 | |
| 460 | static int opt_handler(int option, int option_index, void *input) |
| 461 | { |
| 462 | switch (option) { |
| 463 | case 'i': |
| 464 | opt.iterations = strtol(optarg, NULL, 0); |
| 465 | |
| 466 | if (opt.iterations < LOOP_FOREVER || opt.iterations == 0) { |
| 467 | igt_info("incorrect number of iterations\n"); |
| 468 | igt_assert(false); |
| 469 | } |
| 470 | |
| 471 | break; |
| 472 | case 's': |
| 473 | opt.user_seed = true; |
| 474 | opt.seed = strtol(optarg, NULL, 0); |
| 475 | break; |
| 476 | default: |
| 477 | igt_assert(false); |
| 478 | } |
| 479 | |
| 480 | return 0; |
| 481 | } |
| 482 | |
| 483 | const char *help_str = |
| 484 | " --iterations Number of iterations for test coverage. -1 loop forever, default 64 iterations\n" |
| 485 | " --seed Seed for random number generator\n"; |
| 486 | |
| 487 | int main(int argc, char *argv[]) |
| 488 | { |
| 489 | struct option long_options[] = { |
| 490 | { "iterations", required_argument, NULL, 'i'}, |
| 491 | { "seed", required_argument, NULL, 's'}, |
| 492 | { 0, 0, 0, 0 } |
| 493 | }; |
Daniel Vetter | 229d7d2 | 2017-08-14 11:32:05 +0200 | [diff] [blame] | 494 | enum pipe pipe; |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 495 | |
| 496 | igt_subtest_init_parse_opts(&argc, argv, "", long_options, help_str, |
| 497 | opt_handler, NULL); |
| 498 | |
| 499 | igt_skip_on_simulation(); |
| 500 | |
| 501 | igt_fixture { |
| 502 | data.drm_fd = drm_open_driver_master(DRIVER_INTEL); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 503 | kmstest_set_vt_graphics_mode(); |
Chris Wilson | 83884e9 | 2017-03-21 17:16:03 +0000 | [diff] [blame] | 504 | igt_require_pipe_crc(data.drm_fd); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 505 | igt_display_init(&data.display, data.drm_fd); |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 506 | igt_require(data.display.n_pipes > 0); |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 507 | } |
| 508 | |
Daniel Vetter | 229d7d2 | 2017-08-14 11:32:05 +0200 | [diff] [blame] | 509 | for_each_pipe_static(pipe) { |
Mika Kahola | 6200c7e | 2017-02-02 13:03:18 +0200 | [diff] [blame] | 510 | igt_subtest_group |
| 511 | run_tests_for_pipe(&data, pipe); |
| 512 | } |
Mika Kahola | d072258 | 2016-11-08 15:56:13 +0200 | [diff] [blame] | 513 | |
| 514 | igt_fixture { |
| 515 | igt_display_fini(&data.display); |
| 516 | } |
| 517 | |
| 518 | igt_exit(); |
| 519 | } |