From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755915AbcGZHrG (ORCPT ); Tue, 26 Jul 2016 03:47:06 -0400 Received: from regular1.263xmail.com ([211.150.99.137]:39343 "EHLO regular1.263xmail.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755886AbcGZHrC (ORCPT ); Tue, 26 Jul 2016 03:47:02 -0400 X-263anti-spam: KSV:0; X-MAIL-GRAY: 0 X-MAIL-DELIVERY: 1 X-KSVirus-check: 0 X-ABS-CHECKED: 4 X-ADDR-CHECKED: 0 X-RL-SENDER: mark.yao@rock-chips.com X-FST-TO: airlied@linux.ie X-SENDER-IP: 58.22.7.114 X-LOGIN-NAME: mark.yao@rock-chips.com X-UNIQUE-TAG: <460ee7f7e956ac273257b88f4bed667a> X-ATTACHMENT-NUM: 0 X-DNS-TYPE: 0 From: Mark Yao To: David Airlie , Heiko Stuebner , dri-devel@lists.freedesktop.org, linux-arm-kernel@lists.infradead.org, linux-rockchip@lists.infradead.org, linux-kernel@vger.kernel.org Cc: Mark Yao Subject: [PATCH 1/3] drm: introduce share plane Date: Tue, 26 Jul 2016 15:46:32 +0800 Message-Id: <1469519194-23133-1-git-send-email-mark.yao@rock-chips.com> X-Mailer: git-send-email 1.9.1 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org What is share plane: Plane hardware only be used when the display scanout run into plane active scanout, that means we can reuse the plane hardware resources on plane non-active scanout. -------------------------------------------------- | scanout | | ------------------ | | | parent plane | | | | active scanout | | | | | ----------------- | | ------------------ | share plane 1 | | | ----------------- |active scanout | | | | share plane 0 | | | | | |active scanout | ----------------- | | | | | | ----------------- | -------------------------------------------------- One plane hardware can be reuse for multi-planes, we assume the first plane is parent plane, other planes share the resource with first one. parent plane |---share plane 0 |---share plane 1 ... Because resource share, There are some limit on share plane: one group of share planes need use same zpos, can not overlap, etc. We assume share plane is a universal plane with some limit flags. people who use the share plane need know the limit, should call the ioctl DRM_CLIENT_CAP_SHARE_PLANES, and judge the planes limit before use it. A group of share planes would has same shard id, so userspace can group them, judge share plane's limit. Signed-off-by: Mark Yao --- drivers/gpu/drm/drm_crtc.c | 110 ++++++++++++++++++++++++++++++++++++++++++++ drivers/gpu/drm/drm_ioctl.c | 5 ++ include/drm/drmP.h | 5 ++ include/drm/drm_crtc.h | 14 ++++++ include/uapi/drm/drm.h | 7 +++ 5 files changed, 141 insertions(+) diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c index 9d3f80e..3a8257e 100644 --- a/drivers/gpu/drm/drm_crtc.c +++ b/drivers/gpu/drm/drm_crtc.c @@ -1426,6 +1426,96 @@ int drm_plane_init(struct drm_device *dev, struct drm_plane *plane, EXPORT_SYMBOL(drm_plane_init); /** + * drm_share_plane_init - Initialize a share plane + * @dev: DRM device + * @plane: plane object to init + * @parent: this plane share some resources with parent plane. + * @possible_crtcs: bitmask of possible CRTCs + * @funcs: callbacks for the new plane + * @formats: array of supported formats (%DRM_FORMAT_*) + * @format_count: number of elements in @formats + * @type: type of plane (overlay, primary, cursor) + * + * With this API, the plane can share hardware resources with other planes. + * + * -------------------------------------------------- + * | scanout | + * | ------------------ | + * | | parent plane | | + * | | active scanout | | + * | | | ----------------- | + * | ------------------ | share plane 1 | | + * | ----------------- |active scanout | | + * | | share plane 0 | | | | + * | |active scanout | ----------------- | + * | | | | + * | ----------------- | + * -------------------------------------------------- + * + * parent plane + * |---share plane 0 + * |---share plane 1 + * ... + * + * The plane hardware is used when the display scanout run into plane active + * scanout, that means we can reuse the plane hardware resources on plane + * non-active scanout. + * + * Because resource share, There are some limit on share plane: one group + * of share planes need use same zpos, can't not overlap, etc. + * + * Here assume share plane is a universal plane with some limit flags. + * people who use the share plane need know the limit, should call the ioctl + * DRM_CLIENT_CAP_SHARE_PLANES, and judge the planes limit before use it. + * + * Returns: + * Zero on success, error code on failure. + */ + +int drm_share_plane_init(struct drm_device *dev, struct drm_plane *plane, + struct drm_plane *parent, + unsigned long possible_crtcs, + const struct drm_plane_funcs *funcs, + const uint32_t *formats, unsigned int format_count, + enum drm_plane_type type) +{ + struct drm_mode_config *config = &dev->mode_config; + int ret; + int share_id; + + /* + * TODO: only verified on ATOMIC drm driver. + */ + if (!drm_core_check_feature(dev, DRIVER_ATOMIC)) + return -EINVAL; + + ret = drm_universal_plane_init(dev, plane, possible_crtcs, funcs, + formats, format_count, type, NULL); + if (ret) + return ret; + + if (parent) { + /* + * Can't support more than two level plane share. + */ + WARN_ON(parent->parent); + share_id = parent->base.id; + plane->parent = parent; + + config->num_share_plane++; + if (plane->type == DRM_PLANE_TYPE_OVERLAY) + config->num_share_overlay_plane++; + } else { + share_id = plane->base.id; + } + + drm_object_attach_property(&plane->base, + config->prop_share_id, share_id); + return 0; +} +EXPORT_SYMBOL(drm_share_plane_init); + +/** * drm_plane_cleanup - Clean up the core plane usage * @plane: plane to cleanup * @@ -1452,6 +1542,11 @@ void drm_plane_cleanup(struct drm_plane *plane) dev->mode_config.num_total_plane--; if (plane->type == DRM_PLANE_TYPE_OVERLAY) dev->mode_config.num_overlay_plane--; + if (plane->parent) { + dev->mode_config.num_share_plane--; + if (plane->type == DRM_PLANE_TYPE_OVERLAY) + dev->mode_config.num_share_overlay_plane--; + } drm_modeset_unlock_all(dev); WARN_ON(plane->state && !plane->funcs->atomic_destroy_state); @@ -1600,6 +1695,13 @@ static int drm_mode_create_standard_properties(struct drm_device *dev) return -ENOMEM; dev->mode_config.plane_type_property = prop; + prop = drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, + "SHARE_ID", 0, UINT_MAX); + if (!prop) + return -ENOMEM; + + dev->mode_config.prop_share_id = prop; + prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, "SRC_X", 0, UINT_MAX); if (!prop) @@ -2431,6 +2533,12 @@ int drm_mode_getplane_res(struct drm_device *dev, void *data, num_planes = config->num_total_plane; else num_planes = config->num_overlay_plane; + if (!file_priv->share_planes) { + if (file_priv->universal_planes) + num_planes -= config->num_share_plane; + else + num_planes -= config->num_share_overlay_plane; + } /* * This ioctl is called twice, once to determine how much space is @@ -2449,6 +2557,8 @@ int drm_mode_getplane_res(struct drm_device *dev, void *data, if (plane->type != DRM_PLANE_TYPE_OVERLAY && !file_priv->universal_planes) continue; + if (plane->parent && !file_priv->share_planes) + continue; if (put_user(plane->base.id, plane_ptr + copied)) return -EFAULT; diff --git a/drivers/gpu/drm/drm_ioctl.c b/drivers/gpu/drm/drm_ioctl.c index 33af4a5..8b0120d 100644 --- a/drivers/gpu/drm/drm_ioctl.c +++ b/drivers/gpu/drm/drm_ioctl.c @@ -294,6 +294,11 @@ drm_setclientcap(struct drm_device *dev, void *data, struct drm_file *file_priv) return -EINVAL; file_priv->universal_planes = req->value; break; + case DRM_CLIENT_CAP_SHARE_PLANES: + if (req->value > 1) + return -EINVAL; + file_priv->share_planes = req->value; + break; case DRM_CLIENT_CAP_ATOMIC: if (!drm_core_check_feature(dev, DRIVER_ATOMIC)) return -EINVAL; diff --git a/include/drm/drmP.h b/include/drm/drmP.h index c2fe2cf..285d177 100644 --- a/include/drm/drmP.h +++ b/include/drm/drmP.h @@ -314,6 +314,11 @@ struct drm_file { /* true if client understands atomic properties */ unsigned atomic:1; /* + * true if client understands share planes and + * hardware support share planes. + */ + unsigned share_planes:1; + /* * This client is the creator of @master. * Protected by struct drm_device::master_mutex. */ diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h index 9e6ab4a..a3fe9b0 100644 --- a/include/drm/drm_crtc.h +++ b/include/drm/drm_crtc.h @@ -1660,6 +1660,7 @@ enum drm_plane_type { /** * struct drm_plane - central DRM plane control structure * @dev: DRM device this plane belongs to + * @parent: this plane share some resources with parent plane. * @head: for list management * @name: human readable name, can be overwritten by the driver * @base: base mode object @@ -1679,6 +1680,7 @@ enum drm_plane_type { */ struct drm_plane { struct drm_device *dev; + struct drm_plane *parent; struct list_head head; char *name; @@ -2408,6 +2410,8 @@ struct drm_mode_config { */ int num_overlay_plane; int num_total_plane; + int num_share_plane; + int num_share_overlay_plane; struct list_head plane_list; int num_crtc; @@ -2428,6 +2432,9 @@ struct drm_mode_config { struct mutex blob_lock; + /* pointers to share properties */ + struct drm_property *prop_share_id; + /* pointers to standard properties */ struct list_head property_blob_list; struct drm_property *edid_property; @@ -2636,6 +2643,13 @@ extern int drm_plane_init(struct drm_device *dev, const struct drm_plane_funcs *funcs, const uint32_t *formats, unsigned int format_count, bool is_primary); +extern int drm_share_plane_init(struct drm_device *dev, struct drm_plane *plane, + struct drm_plane *parent, + unsigned long possible_crtcs, + const struct drm_plane_funcs *funcs, + const uint32_t *formats, + unsigned int format_count, + enum drm_plane_type type); extern void drm_plane_cleanup(struct drm_plane *plane); /** diff --git a/include/uapi/drm/drm.h b/include/uapi/drm/drm.h index 452675f..01979a4 100644 --- a/include/uapi/drm/drm.h +++ b/include/uapi/drm/drm.h @@ -677,6 +677,13 @@ struct drm_get_cap { */ #define DRM_CLIENT_CAP_ATOMIC 3 +/** + * DRM_CLIENT_CAP_SHARE_PLANES + * + * If set to 1, the DRM core will expose share planes to userspace. + */ +#define DRM_CLIENT_CAP_SHARE_PLANES 4 + /** DRM_IOCTL_SET_CLIENT_CAP ioctl argument type */ struct drm_set_client_cap { __u64 capability; -- 1.9.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Mark Yao Subject: [PATCH 1/3] drm: introduce share plane Date: Tue, 26 Jul 2016 15:46:32 +0800 Message-ID: <1469519194-23133-1-git-send-email-mark.yao@rock-chips.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: David Airlie , Heiko Stuebner , dri-devel@lists.freedesktop.org, linux-arm-kernel@lists.infradead.org, linux-rockchip@lists.infradead.org, linux-kernel@vger.kernel.org List-Id: linux-rockchip.vger.kernel.org V2hhdCBpcyBzaGFyZSBwbGFuZToKUGxhbmUgaGFyZHdhcmUgb25seSBiZSB1c2VkIHdoZW4gdGhl IGRpc3BsYXkgc2Nhbm91dCBydW4gaW50byBwbGFuZSBhY3RpdmUKc2Nhbm91dCwgdGhhdCBtZWFu cyB3ZSBjYW4gcmV1c2UgdGhlIHBsYW5lIGhhcmR3YXJlIHJlc291cmNlcyBvbiBwbGFuZQpub24t YWN0aXZlIHNjYW5vdXQuCgogICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tCiAgICB8ICBzY2Fub3V0ICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgfAogICAgfCAgICAgICAgIC0tLS0tLS0tLS0tLS0tLS0tLSAgICAgICAgICAg ICAgICAgICAgIHwKICAgIHwgICAgICAgICB8IHBhcmVudCBwbGFuZSAgIHwgICAgICAgICAgICAg ICAgICAgICB8CiAgICB8ICAgICAgICAgfCBhY3RpdmUgc2Nhbm91dCB8ICAgICAgICAgICAgICAg ICAgICAgfAogICAgfCAgICAgICAgIHwgICAgICAgICAgICAgICAgfCAgIC0tLS0tLS0tLS0tLS0t LS0tIHwKICAgIHwgICAgICAgICAtLS0tLS0tLS0tLS0tLS0tLS0gICB8IHNoYXJlIHBsYW5lIDEg fCB8CiAgICB8ICAtLS0tLS0tLS0tLS0tLS0tLSAgICAgICAgICAgfGFjdGl2ZSBzY2Fub3V0IHwg fAogICAgfCAgfCBzaGFyZSBwbGFuZSAwIHwgICAgICAgICAgIHwgICAgICAgICAgICAgICB8IHwK ICAgIHwgIHxhY3RpdmUgc2Nhbm91dCB8ICAgICAgICAgICAtLS0tLS0tLS0tLS0tLS0tLSB8CiAg ICB8ICB8ICAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAg fCAgLS0tLS0tLS0tLS0tLS0tLS0gICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgIC0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCk9uZSBwbGFu ZSBoYXJkd2FyZSBjYW4gYmUgcmV1c2UgZm9yIG11bHRpLXBsYW5lcywgd2UgYXNzdW1lIHRoZSBm aXJzdApwbGFuZSBpcyBwYXJlbnQgcGxhbmUsIG90aGVyIHBsYW5lcyBzaGFyZSB0aGUgcmVzb3Vy Y2Ugd2l0aCBmaXJzdCBvbmUuCiAgICBwYXJlbnQgcGxhbmUKICAgICAgICB8LS0tc2hhcmUgcGxh bmUgMAogICAgICAgIHwtLS1zaGFyZSBwbGFuZSAxCiAgICAgICAgLi4uCgpCZWNhdXNlIHJlc291 cmNlIHNoYXJlLCBUaGVyZSBhcmUgc29tZSBsaW1pdCBvbiBzaGFyZSBwbGFuZTogb25lIGdyb3Vw Cm9mIHNoYXJlIHBsYW5lcyBuZWVkIHVzZSBzYW1lIHpwb3MsIGNhbiBub3Qgb3ZlcmxhcCwgZXRj LgoKV2UgYXNzdW1lIHNoYXJlIHBsYW5lIGlzIGEgdW5pdmVyc2FsIHBsYW5lIHdpdGggc29tZSBs aW1pdCBmbGFncy4KcGVvcGxlIHdobyB1c2UgdGhlIHNoYXJlIHBsYW5lIG5lZWQga25vdyB0aGUg bGltaXQsIHNob3VsZCBjYWxsIHRoZSBpb2N0bApEUk1fQ0xJRU5UX0NBUF9TSEFSRV9QTEFORVMs IGFuZCBqdWRnZSB0aGUgcGxhbmVzIGxpbWl0IGJlZm9yZSB1c2UgaXQuCgpBIGdyb3VwIG9mIHNo YXJlIHBsYW5lcyB3b3VsZCBoYXMgc2FtZSBzaGFyZCBpZCwgc28gdXNlcnNwYWNlIGNhbgpncm91 cCB0aGVtLCBqdWRnZSBzaGFyZSBwbGFuZSdzIGxpbWl0LgoKU2lnbmVkLW9mZi1ieTogTWFyayBZ YW8gPG1hcmsueWFvQHJvY2stY2hpcHMuY29tPgotLS0KIGRyaXZlcnMvZ3B1L2RybS9kcm1fY3J0 Yy5jICB8IDExMCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwog ZHJpdmVycy9ncHUvZHJtL2RybV9pb2N0bC5jIHwgICA1ICsrCiBpbmNsdWRlL2RybS9kcm1QLmgg ICAgICAgICAgfCAgIDUgKysKIGluY2x1ZGUvZHJtL2RybV9jcnRjLmggICAgICB8ICAxNCArKysr KysKIGluY2x1ZGUvdWFwaS9kcm0vZHJtLmggICAgICB8ICAgNyArKysKIDUgZmlsZXMgY2hhbmdl ZCwgMTQxIGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2Ny dGMuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fY3J0Yy5jCmluZGV4IDlkM2Y4MGUuLjNhODI1N2Ug MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fY3J0Yy5jCisrKyBiL2RyaXZlcnMvZ3B1 L2RybS9kcm1fY3J0Yy5jCkBAIC0xNDI2LDYgKzE0MjYsOTYgQEAgaW50IGRybV9wbGFuZV9pbml0 KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lLAogRVhQT1JU X1NZTUJPTChkcm1fcGxhbmVfaW5pdCk7CiAKIC8qKgorICogZHJtX3NoYXJlX3BsYW5lX2luaXQg LSBJbml0aWFsaXplIGEgc2hhcmUgcGxhbmUKKyAqIEBkZXY6IERSTSBkZXZpY2UKKyAqIEBwbGFu ZTogcGxhbmUgb2JqZWN0IHRvIGluaXQKKyAqIEBwYXJlbnQ6IHRoaXMgcGxhbmUgc2hhcmUgc29t ZSByZXNvdXJjZXMgd2l0aCBwYXJlbnQgcGxhbmUuCisgKiBAcG9zc2libGVfY3J0Y3M6IGJpdG1h c2sgb2YgcG9zc2libGUgQ1JUQ3MKKyAqIEBmdW5jczogY2FsbGJhY2tzIGZvciB0aGUgbmV3IHBs YW5lCisgKiBAZm9ybWF0czogYXJyYXkgb2Ygc3VwcG9ydGVkIGZvcm1hdHMgKCVEUk1fRk9STUFU XyopCisgKiBAZm9ybWF0X2NvdW50OiBudW1iZXIgb2YgZWxlbWVudHMgaW4gQGZvcm1hdHMKKyAq IEB0eXBlOiB0eXBlIG9mIHBsYW5lIChvdmVybGF5LCBwcmltYXJ5LCBjdXJzb3IpCisgKgorICog V2l0aCB0aGlzIEFQSSwgdGhlIHBsYW5lIGNhbiBzaGFyZSBoYXJkd2FyZSByZXNvdXJjZXMgd2l0 aCBvdGhlciBwbGFuZXMuCisgKgorICogICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLQorICogICB8ICBzY2Fub3V0ICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgfAorICogICB8ICAgICAgICAgLS0tLS0tLS0tLS0tLS0tLS0tICAg ICAgICAgICAgICAgICAgICAgfAorICogICB8ICAgICAgICAgfCAgcGFyZW50IHBsYW5lICB8ICAg ICAgICAgICAgICAgICAgICAgfAorICogICB8ICAgICAgICAgfCBhY3RpdmUgc2Nhbm91dCB8ICAg ICAgICAgICAgICAgICAgICAgfAorICogICB8ICAgICAgICAgfCAgICAgICAgICAgICAgICB8ICAg LS0tLS0tLS0tLS0tLS0tLS0gfAorICogICB8ICAgICAgICAgLS0tLS0tLS0tLS0tLS0tLS0tICAg fCBzaGFyZSBwbGFuZSAxIHwgfAorICogICB8ICAtLS0tLS0tLS0tLS0tLS0tLSAgICAgICAgICAg fGFjdGl2ZSBzY2Fub3V0IHwgfAorICogICB8ICB8IHNoYXJlIHBsYW5lIDAgfCAgICAgICAgICAg fCAgICAgICAgICAgICAgIHwgfAorICogICB8ICB8YWN0aXZlIHNjYW5vdXQgfCAgICAgICAgICAg LS0tLS0tLS0tLS0tLS0tLS0gfAorICogICB8ICB8ICAgICAgICAgICAgICAgfCAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgfAorICogICB8ICAtLS0tLS0tLS0tLS0tLS0tLSAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgfAorICogICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLQorICoKKyAqICAgIHBhcmVudCBwbGFuZQorICogICAgICAgIHwt LS1zaGFyZSBwbGFuZSAwCisgKiAgICAgICAgfC0tLXNoYXJlIHBsYW5lIDEKKyAqICAgICAgICAu Li4KKyAqCisgKiBUaGUgcGxhbmUgaGFyZHdhcmUgaXMgdXNlZCB3aGVuIHRoZSBkaXNwbGF5IHNj YW5vdXQgcnVuIGludG8gcGxhbmUgYWN0aXZlCisgKiBzY2Fub3V0LCB0aGF0IG1lYW5zIHdlIGNh biByZXVzZSB0aGUgcGxhbmUgaGFyZHdhcmUgcmVzb3VyY2VzIG9uIHBsYW5lCisgKiBub24tYWN0 aXZlIHNjYW5vdXQuCisgKgorICogQmVjYXVzZSByZXNvdXJjZSBzaGFyZSwgVGhlcmUgYXJlIHNv bWUgbGltaXQgb24gc2hhcmUgcGxhbmU6IG9uZSBncm91cAorICogb2Ygc2hhcmUgcGxhbmVzIG5l ZWQgdXNlIHNhbWUgenBvcywgY2FuJ3Qgbm90IG92ZXJsYXAsIGV0Yy4KKyAqCisgKiBIZXJlIGFz c3VtZSBzaGFyZSBwbGFuZSBpcyBhIHVuaXZlcnNhbCBwbGFuZSB3aXRoIHNvbWUgbGltaXQgZmxh Z3MuCisgKiBwZW9wbGUgd2hvIHVzZSB0aGUgc2hhcmUgcGxhbmUgbmVlZCBrbm93IHRoZSBsaW1p dCwgc2hvdWxkIGNhbGwgdGhlIGlvY3RsCisgKiBEUk1fQ0xJRU5UX0NBUF9TSEFSRV9QTEFORVMs IGFuZCBqdWRnZSB0aGUgcGxhbmVzIGxpbWl0IGJlZm9yZSB1c2UgaXQuCisgKgorICogUmV0dXJu czoKKyAqIFplcm8gb24gc3VjY2VzcywgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgorICovCisKK2lu dCBkcm1fc2hhcmVfcGxhbmVfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBzdHJ1Y3QgZHJt X3BsYW5lICpwbGFuZSwKKwkJCSBzdHJ1Y3QgZHJtX3BsYW5lICpwYXJlbnQsCisJCQkgdW5zaWdu ZWQgbG9uZyBwb3NzaWJsZV9jcnRjcywKKwkJCSBjb25zdCBzdHJ1Y3QgZHJtX3BsYW5lX2Z1bmNz ICpmdW5jcywKKwkJCSBjb25zdCB1aW50MzJfdCAqZm9ybWF0cywgdW5zaWduZWQgaW50IGZvcm1h dF9jb3VudCwKKwkJCSBlbnVtIGRybV9wbGFuZV90eXBlIHR5cGUpCit7CisJc3RydWN0IGRybV9t b2RlX2NvbmZpZyAqY29uZmlnID0gJmRldi0+bW9kZV9jb25maWc7CisJaW50IHJldDsKKwlpbnQg c2hhcmVfaWQ7CisKKwkvKgorCSAqIFRPRE86IG9ubHkgdmVyaWZpZWQgb24gQVRPTUlDIGRybSBk cml2ZXIuCisJICovCisJaWYgKCFkcm1fY29yZV9jaGVja19mZWF0dXJlKGRldiwgRFJJVkVSX0FU T01JQykpCisJCXJldHVybiAtRUlOVkFMOworCisJcmV0ID0gZHJtX3VuaXZlcnNhbF9wbGFuZV9p bml0KGRldiwgcGxhbmUsIHBvc3NpYmxlX2NydGNzLCBmdW5jcywKKwkJCQkgICAgICAgZm9ybWF0 cywgZm9ybWF0X2NvdW50LCB0eXBlLCBOVUxMKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0Owor CisJaWYgKHBhcmVudCkgeworCQkvKgorCQkgKiBDYW4ndCBzdXBwb3J0IG1vcmUgdGhhbiB0d28g bGV2ZWwgcGxhbmUgc2hhcmUuCisJCSAqLworCQlXQVJOX09OKHBhcmVudC0+cGFyZW50KTsKKwkJ c2hhcmVfaWQgPSBwYXJlbnQtPmJhc2UuaWQ7CisJCXBsYW5lLT5wYXJlbnQgPSBwYXJlbnQ7CisK KwkJY29uZmlnLT5udW1fc2hhcmVfcGxhbmUrKzsKKwkJaWYgKHBsYW5lLT50eXBlID09IERSTV9Q TEFORV9UWVBFX09WRVJMQVkpCisJCQljb25maWctPm51bV9zaGFyZV9vdmVybGF5X3BsYW5lKys7 CisJfSBlbHNlIHsKKwkJc2hhcmVfaWQgPSBwbGFuZS0+YmFzZS5pZDsKKwl9CisKKwlkcm1fb2Jq ZWN0X2F0dGFjaF9wcm9wZXJ0eSgmcGxhbmUtPmJhc2UsCisJCQkJICAgY29uZmlnLT5wcm9wX3No YXJlX2lkLCBzaGFyZV9pZCk7CisJcmV0dXJuIDA7Cit9CitFWFBPUlRfU1lNQk9MKGRybV9zaGFy ZV9wbGFuZV9pbml0KTsKKworLyoqCiAgKiBkcm1fcGxhbmVfY2xlYW51cCAtIENsZWFuIHVwIHRo ZSBjb3JlIHBsYW5lIHVzYWdlCiAgKiBAcGxhbmU6IHBsYW5lIHRvIGNsZWFudXAKICAqCkBAIC0x NDUyLDYgKzE1NDIsMTEgQEAgdm9pZCBkcm1fcGxhbmVfY2xlYW51cChzdHJ1Y3QgZHJtX3BsYW5l ICpwbGFuZSkKIAlkZXYtPm1vZGVfY29uZmlnLm51bV90b3RhbF9wbGFuZS0tOwogCWlmIChwbGFu ZS0+dHlwZSA9PSBEUk1fUExBTkVfVFlQRV9PVkVSTEFZKQogCQlkZXYtPm1vZGVfY29uZmlnLm51 bV9vdmVybGF5X3BsYW5lLS07CisJaWYgKHBsYW5lLT5wYXJlbnQpIHsKKwkJZGV2LT5tb2RlX2Nv bmZpZy5udW1fc2hhcmVfcGxhbmUtLTsKKwkJaWYgKHBsYW5lLT50eXBlID09IERSTV9QTEFORV9U WVBFX09WRVJMQVkpCisJCQlkZXYtPm1vZGVfY29uZmlnLm51bV9zaGFyZV9vdmVybGF5X3BsYW5l LS07CisJfQogCWRybV9tb2Rlc2V0X3VubG9ja19hbGwoZGV2KTsKIAogCVdBUk5fT04ocGxhbmUt PnN0YXRlICYmICFwbGFuZS0+ZnVuY3MtPmF0b21pY19kZXN0cm95X3N0YXRlKTsKQEAgLTE2MDAs NiArMTY5NSwxMyBAQCBzdGF0aWMgaW50IGRybV9tb2RlX2NyZWF0ZV9zdGFuZGFyZF9wcm9wZXJ0 aWVzKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCiAJCXJldHVybiAtRU5PTUVNOwogCWRldi0+bW9k ZV9jb25maWcucGxhbmVfdHlwZV9wcm9wZXJ0eSA9IHByb3A7CiAKKwlwcm9wID0gZHJtX3Byb3Bl cnR5X2NyZWF0ZV9yYW5nZShkZXYsIERSTV9NT0RFX1BST1BfSU1NVVRBQkxFLAorCQkJCQkgIlNI QVJFX0lEIiwgMCwgVUlOVF9NQVgpOworCWlmICghcHJvcCkKKwkJcmV0dXJuIC1FTk9NRU07CisK KwlkZXYtPm1vZGVfY29uZmlnLnByb3Bfc2hhcmVfaWQgPSBwcm9wOworCiAJcHJvcCA9IGRybV9w cm9wZXJ0eV9jcmVhdGVfcmFuZ2UoZGV2LCBEUk1fTU9ERV9QUk9QX0FUT01JQywKIAkJCSJTUkNf WCIsIDAsIFVJTlRfTUFYKTsKIAlpZiAoIXByb3ApCkBAIC0yNDMxLDYgKzI1MzMsMTIgQEAgaW50 IGRybV9tb2RlX2dldHBsYW5lX3JlcyhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB2b2lkICpkYXRh LAogCQludW1fcGxhbmVzID0gY29uZmlnLT5udW1fdG90YWxfcGxhbmU7CiAJZWxzZQogCQludW1f cGxhbmVzID0gY29uZmlnLT5udW1fb3ZlcmxheV9wbGFuZTsKKwlpZiAoIWZpbGVfcHJpdi0+c2hh cmVfcGxhbmVzKSB7CisJCWlmIChmaWxlX3ByaXYtPnVuaXZlcnNhbF9wbGFuZXMpCisJCQludW1f cGxhbmVzIC09IGNvbmZpZy0+bnVtX3NoYXJlX3BsYW5lOworCQllbHNlCisJCQludW1fcGxhbmVz IC09IGNvbmZpZy0+bnVtX3NoYXJlX292ZXJsYXlfcGxhbmU7CisJfQogCiAJLyoKIAkgKiBUaGlz IGlvY3RsIGlzIGNhbGxlZCB0d2ljZSwgb25jZSB0byBkZXRlcm1pbmUgaG93IG11Y2ggc3BhY2Ug aXMKQEAgLTI0NDksNiArMjU1Nyw4IEBAIGludCBkcm1fbW9kZV9nZXRwbGFuZV9yZXMoc3RydWN0 IGRybV9kZXZpY2UgKmRldiwgdm9pZCAqZGF0YSwKIAkJCWlmIChwbGFuZS0+dHlwZSAhPSBEUk1f UExBTkVfVFlQRV9PVkVSTEFZICYmCiAJCQkgICAgIWZpbGVfcHJpdi0+dW5pdmVyc2FsX3BsYW5l cykKIAkJCQljb250aW51ZTsKKwkJCWlmIChwbGFuZS0+cGFyZW50ICYmICFmaWxlX3ByaXYtPnNo YXJlX3BsYW5lcykKKwkJCQljb250aW51ZTsKIAogCQkJaWYgKHB1dF91c2VyKHBsYW5lLT5iYXNl LmlkLCBwbGFuZV9wdHIgKyBjb3BpZWQpKQogCQkJCXJldHVybiAtRUZBVUxUOwpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9ncHUvZHJtL2RybV9pb2N0bC5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9pb2N0 bC5jCmluZGV4IDMzYWY0YTUuLjhiMDEyMGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9k cm1faW9jdGwuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2lvY3RsLmMKQEAgLTI5NCw2ICsy OTQsMTEgQEAgZHJtX3NldGNsaWVudGNhcChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB2b2lkICpk YXRhLCBzdHJ1Y3QgZHJtX2ZpbGUgKmZpbGVfcHJpdikKIAkJCXJldHVybiAtRUlOVkFMOwogCQlm aWxlX3ByaXYtPnVuaXZlcnNhbF9wbGFuZXMgPSByZXEtPnZhbHVlOwogCQlicmVhazsKKwljYXNl IERSTV9DTElFTlRfQ0FQX1NIQVJFX1BMQU5FUzoKKwkJaWYgKHJlcS0+dmFsdWUgPiAxKQorCQkJ cmV0dXJuIC1FSU5WQUw7CisJCWZpbGVfcHJpdi0+c2hhcmVfcGxhbmVzID0gcmVxLT52YWx1ZTsK KwkJYnJlYWs7CiAJY2FzZSBEUk1fQ0xJRU5UX0NBUF9BVE9NSUM6CiAJCWlmICghZHJtX2NvcmVf Y2hlY2tfZmVhdHVyZShkZXYsIERSSVZFUl9BVE9NSUMpKQogCQkJcmV0dXJuIC1FSU5WQUw7CmRp ZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1QLmggYi9pbmNsdWRlL2RybS9kcm1QLmgKaW5kZXgg YzJmZTJjZi4uMjg1ZDE3NyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9kcm0vZHJtUC5oCisrKyBiL2lu Y2x1ZGUvZHJtL2RybVAuaApAQCAtMzE0LDYgKzMxNCwxMSBAQCBzdHJ1Y3QgZHJtX2ZpbGUgewog CS8qIHRydWUgaWYgY2xpZW50IHVuZGVyc3RhbmRzIGF0b21pYyBwcm9wZXJ0aWVzICovCiAJdW5z aWduZWQgYXRvbWljOjE7CiAJLyoKKwkgKiB0cnVlIGlmIGNsaWVudCB1bmRlcnN0YW5kcyBzaGFy ZSBwbGFuZXMgYW5kCisJICogaGFyZHdhcmUgc3VwcG9ydCBzaGFyZSBwbGFuZXMuCisJICovCisJ dW5zaWduZWQgc2hhcmVfcGxhbmVzOjE7CisJLyoKIAkgKiBUaGlzIGNsaWVudCBpcyB0aGUgY3Jl YXRvciBvZiBAbWFzdGVyLgogCSAqIFByb3RlY3RlZCBieSBzdHJ1Y3QgZHJtX2RldmljZTo6bWFz dGVyX211dGV4LgogCSAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJtX2NydGMuaCBiL2lu Y2x1ZGUvZHJtL2RybV9jcnRjLmgKaW5kZXggOWU2YWI0YS4uYTNmZTliMCAxMDA2NDQKLS0tIGEv aW5jbHVkZS9kcm0vZHJtX2NydGMuaAorKysgYi9pbmNsdWRlL2RybS9kcm1fY3J0Yy5oCkBAIC0x NjYwLDYgKzE2NjAsNyBAQCBlbnVtIGRybV9wbGFuZV90eXBlIHsKIC8qKgogICogc3RydWN0IGRy bV9wbGFuZSAtIGNlbnRyYWwgRFJNIHBsYW5lIGNvbnRyb2wgc3RydWN0dXJlCiAgKiBAZGV2OiBE Uk0gZGV2aWNlIHRoaXMgcGxhbmUgYmVsb25ncyB0bworICogQHBhcmVudDogdGhpcyBwbGFuZSBz aGFyZSBzb21lIHJlc291cmNlcyB3aXRoIHBhcmVudCBwbGFuZS4KICAqIEBoZWFkOiBmb3IgbGlz dCBtYW5hZ2VtZW50CiAgKiBAbmFtZTogaHVtYW4gcmVhZGFibGUgbmFtZSwgY2FuIGJlIG92ZXJ3 cml0dGVuIGJ5IHRoZSBkcml2ZXIKICAqIEBiYXNlOiBiYXNlIG1vZGUgb2JqZWN0CkBAIC0xNjc5 LDYgKzE2ODAsNyBAQCBlbnVtIGRybV9wbGFuZV90eXBlIHsKICAqLwogc3RydWN0IGRybV9wbGFu ZSB7CiAJc3RydWN0IGRybV9kZXZpY2UgKmRldjsKKwlzdHJ1Y3QgZHJtX3BsYW5lICpwYXJlbnQ7 CiAJc3RydWN0IGxpc3RfaGVhZCBoZWFkOwogCiAJY2hhciAqbmFtZTsKQEAgLTI0MDgsNiArMjQx MCw4IEBAIHN0cnVjdCBkcm1fbW9kZV9jb25maWcgewogCSAqLwogCWludCBudW1fb3ZlcmxheV9w bGFuZTsKIAlpbnQgbnVtX3RvdGFsX3BsYW5lOworCWludCBudW1fc2hhcmVfcGxhbmU7CisJaW50 IG51bV9zaGFyZV9vdmVybGF5X3BsYW5lOwogCXN0cnVjdCBsaXN0X2hlYWQgcGxhbmVfbGlzdDsK IAogCWludCBudW1fY3J0YzsKQEAgLTI0MjgsNiArMjQzMiw5IEBAIHN0cnVjdCBkcm1fbW9kZV9j b25maWcgewogCiAJc3RydWN0IG11dGV4IGJsb2JfbG9jazsKIAorCS8qIHBvaW50ZXJzIHRvIHNo YXJlIHByb3BlcnRpZXMgKi8KKwlzdHJ1Y3QgZHJtX3Byb3BlcnR5ICpwcm9wX3NoYXJlX2lkOwor CiAJLyogcG9pbnRlcnMgdG8gc3RhbmRhcmQgcHJvcGVydGllcyAqLwogCXN0cnVjdCBsaXN0X2hl YWQgcHJvcGVydHlfYmxvYl9saXN0OwogCXN0cnVjdCBkcm1fcHJvcGVydHkgKmVkaWRfcHJvcGVy dHk7CkBAIC0yNjM2LDYgKzI2NDMsMTMgQEAgZXh0ZXJuIGludCBkcm1fcGxhbmVfaW5pdChzdHJ1 Y3QgZHJtX2RldmljZSAqZGV2LAogCQkJICBjb25zdCBzdHJ1Y3QgZHJtX3BsYW5lX2Z1bmNzICpm dW5jcywKIAkJCSAgY29uc3QgdWludDMyX3QgKmZvcm1hdHMsIHVuc2lnbmVkIGludCBmb3JtYXRf Y291bnQsCiAJCQkgIGJvb2wgaXNfcHJpbWFyeSk7CitleHRlcm4gaW50IGRybV9zaGFyZV9wbGFu ZV9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lLAor CQkJCXN0cnVjdCBkcm1fcGxhbmUgKnBhcmVudCwKKwkJCQl1bnNpZ25lZCBsb25nIHBvc3NpYmxl X2NydGNzLAorCQkJCWNvbnN0IHN0cnVjdCBkcm1fcGxhbmVfZnVuY3MgKmZ1bmNzLAorCQkJCWNv bnN0IHVpbnQzMl90ICpmb3JtYXRzLAorCQkJCXVuc2lnbmVkIGludCBmb3JtYXRfY291bnQsCisJ CQkJZW51bSBkcm1fcGxhbmVfdHlwZSB0eXBlKTsKIGV4dGVybiB2b2lkIGRybV9wbGFuZV9jbGVh bnVwKHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lKTsKIAogLyoqCmRpZmYgLS1naXQgYS9pbmNsdWRl L3VhcGkvZHJtL2RybS5oIGIvaW5jbHVkZS91YXBpL2RybS9kcm0uaAppbmRleCA0NTI2NzVmLi4w MTk3OWE0IDEwMDY0NAotLS0gYS9pbmNsdWRlL3VhcGkvZHJtL2RybS5oCisrKyBiL2luY2x1ZGUv dWFwaS9kcm0vZHJtLmgKQEAgLTY3Nyw2ICs2NzcsMTMgQEAgc3RydWN0IGRybV9nZXRfY2FwIHsK ICAqLwogI2RlZmluZSBEUk1fQ0xJRU5UX0NBUF9BVE9NSUMJMwogCisvKioKKyAqIERSTV9DTElF TlRfQ0FQX1NIQVJFX1BMQU5FUworICoKKyAqIElmIHNldCB0byAxLCB0aGUgRFJNIGNvcmUgd2ls bCBleHBvc2Ugc2hhcmUgcGxhbmVzIHRvIHVzZXJzcGFjZS4KKyAqLworI2RlZmluZSBEUk1fQ0xJ RU5UX0NBUF9TSEFSRV9QTEFORVMJNAorCiAvKiogRFJNX0lPQ1RMX1NFVF9DTElFTlRfQ0FQIGlv Y3RsIGFyZ3VtZW50IHR5cGUgKi8KIHN0cnVjdCBkcm1fc2V0X2NsaWVudF9jYXAgewogCV9fdTY0 IGNhcGFiaWxpdHk7Ci0tIAoxLjkuMQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZy ZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 From: mark.yao@rock-chips.com (Mark Yao) Date: Tue, 26 Jul 2016 15:46:32 +0800 Subject: [PATCH 1/3] drm: introduce share plane Message-ID: <1469519194-23133-1-git-send-email-mark.yao@rock-chips.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org What is share plane: Plane hardware only be used when the display scanout run into plane active scanout, that means we can reuse the plane hardware resources on plane non-active scanout. -------------------------------------------------- | scanout | | ------------------ | | | parent plane | | | | active scanout | | | | | ----------------- | | ------------------ | share plane 1 | | | ----------------- |active scanout | | | | share plane 0 | | | | | |active scanout | ----------------- | | | | | | ----------------- | -------------------------------------------------- One plane hardware can be reuse for multi-planes, we assume the first plane is parent plane, other planes share the resource with first one. parent plane |---share plane 0 |---share plane 1 ... Because resource share, There are some limit on share plane: one group of share planes need use same zpos, can not overlap, etc. We assume share plane is a universal plane with some limit flags. people who use the share plane need know the limit, should call the ioctl DRM_CLIENT_CAP_SHARE_PLANES, and judge the planes limit before use it. A group of share planes would has same shard id, so userspace can group them, judge share plane's limit. Signed-off-by: Mark Yao --- drivers/gpu/drm/drm_crtc.c | 110 ++++++++++++++++++++++++++++++++++++++++++++ drivers/gpu/drm/drm_ioctl.c | 5 ++ include/drm/drmP.h | 5 ++ include/drm/drm_crtc.h | 14 ++++++ include/uapi/drm/drm.h | 7 +++ 5 files changed, 141 insertions(+) diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c index 9d3f80e..3a8257e 100644 --- a/drivers/gpu/drm/drm_crtc.c +++ b/drivers/gpu/drm/drm_crtc.c @@ -1426,6 +1426,96 @@ int drm_plane_init(struct drm_device *dev, struct drm_plane *plane, EXPORT_SYMBOL(drm_plane_init); /** + * drm_share_plane_init - Initialize a share plane + * @dev: DRM device + * @plane: plane object to init + * @parent: this plane share some resources with parent plane. + * @possible_crtcs: bitmask of possible CRTCs + * @funcs: callbacks for the new plane + * @formats: array of supported formats (%DRM_FORMAT_*) + * @format_count: number of elements in @formats + * @type: type of plane (overlay, primary, cursor) + * + * With this API, the plane can share hardware resources with other planes. + * + * -------------------------------------------------- + * | scanout | + * | ------------------ | + * | | parent plane | | + * | | active scanout | | + * | | | ----------------- | + * | ------------------ | share plane 1 | | + * | ----------------- |active scanout | | + * | | share plane 0 | | | | + * | |active scanout | ----------------- | + * | | | | + * | ----------------- | + * -------------------------------------------------- + * + * parent plane + * |---share plane 0 + * |---share plane 1 + * ... + * + * The plane hardware is used when the display scanout run into plane active + * scanout, that means we can reuse the plane hardware resources on plane + * non-active scanout. + * + * Because resource share, There are some limit on share plane: one group + * of share planes need use same zpos, can't not overlap, etc. + * + * Here assume share plane is a universal plane with some limit flags. + * people who use the share plane need know the limit, should call the ioctl + * DRM_CLIENT_CAP_SHARE_PLANES, and judge the planes limit before use it. + * + * Returns: + * Zero on success, error code on failure. + */ + +int drm_share_plane_init(struct drm_device *dev, struct drm_plane *plane, + struct drm_plane *parent, + unsigned long possible_crtcs, + const struct drm_plane_funcs *funcs, + const uint32_t *formats, unsigned int format_count, + enum drm_plane_type type) +{ + struct drm_mode_config *config = &dev->mode_config; + int ret; + int share_id; + + /* + * TODO: only verified on ATOMIC drm driver. + */ + if (!drm_core_check_feature(dev, DRIVER_ATOMIC)) + return -EINVAL; + + ret = drm_universal_plane_init(dev, plane, possible_crtcs, funcs, + formats, format_count, type, NULL); + if (ret) + return ret; + + if (parent) { + /* + * Can't support more than two level plane share. + */ + WARN_ON(parent->parent); + share_id = parent->base.id; + plane->parent = parent; + + config->num_share_plane++; + if (plane->type == DRM_PLANE_TYPE_OVERLAY) + config->num_share_overlay_plane++; + } else { + share_id = plane->base.id; + } + + drm_object_attach_property(&plane->base, + config->prop_share_id, share_id); + return 0; +} +EXPORT_SYMBOL(drm_share_plane_init); + +/** * drm_plane_cleanup - Clean up the core plane usage * @plane: plane to cleanup * @@ -1452,6 +1542,11 @@ void drm_plane_cleanup(struct drm_plane *plane) dev->mode_config.num_total_plane--; if (plane->type == DRM_PLANE_TYPE_OVERLAY) dev->mode_config.num_overlay_plane--; + if (plane->parent) { + dev->mode_config.num_share_plane--; + if (plane->type == DRM_PLANE_TYPE_OVERLAY) + dev->mode_config.num_share_overlay_plane--; + } drm_modeset_unlock_all(dev); WARN_ON(plane->state && !plane->funcs->atomic_destroy_state); @@ -1600,6 +1695,13 @@ static int drm_mode_create_standard_properties(struct drm_device *dev) return -ENOMEM; dev->mode_config.plane_type_property = prop; + prop = drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, + "SHARE_ID", 0, UINT_MAX); + if (!prop) + return -ENOMEM; + + dev->mode_config.prop_share_id = prop; + prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, "SRC_X", 0, UINT_MAX); if (!prop) @@ -2431,6 +2533,12 @@ int drm_mode_getplane_res(struct drm_device *dev, void *data, num_planes = config->num_total_plane; else num_planes = config->num_overlay_plane; + if (!file_priv->share_planes) { + if (file_priv->universal_planes) + num_planes -= config->num_share_plane; + else + num_planes -= config->num_share_overlay_plane; + } /* * This ioctl is called twice, once to determine how much space is @@ -2449,6 +2557,8 @@ int drm_mode_getplane_res(struct drm_device *dev, void *data, if (plane->type != DRM_PLANE_TYPE_OVERLAY && !file_priv->universal_planes) continue; + if (plane->parent && !file_priv->share_planes) + continue; if (put_user(plane->base.id, plane_ptr + copied)) return -EFAULT; diff --git a/drivers/gpu/drm/drm_ioctl.c b/drivers/gpu/drm/drm_ioctl.c index 33af4a5..8b0120d 100644 --- a/drivers/gpu/drm/drm_ioctl.c +++ b/drivers/gpu/drm/drm_ioctl.c @@ -294,6 +294,11 @@ drm_setclientcap(struct drm_device *dev, void *data, struct drm_file *file_priv) return -EINVAL; file_priv->universal_planes = req->value; break; + case DRM_CLIENT_CAP_SHARE_PLANES: + if (req->value > 1) + return -EINVAL; + file_priv->share_planes = req->value; + break; case DRM_CLIENT_CAP_ATOMIC: if (!drm_core_check_feature(dev, DRIVER_ATOMIC)) return -EINVAL; diff --git a/include/drm/drmP.h b/include/drm/drmP.h index c2fe2cf..285d177 100644 --- a/include/drm/drmP.h +++ b/include/drm/drmP.h @@ -314,6 +314,11 @@ struct drm_file { /* true if client understands atomic properties */ unsigned atomic:1; /* + * true if client understands share planes and + * hardware support share planes. + */ + unsigned share_planes:1; + /* * This client is the creator of @master. * Protected by struct drm_device::master_mutex. */ diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h index 9e6ab4a..a3fe9b0 100644 --- a/include/drm/drm_crtc.h +++ b/include/drm/drm_crtc.h @@ -1660,6 +1660,7 @@ enum drm_plane_type { /** * struct drm_plane - central DRM plane control structure * @dev: DRM device this plane belongs to + * @parent: this plane share some resources with parent plane. * @head: for list management * @name: human readable name, can be overwritten by the driver * @base: base mode object @@ -1679,6 +1680,7 @@ enum drm_plane_type { */ struct drm_plane { struct drm_device *dev; + struct drm_plane *parent; struct list_head head; char *name; @@ -2408,6 +2410,8 @@ struct drm_mode_config { */ int num_overlay_plane; int num_total_plane; + int num_share_plane; + int num_share_overlay_plane; struct list_head plane_list; int num_crtc; @@ -2428,6 +2432,9 @@ struct drm_mode_config { struct mutex blob_lock; + /* pointers to share properties */ + struct drm_property *prop_share_id; + /* pointers to standard properties */ struct list_head property_blob_list; struct drm_property *edid_property; @@ -2636,6 +2643,13 @@ extern int drm_plane_init(struct drm_device *dev, const struct drm_plane_funcs *funcs, const uint32_t *formats, unsigned int format_count, bool is_primary); +extern int drm_share_plane_init(struct drm_device *dev, struct drm_plane *plane, + struct drm_plane *parent, + unsigned long possible_crtcs, + const struct drm_plane_funcs *funcs, + const uint32_t *formats, + unsigned int format_count, + enum drm_plane_type type); extern void drm_plane_cleanup(struct drm_plane *plane); /** diff --git a/include/uapi/drm/drm.h b/include/uapi/drm/drm.h index 452675f..01979a4 100644 --- a/include/uapi/drm/drm.h +++ b/include/uapi/drm/drm.h @@ -677,6 +677,13 @@ struct drm_get_cap { */ #define DRM_CLIENT_CAP_ATOMIC 3 +/** + * DRM_CLIENT_CAP_SHARE_PLANES + * + * If set to 1, the DRM core will expose share planes to userspace. + */ +#define DRM_CLIENT_CAP_SHARE_PLANES 4 + /** DRM_IOCTL_SET_CLIENT_CAP ioctl argument type */ struct drm_set_client_cap { __u64 capability; -- 1.9.1