From patchwork Wed Jun 18 08:57:27 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: sonika.jindal@intel.com X-Patchwork-Id: 4374461 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.19.201]) by patchwork1.web.kernel.org (Postfix) with ESMTP id 260FE9F3B4 for ; Wed, 18 Jun 2014 09:01:27 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 6468920127 for ; Wed, 18 Jun 2014 09:01:25 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) by mail.kernel.org (Postfix) with ESMTP id 0510E2020F for ; Wed, 18 Jun 2014 09:01:24 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 80B7F6E32C; Wed, 18 Jun 2014 02:01:23 -0700 (PDT) X-Original-To: intel-gfx@lists.freedesktop.org Delivered-To: intel-gfx@lists.freedesktop.org Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by gabe.freedesktop.org (Postfix) with ESMTP id 09C986E330 for ; Wed, 18 Jun 2014 02:01:21 -0700 (PDT) Received: from fmsmga002.fm.intel.com ([10.253.24.26]) by fmsmga101.fm.intel.com with ESMTP; 18 Jun 2014 02:01:19 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.01,499,1400050800"; d="scan'208";a="557284954" Received: from sonikaji-desktop.iind.intel.com ([10.223.25.81]) by fmsmga002.fm.intel.com with ESMTP; 18 Jun 2014 02:01:08 -0700 From: sonika.jindal@intel.com To: intel-gfx@lists.freedesktop.org Date: Wed, 18 Jun 2014 14:27:27 +0530 Message-Id: <1403081847-4364-12-git-send-email-sonika.jindal@intel.com> X-Mailer: git-send-email 1.7.10.4 In-Reply-To: <1403081847-4364-1-git-send-email-sonika.jindal@intel.com> References: <1403081847-4364-1-git-send-email-sonika.jindal@intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] =?utf-8?q?=5BPATCH_11/11=5D_tests/kms=5Frotation=5Fcr?= =?utf-8?q?c=3A_IGT_for_180_degree_HW_rotation?= X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.15 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=-4.2 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_MED, T_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 From: Sonika Jindal Testcase for 180 degree HW rotation Cc: sagar.a.kamble@intel.com Signed-off-by: Sonika Jindal --- tests/Makefile.sources | 1 + tests/kms_rotation_crc.c | 427 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 428 insertions(+) create mode 100644 tests/kms_rotation_crc.c diff --git a/tests/Makefile.sources b/tests/Makefile.sources index e4c23b3..b59c146 100644 --- a/tests/Makefile.sources +++ b/tests/Makefile.sources @@ -69,6 +69,7 @@ TESTS_progs_M = \ kms_plane \ kms_render \ kms_setmode \ + kms_rotation_crc \ pm_lpsp \ pm_rpm \ pm_rps \ diff --git a/tests/kms_rotation_crc.c b/tests/kms_rotation_crc.c new file mode 100644 index 0000000..74a52cd --- /dev/null +++ b/tests/kms_rotation_crc.c @@ -0,0 +1,427 @@ +/* + * Copyright © 2013 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "drmtest.h" +#include "igt_debugfs.h" +#include "igt_kms.h" +#include "igt_core.h" + +#define DRM_ROTATE_0 0 +#define DRM_ROTATE_90 1 +#define DRM_ROTATE_180 2 +#define DRM_ROTATE_270 3 +#define DRM_REFLECT_X 4 +#define DRM_REFLECT_Y 5 +#define DRM_ROTATE_NUM 6 + +#define BIT(x) (1 << x) + +// This will be part of libdrm later. Adding here temporarily +#define DRM_PLANE_TYPE_OVERLAY 0 +#define DRM_PLANE_TYPE_PRIMARY 1 +#define DRM_PLANE_TYPE_CURSOR 2 +#define DRM_CLIENT_CAP_EXPOSE_PRIMARY_PLANES 2 + +typedef struct { + int gfx_fd; + igt_display_t display; + igt_output_t *output; + int type; + int pipe; + struct igt_fb fb; + igt_crc_t ref_crc[2]; + igt_pipe_crc_t *pipe_crc; + int rotate; +} data_t; + +bool check_plane_type(int drm_fd, uint32_t plane_id, uint32_t type); +int set_plane_property(data_t *data, int plane_id, const char *prop_name, int + val, igt_crc_t *crc_output); +void test_sprite_rotation(data_t *data); +void test_primary_rotation(data_t *data); +bool prepare_crtc(data_t *data); + +bool prepare_crtc(data_t *data) +{ + drmModeModeInfo *mode; + igt_display_t *display = &data->display; + igt_output_t *output = data->output; + cairo_t *cr; + igt_plane_t *primary, *sprite; + int fb_id; + int w, h; + + igt_output_set_pipe(output, data->pipe); + igt_display_commit(display); + + /* create the pipe_crc object for this pipe */ + if (data->pipe_crc) + igt_pipe_crc_free(data->pipe_crc); + + data->pipe_crc = igt_pipe_crc_new(data->pipe, + INTEL_PIPE_CRC_SOURCE_AUTO); + if (!data->pipe_crc) { + igt_info("auto crc not supported on this connector with pipe %i\n", + data->pipe); + return false; + } + + + if (!data->output->valid) { + igt_output_set_pipe(output, PIPE_ANY); + igt_display_commit(display); + return false; + } + + switch (data->type) { + + case DRM_PLANE_TYPE_OVERLAY: /* Sprite */ + igt_info("Sprite plane\n"); + mode = igt_output_get_mode(output); + w = mode->hdisplay; + h = mode->vdisplay; + + fb_id = igt_create_fb(data->gfx_fd, + mode->hdisplay, mode->vdisplay, + DRM_FORMAT_XRGB8888, + false, /* tiled */ + &data->fb); + igt_assert(fb_id); + cr = igt_get_cairo_ctx(data->gfx_fd, &data->fb); + + /* Paint rotated image of 4 colors */ + igt_paint_color(cr, (w/2)-1, (h/2)-1, w/2, h/2, 1.0, 0.0, 0.0); + igt_paint_color(cr, 0, (h/2)-1, w/2, h/2, 0.0, 1.0, 0.0); + igt_paint_color(cr, (w/2)-1, 0, w/2, h/2, 0.0, 0.0, 1.0); + igt_paint_color(cr, 0, 0, w/2, h/2, 1.0, 1.0, 1.0); + sprite = igt_output_get_plane(output, IGT_PLANE_2); + igt_plane_set_fb(sprite, &data->fb); + igt_display_commit(display); + + /* Collect reference crc */ + igt_pipe_crc_collect_crc(data->pipe_crc, &data->ref_crc[1]); + + /* Paint with 4 squares of Red, Green, White, Blue Clockwise */ + igt_paint_color(cr, 0, 0, w/2, h/2, 1.0, 0.0, 0.0); + igt_paint_color(cr, (w/2)-1, 0, w/2, h/2, 0.0, 1.0, 0.0); + igt_paint_color(cr, 0, (h/2)-1, w/2, h/2, 0.0, 0.0, 1.0); + igt_paint_color(cr, (w/2)-1, (h/2)-1, w/2, h/2, 1.0, 1.0, 1.0); + cairo_destroy(cr); + sprite = igt_output_get_plane(output, IGT_PLANE_2); + igt_plane_set_fb(sprite, &data->fb); + igt_display_commit(display); + + break; + case DRM_PLANE_TYPE_PRIMARY: /* Primary */ + igt_info("Primary plane\n"); + mode = igt_output_get_mode(output); + w = mode->hdisplay; + h = mode->vdisplay; + + fb_id = igt_create_fb(data->gfx_fd, + mode->hdisplay, mode->vdisplay, + DRM_FORMAT_XRGB8888, + false, /* tiled */ + &data->fb); + igt_assert(fb_id); + cr = igt_get_cairo_ctx(data->gfx_fd, &data->fb); + + /* Paint rotated image of 4 colors */ + igt_paint_color(cr, (w/2)-1, (h/2)-1, w/2, h/2, 1.0, 0.2, 0.2); + igt_paint_color(cr, 0, (h/2)-1, w/2, h/2, 0.2, 1.0, 0.2); + igt_paint_color(cr, (w/2)-1, 0, w/2, h/2, 0.2, 0.2, 1.0); + igt_paint_color(cr, 0, 0, w/2, h/2, 0.8, 0.8, 0.8); + primary = igt_output_get_plane(output, IGT_PLANE_PRIMARY); + igt_plane_set_fb(primary, &data->fb); + igt_display_commit(display); + + /* Collect reference crc */ + igt_pipe_crc_collect_crc(data->pipe_crc, &data->ref_crc[0]); + + /* Paint with 4 squares of Red, Green, White, Blue Clockwise */ + igt_paint_color(cr, 0, 0, w/2, h/2, 1.0, 0.2, 0.2); + igt_paint_color(cr, (w/2)-1, 0, w/2, h/2, 0.2, 1.0, 0.2); + igt_paint_color(cr, 0, (h/2)-1, w/2, h/2, 0.2, 0.2, 1.0); + igt_paint_color(cr, (w/2)-1, (h/2)-1, w/2, h/2, 0.8, 0.8, 0.8); + cairo_destroy(cr); + primary = igt_output_get_plane(output, IGT_PLANE_PRIMARY); + igt_plane_set_fb(primary, &data->fb); + igt_display_commit(display); + + break; + + + } + + return true; +} + +static int connector_find_plane(int gfx_fd, uint32_t pipe, uint32_t type) +{ + drmModePlaneRes *plane_resources; + drmModePlane *ovr; + uint32_t id = 0; + int i, ret = 0; + + ret = drmSetClientCap(gfx_fd, DRM_CLIENT_CAP_EXPOSE_PRIMARY_PLANES, 1); + if (ret < 0) { + igt_info("Failed to set client cap:%d\n", ret); + return 0; + } + + plane_resources = drmModeGetPlaneResources(gfx_fd); + if (!plane_resources) { + igt_info("drmModeGetPlaneResources failed: %s\n", + strerror(errno)); + return 0; + } + + for (i = 0; i < plane_resources->count_planes; i++) { + ovr = drmModeGetPlane(gfx_fd, plane_resources->planes[i]); + if (!ovr) { + igt_info("drmModeGetPlane failed: %s\n", + strerror(errno)); + continue; + } + + if (ovr->possible_crtcs & (1 << pipe)) { + id = ovr->plane_id; + if (check_plane_type(gfx_fd, id, type)) { + drmModeFreePlane(ovr); + return id; + } + } + drmModeFreePlane(ovr); + } + + return 0; +} + +bool check_plane_type(int drm_fd, uint32_t plane_id, uint32_t type) +{ + int i = 0; + drmModeObjectPropertiesPtr props = NULL; + + props = drmModeObjectGetProperties(drm_fd, plane_id, DRM_MODE_OBJECT_PLANE); + + for (i = 0; i < props->count_props; i++) + { + drmModePropertyPtr prop = drmModeGetProperty(drm_fd, props->props[i]); + + if (strcmp(prop->name, "type") == 0) + { + if (props->prop_values[i] == type) { + return true; + } + igt_info("Didn't find the requested type:%u\n", (unsigned int)props->prop_values[i]); + } + } + return false; +} + +int set_plane_property(data_t *data, int plane_id, const char *prop_name, int + val, igt_crc_t *crc_output) +{ + int i = 0, ret = 0; + int drm_fd = data->gfx_fd; + uint64_t value; + drmModeObjectPropertiesPtr props = NULL; + + value = (uint64_t)val; + props = drmModeObjectGetProperties(drm_fd, plane_id, DRM_MODE_OBJECT_PLANE); + + for (i = 0; i < props->count_props; i++) + { + drmModePropertyPtr prop = drmModeGetProperty(drm_fd, props->props[i]); + igt_info("\nProp->name=%s: plane_id:%d\n ", prop->name, plane_id); + + if (strcmp(prop->name, prop_name) == 0) + { + ret = drmModeObjectSetProperty(drm_fd, plane_id, DRM_MODE_OBJECT_PLANE, + (uint32_t)prop->prop_id, value); + if (ret) + { + igt_info("set_property \"%s\" to %d for plane %d is failed, err:%d\n", prop_name, val, plane_id, ret); + drmModeFreeProperty(prop); + drmModeFreeObjectProperties(props); + return ret; + } + else { + /* Collect crc after rotation */ + igt_pipe_crc_collect_crc(data->pipe_crc, crc_output); + drmModeFreeProperty(prop); + break; + } + } + drmModeFreeProperty(prop); + } + drmModeFreeObjectProperties(props); + return 0; +} + +static void cleanup_crtc(data_t *data, igt_output_t *output) +{ + igt_display_t *display = &data->display; + igt_plane_t *plane = NULL; + + igt_pipe_crc_free(data->pipe_crc); + data->pipe_crc = NULL; + + igt_remove_fb(data->gfx_fd, &data->fb); + + if (data->type == DRM_PLANE_TYPE_PRIMARY) { + plane = igt_output_get_plane(output, IGT_PLANE_PRIMARY); + } + else if (data->type == DRM_PLANE_TYPE_OVERLAY) { + plane = igt_output_get_plane(output, IGT_PLANE_2); + } + + if (plane != NULL) + igt_plane_set_fb(plane, NULL); + + igt_output_set_pipe(output, PIPE_ANY); + igt_display_commit(display); +} + +void test_sprite_rotation(data_t *data) +{ + igt_display_t *display = &data->display; + igt_output_t *output; + igt_plane_t *sprite; + igt_crc_t crc_output; + int p; + int plane_id; + int ret; + int valid_tests = 0; + + for_each_connected_output(display, output) { + data->output = output; + for (p = 0; p < igt_display_get_n_pipes(display); p++) { + data->pipe = p; + data->type = 0; + data->rotate = DRM_ROTATE_180; + + if (!prepare_crtc(data)) + continue; + sleep(2); + + sprite = igt_output_get_plane(output, IGT_PLANE_2); + plane_id = sprite->drm_plane->plane_id; + if (plane_id != 0) { + igt_info("Setting rotation property for plane:%d\n", plane_id); + ret = set_plane_property(data, plane_id, "rotation", BIT(data->rotate), &crc_output); + if (ret < 0) { + igt_info("Setting rotation failed!"); + return; + } + } + igt_assert(igt_crc_equal(&data->ref_crc[1], &crc_output)); + sleep(2); + valid_tests++; + cleanup_crtc(data, output); + } + } + igt_require_f(valid_tests, "no valid crtc/connector combinations found\n"); +} + + +void test_primary_rotation(data_t *data) +{ + igt_display_t *display = &data->display; + igt_output_t *output; + int p; + int plane_id; + int ret; + int valid_tests = 0; + igt_crc_t crc_output; + + for_each_connected_output(display, output) { + data->output = output; + for (p = 0; p < igt_display_get_n_pipes(display); p++) { + data->pipe = p; + data->type = 1; + data->rotate = DRM_ROTATE_180; + + if (!prepare_crtc(data)) + continue; + sleep(2); + + /* Find primary plane. Currently igt_plane_t returned from + * igt_output_get_plane has NULL drm_plane which is needed to get + * the plane_id. So finding the primary plane by checking the "type" + * property of the plane */ + plane_id = connector_find_plane(data->gfx_fd, data->pipe, data->type); + if (plane_id != 0) { + igt_info("Setting rotation property for plane:%d\n", plane_id); + ret = set_plane_property(data, plane_id, "rotation", BIT(data->rotate), &crc_output); + if (ret < 0) { + igt_info("Setting rotation failed!"); + return; + } + } + igt_assert(igt_crc_equal(&data->ref_crc[0], &crc_output)); + sleep(2); + valid_tests++; + cleanup_crtc(data, output); + } + } + igt_require_f(valid_tests, "no valid crtc/connector combinations found\n"); +} + +igt_main +{ + data_t data = {}; + + igt_skip_on_simulation(); + + igt_fixture { + data.gfx_fd = drm_open_any(); + + igt_set_vt_graphics_mode(); + + igt_require_pipe_crc(); + + igt_display_init(&data.display, data.gfx_fd); + } + + igt_subtest_f("primary-rotation") + test_primary_rotation(&data); + + igt_subtest_f("sprite-rotation") + test_sprite_rotation(&data); + + igt_fixture { + igt_display_fini(&data.display); + } +}