From: Brian Starkey brian.starkey@arm.com

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 brian.starkey@arm.com --- 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 <stdbool.h>

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 <dirent.h> +#include <errno.h> +#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/stat.h> +#include <sys/types.h> + +#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 <stdbool.h> +#include <stdint.h> + +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 <stdint.h> #include <stdio.h>

-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 <fcntl.h> #include <string.h> 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 <errno.h> 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 <errno.h> #include <limits.h> #include <stdbool.h> 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 <math.h>

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 <errno.h> #include <limits.h> #include <stdbool.h> 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 <sys/poll.h>

#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 <errno.h> #include <stdbool.h> #include <stdio.h> 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 <errno.h> #include <stdbool.h> #include <stdio.h> 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 <sys/types.h> #include <sys/stat.h> 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 <string.h>

#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 <errno.h> #include <stdbool.h> #include <stdio.h> 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 <errno.h> #include <stdbool.h> 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 <errno.h> #include <stdbool.h> #include <stdio.h> 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 <errno.h> #include <stdbool.h> 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 <errno.h> #include <stdbool.h> 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 <math.h>

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 <errno.h> #include <limits.h> #include <stdbool.h> 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 <math.h>

#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 <errno.h> #include <stdbool.h> #include <stdio.h> 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 <unistd.h>

#include "igt_core.h" +#include "igt_crc.h" #include "igt_debugfs.h" #include "igt_kms.h"

From: Brian Starkey brian.starkey@arm.com

Add support in igt_kms for Writeback connectors, with the ability to attach framebuffers and retrieve fences.

Signed-off-by: Brian Starkey brian.starkey@arm.com --- lib/igt_aux.c | 1 + lib/igt_kms.c | 76 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- lib/igt_kms.h | 16 +++++++++++++ 3 files changed, 92 insertions(+), 1 deletion(-)

diff --git a/lib/igt_aux.c b/lib/igt_aux.c index 86a213c2..ad80452a 100644 --- a/lib/igt_aux.c +++ b/lib/igt_aux.c @@ -1106,6 +1106,7 @@ static const struct type_name connector_type_names[] = { { DRM_MODE_CONNECTOR_eDP, "eDP" }, { DRM_MODE_CONNECTOR_VIRTUAL, "Virtual" }, { DRM_MODE_CONNECTOR_DSI, "DSI" }, + { DRM_MODE_CONNECTOR_WRITEBACK, "Writeback" }, {} };

diff --git a/lib/igt_kms.c b/lib/igt_kms.c index 6390229f..02e2b274 100644 --- a/lib/igt_kms.c +++ b/lib/igt_kms.c @@ -186,7 +186,10 @@ const char *igt_crtc_prop_names[IGT_NUM_CRTC_PROPS] = {

const char *igt_connector_prop_names[IGT_NUM_CONNECTOR_PROPS] = { "scaling mode", - "CRTC_ID" + "CRTC_ID", + "WRITEBACK_PIXEL_FORMATS", + "WRITEBACK_FB_ID", + "WRITEBACK_OUT_FENCE_PTR" };

/* @@ -1832,6 +1835,7 @@ void igt_display_init(igt_display_t *display, int drm_fd) output->pending_crtc_idx_mask = 0; output->id = resources->connectors[i]; output->display = display; + output->writeback_out_fence_fd = -1;

igt_output_refresh(output);

@@ -1899,6 +1903,42 @@ igt_output_t *igt_output_from_connector(igt_display_t *display, return found; }

+void igt_output_set_writeback_fb(igt_output_t *output, struct igt_fb *fb) +{ + igt_display_t *display = output->display; + struct kmstest_connector_config *config = &output->config; + + if (config->connector->connector_type != DRM_MODE_CONNECTOR_WRITEBACK) + return; + + LOG(display, "%s: output_set_writeback_fb(%d)\n", output->name, + fb ? fb->fb_id : 0); + + output->writeback_fb = fb; +} + +static void igt_output_reset_writeback_out_fence(igt_output_t *output) +{ + if (output->writeback_out_fence_fd >= 0) { + close(output->writeback_out_fence_fd); + output->writeback_out_fence_fd = -1; + } +} + +void igt_output_request_writeback_out_fence(igt_output_t *output) +{ + igt_output_reset_writeback_out_fence(output); + output->writeback_out_fence_requested = true; +} + +int igt_output_get_last_writeback_out_fence(igt_output_t *output) +{ + int fd = output->writeback_out_fence_fd; + output->writeback_out_fence_fd = -1; + + return fd; +} + static void igt_pipe_fini(igt_pipe_t *pipe) { int i; @@ -1922,6 +1962,8 @@ static void igt_pipe_fini(igt_pipe_t *pipe) static void igt_output_fini(igt_output_t *output) { kmstest_free_connector_config(&output->config); + if (output->writeback_out_fence_fd >= 0) + close(output->writeback_out_fence_fd); free(output->name); output->name = NULL; } @@ -2541,10 +2583,41 @@ static void igt_atomic_prepare_connector_commit(igt_output_t *output, drmModeAto

igt_atomic_populate_connector_req(req, output, IGT_CONNECTOR_CRTC_ID, crtc_id); } + + if (output->writeback_fb) { + igt_atomic_populate_connector_req(req, output, IGT_CONNECTOR_WRITEBACK_FB_ID, output->writeback_fb->fb_id); + output->writeback_fb = NULL; + } + + igt_output_reset_writeback_out_fence(output); + if (output->writeback_out_fence_requested) { + igt_atomic_populate_connector_req(req, output, IGT_CONNECTOR_WRITEBACK_OUT_FENCE_PTR, + (uint64_t)(uintptr_t)&output->writeback_out_fence_fd); + } + /* * TODO: Add all other connector level properties here */ +} + +static void handle_writeback_out_fences(igt_display_t *display, uint32_t flags, int ret) +{ + int i;

+ for (i = 0; i < display->n_outputs; i++) { + igt_output_t *output = &display->outputs[i]; + + if (!output->config.connector) + continue; + + if (!output->writeback_out_fence_requested) + continue; + + output->writeback_out_fence_requested = false; + + if (ret || (flags & DRM_MODE_ATOMIC_TEST_ONLY)) + igt_assert(output->writeback_out_fence_fd == -1); + } }

/* @@ -2593,6 +2666,7 @@ static int igt_atomic_commit(igt_display_t *display, uint32_t flags, void *user_ }

ret = drmModeAtomicCommit(display->drm_fd, req, flags, user_data); + handle_writeback_out_fences(display, flags, ret);

drmModeAtomicFree(req); return ret; diff --git a/lib/igt_kms.h b/lib/igt_kms.h index 35428f3e..ce9a35ef 100644 --- a/lib/igt_kms.h +++ b/lib/igt_kms.h @@ -37,6 +37,10 @@ #include "igt_fb.h" #include "ioctl_wrappers.h"

+#ifndef DRM_MODE_CONNECTOR_WRITEBACK +#define DRM_MODE_CONNECTOR_WRITEBACK 18 +#endif + /* Low-level helpers with kmstest_ prefix */

/** @@ -113,6 +117,9 @@ extern const char *igt_crtc_prop_names[]; enum igt_atomic_connector_properties { IGT_CONNECTOR_SCALING_MODE = 0, IGT_CONNECTOR_CRTC_ID, + IGT_CONNECTOR_WRITEBACK_PIXEL_FORMATS, + IGT_CONNECTOR_WRITEBACK_FB_ID, + IGT_CONNECTOR_WRITEBACK_OUT_FENCE_PTR, IGT_NUM_CONNECTOR_PROPS };

@@ -363,6 +370,10 @@ typedef struct { unsigned long pending_crtc_idx_mask; bool use_override_mode; drmModeModeInfo override_mode; + + struct igt_fb *writeback_fb; + int32_t writeback_out_fence_fd; + bool writeback_out_fence_requested; } igt_output_t;

struct igt_display { @@ -392,10 +403,15 @@ drmModeModeInfo *igt_output_get_mode(igt_output_t *output); void igt_output_override_mode(igt_output_t *output, drmModeModeInfo *mode); void igt_output_set_pipe(igt_output_t *output, enum pipe pipe); void igt_output_set_scaling_mode(igt_output_t *output, uint64_t scaling_mode); + igt_plane_t *igt_output_get_plane(igt_output_t *output, int plane_idx); igt_plane_t *igt_output_get_plane_type(igt_output_t *output, int plane_type); igt_output_t *igt_output_from_connector(igt_display_t *display, drmModeConnector *connector); +void igt_output_set_writeback_fb(igt_output_t *output, struct igt_fb *fb); +void igt_output_request_writeback_out_fence(igt_output_t *output); +int igt_output_get_last_writeback_out_fence(igt_output_t *output); + igt_plane_t *igt_pipe_get_plane_type(igt_pipe_t *pipe, int plane_type); bool igt_pipe_get_property(igt_pipe_t *pipe, const char *name, uint32_t *prop_id, uint64_t *value,

From: Brian Starkey brian.starkey@arm.com

To use writeback buffers as a CRC source, we need to be able to hash them. Implement a simple FVA-1a hashing routine for this purpose.

Doing a bytewise hash on the framebuffer directly can be very slow if the memory is noncached. By making a copy of each line in the FB first (which can take advantage of word-access speedup), we can do the hash on a cached copy, which is much faster (10x speedup on my platform).

Signed-off-by: Brian Starkey brian.starkey@arm.com --- lib/igt_fb.c | 65 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ lib/igt_fb.h | 5 +++++ 2 files changed, 70 insertions(+)

diff --git a/lib/igt_fb.c b/lib/igt_fb.c index d2b7e9e3..f613bb2e 100644 --- a/lib/igt_fb.c +++ b/lib/igt_fb.c @@ -1302,3 +1302,68 @@ void igt_get_all_cairo_formats(const uint32_t **formats, int *format_count) *formats = drm_formats; *format_count = n_formats; } + +/* + * This implements the FNV-1a hashing algorithm instead of CRC, for + * simplicity + * http://www.isthe.com/chongo/tech/comp/fnv/index.html + * + * hash = offset_basis + * for each octet_of_data to be hashed + * hash = hash xor octet_of_data + * hash = hash * FNV_prime + * return hash + * + * 32 bit offset_basis = 2166136261 + * 32 bit FNV_prime = 224 + 28 + 0x93 = 16777619 + */ +int igt_fb_get_crc(struct igt_fb *fb, igt_crc_t *crc) +{ +#define FNV1a_OFFSET_BIAS 2166136261 +#define FNV1a_PRIME 16777619 + uint32_t hash; + void *map; + char *ptr, *line = NULL; + int x, y, cpp = igt_drm_format_to_bpp(fb->drm_format) / 8; + + if (fb->is_dumb) + map = kmstest_dumb_map_buffer(fb->fd, fb->gem_handle, fb->size, + PROT_READ); + else + map = gem_mmap__gtt(fb->fd, fb->gem_handle, fb->size, + PROT_READ); + ptr = map; + + /* + * Framebuffers are often uncached, which can make byte-wise accesses + * very slow. We copy each line of the FB into a local buffer to speed + * up the hashing. + */ + line = malloc(fb->stride); + if (!line) { + munmap(map, fb->size); + return -ENOMEM; + } + + hash = FNV1a_OFFSET_BIAS; + + for (y = 0; y < fb->height; y++, ptr += fb->stride) { + + memcpy(line, ptr, fb->stride); + + for (x = 0; x < fb->width * cpp; x++) { + hash ^= line[x]; + hash *= FNV1a_PRIME; + } + } + + crc->n_words = 1; + crc->crc[0] = hash; + + free(line); + munmap(map, fb->size); + + return 0; +#undef FNV1a_OFFSET_BIAS +#undef FNV1a_PRIME +} diff --git a/lib/igt_fb.h b/lib/igt_fb.h index 4a680cef..04430e9d 100644 --- a/lib/igt_fb.h +++ b/lib/igt_fb.h @@ -43,6 +43,8 @@ typedef struct _cairo cairo_t;

#include <i915_drm.h>

+#include "igt_crc.h" + /** * igt_fb_t: * @fb_id: KMS ID of the framebuffer @@ -156,5 +158,8 @@ uint32_t igt_drm_format_to_bpp(uint32_t drm_format); const char *igt_format_str(uint32_t drm_format); void igt_get_all_cairo_formats(const uint32_t **formats, int *format_count);

+/* Get a hash for a framebuffer */ +int igt_fb_get_crc(struct igt_fb *fb, igt_crc_t *crc); + #endif /* __IGT_FB_H__ */

From: Brian Starkey brian.starkey@arm.com

An output can be added as a clone of any other output(s) attached to a pipe using igt_output_clone_pipe()

Signed-off-by: Brian Starkey brian.starkey@arm.com --- lib/igt_kms.c | 90 +++++++++++++++++++++++++++++++++++++---------------------- lib/igt_kms.h | 3 ++ 2 files changed, 59 insertions(+), 34 deletions(-)

diff --git a/lib/igt_kms.c b/lib/igt_kms.c index aae32202..85dc0aa8 100644 --- a/lib/igt_kms.c +++ b/lib/igt_kms.c @@ -1560,6 +1560,17 @@ static void igt_display_log_shift(igt_display_t *display, int shift) igt_assert(display->log_shift >= 0); }

+static int igt_output_idx(igt_output_t *output) +{ + int i; + + for (i = 0; i < output->display->n_outputs; i++) + if (&output->display->outputs[i] == output) + return i; + + return -1; +} + static void igt_output_refresh(igt_output_t *output) { igt_display_t *display = output->display; @@ -1990,40 +2001,6 @@ void igt_display_fini(igt_display_t *display) display->pipes = NULL; }

-static void igt_display_refresh(igt_display_t *display) -{ - igt_output_t *output; - int i; - - unsigned long pipes_in_use = 0; - - /* Check that two outputs aren't trying to use the same pipe */ - for (i = 0; i < display->n_outputs; i++) { - output = &display->outputs[i]; - - if (pipes_in_use & output->pending_crtc_idx_mask) - goto report_dup; - - pipes_in_use |= output->pending_crtc_idx_mask; - - if (output->force_reprobe) - igt_output_refresh(output); - } - - return; - -report_dup: - for (; i > 0; i--) { - igt_output_t *b = &display->outputs[i - 1]; - - igt_assert_f(output->pending_crtc_idx_mask != - b->pending_crtc_idx_mask, - "%s and %s are both trying to use pipe %s\n", - igt_output_name(output), igt_output_name(b), - kmstest_pipe_name(ffs(b->pending_crtc_idx_mask) - 1)); - } -} - static igt_pipe_t *igt_output_get_driving_pipe(igt_output_t *output) { igt_display_t *display = output->display; @@ -2047,6 +2024,38 @@ static igt_pipe_t *igt_output_get_driving_pipe(igt_output_t *output) return &display->pipes[pipe]; }

