diff --git a/tests/Makefile.sources b/tests/Makefile.sources
index 8a9a7ec..53afe3c 100644
--- a/tests/Makefile.sources
+++ b/tests/Makefile.sources
@@ -98,7 +98,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 9f7ac7e..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 <math.h>
-#include <unistd.h>
-
-#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);
-
-	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);
-
-		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;
-		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..9f7ac7e
--- /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 <math.h>
+#include <unistd.h>
+
+#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);
+
+	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);
+
+		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;
+		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);
+	}
+}
