From patchwork Tue Jan 23 23:16:36 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 125603 Delivered-To: patches@linaro.org Received: by 10.46.66.141 with SMTP id h13csp50435ljf; Tue, 23 Jan 2018 15:16:49 -0800 (PST) X-Received: by 10.99.184.25 with SMTP id p25mr294081pge.96.1516749409535; Tue, 23 Jan 2018 15:16:49 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516749409; cv=none; d=google.com; s=arc-20160816; b=Skj7L2SQ+ltHTZiETfSPkXIsUiTKwaU2qvUeI1yKn6F92DfGGFpDS5an8PY0jvt+IE kIs0u9YwbceYp7Z3A780hTxlwBlUfC6+KLpUoNlio6vn53Eg0UZ4IsFC3PKkCP0nGF9x iqdI888+MBQGS/RKkLrcEHXBwR2hqPD+BkCOhTbRRyJMVNavKZ0FU1rWZrFAbRYP7h5l DNeuhwpIW4SxzpU8lLa301eanVhHAyMyh5JD9xwUC0DsGY33cosbybkXinp5/ehpBccT InMQkuydaB4SPUtZU4ZpLjnRgF05iE4oN77g9fPN0wMrZR6fo42DIPTjGCZ/4T7Bkfht inbQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature:arc-authentication-results; bh=4ErbTPYQq7WHeTHfr525uHkbAOSEuBZtru0+vBVgfLY=; b=XH+bpXY0QcoZKOdcVAxOHo5dHV/1gptOj4ojBzBWGsJxCQYZfjCfRDN3xIQn6rbBjF EkuZwFH4I02Sb7WZ/Iwm7NII6Vx9lXYRzjKYM5AIVPmO5Znm0hHR7AgmFodMvZFYOaW3 FxZN5WJX8iJlUy2iZmbIRwtm0OGsYk6ZRXOTZGd/rrL82tEqel3rGpucoXVkzLeztgyp 2rh+Yg60opJFyISK2GNenDuHCVfLbBxMgw7i8oAMYbQhqBUSIX/QT0h8pVYT223mpNQO s54YD4qn7Y4S9W2IlWuAf56Ze03D0XUOaSzSmPGm0/AeQ70u6pD7AXJGWpq8REpKDUQH glOQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=UCjZpP4h; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f65.google.com (mail-sor-f65.google.com. [209.85.220.65]) by mx.google.com with SMTPS id t3-v6sor1998122ply.39.2018.01.23.15.16.49 for (Google Transport Security); Tue, 23 Jan 2018 15:16:49 -0800 (PST) Received-SPF: pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) client-ip=209.85.220.65; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=UCjZpP4h; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=4ErbTPYQq7WHeTHfr525uHkbAOSEuBZtru0+vBVgfLY=; b=UCjZpP4h08HclTvii5isrlGel+2jL/5COn9Vk/bm5tk+dNHbyeQN8xZzQ4oIWxf1SF Ob6oT7WyN1QsCIAMq8EHuiO7ph02WbNc3gOBPPwmk5ytJcLfqPqkcryXY+B8Sn2Wg4to Pj4jMh+yhH4TnKpq2Sv3ktxPD8YG8fCv+AZis= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=4ErbTPYQq7WHeTHfr525uHkbAOSEuBZtru0+vBVgfLY=; b=fK64HDogj6LIG0WLE2Wzsta1S5MSP/h6hTQB1TniIJuhk4Yb8mPohRu9+NLD3n09Ud zfNDAxYIaEvPJSlnbzDxzE8cJgOO+CE37BH9o6dFEIbjG2gYl6sJdn5vVbNay5c6DqSF a76RZnHPiMEzM5kZMR+Dx/2EUblhGiJApPmWKf9q9bqbdpnZ14h33zzPJXk7qiftCGRz VdpA+Ue1lMSFIayqhOGMiLuM404dtOILzcaeVz7nnwb2ywD0OEs+D3EhRAMYrM4FXs8F kByGWP/QpC+YeDt9O5aJ7HZCbtp+c6FiQePSacn7wRD0pN7p98RoXG52A+o3gyOvci+A 3/kA== X-Gm-Message-State: AKwxytevH+Vc6S1FfJ3wE9ZsIFiqLIt6l5Od8KMTq9DbO06rLRCutXqu ePOdSBB1CEEitalgwuzxXeM0JGKW X-Google-Smtp-Source: AH8x2251wSbXMQejlxw1oX+Hc9REcH+lY43y9n4R+O65Lmv9/+bq+iZA0ztOexrtuZqO2kGnoUPYvg== X-Received: by 2002:a17:902:581a:: with SMTP id m26-v6mr6317513pli.158.1516749409050; Tue, 23 Jan 2018 15:16:49 -0800 (PST) Return-Path: Received: from localhost.localdomain ([2601:1c2:600:5100:4e72:b9ff:fe99:466a]) by smtp.gmail.com with ESMTPSA id c83sm6924811pfk.8.2018.01.23.15.16.47 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Tue, 23 Jan 2018 15:16:48 -0800 (PST) From: John Stultz To: dri-devel@lists.freedesktop.org Cc: John Stultz , Marissa Wall , Sean Paul , Dmitry Shmidt , Robert Foss , Matt Szczesiak , Liviu Dudau , David Hanna , Rob Herring Subject: [RFC][PATCH 1/4 v2] drm_hwcomposer: Make sure we set the active state when doing modesets Date: Tue, 23 Jan 2018 15:16:36 -0800 Message-Id: <1516749399-29504-2-git-send-email-john.stultz@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516749399-29504-1-git-send-email-john.stultz@linaro.org> References: <1516749399-29504-1-git-send-email-john.stultz@linaro.org> In trying to use drm_hwcomposer with HiKey/HiKey960 boards, I found that the crtc wouldn't intitalize and the atomic commit calls were failing. I initially chased this down to following check in the kernel drm_atomic_crtc_check() function failing: if (state->event && !state->active && !crtc->state->active) { DRM_DEBUG_ATOMIC("[CRTC:%d:%s] requesting event but off\n", crtc->base.id, crtc->name); return -EINVAL; } Where because a fence was submitted state->event was set, but the crtc state was not active. This results in the atomic commit to fail and no mode to be set. After hacking around this in the kernel, Sean Paul helped me understand that it was the kernel complaining about the crtc state being provided in the atomic commit which did not have the active flag set. Thus, the proper fix is to make sure when we do the modesetting that we also set the crtc state active flag in property set. With this change, the kernel no longer rejects the atomic commit and the crtc initializes properly. Cc: Marissa Wall Cc: Sean Paul Cc: Dmitry Shmidt Cc: Robert Foss Cc: Matt Szczesiak Cc: Liviu Dudau Cc: David Hanna Cc: Rob Herring Signed-off-by: John Stultz --- drmdisplaycompositor.cpp | 7 +++++++ 1 file changed, 7 insertions(+) -- 2.7.4 diff --git a/drmdisplaycompositor.cpp b/drmdisplaycompositor.cpp index acd13b8..3a20b31 100644 --- a/drmdisplaycompositor.cpp +++ b/drmdisplaycompositor.cpp @@ -520,6 +520,13 @@ int DrmDisplayCompositor::CommitFrame(DrmDisplayComposition *display_comp, } if (mode_.needs_modeset) { + ret = drmModeAtomicAddProperty(pset, crtc->id(), crtc->active_property().id(), 1); + if (ret < 0) { + ALOGE("Failed to add crtc active to pset\n"); + drmModeAtomicFree(pset); + return ret; + } + ret = drmModeAtomicAddProperty(pset, crtc->id(), crtc->mode_property().id(), mode_.blob_id) < 0 || drmModeAtomicAddProperty(pset, connector->id(), From patchwork Tue Jan 23 23:16:37 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 125604 Delivered-To: patches@linaro.org Received: by 10.46.66.141 with SMTP id h13csp50441ljf; Tue, 23 Jan 2018 15:16:51 -0800 (PST) X-Received: by 2002:a17:902:23:: with SMTP id 32-v6mr6544726pla.350.1516749411500; Tue, 23 Jan 2018 15:16:51 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516749411; cv=none; d=google.com; s=arc-20160816; b=Cb7tVOQVzUo+KVGuFRyzgPQyvUOTlh11TuUmeYyhEamNviKrRRaD1R60nYy+o9uBl/ fflZcBY0Adq8EEq9Q7CUmf+EBLSZ/tujUn9SO5H9LfLixeV71cC3TsAN5QCiJoRzBxst J09RCm4fy3o0k1NiwWofho581hVAy7I99fGr30JIpDXli7Cp4fCqnG8GGdI+CPuMOTAq xK+yN9gf0kwrnEbwbGw4WqdkSexNE0iTLC1U/6eaq13I3ubDd3e5TT3quODeFPYDGOHv AUI+TEIYCyNjjzW88w2YqaRg07BgMCTgRYDCvp1vnkyIVlsR2sf5sp16RxrAZUzH/tZc BsLA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature:arc-authentication-results; bh=mJqfcVeoYSmrIbeGTrj5kPwvXWppIZCaJ9LCCtDqbdo=; b=aHCNnoLQjD2dqfm6Nd0ZUpiugcWRBC4TTjwDLr0+4Q8UXHnfDe4hG6fftraM0mVQPL ghBTJ66+zvORR7jUNczMQJnq1ztwjgoWSbsX8UbQngbh0wjBIDhHn2X2PFqHss6xC7f1 2fVQXU4CMQ6jFzFYoCL19sa4olUTU/i/O569Qmrdzx1E/qtCIcSVNgzD2D9N53KoxiRd j9bwvLtWR4ulUoBRvyW/sxAHAN9nyHWsJCNITHVU4VUtc2SAtnDsEi2ThV2jCa71oOuE Pen88Fp6nzWGW9b5FXSrbmOfbXNRW4p+DRc9A8YTMLz4tYfzoJ9D4gQZNXi4A2HLmWHF x0CQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=g3c2h+Aw; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f65.google.com (mail-sor-f65.google.com. [209.85.220.65]) by mx.google.com with SMTPS id 3-v6sor2266138plt.121.2018.01.23.15.16.51 for (Google Transport Security); Tue, 23 Jan 2018 15:16:51 -0800 (PST) Received-SPF: pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) client-ip=209.85.220.65; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=g3c2h+Aw; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=mJqfcVeoYSmrIbeGTrj5kPwvXWppIZCaJ9LCCtDqbdo=; b=g3c2h+AwEo7zgYMkAggRvCqS1r6vNozBJQphwWkQmcC9FMdRfJL1mTK9/c7GZNzJc0 0pXFWdzRUZ0pm0ZnrRufr/bGJApwgQvGg9nlHcFeIjJmqwlh4HdGTotN9DOsHAhlu3Qp heT4/dxucMM1Im8mzUNPHyo5on1KHIWWwB1NI= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=mJqfcVeoYSmrIbeGTrj5kPwvXWppIZCaJ9LCCtDqbdo=; b=BtOG1AXghKP9zBe53Ce1W5YMFQj3M+t1a8Tz15yeTvQnec9xkq6sBq/VqQGyF83mHw uTXvRisXkMALxAB2EXGLhqzHeV/9TZGSOV5Oya8oDlvBWMBsy0YZI1o+2DkPKbjL3FOw wejs4tMDaIIk09o3+nzztGmscqibQTQnft1l1dYLjyycveirPAOKRzu/O/p3a3Ey11i+ AgGx5DI63bFjeoNKL7+BgwEXkSLivzobBrYlPx4KZlnJvNwomzJ+y5rfL5MayPQdQoRQ bLWZwp0v2UTYfS+kPOitKKqYEijue+7xA4j1EnaycmF71UzQe5vIk98tDlGUyk4wfwDX sA7g== X-Gm-Message-State: AKwxyteR8HYP8J6etJ/mVt2PHVUr9RxU0/GpcFD9oM2aKBR02/jDvIIm jS54/dq4ar+pcmEdHM9i1swu26Y8 X-Google-Smtp-Source: AH8x227Z3RNjP8Tsq+jEL+a4O5ZWS8rFjRDfq6oVKQaMJslD7XW57vqgzfj52K06At7MsoUIK26JKA== X-Received: by 2002:a17:902:900b:: with SMTP id a11-v6mr6281210plp.249.1516749411008; Tue, 23 Jan 2018 15:16:51 -0800 (PST) Return-Path: Received: from localhost.localdomain ([2601:1c2:600:5100:4e72:b9ff:fe99:466a]) by smtp.gmail.com with ESMTPSA id c83sm6924811pfk.8.2018.01.23.15.16.49 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Tue, 23 Jan 2018 15:16:49 -0800 (PST) From: John Stultz To: dri-devel@lists.freedesktop.org Cc: John Stultz , Marissa Wall , Sean Paul , Dmitry Shmidt , Robert Foss , Matt Szczesiak , Liviu Dudau , David Hanna , Rob Herring Subject: [RFC][PATCH 2/4 v2] drm_hwcomposer: Add platformhisi buffer importer for hikey and hikey960 Date: Tue, 23 Jan 2018 15:16:37 -0800 Message-Id: <1516749399-29504-3-git-send-email-john.stultz@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516749399-29504-1-git-send-email-john.stultz@linaro.org> References: <1516749399-29504-1-git-send-email-john.stultz@linaro.org> This allows for importing buffers allocated from the hikey and hikey960 gralloc implelementations. Cc: Marissa Wall Cc: Sean Paul Cc: Dmitry Shmidt Cc: Robert Foss Cc: Matt Szczesiak Cc: Liviu Dudau Cc: David Hanna Cc: Rob Herring Signed-off-by: John Stultz --- v2: * Make platformhisi and the generic importer exclusive in the build * Fixup vendor check --- Android.mk | 15 ++++- platformhisi.cpp | 200 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ platformhisi.h | 50 ++++++++++++++ 3 files changed, 264 insertions(+), 1 deletion(-) create mode 100644 platformhisi.cpp create mode 100644 platformhisi.h -- 2.7.4 diff --git a/Android.mk b/Android.mk index 8b11e37..4a91383 100644 --- a/Android.mk +++ b/Android.mk @@ -66,7 +66,6 @@ LOCAL_SRC_FILES := \ glworker.cpp \ hwcutils.cpp \ platform.cpp \ - platformdrmgeneric.cpp \ separate_rects.cpp \ virtualcompositorworker.cpp \ vsyncworker.cpp @@ -75,7 +74,21 @@ LOCAL_CPPFLAGS += \ -DHWC2_USE_CPP11 \ -DHWC2_INCLUDE_STRINGIFICATION + +ifeq ($(TARGET_PRODUCT),hikey960) +LOCAL_CPPFLAGS += -DUSE_HISI_IMPORTER +LOCAL_C_INCLUDES += device/linaro/hikey/gralloc960/ +LOCAL_SRC_FILES += platformhisi.cpp +else +ifeq ($(TARGET_PRODUCT),hikey) +LOCAL_CPPFLAGS += -DUSE_HISI_IMPORTER -DHIKEY +LOCAL_C_INCLUDES += device/linaro/hikey/gralloc/ +LOCAL_SRC_FILES += platformhisi.cpp +else LOCAL_CPPFLAGS += -DUSE_DRM_GENERIC_IMPORTER +LOCAL_SRC_FILES += platformdrmgeneric.cpp +endif +endif LOCAL_MODULE := hwcomposer.drm LOCAL_MODULE_TAGS := optional diff --git a/platformhisi.cpp b/platformhisi.cpp new file mode 100644 index 0000000..b46bf7c --- /dev/null +++ b/platformhisi.cpp @@ -0,0 +1,200 @@ +/* + * Copyright (C) 2015 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "hwc-platform-hisi" + +#include "drmresources.h" +#include "platform.h" +#include "platformhisi.h" + + +#include +#include +#include +#include +#include + +#include +#include +#include "gralloc_priv.h" + + +namespace android { + +#ifdef USE_HISI_IMPORTER +// static +Importer *Importer::CreateInstance(DrmResources *drm) { + HisiImporter *importer = new HisiImporter(drm); + if (!importer) + return NULL; + + int ret = importer->Init(); + if (ret) { + ALOGE("Failed to initialize the hisi importer %d", ret); + delete importer; + return NULL; + } + return importer; +} +#endif + +HisiImporter::HisiImporter(DrmResources *drm) : drm_(drm) { +} + +HisiImporter::~HisiImporter() { +} + +int HisiImporter::Init() { + int ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, + (const hw_module_t **)&gralloc_); + if (ret) { + ALOGE("Failed to open gralloc module %d", ret); + return ret; + } + + if (strcasecmp(gralloc_->common.author, "ARM Ltd.")) + ALOGW("Using non-ARM gralloc module: %s/%s\n", gralloc_->common.name, + gralloc_->common.author); + + return 0; +} + +#ifdef HIKEY +uint32_t HisiImporter::ConvertHalFormatToDrm(uint32_t hal_format) { + switch (hal_format) { + case HAL_PIXEL_FORMAT_RGB_888: + return DRM_FORMAT_BGR888; + case HAL_PIXEL_FORMAT_BGRA_8888: + return DRM_FORMAT_ARGB8888; + case HAL_PIXEL_FORMAT_RGBX_8888: + return DRM_FORMAT_XBGR8888; + case HAL_PIXEL_FORMAT_RGBA_8888: + return DRM_FORMAT_ABGR8888; + case HAL_PIXEL_FORMAT_RGB_565: + return DRM_FORMAT_BGR565; + case HAL_PIXEL_FORMAT_YV12: + return DRM_FORMAT_YVU420; + default: + ALOGE("Cannot convert hal format to drm format %u", hal_format); + return -EINVAL; + } +} +#else /* HIKEY960 case*/ +uint32_t HisiImporter::ConvertHalFormatToDrm(uint32_t hal_format) { + switch (hal_format) { + case HAL_PIXEL_FORMAT_RGB_888: + return DRM_FORMAT_BGR888; + case HAL_PIXEL_FORMAT_BGRA_8888: + return DRM_FORMAT_XBGR8888; + case HAL_PIXEL_FORMAT_RGBX_8888: + return DRM_FORMAT_XBGR8888; + case HAL_PIXEL_FORMAT_RGBA_8888: + return DRM_FORMAT_XBGR8888; + case HAL_PIXEL_FORMAT_RGB_565: + return DRM_FORMAT_BGR565; + case HAL_PIXEL_FORMAT_YV12: + return DRM_FORMAT_YVU420; + default: + ALOGE("Cannot convert hal format to drm format %u", hal_format); + return -EINVAL; + } +} +#endif /* HIKEY */ + +EGLImageKHR HisiImporter::ImportImage(EGLDisplay egl_display, buffer_handle_t handle) { + private_handle_t const *hnd = reinterpret_cast < private_handle_t const *>(handle); + if (!hnd) + return NULL; + EGLint attr[] = { + EGL_WIDTH, hnd->width, + EGL_HEIGHT, hnd->height, + EGL_LINUX_DRM_FOURCC_EXT, (EGLint)ConvertHalFormatToDrm(hnd->req_format), + EGL_DMA_BUF_PLANE0_FD_EXT, hnd->share_fd, + EGL_DMA_BUF_PLANE0_OFFSET_EXT, 0, + EGL_DMA_BUF_PLANE0_PITCH_EXT, hnd->byte_stride, + EGL_NONE, + }; + return eglCreateImageKHR(egl_display, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, NULL, attr); +} + +int HisiImporter::ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) { + private_handle_t const *hnd = reinterpret_cast < private_handle_t const *>(handle); + if (!hnd) + return -EINVAL; + + uint32_t gem_handle; + int ret = drmPrimeFDToHandle(drm_->fd(), hnd->share_fd, &gem_handle); + if (ret) { + ALOGE("failed to import prime fd %d ret=%d", hnd->share_fd, ret); + return ret; + } + + memset(bo, 0, sizeof(hwc_drm_bo_t)); + bo->width = hnd->width; + bo->height = hnd->height; + bo->format = ConvertHalFormatToDrm(hnd->req_format); + bo->usage = hnd->usage; +#ifdef HIKEY + bo->pitches[0] = hnd->width * 4; +#else + bo->pitches[0] = hnd->byte_stride; +#endif + bo->gem_handles[0] = gem_handle; + bo->offsets[0] = 0; + + ret = drmModeAddFB2(drm_->fd(), bo->width, bo->height, bo->format, + bo->gem_handles, bo->pitches, bo->offsets, &bo->fb_id, 0); + if (ret) { + ALOGE("could not create drm fb %d", ret); + return ret; + } + + return ret; +} + +int HisiImporter::ReleaseBuffer(hwc_drm_bo_t *bo) { + if (bo->fb_id) + if (drmModeRmFB(drm_->fd(), bo->fb_id)) + ALOGE("Failed to rm fb"); + + struct drm_gem_close gem_close; + memset(&gem_close, 0, sizeof(gem_close)); + int num_gem_handles = sizeof(bo->gem_handles) / sizeof(bo->gem_handles[0]); + for (int i = 0; i < num_gem_handles; i++) { + if (!bo->gem_handles[i]) + continue; + + gem_close.handle = bo->gem_handles[i]; + int ret = drmIoctl(drm_->fd(), DRM_IOCTL_GEM_CLOSE, &gem_close); + if (ret) + ALOGE("Failed to close gem handle %d %d", i, ret); + else + bo->gem_handles[i] = 0; + } + return 0; +} + +#ifdef USE_HISI_IMPORTER +std::unique_ptr Planner::CreateInstance(DrmResources *) { + std::unique_ptr planner(new Planner); + planner->AddStage(); + return planner; +} +#endif + +} + + diff --git a/platformhisi.h b/platformhisi.h new file mode 100644 index 0000000..f7a7d8c --- /dev/null +++ b/platformhisi.h @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2015 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ANDROID_PLATFORM_HISI_H_ +#define ANDROID_PLATFORM_HISI_H_ + +#include "drmresources.h" +#include "platform.h" +#include "platformdrmgeneric.h" + +#include + +#include + +namespace android { + +class HisiImporter : public Importer { + public: + HisiImporter(DrmResources *drm); + ~HisiImporter() override; + + int Init(); + + EGLImageKHR ImportImage(EGLDisplay egl_display, buffer_handle_t handle) override; + int ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) override; + int ReleaseBuffer(hwc_drm_bo_t *bo) override; + + private: + uint32_t ConvertHalFormatToDrm(uint32_t hal_format); + + DrmResources *drm_; + + const gralloc_module_t *gralloc_; +}; +} + +#endif From patchwork Tue Jan 23 23:16:38 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 125605 Delivered-To: patches@linaro.org Received: by 10.46.66.141 with SMTP id h13csp50450ljf; Tue, 23 Jan 2018 15:16:53 -0800 (PST) X-Received: by 2002:a17:902:7e0c:: with SMTP id b12-v6mr6297113plm.308.1516749413226; Tue, 23 Jan 2018 15:16:53 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516749413; cv=none; d=google.com; s=arc-20160816; b=hHAtQCaNNhwbD+pQnUHm8bJC01j07WW3Yejb/a4RY4iVcFVr3X1mSjdqIVTV40uQNu PU9G5oZvmTk20eaPrGqdhtix96fPI8ih+t3XhjrAcLaqJ74yjixOKnVt+ZGkECBbcTSO R8m8psGXOsiTttIlMxrSZmMR07CP552GhRGYpKBA6nLGCwVhbRRmc+xluQTGTmDJ0Yhx pz/p4VUdX8l3d+nn8ZB+5dGJH97IknIcHPBQO95SF+vaoRHXjtF+IoYfyYVSjc0mpRKa jP++qtsu+JTrMqb5XrmOBRSNnrKQKM8F20Di02hApUIde9zMQYdkdZSeFNyulte0CHMx n7Zw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature:arc-authentication-results; bh=pTWYiRkH2mM0CNy2+RkIp5kty9IjdWlQq0uGmTTU4Fs=; b=rXc6IF4xQOdKLHP3QGe6mN/3UCWx9vq9wRQ6z26XQbVz9r/j0hd+ksfpox5bJyCBQv HZWcQLGOUfd9CsU+hOe1LpPv9lAtiqRVeGUk9py30fZj8HtcjL065s3y+2IXJtjbgiXz iQKFvzDIfT5fQOt+D48w47LfuFU0Yv5tc0iqQ0JBEX5zqPcPLQeLyj0K2jl73nV2aNHg vSZU2xrSPuHPT0lQSrpxZaGrIPo3jron6jcwKKcGQsrU7ic6CD210eLVIdydZ2wGHFji MvuUT+bwoewheYRiSoE4D3QkicjpIYPwRmDHqbwK4DepnpDD219IOe1fNRsDGFPnjpyz tEOA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=KyZQAL0o; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f65.google.com (mail-sor-f65.google.com. [209.85.220.65]) by mx.google.com with SMTPS id 68sor972337pfp.94.2018.01.23.15.16.53 for (Google Transport Security); Tue, 23 Jan 2018 15:16:53 -0800 (PST) Received-SPF: pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) client-ip=209.85.220.65; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=KyZQAL0o; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=pTWYiRkH2mM0CNy2+RkIp5kty9IjdWlQq0uGmTTU4Fs=; b=KyZQAL0oHqQR1y91fmTddUk3lfIyW437sxG4kEoT5m4ndFN73m6NRvWXqTfv4hibbo ks/bH3OOtFRtU4pTkUot23FykKiUin+ZZ3wbotTDC0VkueAw5SeeAy2/D0JISJ60ofsE w7dbROHQhUJ0zXhAmR7MFUax76vbw7lsG882I= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=pTWYiRkH2mM0CNy2+RkIp5kty9IjdWlQq0uGmTTU4Fs=; b=k5xwjk/fJct1NCbY+B19yUSH/swXZovx0A/tDa1EYRukfrTTHHSyvhUuwE72FkfKID uCcVWBFMq77+iAlh23CnCyIyfrxBtEv59pANQu9MtR310ZKFErhyuQyfesUiuTB7CwDQ ui0EcGoNzxsatWj43Jj/oYTPa0pIgnzxHbDJ8uixbRZ1MrQ1SRlQNFrGn4A2SuU8ZvTP w/QpKqlc8QahRM9vVU6gtWr1lmFNy7vVS4R2jjZ4esO+d5aNT6b4KE84uOWdL4PY7KlC Yq1pzH3R9L9LCE5HIH9eZNyapUzQMnNLBZLzi5dbXsJlCxm1M3GSSA6fpP7umBS1t3RI QFMw== X-Gm-Message-State: AKwxytf7R48UOFn18x7IPAAb3ONlRFcyvlr6Do2P0gqc1jS3AdjSAGAQ ZwTnIlqRyySUqKt06e4I/qUGvz2J X-Google-Smtp-Source: AH8x227Fg8stBSrlfMjwrZN0c4bSkhNtZ1FkB1GQF72GU3sImvkVkQIHH+Z1/0kVRM9OD35B0XIMMw== X-Received: by 10.98.141.199 with SMTP id p68mr10810151pfk.25.1516749412757; Tue, 23 Jan 2018 15:16:52 -0800 (PST) Return-Path: Received: from localhost.localdomain ([2601:1c2:600:5100:4e72:b9ff:fe99:466a]) by smtp.gmail.com with ESMTPSA id c83sm6924811pfk.8.2018.01.23.15.16.51 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Tue, 23 Jan 2018 15:16:51 -0800 (PST) From: John Stultz To: dri-devel@lists.freedesktop.org Cc: John Stultz , Marissa Wall , Sean Paul , Dmitry Shmidt , Robert Foss , Matt Szczesiak , Liviu Dudau , David Hanna , Rob Herring Subject: [RFC][PATCH 3/4 v2] drm_hwcomposer: Use client compositing if there is only one plane Date: Tue, 23 Jan 2018 15:16:38 -0800 Message-Id: <1516749399-29504-4-git-send-email-john.stultz@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516749399-29504-1-git-send-email-john.stultz@linaro.org> References: <1516749399-29504-1-git-send-email-john.stultz@linaro.org> Originally based on work by Rob Herring, this patch changes ValidateDisplay() so that if there is only one plane, we modify Device composited layers to be Client composited. Without this, on devices with just one plane, nothing gets displayed on the screen. Suggestions for alternative solutions here would be greatly appreciated! Cc: Marissa Wall Cc: Sean Paul Cc: Dmitry Shmidt Cc: Robert Foss Cc: Matt Szczesiak Cc: Liviu Dudau Cc: David Hanna Cc: Rob Herring Signed-off-by: John Stultz --- v2: * Rework Rob's change to check planes --- drmhwctwo.cpp | 7 +++++++ 1 file changed, 7 insertions(+) -- 2.7.4 diff --git a/drmhwctwo.cpp b/drmhwctwo.cpp index dfca1a6..6d88c5c 100644 --- a/drmhwctwo.cpp +++ b/drmhwctwo.cpp @@ -695,6 +695,13 @@ HWC2::Error DrmHwcTwo::HwcDisplay::ValidateDisplay(uint32_t *num_types, layer.set_validated_type(HWC2::Composition::Client); ++*num_types; break; + case HWC2::Composition::Device: + /* If we only have one plane, always do Client composition */ + if (primary_planes_.size() + overlay_planes_.size() == 1) { + layer.set_validated_type(HWC2::Composition::Client); + ++*num_types; + break; + } default: layer.set_validated_type(layer.sf_type()); break; From patchwork Tue Jan 23 23:16:39 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 125606 Delivered-To: patches@linaro.org Received: by 10.46.66.141 with SMTP id h13csp50468ljf; Tue, 23 Jan 2018 15:16:55 -0800 (PST) X-Received: by 10.99.168.76 with SMTP id i12mr9589542pgp.119.1516749414944; Tue, 23 Jan 2018 15:16:54 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516749414; cv=none; d=google.com; s=arc-20160816; b=Njr6zEsCHl8GebZpT6jOkFP8gtdlku/wCEopu5pHfQEOQWaUCHpRmtJH3Hi8O6UTbi 8hZxRqxmP6dmt1u+w6+FEwuCjETy/ofPYpIDVKhRXcI+jhRjb3hMx9AOstC/L6EMrWnk TkbUb/yCenOB9GpsMajctNyX+QBfRtRFaPFD51ak1Cerqrm8TAvjCW2hwvLnyZwuHkGy ztuoboC3eQcr0MqyFGHWnYrXimbgVvs0BbJ7k8wU9o6VrVzGsSIjLaTNqQ1kTe1F10tB 2T5RdWYgeX+t8tgT1+TcnvCGx1VG7wh2I3XUrqpFZDSu0jdUdfJeJ2rP0t+HD3OfhUcp xU5A== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature:arc-authentication-results; bh=J3LvMpp+h6c2Vc1dAzfPT6lPUBTmMkcnAIuR4haQupY=; b=bboZd/uf+YUojP6DjqbiyDJ0lRTEgHYwqWd1ZhpPm6+Ieefeidr7VRB3nKw38L2/8Y 1UZCiAgX7hpr8d/4EAaOT4hkCylZ0G82BqUqLApgclAP/b36pMH7NTNtcRtdy1IZbVPT FA3Wtnzqnto5G6QmaarcB1gnQnO6VxGXarDdjY6XzfMYgz4zpV/OR/Ue7HOw+wVCR/lq DF016DopqMgwJ11httPl++C3wphOZYTAnrlcdph94rMTDiHU18PHEjwoDKDg/dRta03b wN4hEYEI6/936ExT8jaM5EIwAX1h2qwAFalmtFk+EcjpWzgjxlvIEWLUQoeAkfwdgHXs R3hQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=kDdyTQhf; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f65.google.com (mail-sor-f65.google.com. [209.85.220.65]) by mx.google.com with SMTPS id b96-v6sor361921pli.126.2018.01.23.15.16.54 for (Google Transport Security); Tue, 23 Jan 2018 15:16:54 -0800 (PST) Received-SPF: pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) client-ip=209.85.220.65; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=kDdyTQhf; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=J3LvMpp+h6c2Vc1dAzfPT6lPUBTmMkcnAIuR4haQupY=; b=kDdyTQhfxXgTdRaVcMGkv146SbChTjKvmh+YOHa9r1ynohixTkUXKQ03hpRUPwXalP lNb6ewzOS24QGWxA1vTd9s1sWUMpzbEmdn1kAsxfN6TdgeED1/bDGptXpuT3J5Q/wNKS GdevWV0NTcOtcyXzMpk1FwjgiRPsH/rIBEMDE= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=J3LvMpp+h6c2Vc1dAzfPT6lPUBTmMkcnAIuR4haQupY=; b=VSaYLKyqpO/ehTEpDv/ljDo0FJ5AKJ1xarPfsNW4VbpHzKyMXGMsTburrWkJU8YA7/ W6/UQ5/x5JRjczNRoimg5MIzm8osnSDq/fmmLriEta75Cbc01AA4yrpOre6GIxeMzVqS q6vdOa6xjE1qUCpXhbX6YBjpvWVzIqnn/XzNx4dHW0RaBMH2mo4FaMZgnGRzNwit0UQ8 loBUn+KWgFyAEufemww9FK7RiaeorRQ/RVSzzIX7cY17IpAG3/CAzIIV76DyQUUG5Qak DFFE456K5q88KbByZR+OwQwYjR5OyN2r3DdcaDIvlDfDwKATSZTTO6wwr0/hSSl6Ewwd +VSQ== X-Gm-Message-State: AKwxytfH8slPhYWASeCH1mnNEDA0t1lsCbKsLVxOA12hc7OBtxK50Cxn iFP29EKKx+cnBstjoFQ75u5jp2Z0 X-Google-Smtp-Source: AH8x2263INX9IS5Gep1Z0OrnuM7qLU6gELsDpII86+1kKSzuzy2yMFN/C+olsF9fO6etnLDRAnOYDg== X-Received: by 2002:a17:902:5a0b:: with SMTP id q11-v6mr6404295pli.207.1516749414490; Tue, 23 Jan 2018 15:16:54 -0800 (PST) Return-Path: Received: from localhost.localdomain ([2601:1c2:600:5100:4e72:b9ff:fe99:466a]) by smtp.gmail.com with ESMTPSA id c83sm6924811pfk.8.2018.01.23.15.16.52 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Tue, 23 Jan 2018 15:16:53 -0800 (PST) From: John Stultz To: dri-devel@lists.freedesktop.org Cc: John Stultz , Marissa Wall , Sean Paul , Dmitry Shmidt , Robert Foss , Matt Szczesiak , Liviu Dudau , David Hanna , Rob Herring Subject: [RFC][PATCH 4/4 v2] drm_hwcomposer: Try to fallback if GLCompisition fails Date: Tue, 23 Jan 2018 15:16:39 -0800 Message-Id: <1516749399-29504-5-git-send-email-john.stultz@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516749399-29504-1-git-send-email-john.stultz@linaro.org> References: <1516749399-29504-1-git-send-email-john.stultz@linaro.org> When using drm_hwcomposer with the hikey board, the resulting display shows lots of tearing. This seems to be due to EGLcomposition not initializing properly, potentially due to I'm guessing limitations of what the utgard mali driver can do. I've noted that with the HiKey960 board, this patch is *not* necessary. Hacking around a bit, I found that since the glworker code isn't running properly, we never call glFinish(), which is required to fix the tearing. Ideas for a better way to implement this would be greatly appreciated! Cc: Marissa Wall Cc: Sean Paul Cc: Dmitry Shmidt Cc: Robert Foss Cc: Matt Szczesiak Cc: Liviu Dudau Cc: David Hanna Cc: Rob Herring Signed-off-by: John Stultz --- v2: * Simplified, focusing on the key glFinsh() call --- drmdisplaycompositor.cpp | 4 ++++ 1 file changed, 4 insertions(+) -- 2.7.4 diff --git a/drmdisplaycompositor.cpp b/drmdisplaycompositor.cpp index 3a20b31..eb0b77a 100644 --- a/drmdisplaycompositor.cpp +++ b/drmdisplaycompositor.cpp @@ -439,6 +439,10 @@ int DrmDisplayCompositor::PrepareFrame(DrmDisplayComposition *display_comp) { fb.set_release_fence_fd(ret); ret = 0; + } else { + /*If we're not doing anything, block to avoid tearing */ + glFinish(); + return 0; } }