| /* |
| * 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 "igt.h" |
| #include <errno.h> |
| #include <stdbool.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <fcntl.h> |
| |
| |
| typedef struct { |
| int drm_fd; |
| igt_display_t display; |
| int gen; |
| } 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, |
| crc_9, crc_10; |
| 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; |
| |
| typedef struct { |
| data_t *data; |
| int x, y; |
| int w, h; |
| struct igt_fb biggreen_fb, smallred_fb, smallblue_fb; |
| } gen9_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(data->drm_fd, 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, |
| LOCAL_DRM_FORMAT_MOD_NONE, |
| 0.0, 0.0, 0.0, |
| &test->black_fb); |
| igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay, |
| DRM_FORMAT_XRGB8888, |
| LOCAL_DRM_FORMAT_MOD_NONE, |
| 0.0, 0.0, 1.0, |
| &test->blue_fb); |
| igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay, |
| DRM_FORMAT_XRGB8888, |
| LOCAL_DRM_FORMAT_MOD_NONE, |
| 1.0, 1.0, 0.0, |
| &test->yellow_fb); |
| igt_create_color_fb(data->drm_fd, 100, 100, |
| DRM_FORMAT_XRGB8888, |
| LOCAL_DRM_FORMAT_MOD_NONE, |
| 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_output_set_pipe(output, PIPE_ANY); |
| igt_display_commit2(&test->data->display, COMMIT_LEGACY); |
| } |
| |
| /* |
| * 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 num_primary = 0, num_cursor = 0; |
| int i; |
| |
| igt_skip_on(pipe >= display->n_pipes); |
| |
| igt_info("Testing connector %s using pipe %s\n", igt_output_name(output), |
| kmstest_pipe_name(pipe)); |
| |
| functional_test_init(&test, output, pipe); |
| |
| /* |
| * Make sure we have no more than one primary or cursor plane per crtc. |
| * If the kernel accidentally calls drm_plane_init() rather than |
| * drm_universal_plane_init(), the type enum can get interpreted as a |
| * boolean and show up in userspace as the wrong type. |
| */ |
| for (i = 0; i < display->pipes[pipe].n_planes; i++) |
| if (display->pipes[pipe].planes[i].type == DRM_PLANE_TYPE_PRIMARY) |
| num_primary++; |
| else if (display->pipes[pipe].planes[i].type == DRM_PLANE_TYPE_CURSOR) |
| num_cursor++; |
| |
| igt_assert_eq(num_primary, 1); |
| igt_assert_lte(num_cursor, 1); |
| |
| primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY); |
| sprite = igt_output_get_plane_type(output, DRM_PLANE_TYPE_OVERLAY); |
| 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_commit2(display, COMMIT_LEGACY); |
| 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_commit2(display, COMMIT_LEGACY); |
| 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_commit2(display, COMMIT_LEGACY); |
| igt_pipe_crc_collect_crc(test.pipe_crc, &test.crc_3); |
| |
| /* Step 4: Universal API's, blue primary, red sprite (CRC 4) */ |
| igt_plane_set_fb(primary, &test.blue_fb); |
| igt_plane_set_fb(sprite, &test.red_fb); |
| igt_display_commit2(display, COMMIT_UNIVERSAL); |
| 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_commit2(display, COMMIT_UNIVERSAL); |
| igt_pipe_crc_collect_crc(test.pipe_crc, &test.crc_5); |
| |
| /* Step 6: Universal API's, re-enable primary with blue (CRC 6) */ |
| igt_plane_set_fb(primary, &test.blue_fb); |
| igt_display_commit2(display, COMMIT_UNIVERSAL); |
| igt_pipe_crc_collect_crc(test.pipe_crc, &test.crc_6); |
| |
| /* Step 7: Legacy API's, yellow primary, no sprite */ |
| igt_plane_set_fb(primary, &test.yellow_fb); |
| igt_plane_set_fb(sprite, NULL); |
| igt_display_commit2(display, COMMIT_LEGACY); |
| |
| /* Step 8: Disable CRTC */ |
| igt_plane_set_fb(primary, NULL); |
| igt_display_commit2(display, COMMIT_LEGACY); |
| |
| /* Step 9: Universal API's with crtc off: |
| * - red sprite |
| * - multiple primary fb's, ending in blue |
| */ |
| igt_plane_set_fb(sprite, &test.red_fb); |
| igt_display_commit2(display, COMMIT_UNIVERSAL); |
| igt_plane_set_fb(primary, &test.yellow_fb); |
| igt_display_commit2(display, COMMIT_UNIVERSAL); |
| igt_plane_set_fb(primary, &test.black_fb); |
| igt_display_commit2(display, COMMIT_UNIVERSAL); |
| igt_plane_set_fb(primary, &test.blue_fb); |
| igt_display_commit2(display, COMMIT_UNIVERSAL); |
| |
| /* Step 10: Enable crtc (fb = -1), take CRC (CRC 7) */ |
| igt_assert(drmModeSetCrtc(data->drm_fd, output->config.crtc->crtc_id, -1, |
| 0, 0, &output->config.connector->connector_id, |
| 1, test.mode) == 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_commit2(display, COMMIT_UNIVERSAL); |
| |
| /* Step 12: Legacy modeset to yellow FB (CRC 8) */ |
| igt_plane_set_fb(primary, &test.yellow_fb); |
| igt_display_commit2(display, COMMIT_LEGACY); |
| igt_pipe_crc_collect_crc(test.pipe_crc, &test.crc_8); |
| |
| /* Step 13: Legacy API', blue primary, red sprite */ |
| igt_plane_set_fb(primary, &test.blue_fb); |
| igt_plane_set_fb(sprite, &test.red_fb); |
| igt_display_commit2(display, COMMIT_LEGACY); |
| |
| /* Step 14: Universal API, set primary completely offscreen (CRC 9) */ |
| igt_assert(drmModeSetPlane(data->drm_fd, primary->drm_plane->plane_id, |
| output->config.crtc->crtc_id, |
| test.blue_fb.fb_id, 0, |
| 9000, 9000, |
| test.mode->hdisplay, |
| test.mode->vdisplay, |
| IGT_FIXED(0,0), IGT_FIXED(0,0), |
| IGT_FIXED(test.mode->hdisplay,0), |
| IGT_FIXED(test.mode->vdisplay,0)) == 0); |
| igt_pipe_crc_collect_crc(test.pipe_crc, &test.crc_9); |
| |
| /* |
| * Step 15: Explicitly disable primary after it's already been |
| * implicitly disabled (CRC 10). |
| */ |
| igt_plane_set_fb(primary, NULL); |
| igt_display_commit2(display, COMMIT_UNIVERSAL); |
| igt_pipe_crc_collect_crc(test.pipe_crc, &test.crc_10); |
| |
| /* Step 16: Legacy API's, blue primary, red sprite */ |
| igt_plane_set_fb(primary, &test.blue_fb); |
| igt_plane_set_fb(sprite, &test.red_fb); |
| igt_display_commit2(display, COMMIT_LEGACY); |
| |
| /* Blue bg + red sprite should be same under both types of API's */ |
| igt_assert_crc_equal(&test.crc_2, &test.crc_4); |
| |
| /* Disabling primary plane should be same as black primary */ |
| igt_assert_crc_equal(&test.crc_1, &test.crc_5); |
| |
| /* Re-enabling primary should return to blue properly */ |
| igt_assert_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_crc_equal(&test.crc_2, &test.crc_7); |
| |
| /* |
| * We should be able to modeset with the primary plane off |
| * successfully |
| */ |
| igt_assert_crc_equal(&test.crc_3, &test.crc_8); |
| |
| /* |
| * We should be able to move the primary plane completely offscreen |
| * and have it disable successfully. |
| */ |
| igt_assert_crc_equal(&test.crc_5, &test.crc_9); |
| |
| /* |
| * We should be able to explicitly disable an already |
| * implicitly-disabled primary plane |
| */ |
| igt_assert_crc_equal(&test.crc_5, &test.crc_10); |
| |
| 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, |
| LOCAL_DRM_FORMAT_MOD_NONE, |
| 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, |
| LOCAL_DRM_FORMAT_MOD_NONE, |
| 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, |
| LOCAL_DRM_FORMAT_MOD_NONE, |
| 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_output_set_pipe(output, PIPE_ANY); |
| igt_display_commit2(&test->data->display, COMMIT_LEGACY); |
| } |
| |
| /* |
| * 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; |
| int expect; |
| |
| igt_skip_on(pipe >= data->display.n_pipes); |
| |
| igt_output_set_pipe(output, pipe); |
| mode = igt_output_get_mode(output); |
| |
| sanity_test_init(&test, output, pipe); |
| |
| primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY); |
| |
| /* Use legacy API to set a mode with a blue FB */ |
| igt_plane_set_fb(primary, &test.blue_fb); |
| igt_display_commit2(&data->display, COMMIT_LEGACY); |
| |
| /* |
| * Try to use universal plane API to set primary plane that |
| * doesn't cover CRTC (should fail on pre-gen9 and succeed on |
| * gen9+). |
| */ |
| igt_plane_set_fb(primary, &test.undersized_fb); |
| expect = (data->gen < 9) ? -EINVAL : 0; |
| igt_assert(igt_display_try_commit2(&data->display, COMMIT_UNIVERSAL) == expect); |
| |
| /* Same as above, but different plane positioning. */ |
| igt_plane_set_position(primary, 100, 100); |
| igt_assert(igt_display_try_commit2(&data->display, COMMIT_UNIVERSAL) == expect); |
| |
| igt_plane_set_position(primary, 0, 0); |
| |
| /* Try to use universal plane API to scale down (should fail on pre-gen9) */ |
| expect = (data->gen < 9) ? -ERANGE : 0; |
| igt_assert(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)) == expect); |
| |
| /* Try to use universal plane API to scale up (should fail on pre-gen9) */ |
| igt_assert(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)) == expect); |
| |
| /* 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) { |
| igt_assert(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)) == -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, |
| LOCAL_DRM_FORMAT_MOD_NONE, |
| 1.0, 0.0, 0.0, |
| &test->red_fb); |
| igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay, |
| DRM_FORMAT_XRGB8888, |
| LOCAL_DRM_FORMAT_MOD_NONE, |
| 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_output_set_pipe(output, PIPE_ANY); |
| igt_display_commit2(&test->data->display, COMMIT_LEGACY); |
| } |
| |
| 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 = 2 }; |
| |
| fd_set fds; |
| int ret = 0; |
| |
| igt_skip_on(pipe >= data->display.n_pipes); |
| |
| igt_output_set_pipe(output, pipe); |
| |
| pageflip_test_init(&test, output, pipe); |
| |
| primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY); |
| |
| /* Use legacy API to set a mode with a blue FB */ |
| igt_plane_set_fb(primary, &test.blue_fb); |
| igt_display_commit2(&data->display, COMMIT_LEGACY); |
| |
| /* Disable the primary plane */ |
| igt_plane_set_fb(primary, NULL); |
| igt_display_commit2(&data->display, COMMIT_UNIVERSAL); |
| |
| /* |
| * Issue a pageflip to red FB |
| * |
| * Note that crtc->primary->fb = NULL causes flip to return EBUSY for |
| * historical reasons... |
| */ |
| igt_assert(drmModePageFlip(data->drm_fd, output->config.crtc->crtc_id, |
| test.red_fb.fb_id, 0, NULL) == -EBUSY); |
| |
| /* Turn primary plane back on */ |
| igt_plane_set_fb(primary, &test.blue_fb); |
| igt_display_commit2(&data->display, COMMIT_UNIVERSAL); |
| |
| /* |
| * 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. |
| */ |
| igt_assert(drmModePageFlip(data->drm_fd, output->config.crtc->crtc_id, |
| test.red_fb.fb_id, DRM_MODE_PAGE_FLIP_EVENT, |
| &test) == 0); |
| igt_plane_set_fb(primary, NULL); |
| igt_display_commit2(&data->display, COMMIT_UNIVERSAL); |
| |
| /* 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_eq(ret, 1); |
| igt_assert(drmHandleEvent(data->drm_fd, &evctx) == 0); |
| |
| igt_plane_set_fb(primary, NULL); |
| pageflip_test_fini(&test, output); |
| } |
| |
| static void |
| cursor_leak_test_fini(data_t *data, |
| igt_output_t *output, |
| struct igt_fb *bg, |
| struct igt_fb *curs) |
| { |
| int i; |
| |
| igt_remove_fb(data->drm_fd, bg); |
| for (i = 0; i < 10; i++) |
| igt_remove_fb(data->drm_fd, &curs[i]); |
| |
| igt_output_set_pipe(output, PIPE_ANY); |
| } |
| |
| static int |
| i915_gem_fb_count(data_t *data) |
| { |
| char buf[1024]; |
| FILE *fp; |
| int fd; |
| int count = 0; |
| |
| fd = igt_debugfs_open(data->drm_fd, "i915_gem_framebuffer", O_RDONLY); |
| fp = fdopen(fd, "r"); |
| igt_require(fp); |
| while (fgets(buf, sizeof(buf), fp) != NULL) |
| count++; |
| fclose(fp); |
| close(fd); |
| |
| return count; |
| } |
| |
| static void |
| cursor_leak_test_pipe(data_t *data, enum pipe pipe, igt_output_t *output) |
| { |
| igt_display_t *display = &data->display; |
| igt_plane_t *primary, *cursor; |
| drmModeModeInfo *mode; |
| struct igt_fb background_fb; |
| struct igt_fb cursor_fb[10]; |
| int i; |
| int r, g, b; |
| int count1, count2; |
| |
| igt_skip_on(pipe >= display->n_pipes); |
| igt_require(display->has_cursor_plane); |
| |
| igt_output_set_pipe(output, pipe); |
| mode = igt_output_get_mode(output); |
| |
| /* Count GEM framebuffers before creating our cursor FB's */ |
| count1 = i915_gem_fb_count(data); |
| |
| /* Black background FB */ |
| igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay, |
| DRM_FORMAT_XRGB8888, |
| false, |
| 0.0, 0.0, 0.0, |
| &background_fb); |
| |
| /* Random color cursors */ |
| for (i = 0; i < 10; i++) { |
| r = rand() % 0xFF; |
| g = rand() % 0xFF; |
| b = rand() % 0xFF; |
| igt_create_color_fb(data->drm_fd, 64, 64, |
| DRM_FORMAT_ARGB8888, |
| false, |
| (double)r / 0xFF, |
| (double)g / 0xFF, |
| (double)b / 0xFF, |
| &cursor_fb[i]); |
| } |
| |
| primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY); |
| cursor = igt_output_get_plane_type(output, DRM_PLANE_TYPE_CURSOR); |
| if (!primary || !cursor) { |
| cursor_leak_test_fini(data, output, &background_fb, cursor_fb); |
| igt_skip("Primary and/or cursor are unavailable\n"); |
| } |
| |
| |
| igt_plane_set_fb(primary, &background_fb); |
| igt_display_commit2(display, COMMIT_LEGACY); |
| |
| igt_plane_set_position(cursor, 100, 100); |
| |
| /* |
| * Exercise both legacy and universal code paths. Note that legacy |
| * handling in the kernel redirects through universal codepaths |
| * internally, so that redirection is where we're most worried about |
| * leaking. |
| */ |
| for (i = 0; i < 10; i++) { |
| igt_plane_set_fb(cursor, &cursor_fb[i]); |
| igt_display_commit2(display, COMMIT_UNIVERSAL); |
| } |
| for (i = 0; i < 10; i++) { |
| igt_plane_set_fb(cursor, &cursor_fb[i]); |
| igt_display_commit2(display, COMMIT_LEGACY); |
| } |
| |
| /* Release our framebuffer handles before we take a second count */ |
| igt_plane_set_fb(primary, NULL); |
| igt_plane_set_fb(cursor, NULL); |
| igt_display_commit2(display, COMMIT_LEGACY); |
| cursor_leak_test_fini(data, output, &background_fb, cursor_fb); |
| |
| /* We should be back to the same framebuffer count as when we started */ |
| count2 = i915_gem_fb_count(data); |
| |
| igt_assert_eq(count1, count2); |
| } |
| |
| static void |
| gen9_test_init(gen9_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); |
| test->w = mode->hdisplay / 2; |
| test->h = mode->vdisplay / 2; |
| test->x = mode->hdisplay / 4; |
| test->y = mode->vdisplay / 4; |
| |
| /* Initial framebuffer of full CRTC size */ |
| igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay, |
| DRM_FORMAT_XRGB8888, |
| LOCAL_DRM_FORMAT_MOD_NONE, |
| 0.0, 1.0, 0.0, |
| &test->biggreen_fb); |
| |
| /* Framebuffers that only cover a quarter of the CRTC size */ |
| igt_create_color_fb(data->drm_fd, test->w, test->h, |
| DRM_FORMAT_XRGB8888, |
| LOCAL_DRM_FORMAT_MOD_NONE, |
| 1.0, 0.0, 0.0, |
| &test->smallred_fb); |
| igt_create_color_fb(data->drm_fd, test->w, test->h, |
| DRM_FORMAT_XRGB8888, |
| LOCAL_DRM_FORMAT_MOD_NONE, |
| 0.0, 0.0, 1.0, |
| &test->smallblue_fb); |
| } |
| |
| static void |
| gen9_test_fini(gen9_test_t *test, igt_output_t *output) |
| { |
| igt_remove_fb(test->data->drm_fd, &test->biggreen_fb); |
| igt_remove_fb(test->data->drm_fd, &test->smallred_fb); |
| igt_remove_fb(test->data->drm_fd, &test->smallblue_fb); |
| |
| igt_output_set_pipe(output, PIPE_ANY); |
| igt_display_commit2(&test->data->display, COMMIT_LEGACY); |
| } |
| |
| /* |
| * Test features specific to gen9+ platforms (i.e., primary plane |
| * windowing) |
| */ |
| static void |
| gen9_test_pipe(data_t *data, enum pipe pipe, igt_output_t *output) |
| { |
| gen9_test_t test = { .data = data }; |
| igt_plane_t *primary; |
| |
| int ret = 0; |
| |
| igt_skip_on(data->gen < 9); |
| igt_skip_on(pipe >= data->display.n_pipes); |
| |
| igt_output_set_pipe(output, pipe); |
| |
| gen9_test_init(&test, output, pipe); |
| |
| primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY); |
| |
| /* Start with a full-screen primary plane */ |
| igt_plane_set_fb(primary, &test.biggreen_fb); |
| igt_display_commit2(&data->display, COMMIT_LEGACY); |
| |
| /* Set primary to windowed size/position */ |
| igt_plane_set_fb(primary, &test.smallblue_fb); |
| igt_plane_set_position(primary, test.x, test.y); |
| igt_plane_set_size(primary, test.w, test.h); |
| igt_display_commit2(&data->display, COMMIT_UNIVERSAL); |
| |
| /* |
| * SetPlane update to another framebuffer of the same size |
| * should succeed |
| */ |
| igt_plane_set_fb(primary, &test.smallred_fb); |
| igt_plane_set_position(primary, test.x, test.y); |
| igt_plane_set_size(primary, test.w, test.h); |
| igt_display_commit2(&data->display, COMMIT_UNIVERSAL); |
| |
| /* PageFlip should also succeed */ |
| ret = drmModePageFlip(data->drm_fd, output->config.crtc->crtc_id, |
| test.smallblue_fb.fb_id, 0, NULL); |
| igt_assert_eq(ret, 0); |
| |
| igt_plane_set_fb(primary, NULL); |
| igt_plane_set_position(primary, 0, 0); |
| gen9_test_fini(&test, output); |
| } |
| |
| static void |
| run_tests_for_pipe(data_t *data, enum pipe pipe) |
| { |
| igt_output_t *output; |
| |
| igt_fixture { |
| int valid_tests = 0; |
| |
| igt_skip_on(pipe >= data->display.n_pipes); |
| |
| for_each_valid_output_on_pipe(&data->display, pipe, output) |
| valid_tests++; |
| |
| igt_require_f(valid_tests, "no valid crtc/connector combinations found\n"); |
| } |
| |
| igt_subtest_f("universal-plane-pipe-%s-functional", |
| kmstest_pipe_name(pipe)) |
| for_each_valid_output_on_pipe(&data->display, pipe, output) |
| functional_test_pipe(data, pipe, output); |
| |
| igt_subtest_f("universal-plane-pipe-%s-sanity", |
| kmstest_pipe_name(pipe)) |
| for_each_valid_output_on_pipe(&data->display, pipe, output) |
| sanity_test_pipe(data, pipe, output); |
| |
| igt_subtest_f("disable-primary-vs-flip-pipe-%s", |
| kmstest_pipe_name(pipe)) |
| for_each_valid_output_on_pipe(&data->display, pipe, output) |
| pageflip_test_pipe(data, pipe, output); |
| |
| igt_subtest_f("cursor-fb-leak-pipe-%s", |
| kmstest_pipe_name(pipe)) |
| for_each_valid_output_on_pipe(&data->display, pipe, output) |
| cursor_leak_test_pipe(data, pipe, output); |
| |
| igt_subtest_f("universal-plane-gen9-features-pipe-%s", |
| kmstest_pipe_name(pipe)) |
| for_each_valid_output_on_pipe(&data->display, pipe, output) |
| gen9_test_pipe(data, pipe, output); |
| } |
| |
| static data_t data; |
| |
| igt_main |
| { |
| enum pipe pipe; |
| |
| igt_skip_on_simulation(); |
| |
| igt_fixture { |
| data.drm_fd = drm_open_driver_master(DRIVER_INTEL); |
| data.gen = intel_gen(intel_get_drm_devid(data.drm_fd)); |
| |
| kmstest_set_vt_graphics_mode(); |
| |
| igt_require_pipe_crc(data.drm_fd); |
| igt_display_init(&data.display, data.drm_fd); |
| } |
| |
| for_each_pipe_static(pipe) { |
| igt_subtest_group |
| run_tests_for_pipe(&data, pipe); |
| } |
| |
| igt_fixture { |
| igt_display_fini(&data.display); |
| } |
| } |