From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755123AbcGZI0w (ORCPT ); Tue, 26 Jul 2016 04:26:52 -0400 Received: from mail-wm0-f66.google.com ([74.125.82.66]:33144 "EHLO mail-wm0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754648AbcGZI0q (ORCPT ); Tue, 26 Jul 2016 04:26:46 -0400 Date: Tue, 26 Jul 2016 10:26:35 +0200 From: Daniel Vetter To: Mark Yao Cc: 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 Subject: Re: [PATCH 1/3] drm: introduce share plane Message-ID: <20160726082635.GA31475@phenom.ffwll.local> Mail-Followup-To: Mark Yao , 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 References: <1469519194-23133-1-git-send-email-mark.yao@rock-chips.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <1469519194-23133-1-git-send-email-mark.yao@rock-chips.com> X-Operating-System: Linux phenom 4.6.0-rc5+ User-Agent: Mutt/1.6.0 (2016-04-01) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Tue, Jul 26, 2016 at 03:46:32PM +0800, Mark Yao wrote: > 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 This seems extremely hw specific, why exactly do we need to add a new relationship on planes? What does this buy on _other_ drivers? Imo this should be solved by virtualizing planes in the driver. Start out by assigning planes, and if you can reuse one for sharing then do that, otherwise allocate a new one. If there's not enough real planes, fail the atomic_check. This seems way to hw specific to be useful as a generic concept. -Daniel > --- > 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 > > > _______________________________________________ > dri-devel mailing list > dri-devel@lists.freedesktop.org > https://lists.freedesktop.org/mailman/listinfo/dri-devel -- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: Re: [PATCH 1/3] drm: introduce share plane Date: Tue, 26 Jul 2016 10:26:35 +0200 Message-ID: <20160726082635.GA31475@phenom.ffwll.local> References: <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: Content-Disposition: inline In-Reply-To: <1469519194-23133-1-git-send-email-mark.yao@rock-chips.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Mark Yao Cc: linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-rockchip@lists.infradead.org, linux-arm-kernel@lists.infradead.org List-Id: linux-rockchip.vger.kernel.org T24gVHVlLCBKdWwgMjYsIDIwMTYgYXQgMDM6NDY6MzJQTSArMDgwMCwgTWFyayBZYW8gd3JvdGU6 Cj4gV2hhdCBpcyBzaGFyZSBwbGFuZToKPiBQbGFuZSBoYXJkd2FyZSBvbmx5IGJlIHVzZWQgd2hl biB0aGUgZGlzcGxheSBzY2Fub3V0IHJ1biBpbnRvIHBsYW5lIGFjdGl2ZQo+IHNjYW5vdXQsIHRo YXQgbWVhbnMgd2UgY2FuIHJldXNlIHRoZSBwbGFuZSBoYXJkd2FyZSByZXNvdXJjZXMgb24gcGxh bmUKPiBub24tYWN0aXZlIHNjYW5vdXQuCj4gCj4gICAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+ICAgICB8ICBzY2Fub3V0ICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfAo+ICAgICB8ICAgICAgICAgLS0tLS0tLS0tLS0t LS0tLS0tICAgICAgICAgICAgICAgICAgICAgfAo+ICAgICB8ICAgICAgICAgfCBwYXJlbnQgcGxh bmUgICB8ICAgICAgICAgICAgICAgICAgICAgfAo+ICAgICB8ICAgICAgICAgfCBhY3RpdmUgc2Nh bm91dCB8ICAgICAgICAgICAgICAgICAgICAgfAo+ICAgICB8ICAgICAgICAgfCAgICAgICAgICAg ICAgICB8ICAgLS0tLS0tLS0tLS0tLS0tLS0gfAo+ICAgICB8ICAgICAgICAgLS0tLS0tLS0tLS0t LS0tLS0tICAgfCBzaGFyZSBwbGFuZSAxIHwgfAo+ICAgICB8ICAtLS0tLS0tLS0tLS0tLS0tLSAg ICAgICAgICAgfGFjdGl2ZSBzY2Fub3V0IHwgfAo+ICAgICB8ICB8IHNoYXJlIHBsYW5lIDAgfCAg ICAgICAgICAgfCAgICAgICAgICAgICAgIHwgfAo+ICAgICB8ICB8YWN0aXZlIHNjYW5vdXQgfCAg ICAgICAgICAgLS0tLS0tLS0tLS0tLS0tLS0gfAo+ICAgICB8ICB8ICAgICAgICAgICAgICAgfCAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfAo+ICAgICB8ICAtLS0tLS0tLS0tLS0tLS0tLSAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfAo+ICAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+IE9uZSBwbGFuZSBoYXJkd2FyZSBjYW4gYmUg cmV1c2UgZm9yIG11bHRpLXBsYW5lcywgd2UgYXNzdW1lIHRoZSBmaXJzdAo+IHBsYW5lIGlzIHBh cmVudCBwbGFuZSwgb3RoZXIgcGxhbmVzIHNoYXJlIHRoZSByZXNvdXJjZSB3aXRoIGZpcnN0IG9u ZS4KPiAgICAgcGFyZW50IHBsYW5lCj4gICAgICAgICB8LS0tc2hhcmUgcGxhbmUgMAo+ICAgICAg ICAgfC0tLXNoYXJlIHBsYW5lIDEKPiAgICAgICAgIC4uLgo+IAo+IEJlY2F1c2UgcmVzb3VyY2Ug c2hhcmUsIFRoZXJlIGFyZSBzb21lIGxpbWl0IG9uIHNoYXJlIHBsYW5lOiBvbmUgZ3JvdXAKPiBv ZiBzaGFyZSBwbGFuZXMgbmVlZCB1c2Ugc2FtZSB6cG9zLCBjYW4gbm90IG92ZXJsYXAsIGV0Yy4K PiAKPiBXZSBhc3N1bWUgc2hhcmUgcGxhbmUgaXMgYSB1bml2ZXJzYWwgcGxhbmUgd2l0aCBzb21l IGxpbWl0IGZsYWdzLgo+IHBlb3BsZSB3aG8gdXNlIHRoZSBzaGFyZSBwbGFuZSBuZWVkIGtub3cg dGhlIGxpbWl0LCBzaG91bGQgY2FsbCB0aGUgaW9jdGwKPiBEUk1fQ0xJRU5UX0NBUF9TSEFSRV9Q TEFORVMsIGFuZCBqdWRnZSB0aGUgcGxhbmVzIGxpbWl0IGJlZm9yZSB1c2UgaXQuCj4gCj4gQSBn cm91cCBvZiBzaGFyZSBwbGFuZXMgd291bGQgaGFzIHNhbWUgc2hhcmQgaWQsIHNvIHVzZXJzcGFj ZSBjYW4KPiBncm91cCB0aGVtLCBqdWRnZSBzaGFyZSBwbGFuZSdzIGxpbWl0Lgo+IAo+IFNpZ25l ZC1vZmYtYnk6IE1hcmsgWWFvIDxtYXJrLnlhb0Byb2NrLWNoaXBzLmNvbT4KClRoaXMgc2VlbXMg ZXh0cmVtZWx5IGh3IHNwZWNpZmljLCB3aHkgZXhhY3RseSBkbyB3ZSBuZWVkIHRvIGFkZCBhIG5l dwpyZWxhdGlvbnNoaXAgb24gcGxhbmVzPyBXaGF0IGRvZXMgdGhpcyBidXkgb24gX290aGVyXyBk cml2ZXJzPwoKSW1vIHRoaXMgc2hvdWxkIGJlIHNvbHZlZCBieSB2aXJ0dWFsaXppbmcgcGxhbmVz IGluIHRoZSBkcml2ZXIuIFN0YXJ0IG91dApieSBhc3NpZ25pbmcgcGxhbmVzLCBhbmQgaWYgeW91 IGNhbiByZXVzZSBvbmUgZm9yIHNoYXJpbmcgdGhlbiBkbyB0aGF0LApvdGhlcndpc2UgYWxsb2Nh dGUgYSBuZXcgb25lLiBJZiB0aGVyZSdzIG5vdCBlbm91Z2ggcmVhbCBwbGFuZXMsIGZhaWwgdGhl CmF0b21pY19jaGVjay4KClRoaXMgc2VlbXMgd2F5IHRvIGh3IHNwZWNpZmljIHRvIGJlIHVzZWZ1 bCBhcyBhIGdlbmVyaWMgY29uY2VwdC4KLURhbmllbAoKPiAtLS0KPiAgZHJpdmVycy9ncHUvZHJt L2RybV9jcnRjLmMgIHwgMTEwICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrCj4gIGRyaXZlcnMvZ3B1L2RybS9kcm1faW9jdGwuYyB8ICAgNSArKwo+ICBpbmNsdWRl L2RybS9kcm1QLmggICAgICAgICAgfCAgIDUgKysKPiAgaW5jbHVkZS9kcm0vZHJtX2NydGMuaCAg ICAgIHwgIDE0ICsrKysrKwo+ICBpbmNsdWRlL3VhcGkvZHJtL2RybS5oICAgICAgfCAgIDcgKysr Cj4gIDUgZmlsZXMgY2hhbmdlZCwgMTQxIGluc2VydGlvbnMoKykKPiAKPiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2RybV9jcnRjLmMgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2NydGMuYwo+ IGluZGV4IDlkM2Y4MGUuLjNhODI1N2UgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2Ry bV9jcnRjLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2NydGMuYwo+IEBAIC0xNDI2LDYg KzE0MjYsOTYgQEAgaW50IGRybV9wbGFuZV9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHN0 cnVjdCBkcm1fcGxhbmUgKnBsYW5lLAo+ICBFWFBPUlRfU1lNQk9MKGRybV9wbGFuZV9pbml0KTsK PiAgCj4gIC8qKgo+ICsgKiBkcm1fc2hhcmVfcGxhbmVfaW5pdCAtIEluaXRpYWxpemUgYSBzaGFy ZSBwbGFuZQo+ICsgKiBAZGV2OiBEUk0gZGV2aWNlCj4gKyAqIEBwbGFuZTogcGxhbmUgb2JqZWN0 IHRvIGluaXQKPiArICogQHBhcmVudDogdGhpcyBwbGFuZSBzaGFyZSBzb21lIHJlc291cmNlcyB3 aXRoIHBhcmVudCBwbGFuZS4KPiArICogQHBvc3NpYmxlX2NydGNzOiBiaXRtYXNrIG9mIHBvc3Np YmxlIENSVENzCj4gKyAqIEBmdW5jczogY2FsbGJhY2tzIGZvciB0aGUgbmV3IHBsYW5lCj4gKyAq IEBmb3JtYXRzOiBhcnJheSBvZiBzdXBwb3J0ZWQgZm9ybWF0cyAoJURSTV9GT1JNQVRfKikKPiAr ICogQGZvcm1hdF9jb3VudDogbnVtYmVyIG9mIGVsZW1lbnRzIGluIEBmb3JtYXRzCj4gKyAqIEB0 eXBlOiB0eXBlIG9mIHBsYW5lIChvdmVybGF5LCBwcmltYXJ5LCBjdXJzb3IpCj4gKyAqCj4gKyAq IFdpdGggdGhpcyBBUEksIHRoZSBwbGFuZSBjYW4gc2hhcmUgaGFyZHdhcmUgcmVzb3VyY2VzIHdp dGggb3RoZXIgcGxhbmVzLgo+ICsgKgo+ICsgKiAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gKyAqICAgfCAgc2Nhbm91dCAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHwKPiArICogICB8ICAgICAgICAgLS0tLS0tLS0tLS0t LS0tLS0tICAgICAgICAgICAgICAgICAgICAgfAo+ICsgKiAgIHwgICAgICAgICB8ICBwYXJlbnQg cGxhbmUgIHwgICAgICAgICAgICAgICAgICAgICB8Cj4gKyAqICAgfCAgICAgICAgIHwgYWN0aXZl IHNjYW5vdXQgfCAgICAgICAgICAgICAgICAgICAgIHwKPiArICogICB8ICAgICAgICAgfCAgICAg ICAgICAgICAgICB8ICAgLS0tLS0tLS0tLS0tLS0tLS0gfAo+ICsgKiAgIHwgICAgICAgICAtLS0t LS0tLS0tLS0tLS0tLS0gICB8IHNoYXJlIHBsYW5lIDEgfCB8Cj4gKyAqICAgfCAgLS0tLS0tLS0t LS0tLS0tLS0gICAgICAgICAgIHxhY3RpdmUgc2Nhbm91dCB8IHwKPiArICogICB8ICB8IHNoYXJl IHBsYW5lIDAgfCAgICAgICAgICAgfCAgICAgICAgICAgICAgIHwgfAo+ICsgKiAgIHwgIHxhY3Rp dmUgc2Nhbm91dCB8ICAgICAgICAgICAtLS0tLS0tLS0tLS0tLS0tLSB8Cj4gKyAqICAgfCAgfCAg ICAgICAgICAgICAgIHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKPiArICogICB8ICAt LS0tLS0tLS0tLS0tLS0tLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAo+ICsgKiAgIC0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gKyAqCj4g KyAqICAgIHBhcmVudCBwbGFuZQo+ICsgKiAgICAgICAgfC0tLXNoYXJlIHBsYW5lIDAKPiArICog ICAgICAgIHwtLS1zaGFyZSBwbGFuZSAxCj4gKyAqICAgICAgICAuLi4KPiArICoKPiArICogVGhl IHBsYW5lIGhhcmR3YXJlIGlzIHVzZWQgd2hlbiB0aGUgZGlzcGxheSBzY2Fub3V0IHJ1biBpbnRv IHBsYW5lIGFjdGl2ZQo+ICsgKiBzY2Fub3V0LCB0aGF0IG1lYW5zIHdlIGNhbiByZXVzZSB0aGUg cGxhbmUgaGFyZHdhcmUgcmVzb3VyY2VzIG9uIHBsYW5lCj4gKyAqIG5vbi1hY3RpdmUgc2Nhbm91 dC4KPiArICoKPiArICogQmVjYXVzZSByZXNvdXJjZSBzaGFyZSwgVGhlcmUgYXJlIHNvbWUgbGlt aXQgb24gc2hhcmUgcGxhbmU6IG9uZSBncm91cAo+ICsgKiBvZiBzaGFyZSBwbGFuZXMgbmVlZCB1 c2Ugc2FtZSB6cG9zLCBjYW4ndCBub3Qgb3ZlcmxhcCwgZXRjLgo+ICsgKgo+ICsgKiBIZXJlIGFz c3VtZSBzaGFyZSBwbGFuZSBpcyBhIHVuaXZlcnNhbCBwbGFuZSB3aXRoIHNvbWUgbGltaXQgZmxh Z3MuCj4gKyAqIHBlb3BsZSB3aG8gdXNlIHRoZSBzaGFyZSBwbGFuZSBuZWVkIGtub3cgdGhlIGxp bWl0LCBzaG91bGQgY2FsbCB0aGUgaW9jdGwKPiArICogRFJNX0NMSUVOVF9DQVBfU0hBUkVfUExB TkVTLCBhbmQganVkZ2UgdGhlIHBsYW5lcyBsaW1pdCBiZWZvcmUgdXNlIGl0Lgo+ICsgKgo+ICsg KiBSZXR1cm5zOgo+ICsgKiBaZXJvIG9uIHN1Y2Nlc3MsIGVycm9yIGNvZGUgb24gZmFpbHVyZS4K PiArICovCj4gKwo+ICtpbnQgZHJtX3NoYXJlX3BsYW5lX2luaXQoc3RydWN0IGRybV9kZXZpY2Ug KmRldiwgc3RydWN0IGRybV9wbGFuZSAqcGxhbmUsCj4gKwkJCSBzdHJ1Y3QgZHJtX3BsYW5lICpw YXJlbnQsCj4gKwkJCSB1bnNpZ25lZCBsb25nIHBvc3NpYmxlX2NydGNzLAo+ICsJCQkgY29uc3Qg c3RydWN0IGRybV9wbGFuZV9mdW5jcyAqZnVuY3MsCj4gKwkJCSBjb25zdCB1aW50MzJfdCAqZm9y bWF0cywgdW5zaWduZWQgaW50IGZvcm1hdF9jb3VudCwKPiArCQkJIGVudW0gZHJtX3BsYW5lX3R5 cGUgdHlwZSkKPiArewo+ICsJc3RydWN0IGRybV9tb2RlX2NvbmZpZyAqY29uZmlnID0gJmRldi0+ bW9kZV9jb25maWc7Cj4gKwlpbnQgcmV0Owo+ICsJaW50IHNoYXJlX2lkOwo+ICsKPiArCS8qCj4g KwkgKiBUT0RPOiBvbmx5IHZlcmlmaWVkIG9uIEFUT01JQyBkcm0gZHJpdmVyLgo+ICsJICovCj4g KwlpZiAoIWRybV9jb3JlX2NoZWNrX2ZlYXR1cmUoZGV2LCBEUklWRVJfQVRPTUlDKSkKPiArCQly ZXR1cm4gLUVJTlZBTDsKPiArCj4gKwlyZXQgPSBkcm1fdW5pdmVyc2FsX3BsYW5lX2luaXQoZGV2 LCBwbGFuZSwgcG9zc2libGVfY3J0Y3MsIGZ1bmNzLAo+ICsJCQkJICAgICAgIGZvcm1hdHMsIGZv cm1hdF9jb3VudCwgdHlwZSwgTlVMTCk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4g Kwo+ICsJaWYgKHBhcmVudCkgewo+ICsJCS8qCj4gKwkJICogQ2FuJ3Qgc3VwcG9ydCBtb3JlIHRo YW4gdHdvIGxldmVsIHBsYW5lIHNoYXJlLgo+ICsJCSAqLwo+ICsJCVdBUk5fT04ocGFyZW50LT5w YXJlbnQpOwo+ICsJCXNoYXJlX2lkID0gcGFyZW50LT5iYXNlLmlkOwo+ICsJCXBsYW5lLT5wYXJl bnQgPSBwYXJlbnQ7Cj4gKwo+ICsJCWNvbmZpZy0+bnVtX3NoYXJlX3BsYW5lKys7Cj4gKwkJaWYg KHBsYW5lLT50eXBlID09IERSTV9QTEFORV9UWVBFX09WRVJMQVkpCj4gKwkJCWNvbmZpZy0+bnVt X3NoYXJlX292ZXJsYXlfcGxhbmUrKzsKPiArCX0gZWxzZSB7Cj4gKwkJc2hhcmVfaWQgPSBwbGFu ZS0+YmFzZS5pZDsKPiArCX0KPiArCj4gKwlkcm1fb2JqZWN0X2F0dGFjaF9wcm9wZXJ0eSgmcGxh bmUtPmJhc2UsCj4gKwkJCQkgICBjb25maWctPnByb3Bfc2hhcmVfaWQsIHNoYXJlX2lkKTsKPiAr CXJldHVybiAwOwo+ICt9Cj4gK0VYUE9SVF9TWU1CT0woZHJtX3NoYXJlX3BsYW5lX2luaXQpOwo+ ICsKPiArLyoqCj4gICAqIGRybV9wbGFuZV9jbGVhbnVwIC0gQ2xlYW4gdXAgdGhlIGNvcmUgcGxh bmUgdXNhZ2UKPiAgICogQHBsYW5lOiBwbGFuZSB0byBjbGVhbnVwCj4gICAqCj4gQEAgLTE0NTIs NiArMTU0MiwxMSBAQCB2b2lkIGRybV9wbGFuZV9jbGVhbnVwKHN0cnVjdCBkcm1fcGxhbmUgKnBs YW5lKQo+ICAJZGV2LT5tb2RlX2NvbmZpZy5udW1fdG90YWxfcGxhbmUtLTsKPiAgCWlmIChwbGFu ZS0+dHlwZSA9PSBEUk1fUExBTkVfVFlQRV9PVkVSTEFZKQo+ICAJCWRldi0+bW9kZV9jb25maWcu bnVtX292ZXJsYXlfcGxhbmUtLTsKPiArCWlmIChwbGFuZS0+cGFyZW50KSB7Cj4gKwkJZGV2LT5t b2RlX2NvbmZpZy5udW1fc2hhcmVfcGxhbmUtLTsKPiArCQlpZiAocGxhbmUtPnR5cGUgPT0gRFJN X1BMQU5FX1RZUEVfT1ZFUkxBWSkKPiArCQkJZGV2LT5tb2RlX2NvbmZpZy5udW1fc2hhcmVfb3Zl cmxheV9wbGFuZS0tOwo+ICsJfQo+ICAJZHJtX21vZGVzZXRfdW5sb2NrX2FsbChkZXYpOwo+ICAK PiAgCVdBUk5fT04ocGxhbmUtPnN0YXRlICYmICFwbGFuZS0+ZnVuY3MtPmF0b21pY19kZXN0cm95 X3N0YXRlKTsKPiBAQCAtMTYwMCw2ICsxNjk1LDEzIEBAIHN0YXRpYyBpbnQgZHJtX21vZGVfY3Jl YXRlX3N0YW5kYXJkX3Byb3BlcnRpZXMoc3RydWN0IGRybV9kZXZpY2UgKmRldikKPiAgCQlyZXR1 cm4gLUVOT01FTTsKPiAgCWRldi0+bW9kZV9jb25maWcucGxhbmVfdHlwZV9wcm9wZXJ0eSA9IHBy b3A7Cj4gIAo+ICsJcHJvcCA9IGRybV9wcm9wZXJ0eV9jcmVhdGVfcmFuZ2UoZGV2LCBEUk1fTU9E RV9QUk9QX0lNTVVUQUJMRSwKPiArCQkJCQkgIlNIQVJFX0lEIiwgMCwgVUlOVF9NQVgpOwo+ICsJ aWYgKCFwcm9wKQo+ICsJCXJldHVybiAtRU5PTUVNOwo+ICsKPiArCWRldi0+bW9kZV9jb25maWcu cHJvcF9zaGFyZV9pZCA9IHByb3A7Cj4gKwo+ICAJcHJvcCA9IGRybV9wcm9wZXJ0eV9jcmVhdGVf cmFuZ2UoZGV2LCBEUk1fTU9ERV9QUk9QX0FUT01JQywKPiAgCQkJIlNSQ19YIiwgMCwgVUlOVF9N QVgpOwo+ICAJaWYgKCFwcm9wKQo+IEBAIC0yNDMxLDYgKzI1MzMsMTIgQEAgaW50IGRybV9tb2Rl X2dldHBsYW5lX3JlcyhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB2b2lkICpkYXRhLAo+ICAJCW51 bV9wbGFuZXMgPSBjb25maWctPm51bV90b3RhbF9wbGFuZTsKPiAgCWVsc2UKPiAgCQludW1fcGxh bmVzID0gY29uZmlnLT5udW1fb3ZlcmxheV9wbGFuZTsKPiArCWlmICghZmlsZV9wcml2LT5zaGFy ZV9wbGFuZXMpIHsKPiArCQlpZiAoZmlsZV9wcml2LT51bml2ZXJzYWxfcGxhbmVzKQo+ICsJCQlu dW1fcGxhbmVzIC09IGNvbmZpZy0+bnVtX3NoYXJlX3BsYW5lOwo+ICsJCWVsc2UKPiArCQkJbnVt X3BsYW5lcyAtPSBjb25maWctPm51bV9zaGFyZV9vdmVybGF5X3BsYW5lOwo+ICsJfQo+ICAKPiAg CS8qCj4gIAkgKiBUaGlzIGlvY3RsIGlzIGNhbGxlZCB0d2ljZSwgb25jZSB0byBkZXRlcm1pbmUg aG93IG11Y2ggc3BhY2UgaXMKPiBAQCAtMjQ0OSw2ICsyNTU3LDggQEAgaW50IGRybV9tb2RlX2dl dHBsYW5lX3JlcyhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB2b2lkICpkYXRhLAo+ICAJCQlpZiAo cGxhbmUtPnR5cGUgIT0gRFJNX1BMQU5FX1RZUEVfT1ZFUkxBWSAmJgo+ICAJCQkgICAgIWZpbGVf cHJpdi0+dW5pdmVyc2FsX3BsYW5lcykKPiAgCQkJCWNvbnRpbnVlOwo+ICsJCQlpZiAocGxhbmUt PnBhcmVudCAmJiAhZmlsZV9wcml2LT5zaGFyZV9wbGFuZXMpCj4gKwkJCQljb250aW51ZTsKPiAg Cj4gIAkJCWlmIChwdXRfdXNlcihwbGFuZS0+YmFzZS5pZCwgcGxhbmVfcHRyICsgY29waWVkKSkK PiAgCQkJCXJldHVybiAtRUZBVUxUOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJt X2lvY3RsLmMgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2lvY3RsLmMKPiBpbmRleCAzM2FmNGE1Li44 YjAxMjBkIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1faW9jdGwuYwo+ICsrKyBi L2RyaXZlcnMvZ3B1L2RybS9kcm1faW9jdGwuYwo+IEBAIC0yOTQsNiArMjk0LDExIEBAIGRybV9z ZXRjbGllbnRjYXAoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgdm9pZCAqZGF0YSwgc3RydWN0IGRy bV9maWxlICpmaWxlX3ByaXYpCj4gIAkJCXJldHVybiAtRUlOVkFMOwo+ICAJCWZpbGVfcHJpdi0+ dW5pdmVyc2FsX3BsYW5lcyA9IHJlcS0+dmFsdWU7Cj4gIAkJYnJlYWs7Cj4gKwljYXNlIERSTV9D TElFTlRfQ0FQX1NIQVJFX1BMQU5FUzoKPiArCQlpZiAocmVxLT52YWx1ZSA+IDEpCj4gKwkJCXJl dHVybiAtRUlOVkFMOwo+ICsJCWZpbGVfcHJpdi0+c2hhcmVfcGxhbmVzID0gcmVxLT52YWx1ZTsK PiArCQlicmVhazsKPiAgCWNhc2UgRFJNX0NMSUVOVF9DQVBfQVRPTUlDOgo+ICAJCWlmICghZHJt X2NvcmVfY2hlY2tfZmVhdHVyZShkZXYsIERSSVZFUl9BVE9NSUMpKQo+ICAJCQlyZXR1cm4gLUVJ TlZBTDsKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJtUC5oIGIvaW5jbHVkZS9kcm0vZHJt UC5oCj4gaW5kZXggYzJmZTJjZi4uMjg1ZDE3NyAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2RybS9k cm1QLmgKPiArKysgYi9pbmNsdWRlL2RybS9kcm1QLmgKPiBAQCAtMzE0LDYgKzMxNCwxMSBAQCBz dHJ1Y3QgZHJtX2ZpbGUgewo+ICAJLyogdHJ1ZSBpZiBjbGllbnQgdW5kZXJzdGFuZHMgYXRvbWlj IHByb3BlcnRpZXMgKi8KPiAgCXVuc2lnbmVkIGF0b21pYzoxOwo+ICAJLyoKPiArCSAqIHRydWUg aWYgY2xpZW50IHVuZGVyc3RhbmRzIHNoYXJlIHBsYW5lcyBhbmQKPiArCSAqIGhhcmR3YXJlIHN1 cHBvcnQgc2hhcmUgcGxhbmVzLgo+ICsJICovCj4gKwl1bnNpZ25lZCBzaGFyZV9wbGFuZXM6MTsK PiArCS8qCj4gIAkgKiBUaGlzIGNsaWVudCBpcyB0aGUgY3JlYXRvciBvZiBAbWFzdGVyLgo+ICAJ ICogUHJvdGVjdGVkIGJ5IHN0cnVjdCBkcm1fZGV2aWNlOjptYXN0ZXJfbXV0ZXguCj4gIAkgKi8K PiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJtX2NydGMuaCBiL2luY2x1ZGUvZHJtL2RybV9j cnRjLmgKPiBpbmRleCA5ZTZhYjRhLi5hM2ZlOWIwIDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvZHJt L2RybV9jcnRjLmgKPiArKysgYi9pbmNsdWRlL2RybS9kcm1fY3J0Yy5oCj4gQEAgLTE2NjAsNiAr MTY2MCw3IEBAIGVudW0gZHJtX3BsYW5lX3R5cGUgewo+ICAvKioKPiAgICogc3RydWN0IGRybV9w bGFuZSAtIGNlbnRyYWwgRFJNIHBsYW5lIGNvbnRyb2wgc3RydWN0dXJlCj4gICAqIEBkZXY6IERS TSBkZXZpY2UgdGhpcyBwbGFuZSBiZWxvbmdzIHRvCj4gKyAqIEBwYXJlbnQ6IHRoaXMgcGxhbmUg c2hhcmUgc29tZSByZXNvdXJjZXMgd2l0aCBwYXJlbnQgcGxhbmUuCj4gICAqIEBoZWFkOiBmb3Ig bGlzdCBtYW5hZ2VtZW50Cj4gICAqIEBuYW1lOiBodW1hbiByZWFkYWJsZSBuYW1lLCBjYW4gYmUg b3ZlcndyaXR0ZW4gYnkgdGhlIGRyaXZlcgo+ICAgKiBAYmFzZTogYmFzZSBtb2RlIG9iamVjdAo+ IEBAIC0xNjc5LDYgKzE2ODAsNyBAQCBlbnVtIGRybV9wbGFuZV90eXBlIHsKPiAgICovCj4gIHN0 cnVjdCBkcm1fcGxhbmUgewo+ICAJc3RydWN0IGRybV9kZXZpY2UgKmRldjsKPiArCXN0cnVjdCBk cm1fcGxhbmUgKnBhcmVudDsKPiAgCXN0cnVjdCBsaXN0X2hlYWQgaGVhZDsKPiAgCj4gIAljaGFy ICpuYW1lOwo+IEBAIC0yNDA4LDYgKzI0MTAsOCBAQCBzdHJ1Y3QgZHJtX21vZGVfY29uZmlnIHsK PiAgCSAqLwo+ICAJaW50IG51bV9vdmVybGF5X3BsYW5lOwo+ICAJaW50IG51bV90b3RhbF9wbGFu ZTsKPiArCWludCBudW1fc2hhcmVfcGxhbmU7Cj4gKwlpbnQgbnVtX3NoYXJlX292ZXJsYXlfcGxh bmU7Cj4gIAlzdHJ1Y3QgbGlzdF9oZWFkIHBsYW5lX2xpc3Q7Cj4gIAo+ICAJaW50IG51bV9jcnRj Owo+IEBAIC0yNDI4LDYgKzI0MzIsOSBAQCBzdHJ1Y3QgZHJtX21vZGVfY29uZmlnIHsKPiAgCj4g IAlzdHJ1Y3QgbXV0ZXggYmxvYl9sb2NrOwo+ICAKPiArCS8qIHBvaW50ZXJzIHRvIHNoYXJlIHBy b3BlcnRpZXMgKi8KPiArCXN0cnVjdCBkcm1fcHJvcGVydHkgKnByb3Bfc2hhcmVfaWQ7Cj4gKwo+ ICAJLyogcG9pbnRlcnMgdG8gc3RhbmRhcmQgcHJvcGVydGllcyAqLwo+ICAJc3RydWN0IGxpc3Rf aGVhZCBwcm9wZXJ0eV9ibG9iX2xpc3Q7Cj4gIAlzdHJ1Y3QgZHJtX3Byb3BlcnR5ICplZGlkX3By b3BlcnR5Owo+IEBAIC0yNjM2LDYgKzI2NDMsMTMgQEAgZXh0ZXJuIGludCBkcm1fcGxhbmVfaW5p dChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAo+ICAJCQkgIGNvbnN0IHN0cnVjdCBkcm1fcGxhbmVf ZnVuY3MgKmZ1bmNzLAo+ICAJCQkgIGNvbnN0IHVpbnQzMl90ICpmb3JtYXRzLCB1bnNpZ25lZCBp bnQgZm9ybWF0X2NvdW50LAo+ICAJCQkgIGJvb2wgaXNfcHJpbWFyeSk7Cj4gK2V4dGVybiBpbnQg ZHJtX3NoYXJlX3BsYW5lX2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgc3RydWN0IGRybV9w bGFuZSAqcGxhbmUsCj4gKwkJCQlzdHJ1Y3QgZHJtX3BsYW5lICpwYXJlbnQsCj4gKwkJCQl1bnNp Z25lZCBsb25nIHBvc3NpYmxlX2NydGNzLAo+ICsJCQkJY29uc3Qgc3RydWN0IGRybV9wbGFuZV9m dW5jcyAqZnVuY3MsCj4gKwkJCQljb25zdCB1aW50MzJfdCAqZm9ybWF0cywKPiArCQkJCXVuc2ln bmVkIGludCBmb3JtYXRfY291bnQsCj4gKwkJCQllbnVtIGRybV9wbGFuZV90eXBlIHR5cGUpOwo+ ICBleHRlcm4gdm9pZCBkcm1fcGxhbmVfY2xlYW51cChzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSk7 Cj4gIAo+ICAvKioKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS91YXBpL2RybS9kcm0uaCBiL2luY2x1 ZGUvdWFwaS9kcm0vZHJtLmgKPiBpbmRleCA0NTI2NzVmLi4wMTk3OWE0IDEwMDY0NAo+IC0tLSBh L2luY2x1ZGUvdWFwaS9kcm0vZHJtLmgKPiArKysgYi9pbmNsdWRlL3VhcGkvZHJtL2RybS5oCj4g QEAgLTY3Nyw2ICs2NzcsMTMgQEAgc3RydWN0IGRybV9nZXRfY2FwIHsKPiAgICovCj4gICNkZWZp bmUgRFJNX0NMSUVOVF9DQVBfQVRPTUlDCTMKPiAgCj4gKy8qKgo+ICsgKiBEUk1fQ0xJRU5UX0NB UF9TSEFSRV9QTEFORVMKPiArICoKPiArICogSWYgc2V0IHRvIDEsIHRoZSBEUk0gY29yZSB3aWxs IGV4cG9zZSBzaGFyZSBwbGFuZXMgdG8gdXNlcnNwYWNlLgo+ICsgKi8KPiArI2RlZmluZSBEUk1f Q0xJRU5UX0NBUF9TSEFSRV9QTEFORVMJNAo+ICsKPiAgLyoqIERSTV9JT0NUTF9TRVRfQ0xJRU5U X0NBUCBpb2N0bCBhcmd1bWVudCB0eXBlICovCj4gIHN0cnVjdCBkcm1fc2V0X2NsaWVudF9jYXAg ewo+ICAJX191NjQgY2FwYWJpbGl0eTsKPiAtLSAKPiAxLjkuMQo+IAo+IAo+IF9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCj4gZHJpLWRldmVsIG1haWxpbmcg bGlzdAo+IGRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKPiBodHRwczovL2xpc3RzLmZy ZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAoKLS0gCkRhbmllbCBWZXR0 ZXIKU29mdHdhcmUgRW5naW5lZXIsIEludGVsIENvcnBvcmF0aW9uCmh0dHA6Ly9ibG9nLmZmd2xs LmNoCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1k ZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczov L2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 From: daniel@ffwll.ch (Daniel Vetter) Date: Tue, 26 Jul 2016 10:26:35 +0200 Subject: [PATCH 1/3] drm: introduce share plane In-Reply-To: <1469519194-23133-1-git-send-email-mark.yao@rock-chips.com> References: <1469519194-23133-1-git-send-email-mark.yao@rock-chips.com> Message-ID: <20160726082635.GA31475@phenom.ffwll.local> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org On Tue, Jul 26, 2016 at 03:46:32PM +0800, Mark Yao wrote: > 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 This seems extremely hw specific, why exactly do we need to add a new relationship on planes? What does this buy on _other_ drivers? Imo this should be solved by virtualizing planes in the driver. Start out by assigning planes, and if you can reuse one for sharing then do that, otherwise allocate a new one. If there's not enough real planes, fail the atomic_check. This seems way to hw specific to be useful as a generic concept. -Daniel > --- > 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 > > > _______________________________________________ > dri-devel mailing list > dri-devel at lists.freedesktop.org > https://lists.freedesktop.org/mailman/listinfo/dri-devel -- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch