flywithu/ntel-gpu-tools
1
0
Fork 0
mirror of https://github.com/tiagovignatti/intel-gpu-tools.git synced 2025-06-12 10:26:12 +00:00
Code Issues Releases Wiki Activity

tests/kms_cursor_crc: Combine data_t and test_data_t

Browse Source 
If a subtest fails, cleanup_crtc() never gets called and then the
test_data_t structure for the test is lost, including the CRC file
descriptor that we never got a chance to release; this causes all
subsequent tests to fail with -EBUSY at igt_pipe_crc_new().

The split between permanent data_t and temporary test_data_t doesn't
seem to serve a purpose, so just combine the fields from both into
data_t.  This will prevent us from losing the CRC filedescriptor so that
we can properly close and reopen it after a failed test.

Signed-off-by: Matt Roper <matthew.d.roper@intel.com>
Signed-off-by: Damien Lespiau <damien.lespiau@intel.com>
This commit is contained in:
Matt Roper 2014-06-30 16:44:29 -07:00 committed by Damien Lespiau
parent 075d9eafdb
commit 07087ada29
1 changed files with 108 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

229
tests/kms_cursor_crc.c
View File

@ -44,10 +44,6 @@ typedef struct {
igt_display_t display; igt_display_t display;
struct igt_fb primary_fb; struct igt_fb primary_fb;
struct igt_fb fb; struct igt_fb fb;
} data_t;
typedef struct {
data_t *data;
igt_output_t *output; igt_output_t *output;
enum pipe pipe; enum pipe pipe;
igt_crc_t ref_crc; igt_crc_t ref_crc;
@ -56,7 +52,7 @@ typedef struct {
int curw, curh; /* cursor size */ int curw, curh; /* cursor size */
int cursor_max_size; int cursor_max_size;
igt_pipe_crc_t *pipe_crc; igt_pipe_crc_t *pipe_crc;
} test_data_t; } data_t;
static void draw_cursor(cairo_t *cr, int x, int y, int w) static void draw_cursor(cairo_t *cr, int x, int y, int w)
{ {
@ -72,11 +68,10 @@ static void draw_cursor(cairo_t *cr, int x, int y, int w)
igt_paint_color_alpha(cr, x + w, y + w, w, w, 0.5, 0.5, 0.5, 1.0); igt_paint_color_alpha(cr, x + w, y + w, w, w, 0.5, 0.5, 0.5, 1.0);
} }
static void cursor_enable(test_data_t *test_data) static void cursor_enable(data_t *data)
{ {
data_t *data = test_data->data;
igt_display_t *display = &data->display; igt_display_t *display = &data->display;
igt_output_t *output = test_data->output; igt_output_t *output = data->output;
igt_plane_t *cursor; igt_plane_t *cursor;
cursor = igt_output_get_plane(output, IGT_PLANE_CURSOR); cursor = igt_output_get_plane(output, IGT_PLANE_CURSOR);
@ -84,11 +79,10 @@ static void cursor_enable(test_data_t *test_data)
igt_display_commit(display); igt_display_commit(display);
} }
static void cursor_disable(test_data_t *test_data) static void cursor_disable(data_t *data)
{ {
data_t *data = test_data->data;
igt_display_t *display = &data->display; igt_display_t *display = &data->display;
igt_output_t *output = test_data->output; igt_output_t *output = data->output;
igt_plane_t *cursor; igt_plane_t *cursor;
cursor = igt_output_get_plane(output, IGT_PLANE_CURSOR); cursor = igt_output_get_plane(output, IGT_PLANE_CURSOR);
@ -97,11 +91,10 @@ static void cursor_disable(test_data_t *test_data)
} }
static void do_single_test(test_data_t *test_data, int x, int y) static void do_single_test(data_t *data, int x, int y)
{ {
data_t *data = test_data->data;
igt_display_t *display = &data->display; igt_display_t *display = &data->display;
igt_pipe_crc_t *pipe_crc = test_data->pipe_crc; igt_pipe_crc_t *pipe_crc = data->pipe_crc;
igt_crc_t crc, ref_crc; igt_crc_t crc, ref_crc;
igt_plane_t *cursor; igt_plane_t *cursor;
cairo_t *cr = igt_get_cairo_ctx(data->drm_fd, &data->primary_fb); cairo_t *cr = igt_get_cairo_ctx(data->drm_fd, &data->primary_fb);
@ -109,93 +102,93 @@ static void do_single_test(test_data_t *test_data, int x, int y)
igt_info("."); fflush(stdout); igt_info("."); fflush(stdout);
/* Hardware test */ /* Hardware test */
igt_paint_test_pattern(cr, test_data->screenw, test_data->screenh); igt_paint_test_pattern(cr, data->screenw, data->screenh);
cursor_enable(test_data); cursor_enable(data);
cursor = igt_output_get_plane(test_data->output, IGT_PLANE_CURSOR); cursor = igt_output_get_plane(data->output, IGT_PLANE_CURSOR);
igt_plane_set_position(cursor, x, y); igt_plane_set_position(cursor, x, y);
igt_display_commit(display); igt_display_commit(display);
igt_wait_for_vblank(data->drm_fd, test_data->pipe); igt_wait_for_vblank(data->drm_fd, data->pipe);
igt_pipe_crc_collect_crc(pipe_crc, &crc); igt_pipe_crc_collect_crc(pipe_crc, &crc);
cursor_disable(test_data); cursor_disable(data);
/* Now render the same in software and collect crc */ /* Now render the same in software and collect crc */
draw_cursor(cr, x, y, test_data->curw); draw_cursor(cr, x, y, data->curw);
igt_display_commit(display); igt_display_commit(display);
igt_wait_for_vblank(data->drm_fd, test_data->pipe); igt_wait_for_vblank(data->drm_fd, data->pipe);
igt_pipe_crc_collect_crc(pipe_crc, &ref_crc); igt_pipe_crc_collect_crc(pipe_crc, &ref_crc);
/* Clear screen afterwards */ /* Clear screen afterwards */
igt_paint_color(cr, 0, 0, test_data->screenw, test_data->screenh, igt_paint_color(cr, 0, 0, data->screenw, data->screenh,
0.0, 0.0, 0.0); 0.0, 0.0, 0.0);
igt_assert(igt_crc_equal(&crc, &ref_crc)); igt_assert(igt_crc_equal(&crc, &ref_crc));
} }
static void do_test(test_data_t *test_data, static void do_test(data_t *data,
int left, int right, int top, int bottom) int left, int right, int top, int bottom)
{ {
do_single_test(test_data, left, top); do_single_test(data, left, top);
do_single_test(test_data, right, top); do_single_test(data, right, top);
do_single_test(test_data, right, bottom); do_single_test(data, right, bottom);
do_single_test(test_data, left, bottom); do_single_test(data, left, bottom);
} }
static void test_crc_onscreen(test_data_t *test_data) static void test_crc_onscreen(data_t *data)
{ {
int left = test_data->left; int left = data->left;
int right = test_data->right; int right = data->right;
int top = test_data->top; int top = data->top;
int bottom = test_data->bottom; int bottom = data->bottom;
int cursor_w = test_data->curw; int cursor_w = data->curw;
int cursor_h = test_data->curh; int cursor_h = data->curh;
/* fully inside */ /* fully inside */
do_test(test_data, left, right, top, bottom); do_test(data, left, right, top, bottom);
/* 2 pixels inside */ /* 2 pixels inside */
do_test(test_data, left - (cursor_w-2), right + (cursor_w-2), top , bottom ); do_test(data, left - (cursor_w-2), right + (cursor_w-2), top , bottom );
do_test(test_data, left , right , top - (cursor_h-2), bottom + (cursor_h-2)); do_test(data, left , right , top - (cursor_h-2), bottom + (cursor_h-2));
do_test(test_data, left - (cursor_w-2), right + (cursor_w-2), 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 */ /* 1 pixel inside */
do_test(test_data, left - (cursor_w-1), right + (cursor_w-1), top , bottom ); do_test(data, left - (cursor_w-1), right + (cursor_w-1), top , bottom );
do_test(test_data, left , right , top - (cursor_h-1), bottom + (cursor_h-1)); do_test(data, left , right , top - (cursor_h-1), bottom + (cursor_h-1));
do_test(test_data, left - (cursor_w-1), right + (cursor_w-1), 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));
} }
static void test_crc_offscreen(test_data_t *test_data) static void test_crc_offscreen(data_t *data)
{ {
int left = test_data->left; int left = data->left;
int right = test_data->right; int right = data->right;
int top = test_data->top; int top = data->top;
int bottom = test_data->bottom; int bottom = data->bottom;
int cursor_w = test_data->curw; int cursor_w = data->curw;
int cursor_h = test_data->curh; int cursor_h = data->curh;
/* fully outside */ /* fully outside */
do_test(test_data, left - (cursor_w), right + (cursor_w), top , bottom ); do_test(data, left - (cursor_w), right + (cursor_w), top , bottom );
do_test(test_data, left , right , top - (cursor_h), bottom + (cursor_h)); do_test(data, left , right , top - (cursor_h), bottom + (cursor_h));
do_test(test_data, left - (cursor_w), right + (cursor_w), 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 */ /* fully outside by 1 extra pixels */
do_test(test_data, left - (cursor_w+1), right + (cursor_w+1), top , bottom ); do_test(data, left - (cursor_w+1), right + (cursor_w+1), top , bottom );
do_test(test_data, left , right , top - (cursor_h+1), bottom + (cursor_h+1)); do_test(data, left , right , top - (cursor_h+1), bottom + (cursor_h+1));
do_test(test_data, left - (cursor_w+1), right + (cursor_w+1), 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 */ /* fully outside by 2 extra pixels */
do_test(test_data, left - (cursor_w+2), right + (cursor_w+2), top , bottom ); do_test(data, left - (cursor_w+2), right + (cursor_w+2), top , bottom );
do_test(test_data, left , right , top - (cursor_h+2), bottom + (cursor_h+2)); do_test(data, left , right , top - (cursor_h+2), bottom + (cursor_h+2));
do_test(test_data, left - (cursor_w+2), right + (cursor_w+2), 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 */ /* fully outside by a lot of extra pixels */
do_test(test_data, left - (cursor_w+512), right + (cursor_w+512), top , bottom ); do_test(data, left - (cursor_w+512), right + (cursor_w+512), top , bottom );
do_test(test_data, left , right , top - (cursor_h+512), bottom + (cursor_h+512)); do_test(data, left , right , top - (cursor_h+512), bottom + (cursor_h+512));
do_test(test_data, left - (cursor_w+512), right + (cursor_w+512), 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 */ /* go nuts */
do_test(test_data, INT_MIN, INT_MAX, INT_MIN, INT_MAX); do_test(data, INT_MIN, INT_MAX, INT_MIN, INT_MAX);
} }
static void test_crc_sliding(test_data_t *test_data) static void test_crc_sliding(data_t *data)
{ {
int i; int i;
@ -203,34 +196,33 @@ static void test_crc_sliding(test_data_t *test_data)
* no alignment issues. Horizontal, vertical and diagonal test. * no alignment issues. Horizontal, vertical and diagonal test.
*/ */
for (i = 0; i < 16; i++) { for (i = 0; i < 16; i++) {
do_single_test(test_data, i, 0); do_single_test(data, i, 0);
do_single_test(test_data, 0, i); do_single_test(data, 0, i);
do_single_test(test_data, i, i); do_single_test(data, i, i);
} }
} }
static void test_crc_random(test_data_t *test_data) static void test_crc_random(data_t *data)
{ {
int i; int i;
/* Random cursor placement */ /* Random cursor placement */
for (i = 0; i < 50; i++) { for (i = 0; i < 50; i++) {
int x = rand() % (test_data->screenw + test_data->curw * 2) - test_data->curw; int x = rand() % (data->screenw + data->curw * 2) - data->curw;
int y = rand() % (test_data->screenh + test_data->curh * 2) - test_data->curh; int y = rand() % (data->screenh + data->curh * 2) - data->curh;
do_single_test(test_data, x, y); do_single_test(data, x, y);
} }
} }
static bool prepare_crtc(test_data_t *test_data, igt_output_t *output, static bool prepare_crtc(data_t *data, igt_output_t *output,
int cursor_w, int cursor_h) int cursor_w, int cursor_h)
{ {
drmModeModeInfo *mode; drmModeModeInfo *mode;
data_t *data = test_data->data;
igt_display_t *display = &data->display; igt_display_t *display = &data->display;
igt_plane_t *primary; igt_plane_t *primary;
/* select the pipe we want to use */ /* select the pipe we want to use */
igt_output_set_pipe(output, test_data->pipe); igt_output_set_pipe(output, data->pipe);
igt_display_commit(display); igt_display_commit(display);
if (!output->valid) { if (!output->valid) {
@ -242,10 +234,10 @@ static bool prepare_crtc(test_data_t *test_data, igt_output_t *output,
/* create and set the primary plane fb */ /* create and set the primary plane fb */
mode = igt_output_get_mode(output); mode = igt_output_get_mode(output);
igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay, igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay,
DRM_FORMAT_XRGB8888, DRM_FORMAT_XRGB8888,
false, /* tiled */ false, /* tiled */
0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
&data->primary_fb); &data->primary_fb);
primary = igt_output_get_plane(output, IGT_PLANE_PRIMARY); primary = igt_output_get_plane(output, IGT_PLANE_PRIMARY);
igt_plane_set_fb(primary, &data->primary_fb); igt_plane_set_fb(primary, &data->primary_fb);
@ -253,46 +245,45 @@ static bool prepare_crtc(test_data_t *test_data, igt_output_t *output,
igt_display_commit(display); igt_display_commit(display);
/* create the pipe_crc object for this pipe */ /* create the pipe_crc object for this pipe */
if (test_data->pipe_crc) if (data->pipe_crc)
igt_pipe_crc_free(test_data->pipe_crc); igt_pipe_crc_free(data->pipe_crc);
test_data->pipe_crc = igt_pipe_crc_new(test_data->pipe, data->pipe_crc = igt_pipe_crc_new(data->pipe,
INTEL_PIPE_CRC_SOURCE_AUTO); INTEL_PIPE_CRC_SOURCE_AUTO);
if (!test_data->pipe_crc) { if (!data->pipe_crc) {
igt_info("auto crc not supported on this connector with pipe %i\n", igt_info("auto crc not supported on this connector with pipe %i\n",
test_data->pipe); data->pipe);
return false; return false;
} }
/* x/y position where the cursor is still fully visible */ /* x/y position where the cursor is still fully visible */
test_data->left = 0; data->left = 0;
test_data->right = mode->hdisplay - cursor_w; data->right = mode->hdisplay - cursor_w;
test_data->top = 0; data->top = 0;
test_data->bottom = mode->vdisplay - cursor_h; data->bottom = mode->vdisplay - cursor_h;
test_data->screenw = mode->hdisplay; data->screenw = mode->hdisplay;
test_data->screenh = mode->vdisplay; data->screenh = mode->vdisplay;
test_data->curw = cursor_w; data->curw = cursor_w;
test_data->curh = cursor_h; data->curh = cursor_h;
test_data->cursor_max_size = cursor_w; data->cursor_max_size = cursor_w;
/* make sure cursor is disabled */ /* make sure cursor is disabled */
cursor_disable(test_data); cursor_disable(data);
igt_wait_for_vblank(data->drm_fd, test_data->pipe); igt_wait_for_vblank(data->drm_fd, data->pipe);
/* get reference crc w/o cursor */ /* get reference crc w/o cursor */
igt_pipe_crc_collect_crc(test_data->pipe_crc, &test_data->ref_crc); igt_pipe_crc_collect_crc(data->pipe_crc, &data->ref_crc);
return true; return true;
} }
static void cleanup_crtc(test_data_t *test_data, igt_output_t *output) static void cleanup_crtc(data_t *data, igt_output_t *output)
{ {
data_t *data = test_data->data;
igt_display_t *display = &data->display; igt_display_t *display = &data->display;
igt_plane_t *primary; igt_plane_t *primary;
igt_pipe_crc_free(test_data->pipe_crc); igt_pipe_crc_free(data->pipe_crc);
test_data->pipe_crc = NULL; data->pipe_crc = NULL;
igt_remove_fb(data->drm_fd, &data->primary_fb); igt_remove_fb(data->drm_fd, &data->primary_fb);
@ -303,38 +294,35 @@ static void cleanup_crtc(test_data_t *test_data, igt_output_t *output)
igt_display_commit(display); igt_display_commit(display);
} }
static void run_test(data_t *data, void (*testfunc)(test_data_t *), int cursor_w, int cursor_h) static void run_test(data_t *data, void (*testfunc)(data_t *), int cursor_w, int cursor_h)
{ {
igt_display_t *display = &data->display; igt_display_t *display = &data->display;
igt_output_t *output; igt_output_t *output;
enum pipe p; enum pipe p;
test_data_t test_data = {
.data = data,
};
int valid_tests = 0; int valid_tests = 0;
for_each_connected_output(display, output) { for_each_connected_output(display, output) {
test_data.output = output; data->output = output;
for (p = 0; p < igt_display_get_n_pipes(display); p++) { for (p = 0; p < igt_display_get_n_pipes(display); p++) {
test_data.pipe = p; data->pipe = p;
if (!prepare_crtc(&test_data, output, cursor_w, cursor_h)) if (!prepare_crtc(data, output, cursor_w, cursor_h))
continue; continue;
valid_tests++; valid_tests++;
igt_info("Beginning %s on pipe %c, connector %s\n", igt_info("Beginning %s on pipe %c, connector %s\n",
igt_subtest_name(), pipe_name(test_data.pipe), igt_subtest_name(), pipe_name(data->pipe),
igt_output_name(output)); igt_output_name(output));
testfunc(&test_data); testfunc(data);
igt_info("\n%s on pipe %c, connector %s: PASSED\n\n", igt_info("\n%s on pipe %c, connector %s: PASSED\n\n",
igt_subtest_name(), pipe_name(test_data.pipe), igt_subtest_name(), pipe_name(data->pipe),
igt_output_name(output)); igt_output_name(output));
/* cleanup what prepare_crtc() has done */ /* cleanup what prepare_crtc() has done */
cleanup_crtc(&test_data, output); cleanup_crtc(data, output);
} }
} }
@ -356,16 +344,15 @@ static void create_cursor_fb(data_t *data, int cur_w, int cur_h)
igt_assert(cairo_status(cr) == 0); igt_assert(cairo_status(cr) == 0);
} }
static void test_cursor_size(test_data_t *test_data) static void test_cursor_size(data_t *data)
{ {
data_t *data = test_data->data;
igt_display_t *display = &data->display; igt_display_t *display = &data->display;
igt_pipe_crc_t *pipe_crc = test_data->pipe_crc; igt_pipe_crc_t *pipe_crc = data->pipe_crc;
igt_crc_t crc[10], ref_crc; igt_crc_t crc[10], ref_crc;
igt_plane_t *cursor; igt_plane_t *cursor;
cairo_t *cr; cairo_t *cr;
uint32_t fb_id; uint32_t fb_id;
int i, size, cursor_max_size = test_data->cursor_max_size; int i, size, cursor_max_size = data->cursor_max_size;
/* Create a maximum size cursor, then change the size in flight to /* Create a maximum size cursor, then change the size in flight to
* smaller ones to see that the size is applied correctly * smaller ones to see that the size is applied correctly
@ -379,28 +366,28 @@ static void test_cursor_size(test_data_t *test_data)
igt_paint_color_alpha(cr, 0, 0, cursor_max_size, cursor_max_size, 1.0, 1.0, 1.0, 1.0); igt_paint_color_alpha(cr, 0, 0, cursor_max_size, cursor_max_size, 1.0, 1.0, 1.0, 1.0);
/* Hardware test loop */ /* Hardware test loop */
cursor_enable(test_data); cursor_enable(data);
cursor = igt_output_get_plane(test_data->output, IGT_PLANE_CURSOR); cursor = igt_output_get_plane(data->output, IGT_PLANE_CURSOR);
igt_plane_set_position(cursor, 0, 0); igt_plane_set_position(cursor, 0, 0);
for (i = 0, size = cursor_max_size; size >= 64; size /= 2, i++) { for (i = 0, size = cursor_max_size; size >= 64; size /= 2, i++) {
/* Change size in flight: */ /* Change size in flight: */
int ret = drmModeSetCursor(data->drm_fd, test_data->output->config.crtc->crtc_id, int ret = drmModeSetCursor(data->drm_fd, data->output->config.crtc->crtc_id,
data->fb.gem_handle, size, size); data->fb.gem_handle, size, size);
igt_assert(ret == 0); igt_assert(ret == 0);
igt_wait_for_vblank(data->drm_fd, test_data->pipe); igt_wait_for_vblank(data->drm_fd, data->pipe);
igt_pipe_crc_collect_crc(pipe_crc, &crc[i]); igt_pipe_crc_collect_crc(pipe_crc, &crc[i]);
} }
cursor_disable(test_data); cursor_disable(data);
/* Software test loop */ /* Software test loop */
cr = igt_get_cairo_ctx(data->drm_fd, &data->primary_fb); cr = igt_get_cairo_ctx(data->drm_fd, &data->primary_fb);
for (i = 0, size = cursor_max_size; size >= 64; size /= 2, i++) { for (i = 0, size = cursor_max_size; size >= 64; size /= 2, i++) {
/* Now render the same in software and collect crc */ /* Now render the same in software and collect crc */
igt_paint_color_alpha(cr, 0, 0, size, size, 1.0, 1.0, 1.0, 1.0); igt_paint_color_alpha(cr, 0, 0, size, size, 1.0, 1.0, 1.0, 1.0);
igt_display_commit(display); igt_display_commit(display);
igt_wait_for_vblank(data->drm_fd, test_data->pipe); igt_wait_for_vblank(data->drm_fd, data->pipe);
igt_pipe_crc_collect_crc(pipe_crc, &ref_crc); igt_pipe_crc_collect_crc(pipe_crc, &ref_crc);
/* Clear screen afterwards */ /* Clear screen afterwards */
igt_paint_color(cr, 0, 0, test_data->screenw, test_data->screenh, igt_paint_color(cr, 0, 0, data->screenw, data->screenh,
0.0, 0.0, 0.0); 0.0, 0.0, 0.0);
igt_assert(igt_crc_equal(&crc[i], &ref_crc)); igt_assert(igt_crc_equal(&crc[i], &ref_crc));
} }