+static void igt_display_refresh(igt_display_t *display) +{ + igt_output_t *output; + igt_pipe_t *pipe; + int i; + + unsigned long pipes_in_use = 0; + + /* Check that outputs and pipes agree wrt. cloning */ + for (i = 0; i < display->n_outputs; i++) { + output = &display->outputs[i]; + + pipe = igt_output_get_driving_pipe(output); + if (pipe) { + igt_assert_f(pipe->outputs & (1 << igt_output_idx(output)), + "Output %s not expected to be using pipe %s\n", + igt_output_name(output), + kmstest_pipe_name(pipe->pipe)); + + if (pipes_in_use & output->pending_crtc_idx_mask) + LOG(display, "Output %s clones pipe %s\n", + igt_output_name(output), + kmstest_pipe_name(pipe->pipe)); + } + + pipes_in_use |= output->pending_crtc_idx_mask; + + if (output->force_reprobe) + igt_output_refresh(output); + } +} + static igt_plane_t *igt_pipe_get_plane(igt_pipe_t *pipe, int plane_idx) { igt_assert_f(plane_idx >= 0 && plane_idx < pipe->n_planes, @@ -2941,6 +2950,16 @@ void igt_output_override_mode(igt_output_t *output, drmModeModeInfo *mode) pipe->mode_changed = true; }

+void igt_output_clone_pipe(igt_output_t *output, enum pipe pipe) +{ + igt_display_t *display = output->display; + uint32_t current_clones = display->pipes[pipe].outputs; + + igt_output_set_pipe(output, pipe); + + display->pipes[pipe].outputs |= current_clones; +} + void igt_output_set_pipe(igt_output_t *output, enum pipe pipe) { igt_display_t *display = output->display; @@ -2952,6 +2971,7 @@ void igt_output_set_pipe(igt_output_t *output, enum pipe pipe) old_pipe = igt_output_get_driving_pipe(output);

old_pipe->mode_changed = true; + old_pipe->outputs &= ~(1 << igt_output_idx(output)); }

if (pipe == PIPE_NONE) { @@ -2963,6 +2983,8 @@ void igt_output_set_pipe(igt_output_t *output, enum pipe pipe) output->pending_crtc_idx_mask = 1 << pipe;

display->pipes[pipe].mode_changed = true; + + display->pipes[pipe].outputs = (1 << igt_output_idx(output)); }

output->config.pipe_changed = true; diff --git a/lib/igt_kms.h b/lib/igt_kms.h index ab8ec764..9ddcfade 100644 --- a/lib/igt_kms.h +++ b/lib/igt_kms.h @@ -358,6 +358,8 @@ struct igt_pipe {

int32_t out_fence_fd; bool out_fence_requested; + + uint32_t outputs; };

typedef struct { @@ -402,6 +404,7 @@ const char *igt_output_name(igt_output_t *output); drmModeModeInfo *igt_output_get_mode(igt_output_t *output); void igt_output_override_mode(igt_output_t *output, drmModeModeInfo *mode); void igt_output_set_pipe(igt_output_t *output, enum pipe pipe); +void igt_output_clone_pipe(igt_output_t *output, enum pipe pipe); void igt_output_set_scaling_mode(igt_output_t *output, uint64_t scaling_mode);

igt_plane_t *igt_output_get_plane(igt_output_t *output, int plane_idx);