From patchwork Mon Apr 18 11:30:26 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Lionel Landwerlin X-Patchwork-Id: 8871391 Return-Path: X-Original-To: patchwork-intel-gfx@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork1.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.136]) by patchwork1.web.kernel.org (Postfix) with ESMTP id 23A079F441 for ; Mon, 18 Apr 2016 11:30:52 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 5DC6920222 for ; Mon, 18 Apr 2016 11:30:48 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) by mail.kernel.org (Postfix) with ESMTP id 2731B201B4 for ; Mon, 18 Apr 2016 11:30:44 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 2B5096E5A4; Mon, 18 Apr 2016 11:30:43 +0000 (UTC) X-Original-To: intel-gfx@lists.freedesktop.org Delivered-To: intel-gfx@lists.freedesktop.org Received: from mga03.intel.com (mga03.intel.com [134.134.136.65]) by gabe.freedesktop.org (Postfix) with ESMTP id D88EE6E5A4 for ; Mon, 18 Apr 2016 11:30:40 +0000 (UTC) Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by orsmga103.jf.intel.com with ESMTP; 18 Apr 2016 04:30:35 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.24,502,1455004800"; d="scan'208";a="947510287" Received: from antonisc-mobl5.ger.corp.intel.com (HELO ivy.ger.corp.intel.com) ([10.252.33.72]) by fmsmga001.fm.intel.com with ESMTP; 18 Apr 2016 04:30:31 -0700 From: Lionel Landwerlin To: intel-gfx@lists.freedesktop.org Date: Mon, 18 Apr 2016 12:30:26 +0100 Message-Id: <1460979026-29538-1-git-send-email-lionel.g.landwerlin@intel.com> X-Mailer: git-send-email 2.8.0.rc3 MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH i-g-t] tests: rename kms_pipe_color to get it picked up by the BAT X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" X-Spam-Status: No, score=-5.2 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_MED, RP_MATCHES_RCVD, UNPARSEABLE_RELAY autolearn=unavailable version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP These tests should skip properly on platforms not supporting color management & pipe CRC. They should also run within 10s. So it makes sense to have run by the BAT as we missed some regressions lately. Signed-off-by: Lionel Landwerlin --- tests/Makefile.sources | 2 +- tests/kms_pipe_color.c | 1184 ------------------------------------------ tests/kms_pipe_color_basic.c | 1184 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 1185 insertions(+), 1185 deletions(-) delete mode 100644 tests/kms_pipe_color.c create mode 100644 tests/kms_pipe_color_basic.c diff --git a/tests/Makefile.sources b/tests/Makefile.sources index 41eca0d..cd194af 100644 --- a/tests/Makefile.sources +++ b/tests/Makefile.sources @@ -93,7 +93,7 @@ TESTS_progs_M = \ kms_legacy_colorkey \ kms_mmio_vs_cs_flip \ kms_pipe_b_c_ivb \ - kms_pipe_color \ + kms_pipe_color_basic \ kms_pipe_crc_basic \ kms_plane \ kms_psr_sink_crc \ diff --git a/tests/kms_pipe_color.c b/tests/kms_pipe_color.c deleted file mode 100644 index f08aabd..0000000 --- a/tests/kms_pipe_color.c +++ /dev/null @@ -1,1184 +0,0 @@ -/* - * Copyright © 2015 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 "drm.h" -#include "drmtest.h" -#include "igt.h" - -IGT_TEST_DESCRIPTION("Test Color Features at Pipe level"); - -/* Data structures for gamma/degamma ramps & ctm matrix. */ -struct _drm_color_ctm { - /* Transformation matrix in S31.32 format. */ - __s64 matrix[9]; -}; - -struct _drm_color_lut { - /* - * Data is U0.16 fixed point format. - */ - __u16 red; - __u16 green; - __u16 blue; - __u16 reserved; -}; - -/* Internal */ -typedef struct { - double r, g, b; -} color_t; - -typedef struct { - int drm_fd; - uint32_t devid; - igt_display_t display; - igt_pipe_crc_t *pipe_crc; - - uint32_t color_depth; - uint64_t degamma_lut_size; - uint64_t gamma_lut_size; -} data_t; - - -static void paint_gradient_rectangles(data_t *data, - drmModeModeInfo *mode, - color_t *colors, - struct igt_fb *fb) -{ - cairo_t *cr = igt_get_cairo_ctx(data->drm_fd, fb); - int i, l = mode->hdisplay / 3; - - /* Paint 3 gradient rectangles with red/green/blue between 1.0 and - * 0.5. We want to avoid 0 so each max LUTs only affect their own - * rectangle. - */ - for (i = 0 ; i < 3; i++) { - igt_paint_color_gradient_range(cr, i * l, 0, l, mode->vdisplay, - colors[i].r != 0 ? 0.2 : 0, - colors[i].g != 0 ? 0.2 : 0, - colors[i].b != 0 ? 0.2 : 0, - colors[i].r, - colors[i].g, - colors[i].b); - } - - cairo_destroy(cr); -} - -static void paint_rectangles(data_t *data, - drmModeModeInfo *mode, - color_t *colors, - struct igt_fb *fb) -{ - cairo_t *cr = igt_get_cairo_ctx(data->drm_fd, fb); - int i, l = mode->hdisplay / 3; - - /* Paint 3 solid rectangles. */ - for (i = 0 ; i < 3; i++) { - igt_paint_color(cr, i * l, 0, l, mode->vdisplay, - colors[i].r, colors[i].g, colors[i].b); - } - - cairo_destroy(cr); -} - -static double *generate_table(uint32_t lut_size, double exp) -{ - double *coeffs = malloc(sizeof(double) * lut_size); - uint32_t i; - - for (i = 0; i < lut_size; i++) - coeffs[i] = powf((double) i * 1.0 / (double) (lut_size - 1), exp); - - return coeffs; -} - -static double *generate_table_max(uint32_t lut_size) -{ - double *coeffs = malloc(sizeof(double) * lut_size); - uint32_t i; - - coeffs[0] = 0.0; - for (i = 1; i < lut_size; i++) - coeffs[i] = 1.0; - - return coeffs; -} - -static double *generate_table_zero(uint32_t lut_size) -{ - double *coeffs = malloc(sizeof(double) * lut_size); - uint32_t i; - - for (i = 0; i < lut_size; i++) - coeffs[i] = 0.0; - - return coeffs; -} - -static struct _drm_color_lut *coeffs_to_lut(data_t *data, - const double *coefficients, - uint32_t lut_size, - uint32_t color_depth, - int off) -{ - struct _drm_color_lut *lut; - uint32_t i; - uint32_t max_value = (1 << 16) - 1; - uint32_t mask = ((1 << color_depth) - 1) << 8; - - lut = malloc(sizeof(struct _drm_color_lut) * lut_size); - - if (IS_CHERRYVIEW(data->devid)) - lut_size -= 1; - for (i = 0; i < lut_size; i++) { - uint32_t v = (coefficients[i] * max_value); - - /* - * Hardware might encode colors on a different number of bits - * than what is in our framebuffer (10 or 12bits for example). - * Mask the lower bits not provided by the framebuffer so we - * can do CRC comparisons. - */ - v &= mask; - - lut[i].red = v; - lut[i].green = v; - lut[i].blue = v; - } - - if (IS_CHERRYVIEW(data->devid)) - lut[lut_size].red = - lut[lut_size].green = - lut[lut_size].blue = lut[lut_size - 1].red; - - return lut; -} - -static void set_degamma(data_t *data, - igt_pipe_t *pipe, - const double *coefficients) -{ - size_t size = sizeof(struct _drm_color_lut) * data->degamma_lut_size; - struct _drm_color_lut *lut = coeffs_to_lut(data, - coefficients, - data->degamma_lut_size, - data->color_depth, 0); - - igt_pipe_set_degamma_lut(pipe, lut, size); - - free(lut); -} - -static void set_gamma(data_t *data, - igt_pipe_t *pipe, - const double *coefficients) -{ - size_t size = sizeof(struct _drm_color_lut) * data->gamma_lut_size; - struct _drm_color_lut *lut = coeffs_to_lut(data, - coefficients, - data->gamma_lut_size, - data->color_depth, 0); - - igt_pipe_set_gamma_lut(pipe, lut, size); - - free(lut); -} - -static void set_ctm(igt_pipe_t *pipe, const double *coefficients) -{ - struct _drm_color_ctm ctm; - int i; - - for (i = 0; i < ARRAY_SIZE(ctm.matrix); i++) { - if (coefficients[i] < 0) { - ctm.matrix[i] = - (int64_t) (-coefficients[i] * ((int64_t) 1L << 32)); - ctm.matrix[i] |= 1ULL << 63; - } else - ctm.matrix[i] = - (int64_t) (coefficients[i] * ((int64_t) 1L << 32)); - } - - igt_pipe_set_ctm_matrix(pipe, &ctm, sizeof(ctm)); -} - -#define disable_degamma(pipe) igt_pipe_set_degamma_lut(pipe, NULL, 0) -#define disable_gamma(pipe) igt_pipe_set_gamma_lut(pipe, NULL, 0) -#define disable_ctm(pipe) igt_pipe_set_ctm_matrix(pipe, NULL, 0) - -static void output_set_property_enum(igt_output_t *output, - const char *property, - const char *enum_value) -{ - int i; - int32_t value = -1; - uint32_t prop_id; - drmModePropertyPtr prop; - - if (!kmstest_get_property(output->display->drm_fd, - output->id, - DRM_MODE_OBJECT_CONNECTOR, - property, - &prop_id, NULL, &prop)) - return; - - igt_assert(prop->flags & DRM_MODE_PROP_ENUM); - - for (i = 0; i < prop->count_enums; i++) { - if (!strcmp(prop->enums[i].name, enum_value)) { - value = prop->enums[i].value; - break; - } - } - igt_assert_neq(value, -1); - - igt_assert_eq(drmModeObjectSetProperty(output->display->drm_fd, - output->id, - DRM_MODE_OBJECT_CONNECTOR, - prop_id, value), 0); - - - drmModeFreeProperty(prop); -} - -/* - * Draw 3 gradient rectangles in red, green and blue, with a maxed out - * degamma LUT and verify we have the same CRC as drawing solid color - * rectangles with linear degamma LUT. - */ -static void test_pipe_degamma(data_t *data, - igt_plane_t *primary) -{ - igt_output_t *output; - double *degamma_linear, *degamma_full; - double *gamma_linear; - color_t red_green_blue[] = { - { 1.0, 0.0, 0.0 }, - { 0.0, 1.0, 0.0 }, - { 0.0, 0.0, 1.0 } - }; - - degamma_linear = generate_table(data->degamma_lut_size, 1.0); - degamma_full = generate_table_max(data->degamma_lut_size); - - gamma_linear = generate_table(data->gamma_lut_size, 1.0); - - for_each_connected_output(&data->display, output) { - drmModeModeInfo *mode; - struct igt_fb fb_modeset, fb; - igt_crc_t crc_fullgamma, crc_fullcolors; - int fb_id, fb_modeset_id; - - igt_output_set_pipe(output, primary->pipe->pipe); - mode = igt_output_get_mode(output); - - /* Create a framebuffer at the size of the output. */ - fb_id = igt_create_fb(data->drm_fd, - mode->hdisplay, - mode->vdisplay, - DRM_FORMAT_XRGB8888, - LOCAL_DRM_FORMAT_MOD_NONE, - &fb); - igt_assert(fb_id); - - fb_modeset_id = igt_create_fb(data->drm_fd, - mode->hdisplay, - mode->vdisplay, - DRM_FORMAT_XRGB8888, - LOCAL_DRM_FORMAT_MOD_NONE, - &fb_modeset); - igt_assert(fb_modeset_id); - - igt_plane_set_fb(primary, &fb_modeset); - disable_ctm(primary->pipe); - disable_degamma(primary->pipe); - set_gamma(data, primary->pipe, gamma_linear); - igt_display_commit(&data->display); - - /* Draw solid colors with no degamma transformation. */ - paint_rectangles(data, mode, red_green_blue, &fb); - igt_plane_set_fb(primary, &fb); - igt_display_commit(&data->display); - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullcolors); - - /* Draw a gradient with degamma LUT to remap all - * values to max red/green/blue. - */ - paint_gradient_rectangles(data, mode, red_green_blue, &fb); - igt_plane_set_fb(primary, &fb); - set_degamma(data, primary->pipe, degamma_full); - igt_display_commit(&data->display); - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullgamma); - - /* Verify that the CRC of the software computed output is - * equal to the CRC of the degamma LUT transformation output. - */ - igt_assert_crc_equal(&crc_fullgamma, &crc_fullcolors); - - igt_output_set_pipe(output, PIPE_ANY); - } - - free(degamma_linear); - free(degamma_full); - free(gamma_linear); -} - -/* - * Draw 3 gradient rectangles in red, green and blue, with a maxed out gamma - * LUT and verify we have the same CRC as drawing solid color rectangles. - */ -static void test_pipe_gamma(data_t *data, - igt_plane_t *primary) -{ - igt_output_t *output; - double *gamma_full; - color_t red_green_blue[] = { - { 1.0, 0.0, 0.0 }, - { 0.0, 1.0, 0.0 }, - { 0.0, 0.0, 1.0 } - }; - - gamma_full = generate_table_max(data->gamma_lut_size); - - for_each_connected_output(&data->display, output) { - drmModeModeInfo *mode; - struct igt_fb fb_modeset, fb; - igt_crc_t crc_fullgamma, crc_fullcolors; - int fb_id, fb_modeset_id; - - igt_output_set_pipe(output, primary->pipe->pipe); - mode = igt_output_get_mode(output); - - /* Create a framebuffer at the size of the output. */ - fb_id = igt_create_fb(data->drm_fd, - mode->hdisplay, - mode->vdisplay, - DRM_FORMAT_XRGB8888, - LOCAL_DRM_FORMAT_MOD_NONE, - &fb); - igt_assert(fb_id); - - fb_modeset_id = igt_create_fb(data->drm_fd, - mode->hdisplay, - mode->vdisplay, - DRM_FORMAT_XRGB8888, - LOCAL_DRM_FORMAT_MOD_NONE, - &fb_modeset); - igt_assert(fb_modeset_id); - - igt_plane_set_fb(primary, &fb_modeset); - disable_ctm(primary->pipe); - disable_degamma(primary->pipe); - set_gamma(data, primary->pipe, gamma_full); - igt_display_commit(&data->display); - - /* Draw solid colors with no gamma transformation. */ - paint_rectangles(data, mode, red_green_blue, &fb); - igt_plane_set_fb(primary, &fb); - igt_display_commit(&data->display); - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullcolors); - - /* Draw a gradient with gamma LUT to remap all values - * to max red/green/blue. - */ - paint_gradient_rectangles(data, mode, red_green_blue, &fb); - igt_plane_set_fb(primary, &fb); - igt_display_commit(&data->display); - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullgamma); - - /* Verify that the CRC of the software computed output is - * equal to the CRC of the gamma LUT transformation output. - */ - igt_assert_crc_equal(&crc_fullgamma, &crc_fullcolors); - - igt_output_set_pipe(output, PIPE_ANY); - } - - free(gamma_full); -} - -/* - * Draw 3 gradient rectangles in red, green and blue, with a maxed out legacy - * gamma LUT and verify we have the same CRC as drawing solid color rectangles - * with linear legacy gamma LUT. - */ -static void test_pipe_legacy_gamma(data_t *data, - igt_plane_t *primary) -{ - igt_output_t *output; - color_t red_green_blue[] = { - { 1.0, 0.0, 0.0 }, - { 0.0, 1.0, 0.0 }, - { 0.0, 0.0, 1.0 } - }; - drmModeCrtc *kms_crtc; - uint32_t i, legacy_lut_size; - uint16_t *red_lut, *green_lut, *blue_lut; - - kms_crtc = drmModeGetCrtc(data->drm_fd, primary->pipe->crtc_id); - legacy_lut_size = kms_crtc->gamma_size; - drmModeFreeCrtc(kms_crtc); - - red_lut = malloc(sizeof(uint16_t) * legacy_lut_size); - green_lut = malloc(sizeof(uint16_t) * legacy_lut_size); - blue_lut = malloc(sizeof(uint16_t) * legacy_lut_size); - - red_lut[0] = green_lut[0] = blue_lut[0] = 0; - for (i = 1; i < legacy_lut_size; i++) - red_lut[i] = green_lut[i] = blue_lut[i] = 0xffff; - - for_each_connected_output(&data->display, output) { - drmModeModeInfo *mode; - struct igt_fb fb_modeset, fb; - igt_crc_t crc_fullgamma, crc_fullcolors; - int fb_id, fb_modeset_id; - - igt_output_set_pipe(output, primary->pipe->pipe); - mode = igt_output_get_mode(output); - - /* Create a framebuffer at the size of the output. */ - fb_id = igt_create_fb(data->drm_fd, - mode->hdisplay, - mode->vdisplay, - DRM_FORMAT_XRGB8888, - LOCAL_DRM_FORMAT_MOD_NONE, - &fb); - igt_assert(fb_id); - - fb_modeset_id = igt_create_fb(data->drm_fd, - mode->hdisplay, - mode->vdisplay, - DRM_FORMAT_XRGB8888, - LOCAL_DRM_FORMAT_MOD_NONE, - &fb_modeset); - igt_assert(fb_modeset_id); - - igt_plane_set_fb(primary, &fb_modeset); - disable_degamma(primary->pipe); - disable_gamma(primary->pipe); - disable_ctm(primary->pipe); - igt_display_commit(&data->display); - - /* Draw solid colors with no gamma transformation. */ - paint_rectangles(data, mode, red_green_blue, &fb); - igt_plane_set_fb(primary, &fb); - igt_display_commit(&data->display); - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullcolors); - - /* Draw a gradient with gamma LUT to remap all values - * to max red/green/blue. - */ - paint_gradient_rectangles(data, mode, red_green_blue, &fb); - igt_plane_set_fb(primary, &fb); - igt_assert_eq(drmModeCrtcSetGamma(data->drm_fd, primary->pipe->crtc_id, - legacy_lut_size, red_lut, green_lut, blue_lut), 0); - igt_display_commit(&data->display); - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullgamma); - - /* Verify that the CRC of the software computed output is - * equal to the CRC of the gamma LUT transformation output. - */ - igt_assert_crc_equal(&crc_fullgamma, &crc_fullcolors); - - /* Reset output. */ - for (i = 1; i < legacy_lut_size; i++) - red_lut[i] = green_lut[i] = blue_lut[i] = i << 8; - - igt_assert_eq(drmModeCrtcSetGamma(data->drm_fd, primary->pipe->crtc_id, - legacy_lut_size, red_lut, green_lut, blue_lut), 0); - igt_display_commit(&data->display); - - igt_output_set_pipe(output, PIPE_ANY); - } - - free(red_lut); - free(green_lut); - free(blue_lut); -} - -static drmModePropertyBlobPtr -get_blob(data_t *data, igt_pipe_t *pipe, const char *property_name) -{ - uint64_t prop_value; - drmModePropertyPtr prop; - drmModePropertyBlobPtr blob; - - igt_assert(igt_pipe_get_property(pipe, property_name, - NULL, &prop_value, &prop)); - - if (prop_value == 0) - return NULL; - - igt_assert(prop->flags & DRM_MODE_PROP_BLOB); - blob = drmModeGetPropertyBlob(data->drm_fd, prop_value); - drmModeFreeProperty(prop); - - return blob; -} - -/* - * Verify that setting the legacy gamma LUT resets the gamma LUT set - * through the GAMMA_LUT property. - */ -static void test_pipe_legacy_gamma_reset(data_t *data, - igt_plane_t *primary) -{ - const double ctm_identity[] = { - 1.0, 0.0, 0.0, - 0.0, 1.0, 0.0, - 0.0, 0.0, 1.0 - }; - drmModeCrtc *kms_crtc; - double *degamma_linear, *gamma_zero; - uint32_t i, legacy_lut_size; - uint16_t *red_lut, *green_lut, *blue_lut; - struct _drm_color_lut *lut; - drmModePropertyBlobPtr blob; - igt_output_t *output; - - degamma_linear = generate_table(data->degamma_lut_size, 1.0); - gamma_zero = generate_table_zero(data->gamma_lut_size); - - for_each_connected_output(&data->display, output) { - igt_output_set_pipe(output, primary->pipe->pipe); - - /* Ensure we have a clean state to start with. */ - disable_degamma(primary->pipe); - disable_ctm(primary->pipe); - disable_gamma(primary->pipe); - igt_display_commit(&data->display); - - /* Set a degama & gamma LUT and a CTM using the - * properties and verify the content of the - * properties. */ - set_degamma(data, primary->pipe, degamma_linear); - set_ctm(primary->pipe, ctm_identity); - set_gamma(data, primary->pipe, gamma_zero); - igt_display_commit(&data->display); - - blob = get_blob(data, primary->pipe, "DEGAMMA_LUT"); - igt_assert(blob && - blob->length == (sizeof(struct _drm_color_lut) * - data->degamma_lut_size)); - drmModeFreePropertyBlob(blob); - - blob = get_blob(data, primary->pipe, "CTM"); - igt_assert(blob && - blob->length == sizeof(struct _drm_color_ctm)); - drmModeFreePropertyBlob(blob); - - blob = get_blob(data, primary->pipe, "GAMMA_LUT"); - igt_assert(blob && - blob->length == (sizeof(struct _drm_color_lut) * - data->gamma_lut_size)); - lut = (struct _drm_color_lut *) blob->data; - for (i = 0; i < data->gamma_lut_size; i++) - igt_assert(lut[i].red == 0 && - lut[i].green == 0 && - lut[i].blue == 0); - drmModeFreePropertyBlob(blob); - - /* Set a gamma LUT using the legacy ioctl and verify - * the content of the GAMMA_LUT property is changed - * and that CTM and DEGAMMA_LUT are empty. */ - kms_crtc = drmModeGetCrtc(data->drm_fd, primary->pipe->crtc_id); - legacy_lut_size = kms_crtc->gamma_size; - drmModeFreeCrtc(kms_crtc); - - red_lut = malloc(sizeof(uint16_t) * legacy_lut_size); - green_lut = malloc(sizeof(uint16_t) * legacy_lut_size); - blue_lut = malloc(sizeof(uint16_t) * legacy_lut_size); - - for (i = 0; i < legacy_lut_size; i++) - red_lut[i] = green_lut[i] = blue_lut[i] = 0xffff; - - igt_assert_eq(drmModeCrtcSetGamma(data->drm_fd, - primary->pipe->crtc_id, - legacy_lut_size, - red_lut, green_lut, blue_lut), - 0); - igt_display_commit(&data->display); - - igt_assert(get_blob(data, primary->pipe, - "DEGAMMA_LUT") == NULL); - igt_assert(get_blob(data, primary->pipe, "CTM") == NULL); - - blob = get_blob(data, primary->pipe, "GAMMA_LUT"); - igt_assert(blob && - blob->length == (sizeof(struct _drm_color_lut) * - legacy_lut_size)); - lut = (struct _drm_color_lut *) blob->data; - for (i = 0; i < legacy_lut_size; i++) - igt_assert(lut[i].red == 0xffff && - lut[i].green == 0xffff && - lut[i].blue == 0xffff); - drmModeFreePropertyBlob(blob); - - igt_output_set_pipe(output, PIPE_ANY); - } - - free(degamma_linear); - free(gamma_zero); -} - -/* - * Draw 3 rectangles using before colors with the ctm matrix apply and verify - * the CRC is equal to using after colors with an identify ctm matrix. - */ -static bool test_pipe_ctm(data_t *data, - igt_plane_t *primary, - color_t *before, - color_t *after, - double *ctm_matrix) -{ - const double ctm_identity[] = { - 1.0, 0.0, 0.0, - 0.0, 1.0, 0.0, - 0.0, 0.0, 1.0 - }; - double *degamma_linear, *gamma_linear; - igt_output_t *output; - bool ret = true; - - degamma_linear = generate_table(data->degamma_lut_size, 1.0); - gamma_linear = generate_table(data->gamma_lut_size, 1.0); - - for_each_connected_output(&data->display, output) { - drmModeModeInfo *mode; - struct igt_fb fb_modeset, fb; - igt_crc_t crc_software, crc_hardware; - int fb_id, fb_modeset_id; - - igt_output_set_pipe(output, primary->pipe->pipe); - mode = igt_output_get_mode(output); - - /* Create a framebuffer at the size of the output. */ - fb_id = igt_create_fb(data->drm_fd, - mode->hdisplay, - mode->vdisplay, - DRM_FORMAT_XRGB8888, - LOCAL_DRM_FORMAT_MOD_NONE, - &fb); - igt_assert(fb_id); - - fb_modeset_id = igt_create_fb(data->drm_fd, - mode->hdisplay, - mode->vdisplay, - DRM_FORMAT_XRGB8888, - LOCAL_DRM_FORMAT_MOD_NONE, - &fb_modeset); - igt_assert(fb_modeset_id); - igt_plane_set_fb(primary, &fb_modeset); - - set_degamma(data, primary->pipe, degamma_linear); - set_gamma(data, primary->pipe, gamma_linear); - disable_ctm(primary->pipe); - igt_display_commit(&data->display); - - paint_rectangles(data, mode, after, &fb); - igt_plane_set_fb(primary, &fb); - set_ctm(primary->pipe, ctm_identity); - igt_display_commit(&data->display); - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_software); - - /* With CTM transformation. */ - paint_rectangles(data, mode, before, &fb); - igt_plane_set_fb(primary, &fb); - set_ctm(primary->pipe, ctm_matrix); - igt_display_commit(&data->display); - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_hardware); - - /* Verify that the CRC of the software computed output is - * equal to the CRC of the CTM matrix transformation output. - */ - ret &= igt_crc_equal(&crc_software, &crc_hardware); - - igt_output_set_pipe(output, PIPE_ANY); - } - - free(degamma_linear); - free(gamma_linear); - - return ret; -} - -/* - * Hardware computes CRC based on the number of bits it is working with (8, - * 10, 12, 16 bits), meaning with a framebuffer of 8bits per color will - * usually leave the remaining lower bits at 0. - * - * We're programming the gamma LUT in order to get rid of those lower bits so - * we can compare the CRC of a framebuffer without any transformation to a CRC - * with transformation applied and verify the CRCs match. - * - * This test is currently disabled as the CRC computed on Intel hardware seems - * to include data on the lower bits, this is preventing us to CRC checks. - */ -#if 0 -static void test_pipe_limited_range_ctm(data_t *data, - igt_plane_t *primary) -{ - double limited_result = 235.0 / 255.0; - color_t red_green_blue_limited[] = { - { limited_result, 0.0, 0.0 }, - { 0.0, limited_result, 0.0 }, - { 0.0, 0.0, limited_result } - }; - color_t red_green_blue_full[] = { - { 0.5, 0.0, 0.0 }, - { 0.0, 0.5, 0.0 }, - { 0.0, 0.0, 0.5 } - }; - double ctm[] = { 1.0, 0.0, 0.0, - 0.0, 1.0, 0.0, - 0.0, 0.0, 1.0 }; - double *degamma_linear, *gamma_linear; - igt_output_t *output; - - degamma_linear = generate_table(data->degamma_lut_size, 1.0); - gamma_linear = generate_table(data->gamma_lut_size, 1.0); - - for_each_connected_output(&data->display, output) { - drmModeModeInfo *mode; - struct igt_fb fb_modeset, fb; - igt_crc_t crc_full, crc_limited; - int fb_id, fb_modeset_id; - - igt_output_set_pipe(output, primary->pipe->pipe); - mode = igt_output_get_mode(output); - - /* Create a framebuffer at the size of the output. */ - fb_id = igt_create_fb(data->drm_fd, - mode->hdisplay, - mode->vdisplay, - DRM_FORMAT_XRGB8888, - LOCAL_DRM_FORMAT_MOD_NONE, - &fb); - igt_assert(fb_id); - - fb_modeset_id = igt_create_fb(data->drm_fd, - mode->hdisplay, - mode->vdisplay, - DRM_FORMAT_XRGB8888, - LOCAL_DRM_FORMAT_MOD_NONE, - &fb_modeset); - igt_assert(fb_modeset_id); - igt_plane_set_fb(primary, &fb_modeset); - - set_degamma(data, primary->pipe, degamma_linear); - set_gamma(data, primary->pipe, gamma_linear); - set_ctm(primary->pipe, ctm); - - output_set_property_enum(output, "Broadcast RGB", "Full"); - paint_rectangles(data, mode, red_green_blue_limited, &fb); - igt_plane_set_fb(primary, &fb); - igt_display_commit(&data->display); - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_full); - - /* Set the output into limited range. */ - output_set_property_enum(output, "Broadcast RGB", "Limited 16:235"); - paint_rectangles(data, mode, red_green_blue_full, &fb); - igt_plane_set_fb(primary, &fb); - igt_display_commit(&data->display); - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_limited); - - /* Verify that the CRC of the software computed output is - * equal to the CRC of the CTM matrix transformation output. - */ - igt_assert_crc_equal(&crc_full, &crc_limited); - - igt_output_set_pipe(output, PIPE_ANY); - } - - free(gamma_linear); - free(degamma_linear); -} -#endif - -static void -run_tests_for_pipe(data_t *data, enum pipe p) -{ - igt_output_t *output; - igt_pipe_t *pipe; - igt_plane_t *primary; - double delta; - int i; - color_t red_green_blue[] = { - { 1.0, 0.0, 0.0 }, - { 0.0, 1.0, 0.0 }, - { 0.0, 0.0, 1.0 } - }; - - igt_fixture { - igt_require_pipe_crc(); - - if (p >= data->display.n_pipes) - return; - - pipe = &data->display.pipes[p]; - if (pipe->n_planes < IGT_PLANE_PRIMARY) - return; - - primary = &pipe->planes[IGT_PLANE_PRIMARY]; - - data->pipe_crc = igt_pipe_crc_new(primary->pipe->pipe, - INTEL_PIPE_CRC_SOURCE_AUTO); - - igt_require(igt_pipe_get_property(&data->display.pipes[p], - "DEGAMMA_LUT_SIZE", - NULL, - &data->degamma_lut_size, - NULL)); - igt_require(igt_pipe_get_property(&data->display.pipes[p], - "GAMMA_LUT_SIZE", - NULL, - &data->gamma_lut_size, - NULL)); - - for_each_connected_output(&data->display, output) - output_set_property_enum(output, "Broadcast RGB", "Full"); - } - - /* We assume an 8bits depth per color for degamma/gamma LUTs - * for CRC checks with framebuffer references. */ - data->color_depth = 8; - delta = 1.0 / (1 << data->color_depth); - - igt_subtest_f("ctm-red-to-blue-pipe%d", p) { - color_t blue_green_blue[] = { - { 0.0, 0.0, 1.0 }, - { 0.0, 1.0, 0.0 }, - { 0.0, 0.0, 1.0 } - }; - double ctm[] = { 0.0, 0.0, 0.0, - 0.0, 1.0, 0.0, - 1.0, 0.0, 1.0 }; - igt_assert(test_pipe_ctm(data, primary, red_green_blue, - blue_green_blue, ctm)); - } - - igt_subtest_f("ctm-green-to-red-pipe%d", p) { - color_t red_red_blue[] = { - { 1.0, 0.0, 0.0 }, - { 1.0, 0.0, 0.0 }, - { 0.0, 0.0, 1.0 } - }; - double ctm[] = { 1.0, 1.0, 0.0, - 0.0, 0.0, 0.0, - 0.0, 0.0, 1.0 }; - igt_assert(test_pipe_ctm(data, primary, red_green_blue, - red_red_blue, ctm)); - } - - igt_subtest_f("ctm-blue-to-red-pipe%d", p) { - color_t red_green_red[] = { - { 1.0, 0.0, 0.0 }, - { 0.0, 1.0, 0.0 }, - { 1.0, 0.0, 0.0 } - }; - double ctm[] = { 1.0, 0.0, 1.0, - 0.0, 1.0, 0.0, - 0.0, 0.0, 0.0 }; - igt_assert(test_pipe_ctm(data, primary, red_green_blue, - red_green_red, ctm)); - } - - /* We tests a few values around the expected result because - * the it depends on the hardware we're dealing with, we can - * either get clamped or rounded values and we also need to - * account for odd number of items in the LUTs. */ - igt_subtest_f("ctm-0-25-pipe%d", p) { - color_t expected_colors[] = { - { 0.0, }, { 0.0, }, { 0.0, } - }; - double ctm[] = { 0.25, 0.0, 0.0, - 0.0, 0.25, 0.0, - 0.0, 0.0, 0.25 }; - bool success = false; - - for (i = 0; i < 5; i++) { - expected_colors[0].r = - expected_colors[1].g = - expected_colors[2].b = - 0.25 + delta * (i - 2); - success |= test_pipe_ctm(data, primary, - red_green_blue, - expected_colors, ctm); - } - igt_assert(success); - } - - igt_subtest_f("ctm-0-5-pipe%d", p) { - color_t expected_colors[] = { - { 0.0, }, { 0.0, }, { 0.0, } - }; - double ctm[] = { 0.5, 0.0, 0.0, - 0.0, 0.5, 0.0, - 0.0, 0.0, 0.5 }; - bool success = false; - - for (i = 0; i < 5; i++) { - expected_colors[0].r = - expected_colors[1].g = - expected_colors[2].b = - 0.5 + delta * (i - 2); - success |= test_pipe_ctm(data, primary, - red_green_blue, - expected_colors, ctm); - } - igt_assert(success); - } - - igt_subtest_f("ctm-0-75-pipe%d", p) { - color_t expected_colors[] = { - { 0.0, }, { 0.0, }, { 0.0, } - }; - double ctm[] = { 0.75, 0.0, 0.0, - 0.0, 0.75, 0.0, - 0.0, 0.0, 0.75 }; - bool success = false; - - for (i = 0; i < 7; i++) { - expected_colors[0].r = - expected_colors[1].g = - expected_colors[2].b = - 0.75 + delta * (i - 3); - success |= test_pipe_ctm(data, primary, - red_green_blue, - expected_colors, ctm); - } - igt_assert(success); - } - - igt_subtest_f("ctm-max-pipe%d", p) { - color_t full_rgb[] = { - { 1.0, 0.0, 0.0 }, - { 0.0, 1.0, 0.0 }, - { 0.0, 0.0, 1.0 } - }; - double ctm[] = { 100.0, 0.0, 0.0, - 0.0, 100.0, 0.0, - 0.0, 0.0, 100.0 }; - - /* CherryView generates values on 10bits that we - * produce with an 8 bits per color framebuffer. */ - igt_require(!IS_CHERRYVIEW(data->devid)); - - igt_assert(test_pipe_ctm(data, primary, red_green_blue, - full_rgb, ctm)); - } - - igt_subtest_f("ctm-negative-pipe%d", p) { - color_t all_black[] = { - { 0.0, 0.0, 0.0 }, - { 0.0, 0.0, 0.0 }, - { 0.0, 0.0, 0.0 } - }; - double ctm[] = { -1.0, 0.0, 0.0, - 0.0, -1.0, 0.0, - 0.0, 0.0, -1.0 }; - igt_assert(test_pipe_ctm(data, primary, red_green_blue, - all_black, ctm)); - } - -#if 0 - igt_subtest_f("ctm-limited-range-pipe%d", p) - test_pipe_limited_range_ctm(data, primary); -#endif - - igt_subtest_f("degamma-pipe%d", p) - test_pipe_degamma(data, primary); - - igt_subtest_f("gamma-pipe%d", p) - test_pipe_gamma(data, primary); - - igt_subtest_f("legacy-gamma-pipe%d", p) - test_pipe_legacy_gamma(data, primary); - - igt_subtest_f("legacy-gamma-reset-pipe%d", p) - test_pipe_legacy_gamma_reset(data, primary); - - igt_fixture { - for_each_connected_output(&data->display, output) - output_set_property_enum(output, "Broadcast RGB", "Full"); - - disable_degamma(primary->pipe); - disable_gamma(primary->pipe); - disable_ctm(primary->pipe); - igt_display_commit(&data->display); - - igt_pipe_crc_free(data->pipe_crc); - data->pipe_crc = NULL; - } -} - -static int -pipe_set_property_blob_id(igt_pipe_t *pipe, const char *property, uint32_t blob_id) -{ - uint32_t prop_id; - - igt_assert(kmstest_get_property(pipe->display->drm_fd, - pipe->crtc_id, - DRM_MODE_OBJECT_CRTC, - property, - &prop_id, NULL, NULL)); - - return drmModeObjectSetProperty(pipe->display->drm_fd, - pipe->crtc_id, - DRM_MODE_OBJECT_CRTC, - prop_id, blob_id); -} - -static int -pipe_set_property_blob(igt_pipe_t *pipe, const char *property, void *ptr, size_t length) -{ - int ret = 0; - uint32_t blob_id = 0; - - if (length > 0) - igt_assert_eq(drmModeCreatePropertyBlob(pipe->display->drm_fd, - ptr, length, - &blob_id), 0); - - ret = pipe_set_property_blob_id(pipe, property, blob_id); - - if (blob_id != 0) - igt_assert_eq(drmModeDestroyPropertyBlob(pipe->display->drm_fd, blob_id), 0); - - return ret; -} - -static void -invalid_lut_sizes(data_t *data) -{ - igt_pipe_t *pipe = &data->display.pipes[0]; - size_t degamma_lut_size = data->degamma_lut_size * sizeof(struct _drm_color_lut); - size_t gamma_lut_size = data->gamma_lut_size * sizeof(struct _drm_color_lut); - - struct _drm_color_lut *degamma_lut = malloc(data->degamma_lut_size * sizeof(struct _drm_color_lut) * 2); - struct _drm_color_lut *gamma_lut = malloc(data->gamma_lut_size * sizeof(struct _drm_color_lut) * 2); - - igt_assert_eq(pipe_set_property_blob(pipe, "DEGAMMA_LUT", - degamma_lut, 1), -EINVAL); - igt_assert_eq(pipe_set_property_blob(pipe, "DEGAMMA_LUT", - degamma_lut, degamma_lut_size + 1), - -EINVAL); - igt_assert_eq(pipe_set_property_blob(pipe, "DEGAMMA_LUT", - degamma_lut, degamma_lut_size - 1), - -EINVAL); - igt_assert_eq(pipe_set_property_blob(pipe, "DEGAMMA_LUT", - degamma_lut, degamma_lut_size + sizeof(struct _drm_color_lut)), - -EINVAL); - igt_assert_eq(pipe_set_property_blob_id(pipe, "DEGAMMA_LUT", pipe->crtc_id), - -EINVAL); - igt_assert_eq(pipe_set_property_blob_id(pipe, "DEGAMMA_LUT", 4096 * 4096), - -EINVAL); - - igt_assert_eq(pipe_set_property_blob(pipe, "GAMMA_LUT", - gamma_lut, 1), - -EINVAL); - igt_assert_eq(pipe_set_property_blob(pipe, "GAMMA_LUT", - gamma_lut, gamma_lut_size + 1), - -EINVAL); - igt_assert_eq(pipe_set_property_blob(pipe, "GAMMA_LUT", - gamma_lut, gamma_lut_size - 1), - -EINVAL); - igt_assert_eq(pipe_set_property_blob(pipe, "GAMMA_LUT", - gamma_lut, gamma_lut_size + sizeof(struct _drm_color_lut)), - -EINVAL); - igt_assert_eq(pipe_set_property_blob_id(pipe, "GAMMA_LUT", pipe->crtc_id), - -EINVAL); - igt_assert_eq(pipe_set_property_blob_id(pipe, "GAMMA_LUT", 4096 * 4096), - -EINVAL); - - free(degamma_lut); - free(gamma_lut); -} - -static void -invalid_ctm_matrix_sizes(data_t *data) -{ - igt_pipe_t *pipe = &data->display.pipes[0]; - void *ptr = malloc(sizeof(struct _drm_color_ctm) * 4); - - igt_assert_eq(pipe_set_property_blob(pipe, "CTM", ptr, 1), - -EINVAL); - igt_assert_eq(pipe_set_property_blob(pipe, "CTM", ptr, - sizeof(struct _drm_color_ctm) + 1), - -EINVAL); - igt_assert_eq(pipe_set_property_blob(pipe, "CTM", ptr, - sizeof(struct _drm_color_ctm) - 1), - -EINVAL); - igt_assert_eq(pipe_set_property_blob(pipe, "CTM", ptr, - sizeof(struct _drm_color_ctm) * 2), - -EINVAL); - igt_assert_eq(pipe_set_property_blob_id(pipe, "CTM", pipe->crtc_id), - -EINVAL); - igt_assert_eq(pipe_set_property_blob_id(pipe, "CTM", 4096 * 4096), - -EINVAL); - - free(ptr); -} - -igt_main -{ - data_t data = {}; - - igt_skip_on_simulation(); - - igt_fixture { - data.drm_fd = drm_open_driver_master(DRIVER_INTEL); - data.devid = intel_get_drm_devid(data.drm_fd); - kmstest_set_vt_graphics_mode(); - - igt_display_init(&data.display, data.drm_fd); - } - - for (int pipe = 0; pipe < I915_MAX_PIPES; pipe++) - run_tests_for_pipe(&data, pipe); - - igt_subtest_f("invalid-lut-sizes") - invalid_lut_sizes(&data); - - igt_subtest_f("invalid-ctm-matrix-sizes") - invalid_ctm_matrix_sizes(&data); - - igt_fixture { - igt_display_fini(&data.display); - } -} diff --git a/tests/kms_pipe_color_basic.c b/tests/kms_pipe_color_basic.c new file mode 100644 index 0000000..f08aabd --- /dev/null +++ b/tests/kms_pipe_color_basic.c @@ -0,0 +1,1184 @@ +/* + * Copyright © 2015 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 "drm.h" +#include "drmtest.h" +#include "igt.h" + +IGT_TEST_DESCRIPTION("Test Color Features at Pipe level"); + +/* Data structures for gamma/degamma ramps & ctm matrix. */ +struct _drm_color_ctm { + /* Transformation matrix in S31.32 format. */ + __s64 matrix[9]; +}; + +struct _drm_color_lut { + /* + * Data is U0.16 fixed point format. + */ + __u16 red; + __u16 green; + __u16 blue; + __u16 reserved; +}; + +/* Internal */ +typedef struct { + double r, g, b; +} color_t; + +typedef struct { + int drm_fd; + uint32_t devid; + igt_display_t display; + igt_pipe_crc_t *pipe_crc; + + uint32_t color_depth; + uint64_t degamma_lut_size; + uint64_t gamma_lut_size; +} data_t; + + +static void paint_gradient_rectangles(data_t *data, + drmModeModeInfo *mode, + color_t *colors, + struct igt_fb *fb) +{ + cairo_t *cr = igt_get_cairo_ctx(data->drm_fd, fb); + int i, l = mode->hdisplay / 3; + + /* Paint 3 gradient rectangles with red/green/blue between 1.0 and + * 0.5. We want to avoid 0 so each max LUTs only affect their own + * rectangle. + */ + for (i = 0 ; i < 3; i++) { + igt_paint_color_gradient_range(cr, i * l, 0, l, mode->vdisplay, + colors[i].r != 0 ? 0.2 : 0, + colors[i].g != 0 ? 0.2 : 0, + colors[i].b != 0 ? 0.2 : 0, + colors[i].r, + colors[i].g, + colors[i].b); + } + + cairo_destroy(cr); +} + +static void paint_rectangles(data_t *data, + drmModeModeInfo *mode, + color_t *colors, + struct igt_fb *fb) +{ + cairo_t *cr = igt_get_cairo_ctx(data->drm_fd, fb); + int i, l = mode->hdisplay / 3; + + /* Paint 3 solid rectangles. */ + for (i = 0 ; i < 3; i++) { + igt_paint_color(cr, i * l, 0, l, mode->vdisplay, + colors[i].r, colors[i].g, colors[i].b); + } + + cairo_destroy(cr); +} + +static double *generate_table(uint32_t lut_size, double exp) +{ + double *coeffs = malloc(sizeof(double) * lut_size); + uint32_t i; + + for (i = 0; i < lut_size; i++) + coeffs[i] = powf((double) i * 1.0 / (double) (lut_size - 1), exp); + + return coeffs; +} + +static double *generate_table_max(uint32_t lut_size) +{ + double *coeffs = malloc(sizeof(double) * lut_size); + uint32_t i; + + coeffs[0] = 0.0; + for (i = 1; i < lut_size; i++) + coeffs[i] = 1.0; + + return coeffs; +} + +static double *generate_table_zero(uint32_t lut_size) +{ + double *coeffs = malloc(sizeof(double) * lut_size); + uint32_t i; + + for (i = 0; i < lut_size; i++) + coeffs[i] = 0.0; + + return coeffs; +} + +static struct _drm_color_lut *coeffs_to_lut(data_t *data, + const double *coefficients, + uint32_t lut_size, + uint32_t color_depth, + int off) +{ + struct _drm_color_lut *lut; + uint32_t i; + uint32_t max_value = (1 << 16) - 1; + uint32_t mask = ((1 << color_depth) - 1) << 8; + + lut = malloc(sizeof(struct _drm_color_lut) * lut_size); + + if (IS_CHERRYVIEW(data->devid)) + lut_size -= 1; + for (i = 0; i < lut_size; i++) { + uint32_t v = (coefficients[i] * max_value); + + /* + * Hardware might encode colors on a different number of bits + * than what is in our framebuffer (10 or 12bits for example). + * Mask the lower bits not provided by the framebuffer so we + * can do CRC comparisons. + */ + v &= mask; + + lut[i].red = v; + lut[i].green = v; + lut[i].blue = v; + } + + if (IS_CHERRYVIEW(data->devid)) + lut[lut_size].red = + lut[lut_size].green = + lut[lut_size].blue = lut[lut_size - 1].red; + + return lut; +} + +static void set_degamma(data_t *data, + igt_pipe_t *pipe, + const double *coefficients) +{ + size_t size = sizeof(struct _drm_color_lut) * data->degamma_lut_size; + struct _drm_color_lut *lut = coeffs_to_lut(data, + coefficients, + data->degamma_lut_size, + data->color_depth, 0); + + igt_pipe_set_degamma_lut(pipe, lut, size); + + free(lut); +} + +static void set_gamma(data_t *data, + igt_pipe_t *pipe, + const double *coefficients) +{ + size_t size = sizeof(struct _drm_color_lut) * data->gamma_lut_size; + struct _drm_color_lut *lut = coeffs_to_lut(data, + coefficients, + data->gamma_lut_size, + data->color_depth, 0); + + igt_pipe_set_gamma_lut(pipe, lut, size); + + free(lut); +} + +static void set_ctm(igt_pipe_t *pipe, const double *coefficients) +{ + struct _drm_color_ctm ctm; + int i; + + for (i = 0; i < ARRAY_SIZE(ctm.matrix); i++) { + if (coefficients[i] < 0) { + ctm.matrix[i] = + (int64_t) (-coefficients[i] * ((int64_t) 1L << 32)); + ctm.matrix[i] |= 1ULL << 63; + } else + ctm.matrix[i] = + (int64_t) (coefficients[i] * ((int64_t) 1L << 32)); + } + + igt_pipe_set_ctm_matrix(pipe, &ctm, sizeof(ctm)); +} + +#define disable_degamma(pipe) igt_pipe_set_degamma_lut(pipe, NULL, 0) +#define disable_gamma(pipe) igt_pipe_set_gamma_lut(pipe, NULL, 0) +#define disable_ctm(pipe) igt_pipe_set_ctm_matrix(pipe, NULL, 0) + +static void output_set_property_enum(igt_output_t *output, + const char *property, + const char *enum_value) +{ + int i; + int32_t value = -1; + uint32_t prop_id; + drmModePropertyPtr prop; + + if (!kmstest_get_property(output->display->drm_fd, + output->id, + DRM_MODE_OBJECT_CONNECTOR, + property, + &prop_id, NULL, &prop)) + return; + + igt_assert(prop->flags & DRM_MODE_PROP_ENUM); + + for (i = 0; i < prop->count_enums; i++) { + if (!strcmp(prop->enums[i].name, enum_value)) { + value = prop->enums[i].value; + break; + } + } + igt_assert_neq(value, -1); + + igt_assert_eq(drmModeObjectSetProperty(output->display->drm_fd, + output->id, + DRM_MODE_OBJECT_CONNECTOR, + prop_id, value), 0); + + + drmModeFreeProperty(prop); +} + +/* + * Draw 3 gradient rectangles in red, green and blue, with a maxed out + * degamma LUT and verify we have the same CRC as drawing solid color + * rectangles with linear degamma LUT. + */ +static void test_pipe_degamma(data_t *data, + igt_plane_t *primary) +{ + igt_output_t *output; + double *degamma_linear, *degamma_full; + double *gamma_linear; + color_t red_green_blue[] = { + { 1.0, 0.0, 0.0 }, + { 0.0, 1.0, 0.0 }, + { 0.0, 0.0, 1.0 } + }; + + degamma_linear = generate_table(data->degamma_lut_size, 1.0); + degamma_full = generate_table_max(data->degamma_lut_size); + + gamma_linear = generate_table(data->gamma_lut_size, 1.0); + + for_each_connected_output(&data->display, output) { + drmModeModeInfo *mode; + struct igt_fb fb_modeset, fb; + igt_crc_t crc_fullgamma, crc_fullcolors; + int fb_id, fb_modeset_id; + + igt_output_set_pipe(output, primary->pipe->pipe); + mode = igt_output_get_mode(output); + + /* Create a framebuffer at the size of the output. */ + fb_id = igt_create_fb(data->drm_fd, + mode->hdisplay, + mode->vdisplay, + DRM_FORMAT_XRGB8888, + LOCAL_DRM_FORMAT_MOD_NONE, + &fb); + igt_assert(fb_id); + + fb_modeset_id = igt_create_fb(data->drm_fd, + mode->hdisplay, + mode->vdisplay, + DRM_FORMAT_XRGB8888, + LOCAL_DRM_FORMAT_MOD_NONE, + &fb_modeset); + igt_assert(fb_modeset_id); + + igt_plane_set_fb(primary, &fb_modeset); + disable_ctm(primary->pipe); + disable_degamma(primary->pipe); + set_gamma(data, primary->pipe, gamma_linear); + igt_display_commit(&data->display); + + /* Draw solid colors with no degamma transformation. */ + paint_rectangles(data, mode, red_green_blue, &fb); + igt_plane_set_fb(primary, &fb); + igt_display_commit(&data->display); + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullcolors); + + /* Draw a gradient with degamma LUT to remap all + * values to max red/green/blue. + */ + paint_gradient_rectangles(data, mode, red_green_blue, &fb); + igt_plane_set_fb(primary, &fb); + set_degamma(data, primary->pipe, degamma_full); + igt_display_commit(&data->display); + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullgamma); + + /* Verify that the CRC of the software computed output is + * equal to the CRC of the degamma LUT transformation output. + */ + igt_assert_crc_equal(&crc_fullgamma, &crc_fullcolors); + + igt_output_set_pipe(output, PIPE_ANY); + } + + free(degamma_linear); + free(degamma_full); + free(gamma_linear); +} + +/* + * Draw 3 gradient rectangles in red, green and blue, with a maxed out gamma + * LUT and verify we have the same CRC as drawing solid color rectangles. + */ +static void test_pipe_gamma(data_t *data, + igt_plane_t *primary) +{ + igt_output_t *output; + double *gamma_full; + color_t red_green_blue[] = { + { 1.0, 0.0, 0.0 }, + { 0.0, 1.0, 0.0 }, + { 0.0, 0.0, 1.0 } + }; + + gamma_full = generate_table_max(data->gamma_lut_size); + + for_each_connected_output(&data->display, output) { + drmModeModeInfo *mode; + struct igt_fb fb_modeset, fb; + igt_crc_t crc_fullgamma, crc_fullcolors; + int fb_id, fb_modeset_id; + + igt_output_set_pipe(output, primary->pipe->pipe); + mode = igt_output_get_mode(output); + + /* Create a framebuffer at the size of the output. */ + fb_id = igt_create_fb(data->drm_fd, + mode->hdisplay, + mode->vdisplay, + DRM_FORMAT_XRGB8888, + LOCAL_DRM_FORMAT_MOD_NONE, + &fb); + igt_assert(fb_id); + + fb_modeset_id = igt_create_fb(data->drm_fd, + mode->hdisplay, + mode->vdisplay, + DRM_FORMAT_XRGB8888, + LOCAL_DRM_FORMAT_MOD_NONE, + &fb_modeset); + igt_assert(fb_modeset_id); + + igt_plane_set_fb(primary, &fb_modeset); + disable_ctm(primary->pipe); + disable_degamma(primary->pipe); + set_gamma(data, primary->pipe, gamma_full); + igt_display_commit(&data->display); + + /* Draw solid colors with no gamma transformation. */ + paint_rectangles(data, mode, red_green_blue, &fb); + igt_plane_set_fb(primary, &fb); + igt_display_commit(&data->display); + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullcolors); + + /* Draw a gradient with gamma LUT to remap all values + * to max red/green/blue. + */ + paint_gradient_rectangles(data, mode, red_green_blue, &fb); + igt_plane_set_fb(primary, &fb); + igt_display_commit(&data->display); + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullgamma); + + /* Verify that the CRC of the software computed output is + * equal to the CRC of the gamma LUT transformation output. + */ + igt_assert_crc_equal(&crc_fullgamma, &crc_fullcolors); + + igt_output_set_pipe(output, PIPE_ANY); + } + + free(gamma_full); +} + +/* + * Draw 3 gradient rectangles in red, green and blue, with a maxed out legacy + * gamma LUT and verify we have the same CRC as drawing solid color rectangles + * with linear legacy gamma LUT. + */ +static void test_pipe_legacy_gamma(data_t *data, + igt_plane_t *primary) +{ + igt_output_t *output; + color_t red_green_blue[] = { + { 1.0, 0.0, 0.0 }, + { 0.0, 1.0, 0.0 }, + { 0.0, 0.0, 1.0 } + }; + drmModeCrtc *kms_crtc; + uint32_t i, legacy_lut_size; + uint16_t *red_lut, *green_lut, *blue_lut; + + kms_crtc = drmModeGetCrtc(data->drm_fd, primary->pipe->crtc_id); + legacy_lut_size = kms_crtc->gamma_size; + drmModeFreeCrtc(kms_crtc); + + red_lut = malloc(sizeof(uint16_t) * legacy_lut_size); + green_lut = malloc(sizeof(uint16_t) * legacy_lut_size); + blue_lut = malloc(sizeof(uint16_t) * legacy_lut_size); + + red_lut[0] = green_lut[0] = blue_lut[0] = 0; + for (i = 1; i < legacy_lut_size; i++) + red_lut[i] = green_lut[i] = blue_lut[i] = 0xffff; + + for_each_connected_output(&data->display, output) { + drmModeModeInfo *mode; + struct igt_fb fb_modeset, fb; + igt_crc_t crc_fullgamma, crc_fullcolors; + int fb_id, fb_modeset_id; + + igt_output_set_pipe(output, primary->pipe->pipe); + mode = igt_output_get_mode(output); + + /* Create a framebuffer at the size of the output. */ + fb_id = igt_create_fb(data->drm_fd, + mode->hdisplay, + mode->vdisplay, + DRM_FORMAT_XRGB8888, + LOCAL_DRM_FORMAT_MOD_NONE, + &fb); + igt_assert(fb_id); + + fb_modeset_id = igt_create_fb(data->drm_fd, + mode->hdisplay, + mode->vdisplay, + DRM_FORMAT_XRGB8888, + LOCAL_DRM_FORMAT_MOD_NONE, + &fb_modeset); + igt_assert(fb_modeset_id); + + igt_plane_set_fb(primary, &fb_modeset); + disable_degamma(primary->pipe); + disable_gamma(primary->pipe); + disable_ctm(primary->pipe); + igt_display_commit(&data->display); + + /* Draw solid colors with no gamma transformation. */ + paint_rectangles(data, mode, red_green_blue, &fb); + igt_plane_set_fb(primary, &fb); + igt_display_commit(&data->display); + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullcolors); + + /* Draw a gradient with gamma LUT to remap all values + * to max red/green/blue. + */ + paint_gradient_rectangles(data, mode, red_green_blue, &fb); + igt_plane_set_fb(primary, &fb); + igt_assert_eq(drmModeCrtcSetGamma(data->drm_fd, primary->pipe->crtc_id, + legacy_lut_size, red_lut, green_lut, blue_lut), 0); + igt_display_commit(&data->display); + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullgamma); + + /* Verify that the CRC of the software computed output is + * equal to the CRC of the gamma LUT transformation output. + */ + igt_assert_crc_equal(&crc_fullgamma, &crc_fullcolors); + + /* Reset output. */ + for (i = 1; i < legacy_lut_size; i++) + red_lut[i] = green_lut[i] = blue_lut[i] = i << 8; + + igt_assert_eq(drmModeCrtcSetGamma(data->drm_fd, primary->pipe->crtc_id, + legacy_lut_size, red_lut, green_lut, blue_lut), 0); + igt_display_commit(&data->display); + + igt_output_set_pipe(output, PIPE_ANY); + } + + free(red_lut); + free(green_lut); + free(blue_lut); +} + +static drmModePropertyBlobPtr +get_blob(data_t *data, igt_pipe_t *pipe, const char *property_name) +{ + uint64_t prop_value; + drmModePropertyPtr prop; + drmModePropertyBlobPtr blob; + + igt_assert(igt_pipe_get_property(pipe, property_name, + NULL, &prop_value, &prop)); + + if (prop_value == 0) + return NULL; + + igt_assert(prop->flags & DRM_MODE_PROP_BLOB); + blob = drmModeGetPropertyBlob(data->drm_fd, prop_value); + drmModeFreeProperty(prop); + + return blob; +} + +/* + * Verify that setting the legacy gamma LUT resets the gamma LUT set + * through the GAMMA_LUT property. + */ +static void test_pipe_legacy_gamma_reset(data_t *data, + igt_plane_t *primary) +{ + const double ctm_identity[] = { + 1.0, 0.0, 0.0, + 0.0, 1.0, 0.0, + 0.0, 0.0, 1.0 + }; + drmModeCrtc *kms_crtc; + double *degamma_linear, *gamma_zero; + uint32_t i, legacy_lut_size; + uint16_t *red_lut, *green_lut, *blue_lut; + struct _drm_color_lut *lut; + drmModePropertyBlobPtr blob; + igt_output_t *output; + + degamma_linear = generate_table(data->degamma_lut_size, 1.0); + gamma_zero = generate_table_zero(data->gamma_lut_size); + + for_each_connected_output(&data->display, output) { + igt_output_set_pipe(output, primary->pipe->pipe); + + /* Ensure we have a clean state to start with. */ + disable_degamma(primary->pipe); + disable_ctm(primary->pipe); + disable_gamma(primary->pipe); + igt_display_commit(&data->display); + + /* Set a degama & gamma LUT and a CTM using the + * properties and verify the content of the + * properties. */ + set_degamma(data, primary->pipe, degamma_linear); + set_ctm(primary->pipe, ctm_identity); + set_gamma(data, primary->pipe, gamma_zero); + igt_display_commit(&data->display); + + blob = get_blob(data, primary->pipe, "DEGAMMA_LUT"); + igt_assert(blob && + blob->length == (sizeof(struct _drm_color_lut) * + data->degamma_lut_size)); + drmModeFreePropertyBlob(blob); + + blob = get_blob(data, primary->pipe, "CTM"); + igt_assert(blob && + blob->length == sizeof(struct _drm_color_ctm)); + drmModeFreePropertyBlob(blob); + + blob = get_blob(data, primary->pipe, "GAMMA_LUT"); + igt_assert(blob && + blob->length == (sizeof(struct _drm_color_lut) * + data->gamma_lut_size)); + lut = (struct _drm_color_lut *) blob->data; + for (i = 0; i < data->gamma_lut_size; i++) + igt_assert(lut[i].red == 0 && + lut[i].green == 0 && + lut[i].blue == 0); + drmModeFreePropertyBlob(blob); + + /* Set a gamma LUT using the legacy ioctl and verify + * the content of the GAMMA_LUT property is changed + * and that CTM and DEGAMMA_LUT are empty. */ + kms_crtc = drmModeGetCrtc(data->drm_fd, primary->pipe->crtc_id); + legacy_lut_size = kms_crtc->gamma_size; + drmModeFreeCrtc(kms_crtc); + + red_lut = malloc(sizeof(uint16_t) * legacy_lut_size); + green_lut = malloc(sizeof(uint16_t) * legacy_lut_size); + blue_lut = malloc(sizeof(uint16_t) * legacy_lut_size); + + for (i = 0; i < legacy_lut_size; i++) + red_lut[i] = green_lut[i] = blue_lut[i] = 0xffff; + + igt_assert_eq(drmModeCrtcSetGamma(data->drm_fd, + primary->pipe->crtc_id, + legacy_lut_size, + red_lut, green_lut, blue_lut), + 0); + igt_display_commit(&data->display); + + igt_assert(get_blob(data, primary->pipe, + "DEGAMMA_LUT") == NULL); + igt_assert(get_blob(data, primary->pipe, "CTM") == NULL); + + blob = get_blob(data, primary->pipe, "GAMMA_LUT"); + igt_assert(blob && + blob->length == (sizeof(struct _drm_color_lut) * + legacy_lut_size)); + lut = (struct _drm_color_lut *) blob->data; + for (i = 0; i < legacy_lut_size; i++) + igt_assert(lut[i].red == 0xffff && + lut[i].green == 0xffff && + lut[i].blue == 0xffff); + drmModeFreePropertyBlob(blob); + + igt_output_set_pipe(output, PIPE_ANY); + } + + free(degamma_linear); + free(gamma_zero); +} + +/* + * Draw 3 rectangles using before colors with the ctm matrix apply and verify + * the CRC is equal to using after colors with an identify ctm matrix. + */ +static bool test_pipe_ctm(data_t *data, + igt_plane_t *primary, + color_t *before, + color_t *after, + double *ctm_matrix) +{ + const double ctm_identity[] = { + 1.0, 0.0, 0.0, + 0.0, 1.0, 0.0, + 0.0, 0.0, 1.0 + }; + double *degamma_linear, *gamma_linear; + igt_output_t *output; + bool ret = true; + + degamma_linear = generate_table(data->degamma_lut_size, 1.0); + gamma_linear = generate_table(data->gamma_lut_size, 1.0); + + for_each_connected_output(&data->display, output) { + drmModeModeInfo *mode; + struct igt_fb fb_modeset, fb; + igt_crc_t crc_software, crc_hardware; + int fb_id, fb_modeset_id; + + igt_output_set_pipe(output, primary->pipe->pipe); + mode = igt_output_get_mode(output); + + /* Create a framebuffer at the size of the output. */ + fb_id = igt_create_fb(data->drm_fd, + mode->hdisplay, + mode->vdisplay, + DRM_FORMAT_XRGB8888, + LOCAL_DRM_FORMAT_MOD_NONE, + &fb); + igt_assert(fb_id); + + fb_modeset_id = igt_create_fb(data->drm_fd, + mode->hdisplay, + mode->vdisplay, + DRM_FORMAT_XRGB8888, + LOCAL_DRM_FORMAT_MOD_NONE, + &fb_modeset); + igt_assert(fb_modeset_id); + igt_plane_set_fb(primary, &fb_modeset); + + set_degamma(data, primary->pipe, degamma_linear); + set_gamma(data, primary->pipe, gamma_linear); + disable_ctm(primary->pipe); + igt_display_commit(&data->display); + + paint_rectangles(data, mode, after, &fb); + igt_plane_set_fb(primary, &fb); + set_ctm(primary->pipe, ctm_identity); + igt_display_commit(&data->display); + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_software); + + /* With CTM transformation. */ + paint_rectangles(data, mode, before, &fb); + igt_plane_set_fb(primary, &fb); + set_ctm(primary->pipe, ctm_matrix); + igt_display_commit(&data->display); + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_hardware); + + /* Verify that the CRC of the software computed output is + * equal to the CRC of the CTM matrix transformation output. + */ + ret &= igt_crc_equal(&crc_software, &crc_hardware); + + igt_output_set_pipe(output, PIPE_ANY); + } + + free(degamma_linear); + free(gamma_linear); + + return ret; +} + +/* + * Hardware computes CRC based on the number of bits it is working with (8, + * 10, 12, 16 bits), meaning with a framebuffer of 8bits per color will + * usually leave the remaining lower bits at 0. + * + * We're programming the gamma LUT in order to get rid of those lower bits so + * we can compare the CRC of a framebuffer without any transformation to a CRC + * with transformation applied and verify the CRCs match. + * + * This test is currently disabled as the CRC computed on Intel hardware seems + * to include data on the lower bits, this is preventing us to CRC checks. + */ +#if 0 +static void test_pipe_limited_range_ctm(data_t *data, + igt_plane_t *primary) +{ + double limited_result = 235.0 / 255.0; + color_t red_green_blue_limited[] = { + { limited_result, 0.0, 0.0 }, + { 0.0, limited_result, 0.0 }, + { 0.0, 0.0, limited_result } + }; + color_t red_green_blue_full[] = { + { 0.5, 0.0, 0.0 }, + { 0.0, 0.5, 0.0 }, + { 0.0, 0.0, 0.5 } + }; + double ctm[] = { 1.0, 0.0, 0.0, + 0.0, 1.0, 0.0, + 0.0, 0.0, 1.0 }; + double *degamma_linear, *gamma_linear; + igt_output_t *output; + + degamma_linear = generate_table(data->degamma_lut_size, 1.0); + gamma_linear = generate_table(data->gamma_lut_size, 1.0); + + for_each_connected_output(&data->display, output) { + drmModeModeInfo *mode; + struct igt_fb fb_modeset, fb; + igt_crc_t crc_full, crc_limited; + int fb_id, fb_modeset_id; + + igt_output_set_pipe(output, primary->pipe->pipe); + mode = igt_output_get_mode(output); + + /* Create a framebuffer at the size of the output. */ + fb_id = igt_create_fb(data->drm_fd, + mode->hdisplay, + mode->vdisplay, + DRM_FORMAT_XRGB8888, + LOCAL_DRM_FORMAT_MOD_NONE, + &fb); + igt_assert(fb_id); + + fb_modeset_id = igt_create_fb(data->drm_fd, + mode->hdisplay, + mode->vdisplay, + DRM_FORMAT_XRGB8888, + LOCAL_DRM_FORMAT_MOD_NONE, + &fb_modeset); + igt_assert(fb_modeset_id); + igt_plane_set_fb(primary, &fb_modeset); + + set_degamma(data, primary->pipe, degamma_linear); + set_gamma(data, primary->pipe, gamma_linear); + set_ctm(primary->pipe, ctm); + + output_set_property_enum(output, "Broadcast RGB", "Full"); + paint_rectangles(data, mode, red_green_blue_limited, &fb); + igt_plane_set_fb(primary, &fb); + igt_display_commit(&data->display); + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_full); + + /* Set the output into limited range. */ + output_set_property_enum(output, "Broadcast RGB", "Limited 16:235"); + paint_rectangles(data, mode, red_green_blue_full, &fb); + igt_plane_set_fb(primary, &fb); + igt_display_commit(&data->display); + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe); + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_limited); + + /* Verify that the CRC of the software computed output is + * equal to the CRC of the CTM matrix transformation output. + */ + igt_assert_crc_equal(&crc_full, &crc_limited); + + igt_output_set_pipe(output, PIPE_ANY); + } + + free(gamma_linear); + free(degamma_linear); +} +#endif + +static void +run_tests_for_pipe(data_t *data, enum pipe p) +{ + igt_output_t *output; + igt_pipe_t *pipe; + igt_plane_t *primary; + double delta; + int i; + color_t red_green_blue[] = { + { 1.0, 0.0, 0.0 }, + { 0.0, 1.0, 0.0 }, + { 0.0, 0.0, 1.0 } + }; + + igt_fixture { + igt_require_pipe_crc(); + + if (p >= data->display.n_pipes) + return; + + pipe = &data->display.pipes[p]; + if (pipe->n_planes < IGT_PLANE_PRIMARY) + return; + + primary = &pipe->planes[IGT_PLANE_PRIMARY]; + + data->pipe_crc = igt_pipe_crc_new(primary->pipe->pipe, + INTEL_PIPE_CRC_SOURCE_AUTO); + + igt_require(igt_pipe_get_property(&data->display.pipes[p], + "DEGAMMA_LUT_SIZE", + NULL, + &data->degamma_lut_size, + NULL)); + igt_require(igt_pipe_get_property(&data->display.pipes[p], + "GAMMA_LUT_SIZE", + NULL, + &data->gamma_lut_size, + NULL)); + + for_each_connected_output(&data->display, output) + output_set_property_enum(output, "Broadcast RGB", "Full"); + } + + /* We assume an 8bits depth per color for degamma/gamma LUTs + * for CRC checks with framebuffer references. */ + data->color_depth = 8; + delta = 1.0 / (1 << data->color_depth); + + igt_subtest_f("ctm-red-to-blue-pipe%d", p) { + color_t blue_green_blue[] = { + { 0.0, 0.0, 1.0 }, + { 0.0, 1.0, 0.0 }, + { 0.0, 0.0, 1.0 } + }; + double ctm[] = { 0.0, 0.0, 0.0, + 0.0, 1.0, 0.0, + 1.0, 0.0, 1.0 }; + igt_assert(test_pipe_ctm(data, primary, red_green_blue, + blue_green_blue, ctm)); + } + + igt_subtest_f("ctm-green-to-red-pipe%d", p) { + color_t red_red_blue[] = { + { 1.0, 0.0, 0.0 }, + { 1.0, 0.0, 0.0 }, + { 0.0, 0.0, 1.0 } + }; + double ctm[] = { 1.0, 1.0, 0.0, + 0.0, 0.0, 0.0, + 0.0, 0.0, 1.0 }; + igt_assert(test_pipe_ctm(data, primary, red_green_blue, + red_red_blue, ctm)); + } + + igt_subtest_f("ctm-blue-to-red-pipe%d", p) { + color_t red_green_red[] = { + { 1.0, 0.0, 0.0 }, + { 0.0, 1.0, 0.0 }, + { 1.0, 0.0, 0.0 } + }; + double ctm[] = { 1.0, 0.0, 1.0, + 0.0, 1.0, 0.0, + 0.0, 0.0, 0.0 }; + igt_assert(test_pipe_ctm(data, primary, red_green_blue, + red_green_red, ctm)); + } + + /* We tests a few values around the expected result because + * the it depends on the hardware we're dealing with, we can + * either get clamped or rounded values and we also need to + * account for odd number of items in the LUTs. */ + igt_subtest_f("ctm-0-25-pipe%d", p) { + color_t expected_colors[] = { + { 0.0, }, { 0.0, }, { 0.0, } + }; + double ctm[] = { 0.25, 0.0, 0.0, + 0.0, 0.25, 0.0, + 0.0, 0.0, 0.25 }; + bool success = false; + + for (i = 0; i < 5; i++) { + expected_colors[0].r = + expected_colors[1].g = + expected_colors[2].b = + 0.25 + delta * (i - 2); + success |= test_pipe_ctm(data, primary, + red_green_blue, + expected_colors, ctm); + } + igt_assert(success); + } + + igt_subtest_f("ctm-0-5-pipe%d", p) { + color_t expected_colors[] = { + { 0.0, }, { 0.0, }, { 0.0, } + }; + double ctm[] = { 0.5, 0.0, 0.0, + 0.0, 0.5, 0.0, + 0.0, 0.0, 0.5 }; + bool success = false; + + for (i = 0; i < 5; i++) { + expected_colors[0].r = + expected_colors[1].g = + expected_colors[2].b = + 0.5 + delta * (i - 2); + success |= test_pipe_ctm(data, primary, + red_green_blue, + expected_colors, ctm); + } + igt_assert(success); + } + + igt_subtest_f("ctm-0-75-pipe%d", p) { + color_t expected_colors[] = { + { 0.0, }, { 0.0, }, { 0.0, } + }; + double ctm[] = { 0.75, 0.0, 0.0, + 0.0, 0.75, 0.0, + 0.0, 0.0, 0.75 }; + bool success = false; + + for (i = 0; i < 7; i++) { + expected_colors[0].r = + expected_colors[1].g = + expected_colors[2].b = + 0.75 + delta * (i - 3); + success |= test_pipe_ctm(data, primary, + red_green_blue, + expected_colors, ctm); + } + igt_assert(success); + } + + igt_subtest_f("ctm-max-pipe%d", p) { + color_t full_rgb[] = { + { 1.0, 0.0, 0.0 }, + { 0.0, 1.0, 0.0 }, + { 0.0, 0.0, 1.0 } + }; + double ctm[] = { 100.0, 0.0, 0.0, + 0.0, 100.0, 0.0, + 0.0, 0.0, 100.0 }; + + /* CherryView generates values on 10bits that we + * produce with an 8 bits per color framebuffer. */ + igt_require(!IS_CHERRYVIEW(data->devid)); + + igt_assert(test_pipe_ctm(data, primary, red_green_blue, + full_rgb, ctm)); + } + + igt_subtest_f("ctm-negative-pipe%d", p) { + color_t all_black[] = { + { 0.0, 0.0, 0.0 }, + { 0.0, 0.0, 0.0 }, + { 0.0, 0.0, 0.0 } + }; + double ctm[] = { -1.0, 0.0, 0.0, + 0.0, -1.0, 0.0, + 0.0, 0.0, -1.0 }; + igt_assert(test_pipe_ctm(data, primary, red_green_blue, + all_black, ctm)); + } + +#if 0 + igt_subtest_f("ctm-limited-range-pipe%d", p) + test_pipe_limited_range_ctm(data, primary); +#endif + + igt_subtest_f("degamma-pipe%d", p) + test_pipe_degamma(data, primary); + + igt_subtest_f("gamma-pipe%d", p) + test_pipe_gamma(data, primary); + + igt_subtest_f("legacy-gamma-pipe%d", p) + test_pipe_legacy_gamma(data, primary); + + igt_subtest_f("legacy-gamma-reset-pipe%d", p) + test_pipe_legacy_gamma_reset(data, primary); + + igt_fixture { + for_each_connected_output(&data->display, output) + output_set_property_enum(output, "Broadcast RGB", "Full"); + + disable_degamma(primary->pipe); + disable_gamma(primary->pipe); + disable_ctm(primary->pipe); + igt_display_commit(&data->display); + + igt_pipe_crc_free(data->pipe_crc); + data->pipe_crc = NULL; + } +} + +static int +pipe_set_property_blob_id(igt_pipe_t *pipe, const char *property, uint32_t blob_id) +{ + uint32_t prop_id; + + igt_assert(kmstest_get_property(pipe->display->drm_fd, + pipe->crtc_id, + DRM_MODE_OBJECT_CRTC, + property, + &prop_id, NULL, NULL)); + + return drmModeObjectSetProperty(pipe->display->drm_fd, + pipe->crtc_id, + DRM_MODE_OBJECT_CRTC, + prop_id, blob_id); +} + +static int +pipe_set_property_blob(igt_pipe_t *pipe, const char *property, void *ptr, size_t length) +{ + int ret = 0; + uint32_t blob_id = 0; + + if (length > 0) + igt_assert_eq(drmModeCreatePropertyBlob(pipe->display->drm_fd, + ptr, length, + &blob_id), 0); + + ret = pipe_set_property_blob_id(pipe, property, blob_id); + + if (blob_id != 0) + igt_assert_eq(drmModeDestroyPropertyBlob(pipe->display->drm_fd, blob_id), 0); + + return ret; +} + +static void +invalid_lut_sizes(data_t *data) +{ + igt_pipe_t *pipe = &data->display.pipes[0]; + size_t degamma_lut_size = data->degamma_lut_size * sizeof(struct _drm_color_lut); + size_t gamma_lut_size = data->gamma_lut_size * sizeof(struct _drm_color_lut); + + struct _drm_color_lut *degamma_lut = malloc(data->degamma_lut_size * sizeof(struct _drm_color_lut) * 2); + struct _drm_color_lut *gamma_lut = malloc(data->gamma_lut_size * sizeof(struct _drm_color_lut) * 2); + + igt_assert_eq(pipe_set_property_blob(pipe, "DEGAMMA_LUT", + degamma_lut, 1), -EINVAL); + igt_assert_eq(pipe_set_property_blob(pipe, "DEGAMMA_LUT", + degamma_lut, degamma_lut_size + 1), + -EINVAL); + igt_assert_eq(pipe_set_property_blob(pipe, "DEGAMMA_LUT", + degamma_lut, degamma_lut_size - 1), + -EINVAL); + igt_assert_eq(pipe_set_property_blob(pipe, "DEGAMMA_LUT", + degamma_lut, degamma_lut_size + sizeof(struct _drm_color_lut)), + -EINVAL); + igt_assert_eq(pipe_set_property_blob_id(pipe, "DEGAMMA_LUT", pipe->crtc_id), + -EINVAL); + igt_assert_eq(pipe_set_property_blob_id(pipe, "DEGAMMA_LUT", 4096 * 4096), + -EINVAL); + + igt_assert_eq(pipe_set_property_blob(pipe, "GAMMA_LUT", + gamma_lut, 1), + -EINVAL); + igt_assert_eq(pipe_set_property_blob(pipe, "GAMMA_LUT", + gamma_lut, gamma_lut_size + 1), + -EINVAL); + igt_assert_eq(pipe_set_property_blob(pipe, "GAMMA_LUT", + gamma_lut, gamma_lut_size - 1), + -EINVAL); + igt_assert_eq(pipe_set_property_blob(pipe, "GAMMA_LUT", + gamma_lut, gamma_lut_size + sizeof(struct _drm_color_lut)), + -EINVAL); + igt_assert_eq(pipe_set_property_blob_id(pipe, "GAMMA_LUT", pipe->crtc_id), + -EINVAL); + igt_assert_eq(pipe_set_property_blob_id(pipe, "GAMMA_LUT", 4096 * 4096), + -EINVAL); + + free(degamma_lut); + free(gamma_lut); +} + +static void +invalid_ctm_matrix_sizes(data_t *data) +{ + igt_pipe_t *pipe = &data->display.pipes[0]; + void *ptr = malloc(sizeof(struct _drm_color_ctm) * 4); + + igt_assert_eq(pipe_set_property_blob(pipe, "CTM", ptr, 1), + -EINVAL); + igt_assert_eq(pipe_set_property_blob(pipe, "CTM", ptr, + sizeof(struct _drm_color_ctm) + 1), + -EINVAL); + igt_assert_eq(pipe_set_property_blob(pipe, "CTM", ptr, + sizeof(struct _drm_color_ctm) - 1), + -EINVAL); + igt_assert_eq(pipe_set_property_blob(pipe, "CTM", ptr, + sizeof(struct _drm_color_ctm) * 2), + -EINVAL); + igt_assert_eq(pipe_set_property_blob_id(pipe, "CTM", pipe->crtc_id), + -EINVAL); + igt_assert_eq(pipe_set_property_blob_id(pipe, "CTM", 4096 * 4096), + -EINVAL); + + free(ptr); +} + +igt_main +{ + data_t data = {}; + + igt_skip_on_simulation(); + + igt_fixture { + data.drm_fd = drm_open_driver_master(DRIVER_INTEL); + data.devid = intel_get_drm_devid(data.drm_fd); + kmstest_set_vt_graphics_mode(); + + igt_display_init(&data.display, data.drm_fd); + } + + for (int pipe = 0; pipe < I915_MAX_PIPES; pipe++) + run_tests_for_pipe(&data, pipe); + + igt_subtest_f("invalid-lut-sizes") + invalid_lut_sizes(&data); + + igt_subtest_f("invalid-ctm-matrix-sizes") + invalid_ctm_matrix_sizes(&data); + + igt_fixture { + igt_display_fini(&data.display); + } +}