From patchwork Fri Jul 14 15:18:50 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Liviu Dudau X-Patchwork-Id: 107811 Delivered-To: patch@linaro.org Received: by 10.140.101.44 with SMTP id t41csp1035284qge; Fri, 14 Jul 2017 08:20:08 -0700 (PDT) X-Received: by 10.99.44.81 with SMTP id s78mr15531548pgs.146.1500045608011; Fri, 14 Jul 2017 08:20:08 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1500045608; cv=none; d=google.com; s=arc-20160816; b=XaM4TzHdvNKfN8ggIG/LuFjL7s6xop5TpBq3bQkQWVzvZqOSiRNlMQF5O0Hf0KphP7 Hbw0dzD3ZHSTGhXtXsROq0athQy7cpuORZOFronttoRyGh79xYuFSLtmLeVSNbPqFwkk QIuJI96HUTGPab3Xv6oPZjaBz1ci1/Zi90ODd4rP3/dfllaEsZMW9k16FV1qOrV8pDlP qqTx3nNui7fKRTzY8OlrxwdcF0A7bW/r9d39wOplJuAsXmuXuA7IcL27UHRD7ks43U7h O8v4iIu9NJxaUrkFZqTuEAiLJUKVND6AuKLhkW5hmHja2RPaQ5UToNhBMMyKj7ShDqj/ kO+g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:content-transfer-encoding:list-subscribe:list-help :list-post:list-archive:list-unsubscribe:list-id:precedence:cc :mime-version:references:in-reply-to:message-id:date:subject:to:from :delivered-to:arc-authentication-results; bh=slLBYkER0YZgn1SuQNGu1E/l30IOXV6KZo6i7K6x+sw=; b=sVL286mYpP8NaIq1mus/qKfyNfnv95kWhJCrdnqoDItkB9C5UpcNFsJo35G2MIZvRu MaGPtyncvTWXvXmGYX8bWge0ui0oSmHryUlU6kxIVj4NR1L9pzmAx4lbh6ghxITryebG FCeYkxCSdQuz6rjQBl5dF7XFY0TlXYiebEvs43ujHDJcVLhRWXLrp/fxtC+YchPWpPVf hmpUP4GlwOTWgCUs5FZYQLS7tYxwdXpY1nkT5ay3fo9oDfJnkc07FoJSKt/hMJ61WweK tsTiXwWJsriOfyiDuUkqNUtHbuX1e/0YMZSwI/KV8YXHBY/LEV+p7IocHl+MoMegXiSI 0rsQ== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: best guess record for domain of dri-devel-bounces@lists.freedesktop.org designates 131.252.210.177 as permitted sender) smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Return-Path: Received: from gabe.freedesktop.org (gabe.freedesktop.org. [131.252.210.177]) by mx.google.com with ESMTPS id t67si6770964pgt.339.2017.07.14.08.20.07 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Fri, 14 Jul 2017 08:20:07 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of dri-devel-bounces@lists.freedesktop.org designates 131.252.210.177 as permitted sender) client-ip=131.252.210.177; Authentication-Results: mx.google.com; spf=pass (google.com: best guess record for domain of dri-devel-bounces@lists.freedesktop.org designates 131.252.210.177 as permitted sender) smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 18FBB6E87F; Fri, 14 Jul 2017 15:19:08 +0000 (UTC) X-Original-To: dri-devel@lists.freedesktop.org Delivered-To: dri-devel@lists.freedesktop.org Received: from cam-smtp0.cambridge.arm.com (fw-tnat.cambridge.arm.com [217.140.96.140]) by gabe.freedesktop.org (Postfix) with ESMTPS id A2F426E869; Fri, 14 Jul 2017 15:19:01 +0000 (UTC) Received: from e110455-lin.cambridge.arm.com (e110455-lin.cambridge.arm.com [10.2.131.9]) by cam-smtp0.cambridge.arm.com (8.13.8/8.13.8) with ESMTP id v6EFIuFK000867; Fri, 14 Jul 2017 16:18:56 +0100 From: Liviu Dudau To: Intel GFX discussion Subject: [PATCH i-g-t v2 1/7] igt: lib/igt_crc: Split out CRC functionality Date: Fri, 14 Jul 2017 16:18:50 +0100 Message-Id: <20170714151856.32041-2-liviu.dudau@arm.com> X-Mailer: git-send-email 2.13.2 In-Reply-To: <20170714151856.32041-1-liviu.dudau@arm.com> References: <20170714151856.32041-1-liviu.dudau@arm.com> MIME-Version: 1.0 Cc: Boris Brezillon , DRI devel X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" From: Brian Starkey Separate out the CRC code for better compartmentalisation. Should ease the addition of more/different CRC sources in the future. Signed-off-by: Brian Starkey Acked-by: Daniel Vetter --- lib/Makefile.sources | 2 + lib/igt_chamelium.h | 1 + lib/igt_crc.c | 563 ++++++++++++++++++++++++++++++++++++++ lib/igt_crc.h | 125 +++++++++ lib/igt_debugfs.c | 547 ------------------------------------ lib/igt_debugfs.h | 81 ------ tests/chamelium.c | 1 + tests/kms_atomic_transition.c | 1 + tests/kms_ccs.c | 1 + tests/kms_chv_cursor_fail.c | 1 + tests/kms_crtc_background_color.c | 1 + tests/kms_cursor_crc.c | 1 + tests/kms_cursor_legacy.c | 1 + tests/kms_draw_crc.c | 1 + tests/kms_fbc_crc.c | 1 + tests/kms_flip_tiling.c | 1 + tests/kms_frontbuffer_tracking.c | 1 + tests/kms_mmap_write_crc.c | 1 + tests/kms_mmio_vs_cs_flip.c | 1 + tests/kms_pipe_color.c | 1 + tests/kms_pipe_crc_basic.c | 1 + tests/kms_plane.c | 1 + tests/kms_plane_lowres.c | 1 + tests/kms_plane_multiple.c | 1 + tests/kms_plane_scaling.c | 1 + tests/kms_pwrite_crc.c | 1 + tests/kms_rotation_crc.c | 1 + tests/kms_universal_plane.c | 1 + tools/intel_display_crc.c | 1 + 29 files changed, 714 insertions(+), 628 deletions(-) create mode 100644 lib/igt_crc.c create mode 100644 lib/igt_crc.h diff --git a/lib/Makefile.sources b/lib/Makefile.sources index 53fdb54c..cfba15c9 100644 --- a/lib/Makefile.sources +++ b/lib/Makefile.sources @@ -11,6 +11,8 @@ lib_source_list = \ igt_debugfs.h \ igt_aux.c \ igt_aux.h \ + igt_crc.c \ + igt_crc.h \ igt_edid_template.h \ igt_gt.c \ igt_gt.h \ diff --git a/lib/igt_chamelium.h b/lib/igt_chamelium.h index 81322ad2..ea5abc2e 100644 --- a/lib/igt_chamelium.h +++ b/lib/igt_chamelium.h @@ -31,6 +31,7 @@ #endif #include "igt.h" +#include "igt_crc.h" #include struct chamelium; diff --git a/lib/igt_crc.c b/lib/igt_crc.c new file mode 100644 index 00000000..91a0b5a8 --- /dev/null +++ b/lib/igt_crc.c @@ -0,0 +1,563 @@ +/* + * Copyright © 2013 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 +#include +#include +#include + +#include "igt_aux.h" +#include "igt_crc.h" +#include "igt_core.h" +#include "igt_debugfs.h" +#include "igt_kms.h" + +/** + * igt_assert_crc_equal: + * @a: first pipe CRC value + * @b: second pipe CRC value + * + * Compares two CRC values and fails the testcase if they don't match with + * igt_fail(). Note that due to CRC collisions CRC based testcase can only + * assert that CRCs match, never that they are different. Otherwise there might + * be random testcase failures when different screen contents end up with the + * same CRC by chance. + */ +void igt_assert_crc_equal(const igt_crc_t *a, const igt_crc_t *b) +{ + int i; + + for (i = 0; i < a->n_words; i++) + igt_assert_eq_u32(a->crc[i], b->crc[i]); +} + +/** + * igt_crc_to_string: + * @crc: pipe CRC value to print + * + * This formats @crc into a string buffer which is owned by igt_crc_to_string(). + * The next call will override the buffer again, which makes this multithreading + * unsafe. + * + * This should only ever be used for diagnostic debug output. + */ +char *igt_crc_to_string(igt_crc_t *crc) +{ + int i; + char buf[128] = { 0 }; + + for (i = 0; i < crc->n_words; i++) + sprintf(buf + strlen(buf), "%08x ", crc->crc[i]); + + return strdup(buf); +} + +#define MAX_CRC_ENTRIES 10 +#define MAX_LINE_LEN (10 + 11 * MAX_CRC_ENTRIES + 1) + +/* (6 fields, 8 chars each, space separated (5) + '\n') */ +#define LEGACY_LINE_LEN (6 * 8 + 5 + 1) + +struct _igt_pipe_crc { + int fd; + int dir; + int ctl_fd; + int crc_fd; + int flags; + bool is_legacy; + + enum pipe pipe; + enum intel_pipe_crc_source source; +}; + +static const char *pipe_crc_sources[] = { + "none", + "plane1", + "plane2", + "pf", + "pipe", + "TV", + "DP-B", + "DP-C", + "DP-D", + "auto" +}; + +static const char *pipe_crc_source_name(enum intel_pipe_crc_source source) +{ + return pipe_crc_sources[source]; +} + +static bool igt_pipe_crc_do_start(igt_pipe_crc_t *pipe_crc) +{ + char buf[64]; + + /* Stop first just to make sure we don't have lingering state left. */ + igt_pipe_crc_stop(pipe_crc); + + if (pipe_crc->is_legacy) + sprintf(buf, "pipe %s %s", kmstest_pipe_name(pipe_crc->pipe), + pipe_crc_source_name(pipe_crc->source)); + else + sprintf(buf, "%s", pipe_crc_source_name(pipe_crc->source)); + + igt_assert_eq(write(pipe_crc->ctl_fd, buf, strlen(buf)), strlen(buf)); + + if (!pipe_crc->is_legacy) { + int err; + + sprintf(buf, "crtc-%d/crc/data", pipe_crc->pipe); + err = 0; + + pipe_crc->crc_fd = openat(pipe_crc->dir, buf, pipe_crc->flags); + if (pipe_crc->crc_fd < 0) + err = -errno; + + if (err == -EINVAL) + return false; + + igt_assert_eq(err, 0); + } + + errno = 0; + return true; +} + +static void igt_pipe_crc_pipe_off(int fd, enum pipe pipe) +{ + char buf[32]; + + sprintf(buf, "pipe %s none", kmstest_pipe_name(pipe)); + igt_assert_eq(write(fd, buf, strlen(buf)), strlen(buf)); +} + +static void igt_pipe_crc_reset(int drm_fd) +{ + struct dirent *dirent; + const char *cmd = "none"; + bool done = false; + DIR *dir; + int fdir; + int fd; + + fdir = igt_debugfs_dir(drm_fd); + if (fdir < 0) + return; + + dir = fdopendir(fdir); + if (!dir) { + close(fdir); + return; + } + + while ((dirent = readdir(dir))) { + char buf[128]; + + if (strcmp(dirent->d_name, "crtc-") != 0) + continue; + + sprintf(buf, "%s/crc/control", dirent->d_name); + fd = openat(fdir, buf, O_WRONLY); + if (fd < 0) + continue; + + igt_assert_eq(write(fd, cmd, strlen(cmd)), strlen(cmd)); + close(fd); + + done = true; + } + closedir(dir); + + if (!done) { + fd = openat(fdir, "i915_display_crtc_ctl", O_WRONLY); + if (fd != -1) { + igt_pipe_crc_pipe_off(fd, PIPE_A); + igt_pipe_crc_pipe_off(fd, PIPE_B); + igt_pipe_crc_pipe_off(fd, PIPE_C); + + close(fd); + } + } + + close(fdir); +} + +static void pipe_crc_exit_handler(int sig) +{ + struct dirent *dirent; + char buf[128]; + DIR *dir; + int fd; + + dir = opendir("/dev/dri"); + if (!dir) + return; + + /* + * Try to reset CRC capture for all DRM devices, this is only needed + * for the legacy CRC ABI and can be completely removed once the + * legacy codepaths are removed. + */ + while ((dirent = readdir(dir))) { + if (strncmp(dirent->d_name, "card", 4) != 0) + continue; + + sprintf(buf, "/dev/dri/%s", dirent->d_name); + fd = open(buf, O_WRONLY); + + igt_pipe_crc_reset(fd); + + close(fd); + } + closedir(dir); +} + +/** + * igt_require_pipe_crc: + * + * Convenience helper to check whether pipe CRC capturing is supported by the + * kernel. Uses igt_skip to automatically skip the test/subtest if this isn't + * the case. + */ +void igt_require_pipe_crc(int fd) +{ + const char *cmd = "pipe A none"; + int ctl, written; + + ctl = igt_debugfs_open(fd, "crtc-0/crc/control", O_RDONLY); + if (ctl < 0) { + ctl = igt_debugfs_open(fd, "i915_display_crc_ctl", O_WRONLY); + igt_require_f(ctl, + "No display_crc_ctl found, kernel too old\n"); + + written = write(ctl, cmd, strlen(cmd)); + igt_require_f(written < 0, + "CRCs not supported on this platform\n"); + } + close(ctl); +} + +static igt_pipe_crc_t * +pipe_crc_new(int fd, enum pipe pipe, enum intel_pipe_crc_source source, int flags) +{ + igt_pipe_crc_t *pipe_crc; + char buf[128]; + int debugfs; + + debugfs = igt_debugfs_dir(fd); + igt_assert(debugfs != -1); + + igt_install_exit_handler(pipe_crc_exit_handler); + + pipe_crc = calloc(1, sizeof(struct _igt_pipe_crc)); + + sprintf(buf, "crtc-%d/crc/control", pipe); + pipe_crc->ctl_fd = openat(debugfs, buf, O_WRONLY); + if (pipe_crc->ctl_fd == -1) { + pipe_crc->ctl_fd = openat(debugfs, + "i915_display_crc_ctl", O_WRONLY); + igt_assert(pipe_crc->ctl_fd != -1); + pipe_crc->is_legacy = true; + } + + if (pipe_crc->is_legacy) { + sprintf(buf, "i915_pipe_%s_crc", kmstest_pipe_name(pipe)); + pipe_crc->crc_fd = openat(debugfs, buf, flags); + igt_assert(pipe_crc->crc_fd != -1); + igt_debug("Using legacy frame CRC ABI\n"); + } else { + pipe_crc->crc_fd = -1; + igt_debug("Using generic frame CRC ABI\n"); + } + + pipe_crc->fd = fd; + pipe_crc->dir = debugfs; + pipe_crc->pipe = pipe; + pipe_crc->source = source; + pipe_crc->flags = flags; + + return pipe_crc; +} + +/** + * igt_pipe_crc_new: + * @pipe: display pipe to use as source + * @source: CRC tap point to use as source + * + * This sets up a new pipe CRC capture object for the given @pipe and @source + * in blocking mode. + * + * Returns: A pipe CRC object for the given @pipe and @source. The library + * assumes that the source is always available since recent kernels support at + * least INTEL_PIPE_CRC_SOURCE_AUTO everywhere. + */ +igt_pipe_crc_t * +igt_pipe_crc_new(int fd, enum pipe pipe, enum intel_pipe_crc_source source) +{ + return pipe_crc_new(fd, pipe, source, O_RDONLY); +} + +/** + * igt_pipe_crc_new_nonblock: + * @pipe: display pipe to use as source + * @source: CRC tap point to use as source + * + * This sets up a new pipe CRC capture object for the given @pipe and @source + * in nonblocking mode. + * + * Returns: A pipe CRC object for the given @pipe and @source. The library + * assumes that the source is always available since recent kernels support at + * least INTEL_PIPE_CRC_SOURCE_AUTO everywhere. + */ +igt_pipe_crc_t * +igt_pipe_crc_new_nonblock(int fd, enum pipe pipe, enum intel_pipe_crc_source source) +{ + return pipe_crc_new(fd, pipe, source, O_RDONLY | O_NONBLOCK); +} + +/** + * igt_pipe_crc_free: + * @pipe_crc: pipe CRC object + * + * Frees all resources associated with @pipe_crc. + */ +void igt_pipe_crc_free(igt_pipe_crc_t *pipe_crc) +{ + if (!pipe_crc) + return; + + close(pipe_crc->ctl_fd); + close(pipe_crc->crc_fd); + close(pipe_crc->dir); + free(pipe_crc); +} + +static bool pipe_crc_init_from_string(igt_pipe_crc_t *pipe_crc, igt_crc_t *crc, + const char *line) +{ + int n, i; + const char *buf; + + if (pipe_crc->is_legacy) { + crc->has_valid_frame = true; + crc->n_words = 5; + n = sscanf(line, "%8u %8x %8x %8x %8x %8x", &crc->frame, + &crc->crc[0], &crc->crc[1], &crc->crc[2], + &crc->crc[3], &crc->crc[4]); + return n == 6; + } + + if (strncmp(line, "XXXXXXXXXX", 10) == 0) + crc->has_valid_frame = false; + else { + crc->has_valid_frame = true; + crc->frame = strtoul(line, NULL, 16); + } + + buf = line + 10; + for (i = 0; *buf != '\n'; i++, buf += 11) + crc->crc[i] = strtoul(buf, NULL, 16); + + crc->n_words = i; + + return true; +} + +static int read_crc(igt_pipe_crc_t *pipe_crc, igt_crc_t *out) +{ + ssize_t bytes_read; + char buf[MAX_LINE_LEN + 1]; + size_t read_len; + + if (pipe_crc->is_legacy) + read_len = LEGACY_LINE_LEN; + else + read_len = MAX_LINE_LEN; + + igt_set_timeout(5, "CRC reading"); + bytes_read = read(pipe_crc->crc_fd, &buf, read_len); + igt_reset_timeout(); + + if (bytes_read < 0 && errno == EAGAIN) + igt_assert(pipe_crc->flags & O_NONBLOCK); + + if (bytes_read < 0) + bytes_read = 0; + + buf[bytes_read] = '\0'; + + if (bytes_read && !pipe_crc_init_from_string(pipe_crc, out, buf)) + return -EINVAL; + + return bytes_read; +} + +static void read_one_crc(igt_pipe_crc_t *pipe_crc, igt_crc_t *out) +{ + while (read_crc(pipe_crc, out) == 0) + usleep(1000); +} + +/** + * igt_pipe_crc_start: + * @pipe_crc: pipe CRC object + * + * Starts the CRC capture process on @pipe_crc. + */ +void igt_pipe_crc_start(igt_pipe_crc_t *pipe_crc) +{ + igt_crc_t crc; + + igt_assert(igt_pipe_crc_do_start(pipe_crc)); + + if (pipe_crc->is_legacy) { + /* + * For some no yet identified reason, the first CRC is + * bonkers. So let's just wait for the next vblank and read + * out the buggy result. + * + * On CHV sometimes the second CRC is bonkers as well, so + * don't trust that one either. + */ + read_one_crc(pipe_crc, &crc); + read_one_crc(pipe_crc, &crc); + } +} + +/** + * igt_pipe_crc_stop: + * @pipe_crc: pipe CRC object + * + * Stops the CRC capture process on @pipe_crc. + */ +void igt_pipe_crc_stop(igt_pipe_crc_t *pipe_crc) +{ + char buf[32]; + + if (pipe_crc->is_legacy) { + sprintf(buf, "pipe %s none", kmstest_pipe_name(pipe_crc->pipe)); + igt_assert_eq(write(pipe_crc->ctl_fd, buf, strlen(buf)), + strlen(buf)); + } else { + close(pipe_crc->crc_fd); + pipe_crc->crc_fd = -1; + } +} + +/** + * igt_pipe_crc_get_crcs: + * @pipe_crc: pipe CRC object + * @n_crcs: number of CRCs to capture + * @out_crcs: buffer pointer for the captured CRC values + * + * Read up to @n_crcs from @pipe_crc. This function does not block, and will + * return early if not enough CRCs can be captured, if @pipe_crc has been + * opened using igt_pipe_crc_new_nonblock(). It will block until @n_crcs are + * retrieved if @pipe_crc has been opened using igt_pipe_crc_new(). @out_crcs is + * alloced by this function and must be released with free() by the caller. + * + * Callers must start and stop the capturing themselves by calling + * igt_pipe_crc_start() and igt_pipe_crc_stop(). For one-shot CRC collecting + * look at igt_pipe_crc_collect_crc(). + * + * Returns: + * The number of CRCs captured. Should be equal to @n_crcs in blocking mode, but + * can be less (even zero) in non-blocking mode. + */ +int +igt_pipe_crc_get_crcs(igt_pipe_crc_t *pipe_crc, int n_crcs, + igt_crc_t **out_crcs) +{ + igt_crc_t *crcs; + int n = 0; + + crcs = calloc(n_crcs, sizeof(igt_crc_t)); + + do { + igt_crc_t *crc = &crcs[n]; + int ret; + + ret = read_crc(pipe_crc, crc); + if (ret < 0) + continue; + if (ret == 0) + break; + + n++; + } while (n < n_crcs); + + *out_crcs = crcs; + return n; +} + +static void crc_sanity_checks(igt_crc_t *crc) +{ + int i; + bool all_zero = true; + + for (i = 0; i < crc->n_words; i++) { + igt_warn_on_f(crc->crc[i] == 0xffffffff, + "Suspicious CRC: it looks like the CRC " + "read back was from a register in a powered " + "down well\n"); + if (crc->crc[i]) + all_zero = false; + } + + igt_warn_on_f(all_zero, "Suspicious CRC: All values are 0.\n"); +} + +/** + * igt_pipe_crc_collect_crc: + * @pipe_crc: pipe CRC object + * @out_crc: buffer for the captured CRC values + * + * Read a single CRC from @pipe_crc. This function blocks until the CRC is + * retrieved, irrespective of whether @pipe_crc has been opened with + * igt_pipe_crc_new() or igt_pipe_crc_new_nonblock(). @out_crc must be + * allocated by the caller. + * + * This function takes care of the pipe_crc book-keeping, it will start/stop + * the collection of the CRC. + * + * This function also calls the interactive debug with the "crc" domain, so you + * can make use of this feature to actually see the screen that is being CRC'd. + * + * For continuous CRC collection look at igt_pipe_crc_start(), + * igt_pipe_crc_get_crcs() and igt_pipe_crc_stop(). + */ +void igt_pipe_crc_collect_crc(igt_pipe_crc_t *pipe_crc, igt_crc_t *out_crc) +{ + igt_debug_wait_for_keypress("crc"); + + igt_pipe_crc_start(pipe_crc); + read_one_crc(pipe_crc, out_crc); + igt_pipe_crc_stop(pipe_crc); + + crc_sanity_checks(out_crc); +} + diff --git a/lib/igt_crc.h b/lib/igt_crc.h new file mode 100644 index 00000000..b0623baf --- /dev/null +++ b/lib/igt_crc.h @@ -0,0 +1,125 @@ +/* + * Copyright © 2013 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. + * + * # Pipe CRC Support + * + * This library wraps up the kernel's support for capturing pipe CRCs into a + * neat and tidy package. For the detailed usage see all the functions which + * work on #igt_pipe_crc_t. This is supported on all platforms and outputs. + * + * Actually using pipe CRCs to write modeset tests is a bit tricky though, so + * there is no way to directly check a CRC: Both the details of the plane + * blending, color correction and other hardware and how exactly the CRC is + * computed at each tap point vary by hardware generation and are not disclosed. + * + * The only way to use #igt_crc_t CRCs therefore is to compare CRCs among each + * another either for equality or difference. Otherwise CRCs must be treated as + * completely opaque values. Note that not even CRCs from different pipes or tap + * points on the same platform can be compared. Hence only use + * igt_assert_crc_equal() to inspect CRC values captured by the same + * #igt_pipe_crc_t object. + */ + +#ifndef __IGT_CRC_H__ +#define __IGT_CRC_H__ + +#include +#include + +enum pipe; + +/** + * igt_pipe_crc_t: + * + * Pipe CRC support structure. Needs to be allocated and set up with + * igt_pipe_crc_new() for a specific pipe and pipe CRC source value. + */ +typedef struct _igt_pipe_crc igt_pipe_crc_t; + +#define DRM_MAX_CRC_NR 10 +/** + * igt_crc_t: + * @frame: frame number of the capture CRC + * @n_words: internal field, don't access + * @crc: internal field, don't access + * + * Pipe CRC value. All other members than @frame are private and should not be + * inspected by testcases. + */ +typedef struct { + uint32_t frame; + bool has_valid_frame; + int n_words; + uint32_t crc[DRM_MAX_CRC_NR]; +} igt_crc_t; + +/** + * intel_pipe_crc_source: + * @INTEL_PIPE_CRC_SOURCE_NONE: No source + * @INTEL_PIPE_CRC_SOURCE_PLANE1: Plane 1 + * @INTEL_PIPE_CRC_SOURCE_PLANE2: Plane 2 + * @INTEL_PIPE_CRC_SOURCE_PF: Panel Filter + * @INTEL_PIPE_CRC_SOURCE_PIPE: Pipe + * @INTEL_PIPE_CRC_SOURCE_TV: TV + * @INTEL_PIPE_CRC_SOURCE_DP_B: DisplayPort B + * @INTEL_PIPE_CRC_SOURCE_DP_C: DisplayPort C + * @INTEL_PIPE_CRC_SOURCE_DP_D: DisplayPort D + * @INTEL_PIPE_CRC_SOURCE_AUTO: Automatic source selection + * @INTEL_PIPE_CRC_SOURCE_MAX: Number of available sources + * + * Enumeration of all supported pipe CRC sources. Not all platforms and all + * outputs support all of them. Generic tests should just use + * INTEL_PIPE_CRC_SOURCE_AUTO. It should always map to an end-of-pipe CRC + * suitable for checking planes, cursor, color correction and any other + * output-agnostic features. + */ +enum intel_pipe_crc_source { + INTEL_PIPE_CRC_SOURCE_NONE, + INTEL_PIPE_CRC_SOURCE_PLANE1, + INTEL_PIPE_CRC_SOURCE_PLANE2, + INTEL_PIPE_CRC_SOURCE_PF, + INTEL_PIPE_CRC_SOURCE_PIPE, + INTEL_PIPE_CRC_SOURCE_TV, + INTEL_PIPE_CRC_SOURCE_DP_B, + INTEL_PIPE_CRC_SOURCE_DP_C, + INTEL_PIPE_CRC_SOURCE_DP_D, + INTEL_PIPE_CRC_SOURCE_AUTO, + INTEL_PIPE_CRC_SOURCE_MAX, +}; + +void igt_assert_crc_equal(const igt_crc_t *a, const igt_crc_t *b); +char *igt_crc_to_string(igt_crc_t *crc); + +void igt_require_pipe_crc(int fd); +igt_pipe_crc_t * +igt_pipe_crc_new(int fd, enum pipe pipe, enum intel_pipe_crc_source source); +igt_pipe_crc_t * +igt_pipe_crc_new_nonblock(int fd, enum pipe pipe, enum intel_pipe_crc_source source); +void igt_pipe_crc_free(igt_pipe_crc_t *pipe_crc); +void igt_pipe_crc_start(igt_pipe_crc_t *pipe_crc); +void igt_pipe_crc_stop(igt_pipe_crc_t *pipe_crc); +__attribute__((warn_unused_result)) +int igt_pipe_crc_get_crcs(igt_pipe_crc_t *pipe_crc, int n_crcs, + igt_crc_t **out_crcs); +void igt_pipe_crc_collect_crc(igt_pipe_crc_t *pipe_crc, igt_crc_t *out_crc); + +#endif /* __IGT_CRC_H__ */ diff --git a/lib/igt_debugfs.c b/lib/igt_debugfs.c index 80f25c61..e08b7ae8 100644 --- a/lib/igt_debugfs.c +++ b/lib/igt_debugfs.c @@ -51,24 +51,6 @@ * basic functions to access debugfs files with e.g. igt_debugfs_open() it also * provides higher-level wrappers for some debugfs features. * - * # Pipe CRC Support - * - * This library wraps up the kernel's support for capturing pipe CRCs into a - * neat and tidy package. For the detailed usage see all the functions which - * work on #igt_pipe_crc_t. This is supported on all platforms and outputs. - * - * Actually using pipe CRCs to write modeset tests is a bit tricky though, so - * there is no way to directly check a CRC: Both the details of the plane - * blending, color correction and other hardware and how exactly the CRC is - * computed at each tap point vary by hardware generation and are not disclosed. - * - * The only way to use #igt_crc_t CRCs therefore is to compare CRCs among each - * another either for equality or difference. Otherwise CRCs must be treated as - * completely opaque values. Note that not even CRCs from different pipes or tap - * points on the same platform can be compared. Hence only use - * igt_assert_crc_equal() to inspect CRC values captured by the same - * #igt_pipe_crc_t object. - * * # Other debugfs interface wrappers * * This covers the miscellaneous debugfs interface wrappers: @@ -277,235 +259,6 @@ bool igt_debugfs_search(int device, const char *filename, const char *substring) return matched; } -/* - * Pipe CRC - */ - -/** - * igt_assert_crc_equal: - * @a: first pipe CRC value - * @b: second pipe CRC value - * - * Compares two CRC values and fails the testcase if they don't match with - * igt_fail(). Note that due to CRC collisions CRC based testcase can only - * assert that CRCs match, never that they are different. Otherwise there might - * be random testcase failures when different screen contents end up with the - * same CRC by chance. - */ -void igt_assert_crc_equal(const igt_crc_t *a, const igt_crc_t *b) -{ - int i; - - for (i = 0; i < a->n_words; i++) - igt_assert_eq_u32(a->crc[i], b->crc[i]); -} - -/** - * igt_crc_to_string: - * @crc: pipe CRC value to print - * - * This formats @crc into a string buffer which is owned by igt_crc_to_string(). - * The next call will override the buffer again, which makes this multithreading - * unsafe. - * - * This should only ever be used for diagnostic debug output. - */ -char *igt_crc_to_string(igt_crc_t *crc) -{ - int i; - char buf[128] = { 0 }; - - for (i = 0; i < crc->n_words; i++) - sprintf(buf + strlen(buf), "%08x ", crc->crc[i]); - - return strdup(buf); -} - -#define MAX_CRC_ENTRIES 10 -#define MAX_LINE_LEN (10 + 11 * MAX_CRC_ENTRIES + 1) - -/* (6 fields, 8 chars each, space separated (5) + '\n') */ -#define LEGACY_LINE_LEN (6 * 8 + 5 + 1) - -struct _igt_pipe_crc { - int fd; - int dir; - int ctl_fd; - int crc_fd; - int flags; - bool is_legacy; - - enum pipe pipe; - enum intel_pipe_crc_source source; -}; - -static const char *pipe_crc_sources[] = { - "none", - "plane1", - "plane2", - "pf", - "pipe", - "TV", - "DP-B", - "DP-C", - "DP-D", - "auto" -}; - -static const char *pipe_crc_source_name(enum intel_pipe_crc_source source) -{ - return pipe_crc_sources[source]; -} - -static bool igt_pipe_crc_do_start(igt_pipe_crc_t *pipe_crc) -{ - char buf[64]; - - /* Stop first just to make sure we don't have lingering state left. */ - igt_pipe_crc_stop(pipe_crc); - - if (pipe_crc->is_legacy) - sprintf(buf, "pipe %s %s", kmstest_pipe_name(pipe_crc->pipe), - pipe_crc_source_name(pipe_crc->source)); - else - sprintf(buf, "%s", pipe_crc_source_name(pipe_crc->source)); - - igt_assert_eq(write(pipe_crc->ctl_fd, buf, strlen(buf)), strlen(buf)); - - if (!pipe_crc->is_legacy) { - int err; - - sprintf(buf, "crtc-%d/crc/data", pipe_crc->pipe); - err = 0; - - pipe_crc->crc_fd = openat(pipe_crc->dir, buf, pipe_crc->flags); - if (pipe_crc->crc_fd < 0) - err = -errno; - - if (err == -EINVAL) - return false; - - igt_assert_eq(err, 0); - } - - errno = 0; - return true; -} - -static void igt_pipe_crc_pipe_off(int fd, enum pipe pipe) -{ - char buf[32]; - - sprintf(buf, "pipe %s none", kmstest_pipe_name(pipe)); - igt_assert_eq(write(fd, buf, strlen(buf)), strlen(buf)); -} - -static void igt_pipe_crc_reset(int drm_fd) -{ - struct dirent *dirent; - const char *cmd = "none"; - bool done = false; - DIR *dir; - int fdir; - int fd; - - fdir = igt_debugfs_dir(drm_fd); - if (fdir < 0) - return; - - dir = fdopendir(fdir); - if (!dir) { - close(fdir); - return; - } - - while ((dirent = readdir(dir))) { - char buf[128]; - - if (strcmp(dirent->d_name, "crtc-") != 0) - continue; - - sprintf(buf, "%s/crc/control", dirent->d_name); - fd = openat(fdir, buf, O_WRONLY); - if (fd < 0) - continue; - - igt_assert_eq(write(fd, cmd, strlen(cmd)), strlen(cmd)); - close(fd); - - done = true; - } - closedir(dir); - - if (!done) { - fd = openat(fdir, "i915_display_crtc_ctl", O_WRONLY); - if (fd != -1) { - igt_pipe_crc_pipe_off(fd, PIPE_A); - igt_pipe_crc_pipe_off(fd, PIPE_B); - igt_pipe_crc_pipe_off(fd, PIPE_C); - - close(fd); - } - } - - close(fdir); -} - -static void pipe_crc_exit_handler(int sig) -{ - struct dirent *dirent; - char buf[128]; - DIR *dir; - int fd; - - dir = opendir("/dev/dri"); - if (!dir) - return; - - /* - * Try to reset CRC capture for all DRM devices, this is only needed - * for the legacy CRC ABI and can be completely removed once the - * legacy codepaths are removed. - */ - while ((dirent = readdir(dir))) { - if (strncmp(dirent->d_name, "card", 4) != 0) - continue; - - sprintf(buf, "/dev/dri/%s", dirent->d_name); - fd = open(buf, O_WRONLY); - - igt_pipe_crc_reset(fd); - - close(fd); - } - closedir(dir); -} - -/** - * igt_require_pipe_crc: - * - * Convenience helper to check whether pipe CRC capturing is supported by the - * kernel. Uses igt_skip to automatically skip the test/subtest if this isn't - * the case. - */ -void igt_require_pipe_crc(int fd) -{ - const char *cmd = "pipe A none"; - int ctl, written; - - ctl = igt_debugfs_open(fd, "crtc-0/crc/control", O_RDONLY); - if (ctl < 0) { - ctl = igt_debugfs_open(fd, "i915_display_crc_ctl", O_WRONLY); - igt_require_f(ctl, - "No display_crc_ctl found, kernel too old\n"); - - written = write(ctl, cmd, strlen(cmd)); - igt_require_f(written < 0, - "CRCs not supported on this platform\n"); - } - close(ctl); -} - static void igt_hpd_storm_exit_handler(int sig) { int fd = drm_open_driver_master(DRIVER_INTEL); @@ -627,306 +380,6 @@ void igt_require_hpd_storm_ctl(int drm_fd) close(fd); } -static igt_pipe_crc_t * -pipe_crc_new(int fd, enum pipe pipe, enum intel_pipe_crc_source source, int flags) -{ - igt_pipe_crc_t *pipe_crc; - char buf[128]; - int debugfs; - - debugfs = igt_debugfs_dir(fd); - igt_assert(debugfs != -1); - - igt_install_exit_handler(pipe_crc_exit_handler); - - pipe_crc = calloc(1, sizeof(struct _igt_pipe_crc)); - - sprintf(buf, "crtc-%d/crc/control", pipe); - pipe_crc->ctl_fd = openat(debugfs, buf, O_WRONLY); - if (pipe_crc->ctl_fd == -1) { - pipe_crc->ctl_fd = openat(debugfs, - "i915_display_crc_ctl", O_WRONLY); - igt_assert(pipe_crc->ctl_fd != -1); - pipe_crc->is_legacy = true; - } - - if (pipe_crc->is_legacy) { - sprintf(buf, "i915_pipe_%s_crc", kmstest_pipe_name(pipe)); - pipe_crc->crc_fd = openat(debugfs, buf, flags); - igt_assert(pipe_crc->crc_fd != -1); - igt_debug("Using legacy frame CRC ABI\n"); - } else { - pipe_crc->crc_fd = -1; - igt_debug("Using generic frame CRC ABI\n"); - } - - pipe_crc->fd = fd; - pipe_crc->dir = debugfs; - pipe_crc->pipe = pipe; - pipe_crc->source = source; - pipe_crc->flags = flags; - - return pipe_crc; -} - -/** - * igt_pipe_crc_new: - * @pipe: display pipe to use as source - * @source: CRC tap point to use as source - * - * This sets up a new pipe CRC capture object for the given @pipe and @source - * in blocking mode. - * - * Returns: A pipe CRC object for the given @pipe and @source. The library - * assumes that the source is always available since recent kernels support at - * least INTEL_PIPE_CRC_SOURCE_AUTO everywhere. - */ -igt_pipe_crc_t * -igt_pipe_crc_new(int fd, enum pipe pipe, enum intel_pipe_crc_source source) -{ - return pipe_crc_new(fd, pipe, source, O_RDONLY); -} - -/** - * igt_pipe_crc_new_nonblock: - * @pipe: display pipe to use as source - * @source: CRC tap point to use as source - * - * This sets up a new pipe CRC capture object for the given @pipe and @source - * in nonblocking mode. - * - * Returns: A pipe CRC object for the given @pipe and @source. The library - * assumes that the source is always available since recent kernels support at - * least INTEL_PIPE_CRC_SOURCE_AUTO everywhere. - */ -igt_pipe_crc_t * -igt_pipe_crc_new_nonblock(int fd, enum pipe pipe, enum intel_pipe_crc_source source) -{ - return pipe_crc_new(fd, pipe, source, O_RDONLY | O_NONBLOCK); -} - -/** - * igt_pipe_crc_free: - * @pipe_crc: pipe CRC object - * - * Frees all resources associated with @pipe_crc. - */ -void igt_pipe_crc_free(igt_pipe_crc_t *pipe_crc) -{ - if (!pipe_crc) - return; - - close(pipe_crc->ctl_fd); - close(pipe_crc->crc_fd); - close(pipe_crc->dir); - free(pipe_crc); -} - -static bool pipe_crc_init_from_string(igt_pipe_crc_t *pipe_crc, igt_crc_t *crc, - const char *line) -{ - int n, i; - const char *buf; - - if (pipe_crc->is_legacy) { - crc->has_valid_frame = true; - crc->n_words = 5; - n = sscanf(line, "%8u %8x %8x %8x %8x %8x", &crc->frame, - &crc->crc[0], &crc->crc[1], &crc->crc[2], - &crc->crc[3], &crc->crc[4]); - return n == 6; - } - - if (strncmp(line, "XXXXXXXXXX", 10) == 0) - crc->has_valid_frame = false; - else { - crc->has_valid_frame = true; - crc->frame = strtoul(line, NULL, 16); - } - - buf = line + 10; - for (i = 0; *buf != '\n'; i++, buf += 11) - crc->crc[i] = strtoul(buf, NULL, 16); - - crc->n_words = i; - - return true; -} - -static int read_crc(igt_pipe_crc_t *pipe_crc, igt_crc_t *out) -{ - ssize_t bytes_read; - char buf[MAX_LINE_LEN + 1]; - size_t read_len; - - if (pipe_crc->is_legacy) - read_len = LEGACY_LINE_LEN; - else - read_len = MAX_LINE_LEN; - - igt_set_timeout(5, "CRC reading"); - bytes_read = read(pipe_crc->crc_fd, &buf, read_len); - igt_reset_timeout(); - - if (bytes_read < 0 && errno == EAGAIN) - igt_assert(pipe_crc->flags & O_NONBLOCK); - - if (bytes_read < 0) - bytes_read = 0; - - buf[bytes_read] = '\0'; - - if (bytes_read && !pipe_crc_init_from_string(pipe_crc, out, buf)) - return -EINVAL; - - return bytes_read; -} - -static void read_one_crc(igt_pipe_crc_t *pipe_crc, igt_crc_t *out) -{ - while (read_crc(pipe_crc, out) == 0) - usleep(1000); -} - -/** - * igt_pipe_crc_start: - * @pipe_crc: pipe CRC object - * - * Starts the CRC capture process on @pipe_crc. - */ -void igt_pipe_crc_start(igt_pipe_crc_t *pipe_crc) -{ - igt_crc_t crc; - - igt_assert(igt_pipe_crc_do_start(pipe_crc)); - - if (pipe_crc->is_legacy) { - /* - * For some no yet identified reason, the first CRC is - * bonkers. So let's just wait for the next vblank and read - * out the buggy result. - * - * On CHV sometimes the second CRC is bonkers as well, so - * don't trust that one either. - */ - read_one_crc(pipe_crc, &crc); - read_one_crc(pipe_crc, &crc); - } -} - -/** - * igt_pipe_crc_stop: - * @pipe_crc: pipe CRC object - * - * Stops the CRC capture process on @pipe_crc. - */ -void igt_pipe_crc_stop(igt_pipe_crc_t *pipe_crc) -{ - char buf[32]; - - if (pipe_crc->is_legacy) { - sprintf(buf, "pipe %s none", kmstest_pipe_name(pipe_crc->pipe)); - igt_assert_eq(write(pipe_crc->ctl_fd, buf, strlen(buf)), - strlen(buf)); - } else { - close(pipe_crc->crc_fd); - pipe_crc->crc_fd = -1; - } -} - -/** - * igt_pipe_crc_get_crcs: - * @pipe_crc: pipe CRC object - * @n_crcs: number of CRCs to capture - * @out_crcs: buffer pointer for the captured CRC values - * - * Read up to @n_crcs from @pipe_crc. This function does not block, and will - * return early if not enough CRCs can be captured, if @pipe_crc has been - * opened using igt_pipe_crc_new_nonblock(). It will block until @n_crcs are - * retrieved if @pipe_crc has been opened using igt_pipe_crc_new(). @out_crcs is - * alloced by this function and must be released with free() by the caller. - * - * Callers must start and stop the capturing themselves by calling - * igt_pipe_crc_start() and igt_pipe_crc_stop(). For one-shot CRC collecting - * look at igt_pipe_crc_collect_crc(). - * - * Returns: - * The number of CRCs captured. Should be equal to @n_crcs in blocking mode, but - * can be less (even zero) in non-blocking mode. - */ -int -igt_pipe_crc_get_crcs(igt_pipe_crc_t *pipe_crc, int n_crcs, - igt_crc_t **out_crcs) -{ - igt_crc_t *crcs; - int n = 0; - - crcs = calloc(n_crcs, sizeof(igt_crc_t)); - - do { - igt_crc_t *crc = &crcs[n]; - int ret; - - ret = read_crc(pipe_crc, crc); - if (ret < 0) - continue; - if (ret == 0) - break; - - n++; - } while (n < n_crcs); - - *out_crcs = crcs; - return n; -} - -static void crc_sanity_checks(igt_crc_t *crc) -{ - int i; - bool all_zero = true; - - for (i = 0; i < crc->n_words; i++) { - igt_warn_on_f(crc->crc[i] == 0xffffffff, - "Suspicious CRC: it looks like the CRC " - "read back was from a register in a powered " - "down well\n"); - if (crc->crc[i]) - all_zero = false; - } - - igt_warn_on_f(all_zero, "Suspicious CRC: All values are 0.\n"); -} - -/** - * igt_pipe_crc_collect_crc: - * @pipe_crc: pipe CRC object - * @out_crc: buffer for the captured CRC values - * - * Read a single CRC from @pipe_crc. This function blocks until the CRC is - * retrieved, irrespective of whether @pipe_crc has been opened with - * igt_pipe_crc_new() or igt_pipe_crc_new_nonblock(). @out_crc must be - * allocated by the caller. - * - * This function takes care of the pipe_crc book-keeping, it will start/stop - * the collection of the CRC. - * - * This function also calls the interactive debug with the "crc" domain, so you - * can make use of this feature to actually see the screen that is being CRC'd. - * - * For continuous CRC collection look at igt_pipe_crc_start(), - * igt_pipe_crc_get_crcs() and igt_pipe_crc_stop(). - */ -void igt_pipe_crc_collect_crc(igt_pipe_crc_t *pipe_crc, igt_crc_t *out_crc) -{ - igt_debug_wait_for_keypress("crc"); - - igt_pipe_crc_start(pipe_crc); - read_one_crc(pipe_crc, out_crc); - igt_pipe_crc_stop(pipe_crc); - - crc_sanity_checks(out_crc); -} - /* * Drop caches */ diff --git a/lib/igt_debugfs.h b/lib/igt_debugfs.h index 7b846a83..01a5ee07 100644 --- a/lib/igt_debugfs.h +++ b/lib/igt_debugfs.h @@ -29,8 +29,6 @@ #include #include -enum pipe; - const char *igt_debugfs_mount(void); int igt_debugfs_dir(int device); @@ -50,85 +48,6 @@ bool igt_debugfs_search(int fd, const char *filename, const char *substring); #define igt_debugfs_read(fd, filename, buf) \ __igt_debugfs_read(fd, (filename), (buf), sizeof(buf)) -/* - * Pipe CRC - */ - -/** - * igt_pipe_crc_t: - * - * Pipe CRC support structure. Needs to be allocated and set up with - * igt_pipe_crc_new() for a specific pipe and pipe CRC source value. - */ -typedef struct _igt_pipe_crc igt_pipe_crc_t; - -#define DRM_MAX_CRC_NR 10 -/** - * igt_crc_t: - * @frame: frame number of the capture CRC - * @n_words: internal field, don't access - * @crc: internal field, don't access - * - * Pipe CRC value. All other members than @frame are private and should not be - * inspected by testcases. - */ -typedef struct { - uint32_t frame; - bool has_valid_frame; - int n_words; - uint32_t crc[DRM_MAX_CRC_NR]; -} igt_crc_t; - -/** - * intel_pipe_crc_source: - * @INTEL_PIPE_CRC_SOURCE_NONE: No source - * @INTEL_PIPE_CRC_SOURCE_PLANE1: Plane 1 - * @INTEL_PIPE_CRC_SOURCE_PLANE2: Plane 2 - * @INTEL_PIPE_CRC_SOURCE_PF: Panel Filter - * @INTEL_PIPE_CRC_SOURCE_PIPE: Pipe - * @INTEL_PIPE_CRC_SOURCE_TV: TV - * @INTEL_PIPE_CRC_SOURCE_DP_B: DisplayPort B - * @INTEL_PIPE_CRC_SOURCE_DP_C: DisplayPort C - * @INTEL_PIPE_CRC_SOURCE_DP_D: DisplayPort D - * @INTEL_PIPE_CRC_SOURCE_AUTO: Automatic source selection - * @INTEL_PIPE_CRC_SOURCE_MAX: Number of available sources - * - * Enumeration of all supported pipe CRC sources. Not all platforms and all - * outputs support all of them. Generic tests should just use - * INTEL_PIPE_CRC_SOURCE_AUTO. It should always map to an end-of-pipe CRC - * suitable for checking planes, cursor, color correction and any other - * output-agnostic features. - */ -enum intel_pipe_crc_source { - INTEL_PIPE_CRC_SOURCE_NONE, - INTEL_PIPE_CRC_SOURCE_PLANE1, - INTEL_PIPE_CRC_SOURCE_PLANE2, - INTEL_PIPE_CRC_SOURCE_PF, - INTEL_PIPE_CRC_SOURCE_PIPE, - INTEL_PIPE_CRC_SOURCE_TV, - INTEL_PIPE_CRC_SOURCE_DP_B, - INTEL_PIPE_CRC_SOURCE_DP_C, - INTEL_PIPE_CRC_SOURCE_DP_D, - INTEL_PIPE_CRC_SOURCE_AUTO, - INTEL_PIPE_CRC_SOURCE_MAX, -}; - -void igt_assert_crc_equal(const igt_crc_t *a, const igt_crc_t *b); -char *igt_crc_to_string(igt_crc_t *crc); - -void igt_require_pipe_crc(int fd); -igt_pipe_crc_t * -igt_pipe_crc_new(int fd, enum pipe pipe, enum intel_pipe_crc_source source); -igt_pipe_crc_t * -igt_pipe_crc_new_nonblock(int fd, enum pipe pipe, enum intel_pipe_crc_source source); -void igt_pipe_crc_free(igt_pipe_crc_t *pipe_crc); -void igt_pipe_crc_start(igt_pipe_crc_t *pipe_crc); -void igt_pipe_crc_stop(igt_pipe_crc_t *pipe_crc); -__attribute__((warn_unused_result)) -int igt_pipe_crc_get_crcs(igt_pipe_crc_t *pipe_crc, int n_crcs, - igt_crc_t **out_crcs); -void igt_pipe_crc_collect_crc(igt_pipe_crc_t *pipe_crc, igt_crc_t *out_crc); - void igt_hpd_storm_set_threshold(int fd, unsigned int threshold); void igt_hpd_storm_reset(int fd); bool igt_hpd_storm_detected(int fd); diff --git a/tests/chamelium.c b/tests/chamelium.c index e26f0557..5482eb5b 100644 --- a/tests/chamelium.c +++ b/tests/chamelium.c @@ -26,6 +26,7 @@ #include "config.h" #include "igt.h" +#include "igt_crc.h" #include #include diff --git a/tests/kms_atomic_transition.c b/tests/kms_atomic_transition.c index e22763bd..1b9233ad 100644 --- a/tests/kms_atomic_transition.c +++ b/tests/kms_atomic_transition.c @@ -22,6 +22,7 @@ */ #include "igt.h" +#include "igt_crc.h" #include "drmtest.h" #include "sw_sync.h" #include diff --git a/tests/kms_ccs.c b/tests/kms_ccs.c index 29d676af..66bd0f29 100644 --- a/tests/kms_ccs.c +++ b/tests/kms_ccs.c @@ -23,6 +23,7 @@ */ #include "igt.h" +#include "igt_crc.h" IGT_TEST_DESCRIPTION("Test render compression (RC), in which the main surface " "is complemented by a color control surface (CCS) that " diff --git a/tests/kms_chv_cursor_fail.c b/tests/kms_chv_cursor_fail.c index 3e74df11..b02958bd 100644 --- a/tests/kms_chv_cursor_fail.c +++ b/tests/kms_chv_cursor_fail.c @@ -23,6 +23,7 @@ */ #include "igt.h" +#include "igt_crc.h" #include #include #include diff --git a/tests/kms_crtc_background_color.c b/tests/kms_crtc_background_color.c index e12e1634..3bcabcac 100644 --- a/tests/kms_crtc_background_color.c +++ b/tests/kms_crtc_background_color.c @@ -23,6 +23,7 @@ */ #include "igt.h" +#include "igt_crc.h" #include diff --git a/tests/kms_cursor_crc.c b/tests/kms_cursor_crc.c index 4c5e00c0..4693e9f4 100644 --- a/tests/kms_cursor_crc.c +++ b/tests/kms_cursor_crc.c @@ -23,6 +23,7 @@ */ #include "igt.h" +#include "igt_crc.h" #include #include #include diff --git a/tests/kms_cursor_legacy.c b/tests/kms_cursor_legacy.c index 8180b043..505e3f9d 100644 --- a/tests/kms_cursor_legacy.c +++ b/tests/kms_cursor_legacy.c @@ -27,6 +27,7 @@ #include #include "igt.h" +#include "igt_crc.h" #include "igt_rand.h" #include "igt_stats.h" diff --git a/tests/kms_draw_crc.c b/tests/kms_draw_crc.c index c57d3a35..8cb4e147 100644 --- a/tests/kms_draw_crc.c +++ b/tests/kms_draw_crc.c @@ -25,6 +25,7 @@ /* This program tests whether the igt_draw library actually works. */ #include "igt.h" +#include "igt_crc.h" #define MAX_CONNECTORS 32 diff --git a/tests/kms_fbc_crc.c b/tests/kms_fbc_crc.c index 7964e052..10656b89 100644 --- a/tests/kms_fbc_crc.c +++ b/tests/kms_fbc_crc.c @@ -23,6 +23,7 @@ */ #include "igt.h" +#include "igt_crc.h" #include #include #include diff --git a/tests/kms_flip_tiling.c b/tests/kms_flip_tiling.c index 5aae29a8..8e1a2fb4 100644 --- a/tests/kms_flip_tiling.c +++ b/tests/kms_flip_tiling.c @@ -25,6 +25,7 @@ */ #include "igt.h" +#include "igt_crc.h" #include #include #include diff --git a/tests/kms_frontbuffer_tracking.c b/tests/kms_frontbuffer_tracking.c index e03524f1..c1b08669 100644 --- a/tests/kms_frontbuffer_tracking.c +++ b/tests/kms_frontbuffer_tracking.c @@ -25,6 +25,7 @@ */ #include "igt.h" +#include "igt_crc.h" #include "igt_sysfs.h" #include #include diff --git a/tests/kms_mmap_write_crc.c b/tests/kms_mmap_write_crc.c index e5f089f6..79efa792 100644 --- a/tests/kms_mmap_write_crc.c +++ b/tests/kms_mmap_write_crc.c @@ -31,6 +31,7 @@ #include #include "drmtest.h" +#include "igt_crc.h" #include "igt_debugfs.h" #include "igt_kms.h" #include "intel_chipset.h" diff --git a/tests/kms_mmio_vs_cs_flip.c b/tests/kms_mmio_vs_cs_flip.c index fa947d9c..ee1d202a 100644 --- a/tests/kms_mmio_vs_cs_flip.c +++ b/tests/kms_mmio_vs_cs_flip.c @@ -22,6 +22,7 @@ */ #include "igt.h" +#include "igt_crc.h" #include #include #include diff --git a/tests/kms_pipe_color.c b/tests/kms_pipe_color.c index a3100fae..389fb3de 100644 --- a/tests/kms_pipe_color.c +++ b/tests/kms_pipe_color.c @@ -28,6 +28,7 @@ #include "drm.h" #include "drmtest.h" #include "igt.h" +#include "igt_crc.h" IGT_TEST_DESCRIPTION("Test Color Features at Pipe level"); diff --git a/tests/kms_pipe_crc_basic.c b/tests/kms_pipe_crc_basic.c index 35adddba..38da3a42 100644 --- a/tests/kms_pipe_crc_basic.c +++ b/tests/kms_pipe_crc_basic.c @@ -23,6 +23,7 @@ */ #include "igt.h" +#include "igt_crc.h" #include "igt_sysfs.h" #include #include diff --git a/tests/kms_plane.c b/tests/kms_plane.c index 1d92a62b..2fa58e8f 100644 --- a/tests/kms_plane.c +++ b/tests/kms_plane.c @@ -25,6 +25,7 @@ */ #include "igt.h" +#include "igt_crc.h" #include #include #include diff --git a/tests/kms_plane_lowres.c b/tests/kms_plane_lowres.c index ee39759c..a4e37275 100644 --- a/tests/kms_plane_lowres.c +++ b/tests/kms_plane_lowres.c @@ -23,6 +23,7 @@ */ #include "igt.h" +#include "igt_crc.h" #include "drmtest.h" #include #include diff --git a/tests/kms_plane_multiple.c b/tests/kms_plane_multiple.c index f6c62235..1b60a067 100644 --- a/tests/kms_plane_multiple.c +++ b/tests/kms_plane_multiple.c @@ -23,6 +23,7 @@ */ #include "igt.h" +#include "igt_crc.h" #include "drmtest.h" #include #include diff --git a/tests/kms_plane_scaling.c b/tests/kms_plane_scaling.c index 1457894a..d554f27f 100644 --- a/tests/kms_plane_scaling.c +++ b/tests/kms_plane_scaling.c @@ -23,6 +23,7 @@ */ #include "igt.h" +#include "igt_crc.h" #include diff --git a/tests/kms_pwrite_crc.c b/tests/kms_pwrite_crc.c index ee895db6..f1e6f023 100644 --- a/tests/kms_pwrite_crc.c +++ b/tests/kms_pwrite_crc.c @@ -23,6 +23,7 @@ */ #include "igt.h" +#include "igt_crc.h" #include #include #include diff --git a/tests/kms_rotation_crc.c b/tests/kms_rotation_crc.c index 83e37f12..fa361100 100644 --- a/tests/kms_rotation_crc.c +++ b/tests/kms_rotation_crc.c @@ -23,6 +23,7 @@ */ #include "igt.h" +#include "igt_crc.h" #include #define MAX_FENCES 32 diff --git a/tests/kms_universal_plane.c b/tests/kms_universal_plane.c index 31f07804..14300b7a 100644 --- a/tests/kms_universal_plane.c +++ b/tests/kms_universal_plane.c @@ -22,6 +22,7 @@ */ #include "igt.h" +#include "igt_crc.h" #include #include #include diff --git a/tools/intel_display_crc.c b/tools/intel_display_crc.c index d1b28ea7..104f432f 100644 --- a/tools/intel_display_crc.c +++ b/tools/intel_display_crc.c @@ -30,6 +30,7 @@ #include #include "igt_core.h" +#include "igt_crc.h" #include "igt_debugfs.h" #include "igt_kms.h"