From patchwork Thu May 15 19:36:17 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Matt Roper X-Patchwork-Id: 4185531 Return-Path: X-Original-To: patchwork-intel-gfx@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork2.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.19.201]) by patchwork2.web.kernel.org (Postfix) with ESMTP id EF191BFF02 for ; Thu, 15 May 2014 19:35:40 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 6AD9920176 for ; Thu, 15 May 2014 19:35:39 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) by mail.kernel.org (Postfix) with ESMTP id DABF72012F for ; Thu, 15 May 2014 19:35:37 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 79A2A6E852; Thu, 15 May 2014 12:35:37 -0700 (PDT) X-Original-To: intel-gfx@lists.freedesktop.org Delivered-To: intel-gfx@lists.freedesktop.org Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by gabe.freedesktop.org (Postfix) with ESMTP id AD3E26E84F for ; Thu, 15 May 2014 12:35:36 -0700 (PDT) Received: from fmsmga002.fm.intel.com ([10.253.24.26]) by fmsmga101.fm.intel.com with ESMTP; 15 May 2014 12:35:35 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos; i="4.97,1061,1389772800"; d="scan'208"; a="539819621" Received: from mdroper-hswdev.fm.intel.com (HELO mdroper-hswdev) ([10.1.134.215]) by fmsmga002.fm.intel.com with ESMTP; 15 May 2014 12:35:34 -0700 Received: from mattrope by mdroper-hswdev with local (Exim 4.82) (envelope-from ) id 1Wl1S5-0005E7-A6; Thu, 15 May 2014 12:36:25 -0700 From: Matt Roper To: intel-gfx@lists.freedesktop.org Date: Thu, 15 May 2014 12:36:17 -0700 Message-Id: <1400182577-20057-1-git-send-email-matthew.d.roper@intel.com> X-Mailer: git-send-email 1.8.5.1 In-Reply-To: <1398877871-17046-4-git-send-email-matthew.d.roper@intel.com> References: <1398877871-17046-4-git-send-email-matthew.d.roper@intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH 4/4] kms_universal_plane: Universal plane testing (v3) X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" X-Spam-Status: No, score=-4.8 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_MED, RP_MATCHES_RCVD, UNPARSEABLE_RELAY autolearn=unavailable version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Add a simple test to exercise universal plane support. v3: - For testing while crtc is off, switch between several different primary plane fb's before reenabling the crtc. This will help catch pin/unpin mistakes. v2: - Test that pageflips error out gracefully when the primary plane is disabled before the ioctl, or between ioctl and pageflip execution. - Test that nothing blows up if we try to disable the primary plane immediately after a pageflip (presumably before the pageflip actually completes). - Test that we can setup primary + sprite planes with the CRTC off and then have them show up properly when we enable the CRTC (drmModeSetCrtc with fb = -1). - Test that we can modeset properly after having disabled the primary plane - Test that proper error codes are returned for invalid plane programming attempts. Signed-off-by: Matt Roper --- tests/.gitignore | 1 + tests/Makefile.sources | 1 + tests/kms_universal_plane.c | 530 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 532 insertions(+) create mode 100644 tests/kms_universal_plane.c diff --git a/tests/.gitignore b/tests/.gitignore index fedddbf..bb43a18 100644 --- a/tests/.gitignore +++ b/tests/.gitignore @@ -121,6 +121,7 @@ kms_pipe_crc_basic kms_plane kms_render kms_setmode +kms_universal_plane multi-tests.txt pm_lpsp pm_pc8 diff --git a/tests/Makefile.sources b/tests/Makefile.sources index a8a091d..fa8ac9a 100644 --- a/tests/Makefile.sources +++ b/tests/Makefile.sources @@ -65,6 +65,7 @@ TESTS_progs_M = \ kms_plane \ kms_render \ kms_setmode \ + kms_universal_plane \ pm_lpsp \ pm_pc8 \ pm_rps \ diff --git a/tests/kms_universal_plane.c b/tests/kms_universal_plane.c new file mode 100644 index 0000000..20d175c --- /dev/null +++ b/tests/kms_universal_plane.c @@ -0,0 +1,530 @@ +/* + * Copyright © 2014 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#include +#include +#include +#include + +#include "drmtest.h" +#include "igt_debugfs.h" +#include "igt_kms.h" + +typedef struct { + int drm_fd; + igt_display_t display; +} data_t; + +typedef struct { + data_t *data; + igt_pipe_crc_t *pipe_crc; + igt_crc_t crc_1, crc_2, crc_3, crc_4, crc_5, crc_6, crc_7, crc_8; + struct igt_fb red_fb, blue_fb, black_fb, yellow_fb; + drmModeModeInfo *mode; +} functional_test_t; + +typedef struct { + data_t *data; + drmModeResPtr moderes; + struct igt_fb blue_fb, oversized_fb, undersized_fb; +} sanity_test_t; + +typedef struct { + data_t *data; + struct igt_fb red_fb, blue_fb; +} pageflip_test_t; + +static void +functional_test_init(functional_test_t *test, igt_output_t *output, enum pipe pipe) +{ + data_t *data = test->data; + drmModeModeInfo *mode; + + test->pipe_crc = igt_pipe_crc_new(pipe, INTEL_PIPE_CRC_SOURCE_AUTO); + + igt_output_set_pipe(output, pipe); + + mode = igt_output_get_mode(output); + igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay, + DRM_FORMAT_XRGB8888, + false, /* tiled */ + 0.0, 0.0, 0.0, + &test->black_fb); + igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay, + DRM_FORMAT_XRGB8888, + false, /* tiled */ + 0.0, 0.0, 1.0, + &test->blue_fb); + igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay, + DRM_FORMAT_XRGB8888, + false, /* tiled */ + 1.0, 1.0, 0.0, + &test->yellow_fb); + igt_create_color_fb(data->drm_fd, 100, 100, + DRM_FORMAT_XRGB8888, + false, /* tiled */ + 1.0, 0.0, 0.0, + &test->red_fb); + + test->mode = mode; +} + +static void +functional_test_fini(functional_test_t *test, igt_output_t *output) +{ + igt_pipe_crc_free(test->pipe_crc); + + igt_remove_fb(test->data->drm_fd, &test->black_fb); + igt_remove_fb(test->data->drm_fd, &test->blue_fb); + igt_remove_fb(test->data->drm_fd, &test->red_fb); + igt_remove_fb(test->data->drm_fd, &test->yellow_fb); + + igt_display_use_universal_commits(&test->data->display, false); + igt_output_set_pipe(output, PIPE_ANY); + igt_display_commit(&test->data->display); +} + +/* + * Universal plane functional testing. + * - Black primary plane via traditional interfaces, red sprite, grab CRC:1. + * - Blue primary plane via traditional interfaces, red sprite, grab CRC:2. + * - Yellow primary via traditional interfaces + * - Blue primary plane, red sprite via universal planes, grab CRC:3 and compare + * with CRC:2 (should be the same) + * - Disable primary plane, grab CRC:4 (should be same as CRC:1) + * - Reenable primary, grab CRC:5 (should be same as CRC:2 and CRC:3) + * - Yellow primary, no sprite + * - Disable CRTC + * - Program red sprite (while CRTC off) + * - Program blue primary (while CRTC off) + * - Enable CRTC, grab CRC:6 (should be same as CRC:2) + */ +static void +functional_test_pipe(data_t *data, enum pipe pipe, igt_output_t *output) +{ + functional_test_t test = { .data = data }; + igt_display_t *display = &data->display; + igt_plane_t *primary, *sprite; + int ret; + + igt_skip_on(pipe >= display->n_pipes); + + fprintf(stdout, "Testing connector %s using pipe %c\n", + igt_output_name(output), pipe_name(pipe)); + + functional_test_init(&test, output, pipe); + + primary = igt_output_get_plane(output, IGT_PLANE_PRIMARY); + sprite = igt_output_get_plane(output, IGT_PLANE_2); + if (!sprite) { + functional_test_fini(&test, output); + igt_skip("No sprite plane available\n"); + } + + igt_plane_set_position(sprite, 100, 100); + + /* Step 1: Legacy API's, black primary, red sprite (CRC 1) */ + igt_plane_set_fb(primary, &test.black_fb); + igt_plane_set_fb(sprite, &test.red_fb); + igt_display_commit(display); + igt_pipe_crc_collect_crc(test.pipe_crc, &test.crc_1); + + /* Step 2: Legacy API', blue primary, red sprite (CRC 2) */ + igt_plane_set_fb(primary, &test.blue_fb); + igt_plane_set_fb(sprite, &test.red_fb); + igt_display_commit(display); + igt_pipe_crc_collect_crc(test.pipe_crc, &test.crc_2); + + /* Step 3: Legacy API's, yellow primary (CRC 3) */ + igt_plane_set_fb(primary, &test.yellow_fb); + igt_display_commit(display); + igt_pipe_crc_collect_crc(test.pipe_crc, &test.crc_3); + + /* Step 4: Universal API's, blue primary, red sprite (CRC 4) */ + igt_display_use_universal_commits(display, true); + igt_plane_set_fb(primary, &test.blue_fb); + igt_plane_set_fb(sprite, &test.red_fb); + igt_display_commit(display); + igt_pipe_crc_collect_crc(test.pipe_crc, &test.crc_4); + + /* Step 5: Universal API's, disable primary plane (CRC 5) */ + igt_plane_set_fb(primary, NULL); + igt_display_commit(display); + igt_pipe_crc_collect_crc(test.pipe_crc, &test.crc_5); + + /* Step 6: Universal API's, re-enable primary with blue (CRC 6) */ + igt_display_use_universal_commits(display, true); + igt_plane_set_fb(primary, &test.blue_fb); + igt_display_commit(display); + igt_pipe_crc_collect_crc(test.pipe_crc, &test.crc_6); + + /* Step 7: Legacy API's, yellow primary, no sprite */ + igt_display_use_universal_commits(display, false); + igt_plane_set_fb(primary, &test.yellow_fb); + igt_plane_set_fb(sprite, NULL); + igt_display_commit(display); + + /* Step 8: Disable CRTC */ + igt_plane_set_fb(primary, NULL); + igt_display_commit(display); + + /* Step 9: Universal API's with crtc off: + * - red sprite + * - multiple primary fb's, ending in blue + */ + igt_display_use_universal_commits(display, true); + igt_plane_set_fb(sprite, &test.red_fb); + ret = igt_drm_plane_try_commit(sprite, output); + igt_assert(ret == 0); + igt_plane_set_fb(primary, &test.yellow_fb); + ret = igt_drm_plane_try_commit(primary, output); + igt_plane_set_fb(primary, &test.black_fb); + ret = igt_drm_plane_try_commit(primary, output); + igt_plane_set_fb(primary, &test.blue_fb); + ret = igt_drm_plane_try_commit(primary, output); + igt_assert(ret == 0); + display->pipes[output->config.pipe].need_wait_for_vblank = false; + + /* Step 10: Enable crtc (fb = -1), take CRC (CRC 7) */ + ret = drmModeSetCrtc(data->drm_fd, output->config.crtc->crtc_id, -1, + 0, 0, &output->config.connector->connector_id, + 1, test.mode); + igt_assert(ret == 0); + igt_pipe_crc_collect_crc(test.pipe_crc, &test.crc_7); + + /* Step 11: Disable primary plane */ + igt_plane_set_fb(primary, NULL); + igt_display_commit(display); + + /* Step 12: Legacy modeset to yellow FB (CRC 8) */ + igt_display_use_universal_commits(display, false); + igt_plane_set_fb(primary, &test.yellow_fb); + igt_display_commit(display); + igt_pipe_crc_collect_crc(test.pipe_crc, &test.crc_8); + + /* Blue bg + red sprite should be same under both types of API's */ + igt_assert(igt_crc_equal(&test.crc_2, &test.crc_4)); + + /* Disabling primary plane should be same as black primary */ + igt_assert(igt_crc_equal(&test.crc_1, &test.crc_5)); + + /* Re-enabling primary should return to blue properly */ + igt_assert(igt_crc_equal(&test.crc_2, &test.crc_6)); + + /* + * We should be able to setup plane FB's while CRTC is disabled and + * then have them pop up correctly when the CRTC is re-enabled. + */ + igt_assert(igt_crc_equal(&test.crc_2, &test.crc_7)); + + /* + * We should be able to modeset with the primary plane off + * successfully + */ + igt_assert(igt_crc_equal(&test.crc_3, &test.crc_8)); + + igt_plane_set_fb(primary, NULL); + igt_plane_set_fb(sprite, NULL); + + functional_test_fini(&test, output); +} + +static void +sanity_test_init(sanity_test_t *test, igt_output_t *output, enum pipe pipe) +{ + data_t *data = test->data; + drmModeModeInfo *mode; + + igt_output_set_pipe(output, pipe); + + mode = igt_output_get_mode(output); + igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay, + DRM_FORMAT_XRGB8888, + false, /* tiled */ + 0.0, 0.0, 1.0, + &test->blue_fb); + igt_create_color_fb(data->drm_fd, + mode->hdisplay + 100, mode->vdisplay + 100, + DRM_FORMAT_XRGB8888, + false, /* tiled */ + 0.0, 0.0, 1.0, + &test->oversized_fb); + igt_create_color_fb(data->drm_fd, + mode->hdisplay - 100, mode->vdisplay - 100, + DRM_FORMAT_XRGB8888, + false, /* tiled */ + 0.0, 0.0, 1.0, + &test->undersized_fb); + + test->moderes = drmModeGetResources(data->drm_fd); +} + +static void +sanity_test_fini(sanity_test_t *test, igt_output_t *output) +{ + drmModeFreeResources(test->moderes); + + igt_remove_fb(test->data->drm_fd, &test->oversized_fb); + igt_remove_fb(test->data->drm_fd, &test->undersized_fb); + igt_remove_fb(test->data->drm_fd, &test->blue_fb); + + igt_display_use_universal_commits(&test->data->display, false); + igt_output_set_pipe(output, PIPE_ANY); + igt_display_commit(&test->data->display); +} + +/* + * Universal plane sanity testing. + * - Primary doesn't cover CRTC + * - Primary plane tries to scale down + * - Primary plane tries to scale up + */ +static void +sanity_test_pipe(data_t *data, enum pipe pipe, igt_output_t *output) +{ + sanity_test_t test = { .data = data }; + igt_plane_t *primary; + drmModeModeInfo *mode; + int i, ret = 0; + + igt_output_set_pipe(output, pipe); + mode = igt_output_get_mode(output); + + sanity_test_init(&test, output, pipe); + + primary = igt_output_get_plane(output, IGT_PLANE_PRIMARY); + + /* Use legacy API to set a mode with a blue FB */ + igt_plane_set_fb(primary, &test.blue_fb); + igt_display_commit(&data->display); + + /* + * Try to use universal plane API to set primary plane that + * doesn't cover CRTC (should fail). + */ + igt_plane_set_fb(primary, &test.undersized_fb); + ret = igt_drm_plane_try_commit(primary, output); + igt_assert(ret == -EINVAL); + + /* Same as above, but different plane positioning. */ + primary->crtc_x = 100; + primary->crtc_y = 100; + primary->position_changed = true; + ret = igt_drm_plane_try_commit(primary, output); + igt_assert(ret == -EINVAL); + + primary->crtc_x = 0; + primary->crtc_y = 0; + primary->position_changed = false; + + /* Try to use universal plane API to scale down (should fail) */ + ret = drmModeSetPlane(data->drm_fd, primary->drm_plane->plane_id, + output->config.crtc->crtc_id, + test.oversized_fb.fb_id, 0, + 0, 0, + mode->hdisplay + 100, + mode->vdisplay + 100, + IGT_FIXED(0,0), IGT_FIXED(0,0), + IGT_FIXED(mode->hdisplay,0), + IGT_FIXED(mode->vdisplay,0)); + igt_assert(ret == -ERANGE); + + /* Try to use universal plane API to scale up (should fail) */ + ret = drmModeSetPlane(data->drm_fd, primary->drm_plane->plane_id, + output->config.crtc->crtc_id, + test.oversized_fb.fb_id, 0, + 0, 0, + mode->hdisplay, + mode->vdisplay, + IGT_FIXED(0,0), IGT_FIXED(0,0), + IGT_FIXED(mode->hdisplay - 100,0), + IGT_FIXED(mode->vdisplay - 100,0)); + igt_assert(ret == -ERANGE); + + /* Find other crtcs and try to program our primary plane on them */ + for (i = 0; i < test.moderes->count_crtcs; i++) + if (test.moderes->crtcs[i] != output->config.crtc->crtc_id) { + ret = drmModeSetPlane(data->drm_fd, + primary->drm_plane->plane_id, + test.moderes->crtcs[i], + test.blue_fb.fb_id, 0, + 0, 0, + mode->hdisplay, + mode->vdisplay, + IGT_FIXED(0,0), IGT_FIXED(0,0), + IGT_FIXED(mode->hdisplay,0), + IGT_FIXED(mode->vdisplay,0)); + igt_assert(ret == -EINVAL); + } + + igt_plane_set_fb(primary, NULL); + sanity_test_fini(&test, output); +} + +static void +pageflip_test_init(pageflip_test_t *test, igt_output_t *output, enum pipe pipe) +{ + data_t *data = test->data; + drmModeModeInfo *mode; + + igt_output_set_pipe(output, pipe); + + mode = igt_output_get_mode(output); + igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay, + DRM_FORMAT_XRGB8888, + false, /* tiled */ + 1.0, 0.0, 0.0, + &test->red_fb); + igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay, + DRM_FORMAT_XRGB8888, + false, /* tiled */ + 0.0, 0.0, 1.0, + &test->blue_fb); +} + +static void +pageflip_test_fini(pageflip_test_t *test, igt_output_t *output) +{ + igt_remove_fb(test->data->drm_fd, &test->red_fb); + igt_remove_fb(test->data->drm_fd, &test->blue_fb); + + igt_display_use_universal_commits(&test->data->display, false); + igt_output_set_pipe(output, PIPE_ANY); + igt_display_commit(&test->data->display); +} + +static void +pageflip_test_pipe(data_t *data, enum pipe pipe, igt_output_t *output) +{ + pageflip_test_t test = { .data = data }; + igt_plane_t *primary; + struct timeval timeout = { .tv_sec = 0, .tv_usec = 500 }; + drmEventContext evctx = { .version = DRM_EVENT_CONTEXT_VERSION }; + + fd_set fds; + int ret = 0; + + igt_output_set_pipe(output, pipe); + + pageflip_test_init(&test, output, pipe); + + primary = igt_output_get_plane(output, IGT_PLANE_PRIMARY); + + /* Use legacy API to set a mode with a blue FB */ + igt_display_use_universal_commits(&data->display, false); + igt_plane_set_fb(primary, &test.blue_fb); + igt_display_commit(&data->display); + + /* Disable the primary plane */ + igt_display_use_universal_commits(&data->display, true); + igt_plane_set_fb(primary, NULL); + igt_display_commit(&data->display); + + /* + * Issue a pageflip to red FB + * + * Note that crtc->primary->fb = NULL causes flip to return EBUSY for + * historical reasons... + */ + ret = drmModePageFlip(data->drm_fd, output->config.crtc->crtc_id, + test.red_fb.fb_id, 0, NULL); + igt_assert(ret == -EBUSY); + + /* Turn primary plane back on */ + igt_plane_set_fb(primary, &test.blue_fb); + igt_display_commit(&data->display); + + /* + * Issue a pageflip to red, then immediately try to disable the primary + * plane, hopefully before the pageflip has a chance to complete. The + * plane disable operation should wind up blocking while the pageflip + * completes, which we don't have a good way to specifically test for, + * but at least we can make sure that nothing blows up. + */ + ret = drmModePageFlip(data->drm_fd, output->config.crtc->crtc_id, + test.red_fb.fb_id, DRM_MODE_PAGE_FLIP_EVENT, + &test); + igt_assert(ret == 0); + igt_plane_set_fb(primary, NULL); + igt_display_commit(&data->display); + + /* Wait for pageflip completion, then consume event on fd */ + FD_ZERO(&fds); + FD_SET(data->drm_fd, &fds); + do { + ret = select(data->drm_fd + 1, &fds, NULL, NULL, &timeout); + } while (ret < 0 && errno == EINTR); + igt_assert(ret == 1); + ret = drmHandleEvent(data->drm_fd, &evctx); + igt_assert(ret == 0); + + igt_display_use_universal_commits(&data->display, false); + igt_plane_set_fb(primary, NULL); + pageflip_test_fini(&test, output); +} + +static void +run_tests_for_pipe(data_t *data, enum pipe pipe) +{ + igt_output_t *output; + + igt_assert(data->display.has_universal_planes); + + igt_subtest_f("universal-plane-pipe-%c-functional", pipe_name(pipe)) + for_each_connected_output(&data->display, output) + functional_test_pipe(data, pipe, output); + + igt_subtest_f("universal-plane-pipe-%c-sanity", pipe_name(pipe)) + for_each_connected_output(&data->display, output) + sanity_test_pipe(data, pipe, output); + + igt_subtest_f("disable-primary-vs-flip-pipe-%c", pipe_name(pipe)) + for_each_connected_output(&data->display, output) + pageflip_test_pipe(data, pipe, output); +} + +static data_t data; + +igt_main +{ + + igt_skip_on_simulation(); + + igt_fixture { + data.drm_fd = drm_open_any(); + + igt_set_vt_graphics_mode(); + + igt_require_pipe_crc(); + igt_display_init(&data.display, data.drm_fd); + + igt_require(data.display.has_universal_planes); + } + + for (int pipe = 0; pipe < 3; pipe++) + run_tests_for_pipe(&data, pipe); + + igt_fixture { + igt_display_fini(&data.display); + } +}