#include <stdio.h>
#include <string.h>
-#include <glib.h>
-
-#include "drm_fourcc.h"
-
#include "drmtest.h"
#include "igt_debugfs.h"
#include "igt_kms.h"
-#include "rendercopy.h"
+#include "intel_chipset.h"
+#include "intel_batchbuffer.h"
+#include "ioctl_wrappers.h"
enum test_mode {
TEST_PAGE_FLIP,
};
typedef struct {
- struct kmstest_connector_config config;
- drmModeModeInfo mode;
- struct kmstest_fb fb[2];
-} connector_t;
-
-typedef struct {
int drm_fd;
- igt_debugfs_t debugfs;
- drmModeRes *resources;
igt_crc_t ref_crc[2];
- igt_pipe_crc_t **pipe_crc;
+ igt_pipe_crc_t *pipe_crc;
drm_intel_bufmgr *bufmgr;
drm_intel_context *ctx[2];
uint32_t devid;
uint32_t handle[2];
- uint32_t crtc_id;
- uint32_t crtc_idx;
+ igt_display_t display;
+ igt_output_t *output;
+ enum pipe pipe;
+ igt_plane_t *primary;
+ struct igt_fb fb[2];
uint32_t fb_id[2];
} data_t;
return test_modes[mode];
}
-static uint32_t create_fb(data_t *data,
- int w, int h,
- double r, double g, double b,
- struct kmstest_fb *fb)
-{
- uint32_t fb_id;
- cairo_t *cr;
-
- fb_id = kmstest_create_fb2(data->drm_fd, w, h,
- DRM_FORMAT_XRGB8888, true, fb);
- igt_assert(fb_id);
-
- cr = kmstest_get_cairo_ctx(data->drm_fd, fb);
- kmstest_paint_color(cr, 0, 0, w, h, r, g, b);
- igt_assert(cairo_status(cr) == 0);
- cairo_destroy(cr);
-
- return fb_id;
-}
-
-static bool
-connector_set_mode(data_t *data, connector_t *connector,
- drmModeModeInfo *mode, uint32_t fb_id)
-{
- struct kmstest_connector_config *config = &connector->config;
- int ret;
-
-#if 0
- fprintf(stdout, "Using pipe %c, %dx%d\n", pipe_name(config->pipe),
- mode->hdisplay, mode->vdisplay);
-#endif
-
- ret = drmModeSetCrtc(data->drm_fd,
- config->crtc->crtc_id,
- fb_id,
- 0, 0, /* x, y */
- &config->connector->connector_id,
- 1,
- mode);
- igt_assert(ret == 0);
-
- return 0;
-}
-
-static void display_init(data_t *data)
-{
- data->resources = drmModeGetResources(data->drm_fd);
- igt_assert(data->resources);
-
- data->pipe_crc = calloc(data->resources->count_crtcs, sizeof(data->pipe_crc[0]));
-}
-
-static void display_fini(data_t *data)
-{
- free(data->pipe_crc);
-}
-
static void fill_blt(data_t *data, uint32_t handle, unsigned char color)
{
drm_intel_bo *dst = gem_handle_to_libdrm_bo(data->bufmgr,
batch = intel_batchbuffer_alloc(data->bufmgr, data->devid);
igt_assert(batch);
- BEGIN_BATCH(5);
- OUT_BATCH(COLOR_BLT_CMD);
- OUT_BATCH((1 << 24) | (0xf0 << 16) | 0);
+ COLOR_BLIT_COPY_BATCH_START(batch->devid, 0);
+ OUT_BATCH((0 << 24) | (0xf0 << 16) | 0);
+ OUT_BATCH(0);
OUT_BATCH(1 << 16 | 4);
- OUT_RELOC(dst, I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER, 0);
+ OUT_RELOC_FENCED(dst, I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER, 0);
OUT_BATCH(color);
ADVANCE_BATCH();
gem_bo_busy(data->drm_fd, handle);
}
-static void scratch_buf_init(struct scratch_buf *buf, drm_intel_bo *bo)
+static void scratch_buf_init(struct igt_buf *buf, drm_intel_bo *bo)
{
buf->bo = bo;
buf->stride = 4096;
{
drm_intel_bo *src, *dst;
struct intel_batchbuffer *batch;
- struct scratch_buf src_buf, dst_buf;
+ struct igt_buf src_buf, dst_buf;
const uint8_t buf[4] = { color, color, color, color };
- render_copyfunc_t rendercopy = get_render_copyfunc(data->devid);
+ igt_render_copyfunc_t rendercopy = igt_get_render_copyfunc(data->devid);
igt_skip_on(!rendercopy);
FILE *status;
char str[64] = {};
- status = igt_debugfs_fopen(&data->debugfs, "i915_fbc_status", "r");
+ status = igt_debugfs_fopen("i915_fbc_status", "r");
+ igt_assert(status);
+
fread(str, sizeof(str) - 1, 1, status);
fclose(status);
return strstr(str, "FBC enabled") != NULL;
static void test_crc(data_t *data, enum test_mode mode)
{
- igt_pipe_crc_t *pipe_crc = data->pipe_crc[data->crtc_idx];
+ uint32_t crtc_id = data->output->config.crtc->crtc_id;
+ igt_pipe_crc_t *pipe_crc = data->pipe_crc;
igt_crc_t *crcs = NULL;
uint32_t handle = data->handle[0];
if (mode >= TEST_PAGE_FLIP_AND_MMAP_CPU) {
handle = data->handle[1];
- igt_assert(drmModePageFlip(data->drm_fd, data->crtc_id,
+ igt_assert(drmModePageFlip(data->drm_fd, crtc_id,
data->fb_id[1], 0, NULL) == 0);
usleep(300000);
switch (mode) {
void *ptr;
case TEST_PAGE_FLIP:
- igt_assert(drmModePageFlip(data->drm_fd, data->crtc_id,
+ igt_assert(drmModePageFlip(data->drm_fd, crtc_id,
data->fb_id[1], 0, NULL) == 0);
break;
case TEST_MMAP_CPU:
* to leave some leeway for the kernel if we ever do
* some kind of delayed FBC disable for GTT mmaps.
*/
- igt_wait_for_vblank(data->drm_fd, data->crtc_idx);
- igt_wait_for_vblank(data->drm_fd, data->crtc_idx);
+ igt_wait_for_vblank(data->drm_fd, data->pipe);
+ igt_wait_for_vblank(data->drm_fd, data->pipe);
igt_pipe_crc_start(pipe_crc);
igt_pipe_crc_get_crcs(pipe_crc, 1, &crcs);
free(crcs);
}
-static bool prepare_crtc(data_t *data, uint32_t connector_id, enum test_mode mode)
+static bool prepare_crtc(data_t *data)
{
- igt_pipe_crc_t *pipe_crc;
- igt_crc_t *crcs = NULL;
- connector_t connector;
- int ret;
-
- ret = kmstest_get_connector_config(data->drm_fd,
- connector_id,
- 1 << data->crtc_idx,
- &connector.config);
- if (ret)
- return false;
+ igt_display_t *display = &data->display;
+ igt_output_t *output = data->output;
- igt_pipe_crc_free(data->pipe_crc[data->crtc_idx]);
- data->pipe_crc[data->crtc_idx] = NULL;
+ /* select the pipe we want to use */
+ igt_output_set_pipe(output, data->pipe);
+ igt_display_commit(display);
- pipe_crc = igt_pipe_crc_new(&data->debugfs,
- data->drm_fd, data->crtc_idx,
- INTEL_PIPE_CRC_SOURCE_AUTO);
- if (!pipe_crc) {
- printf("auto crc not supported on this connector with crtc %i\n",
- data->crtc_idx);
+ if (!output->valid) {
+ igt_output_set_pipe(output, PIPE_ANY);
+ igt_display_commit(display);
return false;
}
- data->pipe_crc[data->crtc_idx] = pipe_crc;
+ return true;
+}
- data->fb_id[0] = create_fb(data,
- connector.config.default_mode.hdisplay,
- connector.config.default_mode.vdisplay,
- 0.0, 0.0, 0.0, &connector.fb[0]);
- igt_assert(data->fb_id[0]);
+static bool prepare_test(data_t *data, enum test_mode test_mode)
+{
+ igt_display_t *display = &data->display;
+ igt_output_t *output = data->output;
+ drmModeModeInfo *mode;
+ igt_pipe_crc_t *pipe_crc;
+ igt_crc_t *crcs = NULL;
- data->fb_id[1] = create_fb(data,
- connector.config.default_mode.hdisplay,
- connector.config.default_mode.vdisplay,
- 0.1, 0.1, 0.1, &connector.fb[1]);
+ data->primary = igt_output_get_plane(data->output, IGT_PLANE_PRIMARY);
+ mode = igt_output_get_mode(data->output);
+
+ data->fb_id[0] = igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay,
+ DRM_FORMAT_XRGB8888,
+ I915_TILING_X,
+ 0.0, 0.0, 0.0, &data->fb[0]);
+ igt_assert(data->fb_id[0]);
+ data->fb_id[1] = igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay,
+ DRM_FORMAT_XRGB8888,
+ I915_TILING_X,
+ 0.1, 0.1, 0.1,
+ &data->fb[1]);
igt_assert(data->fb_id[1]);
- data->handle[0] = connector.fb[0].gem_handle;
- data->handle[1] = connector.fb[1].gem_handle;
+ data->handle[0] = data->fb[0].gem_handle;
+ data->handle[1] = data->fb[1].gem_handle;
/* scanout = fb[1] */
- connector_set_mode(data, &connector, &connector.config.default_mode,
- data->fb_id[1]);
+ igt_plane_set_fb(data->primary, &data->fb[1]);
+ igt_display_commit(display);
usleep(300000);
- igt_skip_on(!fbc_enabled(data));
+ if (!fbc_enabled(data)) {
+ igt_info("FBC not enabled\n");
+
+ igt_plane_set_fb(data->primary, NULL);
+ igt_output_set_pipe(output, PIPE_ANY);
+ igt_display_commit(display);
- igt_wait_for_vblank(data->drm_fd, data->crtc_idx);
+ igt_remove_fb(data->drm_fd, &data->fb[0]);
+ igt_remove_fb(data->drm_fd, &data->fb[1]);
+ return false;
+ }
+
+ igt_pipe_crc_free(data->pipe_crc);
+ data->pipe_crc = NULL;
+
+ pipe_crc = igt_pipe_crc_new(data->pipe,
+ INTEL_PIPE_CRC_SOURCE_AUTO);
+ if (!pipe_crc) {
+ igt_info("auto crc not supported on this connector with crtc %i\n",
+ data->pipe);
+
+ igt_plane_set_fb(data->primary, NULL);
+ igt_output_set_pipe(output, PIPE_ANY);
+ igt_display_commit(display);
+
+ igt_remove_fb(data->drm_fd, &data->fb[0]);
+ igt_remove_fb(data->drm_fd, &data->fb[1]);
+ return false;
+ }
+
+ data->pipe_crc = pipe_crc;
+
+ igt_wait_for_vblank(data->drm_fd, data->pipe);
/* get reference crc for fb[1] */
igt_pipe_crc_start(pipe_crc);
igt_pipe_crc_stop(pipe_crc);
free(crcs);
- if (mode == TEST_CONTEXT || mode == TEST_PAGE_FLIP_AND_CONTEXT) {
+ if (test_mode == TEST_CONTEXT || test_mode == TEST_PAGE_FLIP_AND_CONTEXT) {
data->ctx[0] = drm_intel_gem_context_create(data->bufmgr);
- igt_require(data->ctx[0]);
+ igt_assert(data->ctx[0]);
data->ctx[1] = drm_intel_gem_context_create(data->bufmgr);
- igt_require(data->ctx[1]);
+ igt_assert(data->ctx[1]);
/*
* Disable FBC RT address for both contexts
}
/* scanout = fb[0] */
- connector_set_mode(data, &connector, &connector.config.default_mode,
- data->fb_id[0]);
+ igt_plane_set_fb(data->primary, &data->fb[0]);
+ igt_display_commit(display);
usleep(300000);
- igt_skip_on(!fbc_enabled(data));
+ igt_assert(fbc_enabled(data));
- if (mode == TEST_CONTEXT || mode == TEST_PAGE_FLIP_AND_CONTEXT) {
+ if (test_mode == TEST_CONTEXT || test_mode == TEST_PAGE_FLIP_AND_CONTEXT) {
/*
* make ctx[0] FBC RT address point to fb[0], ctx[1]
* FBC RT address is left as disabled.
*/
- exec_nop(data, connector.fb[0].gem_handle, data->ctx[0]);
+ exec_nop(data, data->fb[0].gem_handle, data->ctx[0]);
}
- igt_wait_for_vblank(data->drm_fd, data->crtc_idx);
+ igt_wait_for_vblank(data->drm_fd, data->pipe);
/* get reference crc for fb[0] */
igt_pipe_crc_start(pipe_crc);
igt_pipe_crc_stop(pipe_crc);
free(crcs);
- kmstest_free_connector_config(&connector.config);
-
return true;
}
static void finish_crtc(data_t *data, enum test_mode mode)
{
- igt_pipe_crc_free(data->pipe_crc[data->crtc_idx]);
- data->pipe_crc[data->crtc_idx] = NULL;
+ igt_pipe_crc_free(data->pipe_crc);
+ data->pipe_crc = NULL;
if (mode == TEST_CONTEXT || mode == TEST_PAGE_FLIP_AND_CONTEXT) {
drm_intel_gem_context_destroy(data->ctx[0]);
drm_intel_gem_context_destroy(data->ctx[1]);
}
+
+ igt_plane_set_fb(data->primary, NULL);
+ igt_output_set_pipe(data->output, PIPE_ANY);
+ igt_display_commit(&data->display);
+
+ igt_remove_fb(data->drm_fd, &data->fb[0]);
+ igt_remove_fb(data->drm_fd, &data->fb[1]);
+}
+
+static void reset_display(data_t *data)
+{
+ igt_display_t *display = &data->display;
+
+ for_each_connected_output(display, data->output) {
+ if (data->output->valid) {
+ data->primary = igt_output_get_plane(data->output, IGT_PLANE_PRIMARY);
+ igt_plane_set_fb(data->primary, NULL);
+ }
+ igt_output_set_pipe(data->output, PIPE_ANY);
+ }
}
static void run_test(data_t *data, enum test_mode mode)
{
- int i, n;
+ igt_display_t *display = &data->display;
+ int valid_tests = 0;
+
+ if (mode == TEST_CONTEXT || mode == TEST_PAGE_FLIP_AND_CONTEXT) {
+ drm_intel_context *ctx = drm_intel_gem_context_create(data->bufmgr);
+ igt_require(ctx);
+ drm_intel_gem_context_destroy(ctx);
+ }
- for (i = 0; i < data->resources->count_connectors; i++) {
- uint32_t connector_id = data->resources->connectors[i];
+ reset_display(data);
- for (n = 0; n < data->resources->count_crtcs; n++) {
- data->crtc_idx = n;
- data->crtc_id = data->resources->crtcs[n];
+ for_each_connected_output(display, data->output) {
+ for_each_pipe(display, data->pipe) {
+ if (!prepare_crtc(data))
+ continue;
+
+ igt_info("Beginning %s on pipe %s, connector %s\n",
+ igt_subtest_name(),
+ kmstest_pipe_name(data->pipe),
+ igt_output_name(data->output));
- if (!prepare_crtc(data, connector_id, mode))
+ if (!prepare_test(data, mode)) {
+ igt_info("%s on pipe %s, connector %s: SKIPPED\n",
+ igt_subtest_name(),
+ kmstest_pipe_name(data->pipe),
+ igt_output_name(data->output));
continue;
+ }
+
+ valid_tests++;
- fprintf(stdout, "Beginning %s on crtc %d, connector %d\n",
- igt_subtest_name(), data->crtc_id, connector_id);
test_crc(data, mode);
- fprintf(stdout, "\n%s on crtc %d, connector %d: PASSED\n\n",
- igt_subtest_name(), data->crtc_id, connector_id);
+ igt_info("%s on pipe %s, connector %s: PASSED\n",
+ igt_subtest_name(),
+ kmstest_pipe_name(data->pipe),
+ igt_output_name(data->output));
finish_crtc(data, mode);
}
}
+
+ igt_require_f(valid_tests, "no valid crtc/connector combinations found\n");
}
igt_main
FILE *status;
data.drm_fd = drm_open_any();
- igt_set_vt_graphics_mode();
+ kmstest_set_vt_graphics_mode();
data.devid = intel_get_drm_devid(data.drm_fd);
- igt_debugfs_init(&data.debugfs);
- igt_pipe_crc_check(&data.debugfs);
+ igt_require_pipe_crc();
- status = igt_debugfs_fopen(&data.debugfs, "i915_fbc_status", "r");
+ status = igt_debugfs_fopen("i915_fbc_status", "r");
igt_require_f(status, "No i915_fbc_status found\n");
fread(buf, sizeof(buf), 1, status);
fclose(status);
igt_assert(data.bufmgr);
drm_intel_bufmgr_gem_enable_reuse(data.bufmgr);
- display_init(&data);
+ igt_display_init(&data.display, data.drm_fd);
}
for (mode = TEST_PAGE_FLIP; mode <= TEST_PAGE_FLIP_AND_CONTEXT; mode++) {
igt_fixture {
drm_intel_bufmgr_destroy(data.bufmgr);
- display_fini(&data);
+ igt_display_fini(&data.display);
}
}
projects / platform / upstream / intel-gpu-tools.git / blobdiff