[igt-dev] [PATCH i-g-t 1/2] tests/kms_cursor_crc: Separate hw and sw runs on tests
Juha-Pekka Heikkila
juhapekka.heikkila at gmail.com
Tue Aug 17 17:46:22 UTC 2021
On 17.8.2021 18.59, Petri Latvala wrote:
> On Tue, Aug 17, 2021 at 12:27:23PM +0300, Juha-Pekka Heikkila wrote:
>> Reset display structure settings and commit them in before starting
>> test in case some earlier test left tail.
>>
>> Separate hw and sw test runs for optimizing test.
>>
>> Simple cleanup.
>>
>> Signed-off-by: Juha-Pekka Heikkila <juhapekka.heikkila at gmail.com>
>> ---
>> tests/kms_cursor_crc.c | 404 +++++++++++++++++++++++++----------------
>> 1 file changed, 251 insertions(+), 153 deletions(-)
>>
>> diff --git a/tests/kms_cursor_crc.c b/tests/kms_cursor_crc.c
>> index a9bc3a745..f478ae08d 100644
>> --- a/tests/kms_cursor_crc.c
>> +++ b/tests/kms_cursor_crc.c
>> @@ -46,10 +46,17 @@ IGT_TEST_DESCRIPTION(
>> #define DRM_CAP_CURSOR_HEIGHT 0x9
>> #endif
>>
>> +enum cursor_buffers {
>> + HWCURSORBUFFER,
>> + SWCOMPARISONBUFFER1,
>> + SWCOMPARISONBUFFER2,
>> + MAXCURSORBUFFER
>> +};
>> +
>> typedef struct {
>> int drm_fd;
>> igt_display_t display;
>> - struct igt_fb primary_fb[2];
>> + struct igt_fb primary_fb[MAXCURSORBUFFER];
>> struct igt_fb fb;
>> igt_output_t *output;
>> enum pipe pipe;
>> @@ -70,29 +77,40 @@ typedef struct {
>> #define TEST_DPMS (1<<0)
>> #define TEST_SUSPEND (1<<1)
>>
>> -#define HWCURSORBUFFER 0
>> -#define SWCOMPARISONBUFFER 1
>> +#define RED 1.0, 0.0, 0.0
>> +#define GREEN 0.0, 1.0, 0.0
>> +#define BLUE 0.0, 0.0, 1.0
>> +#define WHITE 1.0, 1.0, 1.0
>> +
>> +typedef struct {
>> + int x;
>> + int y;
>> + int width;
>> + int height;
>> +} cursorarea;
>>
>> -static void draw_cursor(cairo_t *cr, int x, int y, int cw, int ch, double a)
>> +static void draw_cursor(cairo_t *cr, cursorarea *cursor)
>> {
>> int wl, wr, ht, hb;
>>
>> /* deal with odd cursor width/height */
>> - wl = cw / 2;
>> - wr = (cw + 1) / 2;
>> - ht = ch / 2;
>> - hb = (ch + 1) / 2;
>> + wl = cursor->width / 2;
>> + wr = (cursor->width + 1) / 2;
>> + ht = cursor->height / 2;
>> + hb = (cursor->height + 1) / 2;
>>
>> /* Cairo doesn't like to be fed numbers that are too wild */
>> - if ((x < SHRT_MIN) || (x > SHRT_MAX) || (y < SHRT_MIN) || (y > SHRT_MAX))
>> + if ((cursor->x < SHRT_MIN) || (cursor->x > SHRT_MAX) ||
>> + (cursor->y < SHRT_MIN) || (cursor->y > SHRT_MAX))
>> return;
>> +
>> cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
>> cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
>> /* 4 color rectangles in the corners, RGBY */
>> - igt_paint_color_alpha(cr, x, y, wl, ht, 1.0, 0.0, 0.0, a);
>> - igt_paint_color_alpha(cr, x + wl, y, wr, ht, 0.0, 1.0, 0.0, a);
>> - igt_paint_color_alpha(cr, x, y + ht, wl, hb, 0.0, 0.0, 1.0, a);
>> - igt_paint_color_alpha(cr, x + wl, y + ht, wr, hb, 1.0, 1.0, 1.0, a);
>> + igt_paint_color(cr, cursor->x, cursor->y, wl, ht, RED);
>> + igt_paint_color(cr, cursor->x + wl, cursor->y, wr, ht, GREEN);
>> + igt_paint_color(cr, cursor->x, cursor->y + ht, wl, hb, BLUE);
>> + igt_paint_color(cr, cursor->x + wl, cursor->y + ht, wr, hb, WHITE);
>> }
>>
>> static void cursor_enable(data_t *data)
>> @@ -144,7 +162,7 @@ static bool cursor_visible(data_t *data, int x, int y)
>> return true;
>> }
>>
>> -static void restore_image(data_t *data, uint32_t buffer)
>> +static void restore_image(data_t *data, uint32_t buffer, cursorarea *cursor)
>> {
>> cairo_t *cr;
>>
>> @@ -153,80 +171,84 @@ static void restore_image(data_t *data, uint32_t buffer)
>> cairo_set_source_surface(cr, data->surface, 0, 0);
>> cairo_rectangle(cr, 0, 0, data->screenw, data->screenh);
>> cairo_fill(cr);
>> +
>> + if (cursor)
>> + draw_cursor(cr, cursor);
>> +
>> igt_put_cairo_ctx(cr);
>> }
>>
>> -static void do_single_test(data_t *data, int x, int y)
>> +static void do_single_test(data_t *data, int x, int y, bool hw_test,
>> + igt_crc_t *hwcrc)
>> {
>> igt_display_t *display = &data->display;
>> igt_pipe_crc_t *pipe_crc = data->pipe_crc;
>> - igt_crc_t crc, ref_crc;
>> - cairo_t *cr;
>> - int ret = 0;
>> + igt_crc_t crc;
>> + int ret = 0, swbufidx;
>>
>> igt_print_activity();
>>
>> - /* Hardware test */
>> - igt_plane_set_position(data->cursor, x, y);
>> - cursor_enable(data);
>> + if (hw_test) {
>> + /* Hardware test */
>> + igt_plane_set_position(data->cursor, x, y);
>>
>> - if (chv_cursor_broken(data, x) && cursor_visible(data, x, y)) {
>> - ret = igt_display_try_commit2(display, COMMIT_LEGACY);
>> - igt_assert_eq(ret, -EINVAL);
>> - igt_plane_set_position(data->cursor, 0, y);
>> - return;
>> - }
>> + if (chv_cursor_broken(data, x) && cursor_visible(data, x, y)) {
>> + ret = igt_display_try_commit2(display, COMMIT_LEGACY);
>> + igt_assert_eq(ret, -EINVAL);
>> + igt_plane_set_position(data->cursor, 0, y);
>> + return;
>> + }
>>
>> - igt_plane_set_fb(data->primary, &data->primary_fb[HWCURSORBUFFER]);
>> - igt_display_commit(display);
>> + igt_display_commit(display);
>>
>> - /* Extra vblank wait is because nonblocking cursor ioctl */
>> - igt_wait_for_vblank(data->drm_fd,
>> - display->pipes[data->pipe].crtc_offset);
>> + /* Extra vblank wait is because nonblocking cursor ioctl */
>> + igt_wait_for_vblank(data->drm_fd,
>> + display->pipes[data->pipe].crtc_offset);
>>
>> - igt_pipe_crc_get_current(data->drm_fd, pipe_crc, &crc);
>> - restore_image(data, SWCOMPARISONBUFFER);
>> + igt_pipe_crc_get_current(data->drm_fd, pipe_crc, hwcrc);
>>
>> - if (data->flags & (TEST_DPMS | TEST_SUSPEND)) {
>> - igt_crc_t crc_after;
>> - /*
>> - * stop/start crc to avoid dmesg notifications about userspace
>> - * reading too slow.
>> - */
>> - igt_pipe_crc_stop(pipe_crc);
>> -
>> - if (data->flags & TEST_DPMS) {
>> - igt_debug("dpms off/on cycle\n");
>> - kmstest_set_connector_dpms(data->drm_fd,
>> - data->output->config.connector,
>> - DRM_MODE_DPMS_OFF);
>> - kmstest_set_connector_dpms(data->drm_fd,
>> - data->output->config.connector,
>> - DRM_MODE_DPMS_ON);
>> + if (data->flags & (TEST_DPMS | TEST_SUSPEND)) {
>> + igt_crc_t crc_after;
>> + /*
>> + * stop/start crc to avoid dmesg notifications about userspace
>> + * reading too slow.
>> + */
>> + igt_pipe_crc_stop(pipe_crc);
>> +
>> + if (data->flags & TEST_DPMS) {
>> + igt_debug("dpms off/on cycle\n");
>> + kmstest_set_connector_dpms(data->drm_fd,
>> + data->output->config.connector,
>> + DRM_MODE_DPMS_OFF);
>> + kmstest_set_connector_dpms(data->drm_fd,
>> + data->output->config.connector,
>> + DRM_MODE_DPMS_ON);
>> + }
>> +
>> + if (data->flags & TEST_SUSPEND)
>> + igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
>> + SUSPEND_TEST_NONE);
>> +
>> + igt_pipe_crc_start(pipe_crc);
>> + igt_pipe_crc_get_current(data->drm_fd, pipe_crc, &crc_after);
>> + igt_assert_crc_equal(hwcrc, &crc_after);
>> }
>> + } else {
>> + /* Now render the same in software and collect crc */
>> + swbufidx = (data->primary->drm_plane->fb_id ==
>> + data->primary_fb[SWCOMPARISONBUFFER1].fb_id) ?
>> + SWCOMPARISONBUFFER2 : SWCOMPARISONBUFFER1;
>>
>> - if (data->flags & TEST_SUSPEND)
>> - igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
>> - SUSPEND_TEST_NONE);
>> -
>> - igt_pipe_crc_start(pipe_crc);
>> - igt_pipe_crc_get_current(data->drm_fd, pipe_crc, &crc_after);
>> - igt_assert_crc_equal(&crc, &crc_after);
>> - }
>> -
>> - /* Now render the same in software and collect crc */
>> - cr = igt_get_cairo_ctx(data->drm_fd, &data->primary_fb[SWCOMPARISONBUFFER]);
>> - draw_cursor(cr, x, y, data->curw, data->curh, 1.0);
>> - igt_put_cairo_ctx(cr);
>> - igt_plane_set_fb(data->primary, &data->primary_fb[SWCOMPARISONBUFFER]);
>> - cursor_disable(data);
>> - igt_display_commit(display);
>> + restore_image(data, swbufidx, &((cursorarea){x, y, data->curw, data->curh}));
>> + igt_plane_set_fb(data->primary, &data->primary_fb[swbufidx]);
>>
>> - igt_wait_for_vblank(data->drm_fd,
>> - display->pipes[data->pipe].crtc_offset);
>> + igt_display_commit(display);
>> + igt_wait_for_vblank(data->drm_fd,
>> + display->pipes[data->pipe].crtc_offset);
>>
>> - igt_pipe_crc_get_current(data->drm_fd, pipe_crc, &ref_crc);
>> - igt_assert_crc_equal(&crc, &ref_crc);
>> + igt_pipe_crc_get_current(data->drm_fd, pipe_crc, &crc);
>> + igt_assert_crc_equal(&crc, hwcrc);
>> + }
>> }
>>
>> static void do_fail_test(data_t *data, int x, int y, int expect)
>> @@ -248,70 +270,112 @@ static void do_fail_test(data_t *data, int x, int y, int expect)
>> igt_assert_eq(ret, expect);
>> }
>>
>> -static void do_test(data_t *data,
>> - int left, int right, int top, int bottom)
>> +static void do_test(data_t *data, const cursorarea *coords, igt_crc_t crc[4],
>> + bool hwtest)
>> {
>> - do_single_test(data, left, top);
>> - do_single_test(data, right, top);
>> - do_single_test(data, right, bottom);
>> - do_single_test(data, left, bottom);
>> + do_single_test(data, coords->x, coords->width, hwtest, &crc[0]);
>> + do_single_test(data, coords->y, coords->width, hwtest, &crc[1]);
>> + do_single_test(data, coords->y, coords->height, hwtest, &crc[2]);
>> + do_single_test(data, coords->x, coords->height, hwtest, &crc[3]);
>> }
>>
>> static void test_crc_onscreen(data_t *data)
>> {
>> - int left = data->left;
>> - int right = data->right;
>> - int top = data->top;
>> - int bottom = data->bottom;
>> - int cursor_w = data->curw;
>> - int cursor_h = data->curh;
>> -
>> - /* fully inside */
>> - do_test(data, left, right, top, bottom);
>> -
>> - /* 2 pixels inside */
>> - do_test(data, left - (cursor_w-2), right + (cursor_w-2), top , bottom );
>> - do_test(data, left , right , top - (cursor_h-2), bottom + (cursor_h-2));
>> - do_test(data, left - (cursor_w-2), right + (cursor_w-2), top - (cursor_h-2), bottom + (cursor_h-2));
>> -
>> - /* 1 pixel inside */
>> - do_test(data, left - (cursor_w-1), right + (cursor_w-1), top , bottom );
>> - do_test(data, left , right , top - (cursor_h-1), bottom + (cursor_h-1));
>> - do_test(data, left - (cursor_w-1), right + (cursor_w-1), top - (cursor_h-1), bottom + (cursor_h-1));
>> + const int left = data->left;
>> + const int right = data->right;
>> + const int top = data->top;
>> + const int bottom = data->bottom;
>> + const int cursor_w = data->curw;
>> + const int cursor_h = data->curh;
>> +
>> + struct {
>> + const cursorarea coords;
>> + igt_crc_t crc[4];
>> + } tests[] = {
>> + /* fully inside */
>> + {{left, right, top, bottom}},
>> + /* 2 pixels inside */
>> + {{left - (cursor_w - 2), right + (cursor_w - 2), top, bottom}},
>> + {{left, right, top - (cursor_h - 2), bottom + (cursor_h - 2)}},
>> + {{left - (cursor_w - 2), right + (cursor_w - 2),
>> + top - (cursor_h - 2), bottom + (cursor_h - 2)}},
>> + /* 1 pixel inside */
>> + {{left - (cursor_w - 1), right + (cursor_w - 1), top, bottom}},
>> + {{left, right, top - (cursor_h - 1), bottom + (cursor_h - 1)}},
>> + {{left - (cursor_w - 1), right + (cursor_w - 1),
>> + top - (cursor_h - 1), bottom + (cursor_h - 1)}},
>> + };
>> +
>> + /* HW test */
>> + cursor_enable(data);
>> + igt_plane_set_fb(data->primary, &data->primary_fb[HWCURSORBUFFER]);
>> + for (int i = 0; i < ARRAY_SIZE(tests); i++)
>> + do_test(data, &tests[i].coords, tests[i].crc, true);
>> +
>> + /* SW test */
>> + cursor_disable(data);
>> + for (int i = 0; i < ARRAY_SIZE(tests); i++)
>> + do_test(data, &tests[i].coords, tests[i].crc, false);
>> }
>>
>> static void test_crc_offscreen(data_t *data)
>> {
>> - int left = data->left;
>> - int right = data->right;
>> - int top = data->top;
>> - int bottom = data->bottom;
>> - int cursor_w = data->curw;
>> - int cursor_h = data->curh;
>> -
>> - /* fully outside */
>> - do_test(data, left - (cursor_w), right + (cursor_w), top , bottom );
>> - do_test(data, left , right , top - (cursor_h), bottom + (cursor_h));
>> - do_test(data, left - (cursor_w), right + (cursor_w), top - (cursor_h), bottom + (cursor_h));
>> -
>> - /* fully outside by 1 extra pixels */
>> - do_test(data, left - (cursor_w+1), right + (cursor_w+1), top , bottom );
>> - do_test(data, left , right , top - (cursor_h+1), bottom + (cursor_h+1));
>> - do_test(data, left - (cursor_w+1), right + (cursor_w+1), top - (cursor_h+1), bottom + (cursor_h+1));
>> -
>> - /* fully outside by 2 extra pixels */
>> - do_test(data, left - (cursor_w+2), right + (cursor_w+2), top , bottom );
>> - do_test(data, left , right , top - (cursor_h+2), bottom + (cursor_h+2));
>> - do_test(data, left - (cursor_w+2), right + (cursor_w+2), top - (cursor_h+2), bottom + (cursor_h+2));
>> -
>> - /* fully outside by a lot of extra pixels */
>> - do_test(data, left - (cursor_w+512), right + (cursor_w+512), top , bottom );
>> - do_test(data, left , right , top - (cursor_h+512), bottom + (cursor_h+512));
>> - do_test(data, left - (cursor_w+512), right + (cursor_w+512), top - (cursor_h+512), bottom + (cursor_h+512));
>> -
>> - /* go nuts */
>> - do_test(data, INT_MIN, INT_MAX - cursor_w, INT_MIN, INT_MAX - cursor_h);
>> - do_test(data, SHRT_MIN, SHRT_MAX, SHRT_MIN, SHRT_MAX);
>> + const int left = data->left;
>> + const int right = data->right;
>> + const int top = data->top;
>> + const int bottom = data->bottom;
>> + const int cursor_w = data->curw;
>> + const int cursor_h = data->curh;
>> +
>> + struct {
>> + const cursorarea coords;
>> + igt_crc_t crc[4];
>> + } tests[] = {
>> + /* fully outside */
>> + {{left - (cursor_w), right + (cursor_w), top, bottom}},
>> + {{left, right, top - (cursor_h), bottom + (cursor_h)}},
>> + {{left - (cursor_w), right + (cursor_w), top - (cursor_h),
>> + bottom + (cursor_h)}},
>> + /* fully outside by 1 extra pixels */
>> + {{left - (cursor_w + 1), right + (cursor_w + 1), top, bottom}},
>> + {{left, right, top - (cursor_h + 1), bottom + (cursor_h + 1)}},
>> + {{left - (cursor_w + 1), right + (cursor_w + 1),
>> + top - (cursor_h + 1), bottom + (cursor_h + 1)}},
>> + /* fully outside by 2 extra pixels */
>> + {{left - (cursor_w + 2), right + (cursor_w + 2), top, bottom}},
>> + {{left, right, top - (cursor_h + 2), bottom + (cursor_h + 2)}},
>> + {{left - (cursor_w + 2), right + (cursor_w + 2),
>> + top - (cursor_h + 2), bottom + (cursor_h + 2)}},
>> + /* fully outside by a lot of extra pixels */
>> + {{left - (cursor_w + 512), right + (cursor_w + 512), top, bottom}},
>> + {{left, right, top - (cursor_h + 512), bottom + (cursor_h + 512)}},
>> + {{left - (cursor_w + 512), right + (cursor_w + 512),
>> + top - (cursor_h + 512), bottom + (cursor_h + 512)}},
>> + /* go nuts */
>> + {{INT_MIN, INT_MAX - cursor_w, INT_MIN, INT_MAX - cursor_h}},
>> + {{SHRT_MIN, SHRT_MAX, SHRT_MIN, SHRT_MAX}},
>> + };
>> +
>> + /* HW test */
>> + cursor_enable(data);
>> + igt_plane_set_fb(data->primary, &data->primary_fb[HWCURSORBUFFER]);
>> + for (int i = 0; i < ARRAY_SIZE(tests); i++)
>> + do_test(data, &tests[i].coords, tests[i].crc, true);
>> +
>> + /* SW test */
>> + cursor_disable(data);
>> + /*
>> + * all these crc's should be the same, actually render only first image
>> + * to check crc and then compare rest of crc are matching
>> + */
>> + do_test(data, &tests[0].coords, tests[0].crc, false);
>> +
>> + for (int i = 1; i < ARRAY_SIZE(tests); i++) {
>> + igt_assert_crc_equal(&tests[0].crc[0], &tests[i].crc[0]);
>> + igt_assert_crc_equal(&tests[0].crc[0], &tests[i].crc[1]);
>> + igt_assert_crc_equal(&tests[0].crc[0], &tests[i].crc[2]);
>> + igt_assert_crc_equal(&tests[0].crc[0], &tests[i].crc[3]);
>> + }
>>
>> /* Make sure we get -ERANGE on integer overflow */
>> do_fail_test(data, INT_MAX - cursor_w + 1, INT_MAX - cursor_h + 1, -ERANGE);
>> @@ -320,29 +384,57 @@ static void test_crc_offscreen(data_t *data)
>> static void test_crc_sliding(data_t *data)
>> {
>> int i;
>> + struct {
>> + igt_crc_t crc[3];
>> + } rounds[16] = {};
>>
>> /* Make sure cursor moves smoothly and pixel-by-pixel, and that there are
>> * no alignment issues. Horizontal, vertical and diagonal test.
>> */
>> - for (i = 0; i < 16; i++) {
>> - do_single_test(data, i, 0);
>> - do_single_test(data, 0, i);
>> - do_single_test(data, i, i);
>> +
>> + /* HW test */
>> + cursor_enable(data);
>> + igt_plane_set_fb(data->primary, &data->primary_fb[HWCURSORBUFFER]);
>> +
>> + for (i = 0; i < ARRAY_SIZE(rounds); i++) {
>> + do_single_test(data, i, 0, true, &rounds[i].crc[0]);
>> + do_single_test(data, 0, i, true, &rounds[i].crc[1]);
>> + do_single_test(data, i, i, true, &rounds[i].crc[2]);
>> + }
>> +
>> + /* SW test */
>> + cursor_disable(data);
>> + for (i = 0; i < ARRAY_SIZE(rounds); i++) {
>> + do_single_test(data, i, 0, false, &rounds[i].crc[0]);
>> + do_single_test(data, 0, i, false, &rounds[i].crc[1]);
>> + do_single_test(data, i, i, false, &rounds[i].crc[2]);
>> }
>> }
>>
>> static void test_crc_random(data_t *data)
>> {
>> - int i, max;
>> + igt_crc_t crc[50];
>> + int i, max, x[ARRAY_SIZE(crc)], y[ARRAY_SIZE(crc)];
>>
>> - max = data->flags & (TEST_DPMS | TEST_SUSPEND) ? 2 : 50;
>> + max = data->flags & (TEST_DPMS | TEST_SUSPEND) ? 2 : ARRAY_SIZE(crc);
>>
>> /* Random cursor placement */
>> +
>> + /* HW test */
>> + cursor_enable(data);
>> + igt_plane_set_fb(data->primary, &data->primary_fb[HWCURSORBUFFER]);
>> +
>> for (i = 0; i < max; i++) {
>> - int x = rand() % (data->screenw + data->curw * 2) - data->curw;
>> - int y = rand() % (data->screenh + data->curh * 2) - data->curh;
>> - do_single_test(data, x, y);
>> + x[i] = rand() % (data->screenw + data->curw * 2) - data->curw;
>> + y[i] = rand() % (data->screenh + data->curh * 2) - data->curh;
>> + do_single_test(data, x[i], y[i], true, &crc[i]);
>> }
>> +
>> + /* SW test */
>> + cursor_disable(data);
>> + for (i = 0; i < max; i++)
>> + do_single_test(data, x[i], y[i], false, &crc[i]);
>> +
>> }
>>
>> static void cleanup_crtc(data_t *data)
>> @@ -362,7 +454,8 @@ static void cleanup_crtc(data_t *data)
>> igt_display_commit(display);
>>
>> igt_remove_fb(data->drm_fd, &data->primary_fb[HWCURSORBUFFER]);
>> - igt_remove_fb(data->drm_fd, &data->primary_fb[SWCOMPARISONBUFFER]);
>> + igt_remove_fb(data->drm_fd, &data->primary_fb[SWCOMPARISONBUFFER1]);
>> + igt_remove_fb(data->drm_fd, &data->primary_fb[SWCOMPARISONBUFFER2]);
>>
>> igt_display_reset(display);
>> }
>> @@ -379,22 +472,22 @@ static void prepare_crtc(data_t *data, igt_output_t *output,
>>
>> /* create and set the primary plane fbs */
>> mode = igt_output_get_mode(output);
>> - igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay,
>> - DRM_FORMAT_XRGB8888,
>> - DRM_FORMAT_MOD_NONE,
>> - 0.0, 0.0, 0.0,
>> - &data->primary_fb[HWCURSORBUFFER]);
>> -
>> - igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay,
>> - DRM_FORMAT_XRGB8888,
>> - DRM_FORMAT_MOD_NONE,
>> - 0.0, 0.0, 0.0,
>> - &data->primary_fb[SWCOMPARISONBUFFER]);
>> + igt_create_fb(data->drm_fd, mode->hdisplay, mode->vdisplay,
>> + DRM_FORMAT_XRGB8888, DRM_FORMAT_MOD_NONE,
>> + &data->primary_fb[HWCURSORBUFFER]);
>> +
>> + igt_create_fb(data->drm_fd, mode->hdisplay, mode->vdisplay,
>> + DRM_FORMAT_XRGB8888, DRM_FORMAT_MOD_NONE,
>> + &data->primary_fb[SWCOMPARISONBUFFER1]);
>> +
>> + igt_create_fb(data->drm_fd, mode->hdisplay, mode->vdisplay,
>> + DRM_FORMAT_XRGB8888, DRM_FORMAT_MOD_NONE,
>> + &data->primary_fb[SWCOMPARISONBUFFER2]);
>>
>> data->primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
>> data->cursor = igt_output_get_plane_type(output, DRM_PLANE_TYPE_CURSOR);
>>
>> - igt_plane_set_fb(data->primary, &data->primary_fb[SWCOMPARISONBUFFER]);
>> + igt_plane_set_fb(data->primary, &data->primary_fb[SWCOMPARISONBUFFER1]);
>>
>> igt_display_commit(display);
>>
>> @@ -427,7 +520,7 @@ static void prepare_crtc(data_t *data, igt_output_t *output,
>> cairo_destroy(cr);
>>
>> /* Set HW cursor buffer in place */
>> - restore_image(data, HWCURSORBUFFER);
>> + restore_image(data, HWCURSORBUFFER, NULL);
>> } else
>> data->surface = NULL;
>>
>> @@ -469,10 +562,10 @@ static void test_cursor_alpha(data_t *data, double a)
>> igt_remove_fb(data->drm_fd, &data->fb);
>>
>> /* Software Test - render cursor in software, drawn it directly on PF */
>> - cr = igt_get_cairo_ctx(data->drm_fd, &data->primary_fb[SWCOMPARISONBUFFER]);
>> + cr = igt_get_cairo_ctx(data->drm_fd, &data->primary_fb[SWCOMPARISONBUFFER1]);
>> igt_paint_color_alpha(cr, 0, 0, curw, curh, 1.0, 1.0, 1.0, a);
>> igt_put_cairo_ctx(cr);
>> - igt_plane_set_fb(data->primary, &data->primary_fb[SWCOMPARISONBUFFER]);
>> + igt_plane_set_fb(data->primary, &data->primary_fb[SWCOMPARISONBUFFER1]);
>> igt_display_commit(display);
>> igt_wait_for_vblank(data->drm_fd,
>> display->pipes[data->pipe].crtc_offset);
>> @@ -513,7 +606,7 @@ static void create_cursor_fb(data_t *data, int cur_w, int cur_h)
>> igt_assert(fb_id);
>>
>> cr = igt_get_cairo_ctx(data->drm_fd, &data->fb);
>> - draw_cursor(cr, 0, 0, cur_w, cur_h, 1.0);
>> + draw_cursor(cr, &((cursorarea){0, 0, cur_w, cur_h}));
>> igt_put_cairo_ctx(cr);
>> }
>>
>> @@ -610,7 +703,7 @@ static void test_cursor_size(data_t *data)
>> igt_display_commit(display);
>>
>> /* Now render the same in software and collect crc */
>> - cr = igt_get_cairo_ctx(data->drm_fd, &data->primary_fb[SWCOMPARISONBUFFER]);
>> + cr = igt_get_cairo_ctx(data->drm_fd, &data->primary_fb[SWCOMPARISONBUFFER1]);
>>
>> /* remove previous cursor sw image */
>> if (prevsize > 0)
>> @@ -619,7 +712,7 @@ static void test_cursor_size(data_t *data)
>>
>> igt_paint_color_alpha(cr, 0, 0, size, size, 1.0, 1.0, 1.0, 1.0);
>> igt_put_cairo_ctx(cr);
>> - igt_plane_set_fb(data->primary, &data->primary_fb[SWCOMPARISONBUFFER]);
>> + igt_plane_set_fb(data->primary, &data->primary_fb[SWCOMPARISONBUFFER1]);
>> igt_display_commit(display);
>> igt_pipe_crc_get_current(data->drm_fd, pipe_crc, &ref_crc);
>>
>> @@ -657,6 +750,8 @@ static void test_rapid_movement(data_t *data)
>> }
>> gettimeofday(&end, NULL);
>>
>> + cursor_disable(data);
>> +
>> /*
>> * We've done 400 cursor updates now. If we're being throttled to
>> * vblank, then that would take roughly 400/refresh seconds. If the
>> @@ -813,6 +908,9 @@ igt_main
>> igt_require_pipe_crc(data.drm_fd);
>>
>> igt_display_require(&data.display, data.drm_fd);
>> + igt_display_reset(&data.display);
>> + igt_display_commit2(&data.display, data.display.is_atomic ?
>> + COMMIT_ATOMIC : COMMIT_LEGACY);
>> }
>
> igt_display_require() calls igt_display_reset at the end of it... but
> after that does igt_enable_connectors. Is that why this extra
> igt_display_reset is needed here?
>
This is something I don't yet know where exactly the problem exists,
earlier failed tests may leave tail which this is able to clear out. I
coined this for myself to do some debugging:
https://patchwork.freedesktop.org/series/93756/
Those igt_display_reset(..) followed by atomic and legacy commit and get
crc of white imo should match but they don't do that for me. Situation
is the same as kms_plane_alpha_blend failed and will arrive to new test,
there maybe differences if test uses legacy or atomic commits.
/Juha-Pekka
More information about the igt-dev
mailing list