From patchwork Mon Jan 18 07:48:29 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Marek Szyprowski X-Patchwork-Id: 8053231 Return-Path: X-Original-To: patchwork-linux-samsung-soc@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork1.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.136]) by patchwork1.web.kernel.org (Postfix) with ESMTP id 748219F818 for ; Mon, 18 Jan 2016 07:49:05 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 02EE820268 for ; Mon, 18 Jan 2016 07:49:03 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 1501E20263 for ; Mon, 18 Jan 2016 07:49:00 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753822AbcARHs5 (ORCPT ); Mon, 18 Jan 2016 02:48:57 -0500 Received: from mailout3.w1.samsung.com ([210.118.77.13]:15651 "EHLO mailout3.w1.samsung.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753778AbcARHs4 (ORCPT ); Mon, 18 Jan 2016 02:48:56 -0500 MIME-version: 1.0 Content-type: text/plain; charset=UTF-8 Received: from eucpsbgm2.samsung.com (unknown [203.254.199.245]) by mailout3.w1.samsung.com (Oracle Communications Messaging Server 7.0.5.31.0 64bit (built May 5 2014)) with ESMTP id <0O1500I5U1PHM160@mailout3.w1.samsung.com> for linux-samsung-soc@vger.kernel.org; Mon, 18 Jan 2016 07:48:53 +0000 (GMT) X-AuditID: cbfec7f5-f79b16d000005389-ea-569c98e5fe63 Received: from eusync4.samsung.com ( [203.254.199.214]) by eucpsbgm2.samsung.com (EUCPMTA) with SMTP id 0C.2A.21385.5E89C965; Mon, 18 Jan 2016 07:48:53 +0000 (GMT) Content-transfer-encoding: 8BIT Received: from amdc1339.digital.local ([106.116.147.30]) by eusync4.samsung.com (Oracle Communications Messaging Server 7.0.5.31.0 64bit (built May 5 2014)) with ESMTPA id <0O1500KY91PBE100@eusync4.samsung.com>; Mon, 18 Jan 2016 07:48:53 +0000 (GMT) From: Marek Szyprowski To: dri-devel@lists.freedesktop.org, linux-samsung-soc@vger.kernel.org Cc: Marek Szyprowski , Inki Dae , Daniel Vetter , =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , Joonyoung Shim , Seung-Woo Kim , Andrzej Hajda , Krzysztof Kozlowski , Bartlomiej Zolnierkiewicz , Tobias Jakobi , Gustavo Padovan , Benjamin Gaignard , vincent.abriou@st.com, fabien.dessenne@st.com Subject: [PATCH v4 1/3] drm: add generic zpos property Date: Mon, 18 Jan 2016 08:48:29 +0100 Message-id: <1453103311-14415-2-git-send-email-m.szyprowski@samsung.com> X-Mailer: git-send-email 1.9.2 In-reply-to: <1453103311-14415-1-git-send-email-m.szyprowski@samsung.com> References: <1453103311-14415-1-git-send-email-m.szyprowski@samsung.com> X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFprJIsWRmVeSWpSXmKPExsVy+t/xa7pPZ8wJM/i3Qc/i1rpzrBYbZ6xn tWg6dIrN4v+2icwWV76+Z7M4tm47o8XOB7vYLSbdn8Bi8eLeRRaL1y8MLWac38dksfbIXXaL GZNfslm0rf7AavH930ImizNXD7A4CHjs/baAxePOtT1sHvNOBnrc7z7O5PHvGLvHzkl7mTz6 tqxi9Hj6Yy+zx+dNcgGcUVw2Kak5mWWpRfp2CVwZB9e8Zi64lVNx9W0ncwPj/MguRk4OCQET ieXXVjBD2GISF+6tZ+ti5OIQEljKKLG/fx8rSIJXQFDix+R7LF2MHBzMAvISRy5lg4SZBdQl Js1bxAxR38QkcWrWcrBBbAKGEl1vu9hAbBEBN4mmwzNZQYqYBe6zSFz9fIAdJCEsYCbxYP0Z MJtFQFViwblf7BDLPCT2rW1ihLhITuL/yxVMIDangKdE8+/5LCC2EFDNvOf/2SYwCsxCct8s hPtmIblvASPzKkbR1NLkguKk9FwjveLE3OLSvHS95PzcTYyQCPu6g3HpMatDjAIcjEo8vA5n Z4cJsSaWFVfmHmKU4GBWEuHlnTwnTIg3JbGyKrUoP76oNCe1+BCjNAeLkjjvzF3vQ4QE0hNL UrNTUwtSi2CyTBycUg2MHW0am5Y21Xz5/FTcr6zxRk077zHpk8GJ9UfzVi3l9FRcN81Uwygn OqhOTdwuVDxTinUGyzyLqg9XnkokfZml+cd0zcLtjwWv/VgZ3rb183uTHLMon0buxAC9t/Yz Yla8buL8ysf2Y+O7I+lhtmsfLkySlIvTcvb1N17+4SOXkVqGqV9mCYMSS3FGoqEWc1FxIgBf M4vZrAIAAA== Sender: linux-samsung-soc-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-samsung-soc@vger.kernel.org X-Spam-Status: No, score=-6.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_HI, 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 This patch adds support for generic plane's zpos property property with well-defined semantics: - added zpos properties to drm core and plane state structures - added helpers for normalizing zpos properties of given set of planes - well defined semantics: planes are sorted by zpos values and then plane id value if zpos equals Normalized zpos values are calculated automatically when generic muttable zpos property has been initialized. Drivers can simply use plane_state->normalized_zpos in their atomic_check and/or plane_update callbacks without any additional calls to DRM core. Signed-off-by: Marek Szyprowski Tested-by: Benjamin Gaignard --- Documentation/DocBook/gpu.tmpl | 14 ++++- drivers/gpu/drm/drm_atomic.c | 4 ++ drivers/gpu/drm/drm_atomic_helper.c | 118 ++++++++++++++++++++++++++++++++++++ drivers/gpu/drm/drm_crtc.c | 67 ++++++++++++++++++++ include/drm/drm_crtc.h | 17 ++++++ 5 files changed, 218 insertions(+), 2 deletions(-) diff --git a/Documentation/DocBook/gpu.tmpl b/Documentation/DocBook/gpu.tmpl index 6c6e81a9eaf4..183de4a5f4db 100644 --- a/Documentation/DocBook/gpu.tmpl +++ b/Documentation/DocBook/gpu.tmpl @@ -2004,7 +2004,7 @@ void intel_crt_init(struct drm_device *dev) Description/Restrictions - DRM + DRM Generic “rotation” BITMASK @@ -2256,7 +2256,7 @@ void intel_crt_init(struct drm_device *dev) property to suggest an Y offset for a connector - Optional + Optional “scaling mode” ENUM { "None", "Full", "Center", "Full aspect" } @@ -2280,6 +2280,16 @@ void intel_crt_init(struct drm_device *dev) TBD + "zpos" + RANGE + Min=0, Max= driver dependent + Plane + Plane's 'z' position during blending operation (0 for background, highest for frontmost). + If two planes assigned to same CRTC have equal zpos values, the plane with higher plane + id is treated as closer to front. Can be IMMUTABLE if driver doesn't support changing + planes' order. Exact value range is driver dependent. + + i915 Generic "Broadcast RGB" diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c index 6a21e5c378c1..97bb069cb6a3 100644 --- a/drivers/gpu/drm/drm_atomic.c +++ b/drivers/gpu/drm/drm_atomic.c @@ -614,6 +614,8 @@ int drm_atomic_plane_set_property(struct drm_plane *plane, state->src_h = val; } else if (property == config->rotation_property) { state->rotation = val; + } else if (property == config->zpos_property) { + state->zpos = val; } else if (plane->funcs->atomic_set_property) { return plane->funcs->atomic_set_property(plane, state, property, val); @@ -670,6 +672,8 @@ drm_atomic_plane_get_property(struct drm_plane *plane, *val = state->src_h; } else if (property == config->rotation_property) { *val = state->rotation; + } else if (property == config->zpos_property) { + *val = state->zpos; } else if (plane->funcs->atomic_get_property) { return plane->funcs->atomic_get_property(plane, state, property, val); } else { diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c index d0d4b2ff7c21..be84b3785de2 100644 --- a/drivers/gpu/drm/drm_atomic_helper.c +++ b/drivers/gpu/drm/drm_atomic_helper.c @@ -31,6 +31,7 @@ #include #include #include +#include /** * DOC: overview @@ -507,6 +508,119 @@ drm_atomic_helper_check_modeset(struct drm_device *dev, } EXPORT_SYMBOL(drm_atomic_helper_check_modeset); +static int drm_atomic_state_zpos_cmp(const void *a, const void *b) +{ + const struct drm_plane_state *sa = *(struct drm_plane_state **)a; + const struct drm_plane_state *sb = *(struct drm_plane_state **)b; + int zpos_a = (sa->zpos << 16) + sa->plane->base.id; + int zpos_b = (sb->zpos << 16) + sb->plane->base.id; + + return zpos_a - zpos_b; +} + +/** + * drm_atomic_helper_crtc_normalize_zpos - calculate normalized zpos values + * @crtc: crtc with planes, which have to be considered for normalization + * @crtc_state: new atomic state to apply + * + * This function checks new states of all planes assigned to given crtc and + * calculates normalized zpos value for them. Planes are compared first by their + * zpos values, then by plane id (if zpos equals). Plane with lowest zpos value + * is at the bottom. The plane_state->normalized_zpos is then filled with uniqe + * values from 0 to number of active planes in crtc minus one. + * + * RETURNS + * Zero for success or -errno + */ +int drm_atomic_helper_crtc_normalize_zpos(struct drm_crtc *crtc, + struct drm_crtc_state *crtc_state) +{ + struct drm_atomic_state *state = crtc_state->state; + struct drm_device *dev = crtc->dev; + int total_planes = dev->mode_config.num_total_plane; + struct drm_plane_state **states; + struct drm_plane *plane; + int i, n = 0; + int ret = 0; + + DRM_DEBUG_ATOMIC("[CRTC:%d:%s] calculating normalized zpos values\n", + crtc->base.id, crtc->name); + + states = kmalloc(total_planes * sizeof(*states), GFP_KERNEL); + if (!states) + return -ENOMEM; + + /* + * Normalization process might create new states for planes which + * normalized_zpos has to be recalculated. + */ + drm_for_each_plane_mask(plane, dev, crtc_state->plane_mask) { + struct drm_plane_state *plane_state = + drm_atomic_get_plane_state(state, plane); + if (IS_ERR(plane_state)) { + ret = PTR_ERR(plane_state); + goto fail; + } + states[n++] = plane_state; + DRM_DEBUG_ATOMIC("[PLANE:%d:%s] processing zpos value %d\n", + plane->base.id, plane->name, plane_state->zpos); + } + + sort(states, n, sizeof(*states), drm_atomic_state_zpos_cmp, NULL); + + for (i = 0; i < n; i++) { + plane = states[i]->plane; + states[i]->normalized_zpos = i; + DRM_DEBUG_ATOMIC("[PLANE:%d:%s] normalized zpos value %d\n", + plane->base.id, plane->name, i); + } + crtc_state->zpos_changed = true; + +fail: + kfree(states); + return ret; +} +EXPORT_SYMBOL(drm_atomic_helper_crtc_normalize_zpos); + +static int drm_atomic_helper_normalize_zpos(struct drm_device *dev, + struct drm_atomic_state *state) +{ + struct drm_crtc *crtc; + struct drm_crtc_state *crtc_state; + struct drm_plane *plane; + struct drm_plane_state *plane_state; + int i, ret = 0; + + /* + * If zpos_property is not initialized, then it makes no sense + * to calculate normalized zpos values. + */ + if (!dev->mode_config.zpos_property) + return 0; + + for_each_plane_in_state(state, plane, plane_state, i) { + crtc = plane_state->crtc; + if (!crtc) + continue; + if (plane->state->zpos != plane_state->zpos) { + crtc_state = + drm_atomic_get_existing_crtc_state(state, crtc); + crtc_state->zpos_changed = true; + } + } + + for_each_crtc_in_state(state, crtc, crtc_state, i) { + if (crtc_state->plane_mask != crtc->state->plane_mask || + crtc_state->zpos_changed) { + ret = drm_atomic_helper_crtc_normalize_zpos(crtc, + crtc_state); + if (ret) + return ret; + } + } + return 0; +} + /** * drm_atomic_helper_check_planes - validate state object for planes changes * @dev: DRM device @@ -532,6 +646,10 @@ drm_atomic_helper_check_planes(struct drm_device *dev, struct drm_plane_state *plane_state; int i, ret = 0; + ret = drm_atomic_helper_normalize_zpos(dev, state); + if (ret) + return ret; + for_each_plane_in_state(state, plane, plane_state, i) { const struct drm_plane_helper_funcs *funcs; diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c index 62fa95fa5471..c6f7238cdab3 100644 --- a/drivers/gpu/drm/drm_crtc.c +++ b/drivers/gpu/drm/drm_crtc.c @@ -5880,6 +5880,73 @@ struct drm_property *drm_mode_create_rotation_property(struct drm_device *dev, EXPORT_SYMBOL(drm_mode_create_rotation_property); /** + * drm_mode_create_zpos_property - create muttable zpos property + * @dev: DRM device + * @min: minimal possible value of zpos property + * @max: maximal possible value of zpos property + * + * This function initializes generic muttable zpos property and enables support + * for it in drm core. Drivers can then attach this property to planes to enable + * support for configurable planes arrangement during blending operation. + * Once muttable zpos property has been enabled, the DRM core will automatically + * calculate drm_plane_state->normalized_zpos values. Usually min should be set + * to 0 and max to maximal number of planes for given crtc - 1. + * + * If zpos of some planes cannot be changed (like fixed backgroud or + * cursor/topmost planes), driver should adjust min/max values and assign those + * planes immutable zpos property with lower or higher values (for more + * information, see drm_mode_create_zpos_immutable_property() function). In such + * case driver should also assign proper initial zpos values for all planes in + * its plane_reset() callback, so the planes will be always sorted properly. + * + * Returns: + * Zero on success, negative errno on failure. + */ +int drm_mode_create_zpos_property(struct drm_device *dev, unsigned int min, + unsigned int max) +{ + struct drm_property *prop; + + prop = drm_property_create_range(dev, 0, "zpos", min, max); + if (!prop) + return -ENOMEM; + + dev->mode_config.zpos_property = prop; + return 0; +} +EXPORT_SYMBOL(drm_mode_create_zpos_property); + +/** + * drm_mode_create_zpos_immutable_property - create immuttable zpos property + * @dev: DRM device + * @min: minimal possible value of zpos property + * @max: maximal possible value of zpos property + * + * This function initializes generic immuttable zpos property and enables + * support for it in drm core. Using this property driver lets userspace + * to get the arrangement of the planes for blending operation and notifies + * it that the hardware (or driver) doesn't support changing of the planes' + * order. + * + * Returns: + * Zero on success, negative errno on failure. + */ +int drm_mode_create_zpos_immutable_property(struct drm_device *dev, + unsigned int min, unsigned int max) +{ + struct drm_property *prop; + + prop = drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "zpos", + min, max); + if (!prop) + return -ENOMEM; + + dev->mode_config.zpos_immutable_property = prop; + return 0; +} +EXPORT_SYMBOL(drm_mode_create_zpos_immutable_property); + +/** * DOC: Tile group * * Tile groups are used to represent tiled monitors with a unique diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h index 3b040b355472..f53cdda1167b 100644 --- a/include/drm/drm_crtc.h +++ b/include/drm/drm_crtc.h @@ -305,6 +305,7 @@ struct drm_plane_helper_funcs; * @mode_changed: crtc_state->mode or crtc_state->enable has been changed * @active_changed: crtc_state->active has been toggled. * @connectors_changed: connectors to this crtc have been updated + * @zpos_changed: zpos values of planes on this crtc have been updated * @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes * @last_vblank_count: for helpers and drivers to capture the vblank of the * update to ensure framebuffer cleanup isn't done too early @@ -331,6 +332,7 @@ struct drm_crtc_state { bool mode_changed : 1; bool active_changed : 1; bool connectors_changed : 1; + bool zpos_changed : 1; /* attached planes bitmask: * WARNING: transitional helpers do not maintain plane_mask so @@ -1243,6 +1245,9 @@ struct drm_connector { * plane (in 16.16) * @src_w: width of visible portion of plane (in 16.16) * @src_h: height of visible portion of plane (in 16.16) + * @zpos: priority of the given plane on crtc (optional) + * @normalized_zpos: normalized value of zpos: uniqe, range from 0 to + * (number of planes - 1) for given crtc * @state: backpointer to global drm_atomic_state */ struct drm_plane_state { @@ -1263,6 +1268,10 @@ struct drm_plane_state { /* Plane rotation */ unsigned int rotation; + /* Plane zpos */ + unsigned int zpos; + unsigned int normalized_zpos; + struct drm_atomic_state *state; }; @@ -2083,6 +2092,8 @@ struct drm_mode_config { struct drm_property *tile_property; struct drm_property *plane_type_property; struct drm_property *rotation_property; + struct drm_property *zpos_property; + struct drm_property *zpos_immutable_property; struct drm_property *prop_src_x; struct drm_property *prop_src_y; struct drm_property *prop_src_w; @@ -2484,6 +2495,12 @@ extern struct drm_property *drm_mode_create_rotation_property(struct drm_device extern unsigned int drm_rotation_simplify(unsigned int rotation, unsigned int supported_rotations); +extern int drm_mode_create_zpos_property(struct drm_device *dev, + unsigned int min, unsigned int max); +extern int drm_mode_create_zpos_immutable_property(struct drm_device *dev, + unsigned int min, + unsigned int max); + /* Helpers */ static inline struct drm_plane *drm_plane_find(struct drm_device *dev,