From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from perceval.ideasonboard.com ([213.167.242.64]:54382 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751331AbeD1UP2 (ORCPT ); Sat, 28 Apr 2018 16:15:28 -0400 From: Laurent Pinchart To: Kieran Bingham Cc: Laurent Pinchart , linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-renesas-soc@vger.kernel.org Subject: Re: [PATCH v2 8/8] drm: rcar-du: Add support for CRC computation Date: Sat, 28 Apr 2018 23:15:42 +0300 Message-ID: <5006409.6GS1l2aLKO@avalon> In-Reply-To: <2d89cb02-6df2-0240-82ab-c6b51ef129ac@ideasonboard.com> References: <20180422223430.16407-1-laurent.pinchart+renesas@ideasonboard.com> <20180422223430.16407-9-laurent.pinchart+renesas@ideasonboard.com> <2d89cb02-6df2-0240-82ab-c6b51ef129ac@ideasonboard.com> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" Sender: linux-renesas-soc-owner@vger.kernel.org List-ID: Hi Kieran, On Saturday, 28 April 2018 22:16:48 EEST Kieran Bingham wrote: > On 22/04/18 23:34, Laurent Pinchart wrote: > > Implement CRC computation configuration and reporting through the DRM > > debugfs-based CRC API. The CRC source can be configured to any input > > plane or the pipeline output. > > > > Signed-off-by: Laurent Pinchart > > > > I don't think I have any actual blocking questions here, so feel free to add > a > > Reviewed-by: Kieran Bingham > > I'll not be in distress if the CRC structures remain duplicated (although I > see from your other mail you've considered defining the structure > non-anonymously > > > --- > > Changes since v1: > > > > - Format the source names using plane IDs instead of plane indices > > --- > > > > drivers/gpu/drm/rcar-du/rcar_du_crtc.c | 156 ++++++++++++++++++++++++++-- > > drivers/gpu/drm/rcar-du/rcar_du_crtc.h | 19 ++++ > > drivers/gpu/drm/rcar-du/rcar_du_vsp.c | 7 ++ > > 3 files changed, 176 insertions(+), 6 deletions(-) > > > > diff --git a/drivers/gpu/drm/rcar-du/rcar_du_crtc.c > > b/drivers/gpu/drm/rcar-du/rcar_du_crtc.c index c4420538ec85..d71d709fe3d9 > > 100644 > > --- a/drivers/gpu/drm/rcar-du/rcar_du_crtc.c > > +++ b/drivers/gpu/drm/rcar-du/rcar_du_crtc.c [snip] > > @@ -710,15 +756,111 @@ static void rcar_du_crtc_disable_vblank(struct > > drm_crtc *crtc) > > rcrtc->vblank_enable = false; > > } > > > > -static const struct drm_crtc_funcs crtc_funcs = { > > - .reset = drm_atomic_helper_crtc_reset, > > +static int rcar_du_crtc_set_crc_source(struct drm_crtc *crtc, > > + const char *source_name, > > + size_t *values_cnt) > > +{ > > + struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc); > > + struct drm_modeset_acquire_ctx ctx; > > + struct drm_crtc_state *crtc_state; > > + struct drm_atomic_state *state; > > + enum vsp1_du_crc_source source; > > + unsigned int index = 0; > > + unsigned int i; > > + int ret; > > + > > + /* > > + * Parse the source name. Supported values are "plane%u" to compute the > > + * CRC on an input plane (%u is the plane ID), and "auto" to compute > > the > > + * CRC on the composer (VSP) output. > > + */ > > + if (!source_name) { > > + source = VSP1_DU_CRC_NONE; > > + } else if (!strcmp(source_name, "auto")) { > > + source = VSP1_DU_CRC_OUTPUT; > > + } else if (strstarts(source_name, "plane")) { > > + source = VSP1_DU_CRC_PLANE; > > + > > + ret = kstrtouint(source_name + strlen("plane"), 10, &index); > > + if (ret < 0) > > + return ret; > > + > > + for (i = 0; i < rcrtc->vsp->num_planes; ++i) { > > + if (index == rcrtc->vsp->planes[i].plane.base.id) { > > + index = i; > > + break; > > + } > > + } > > + > > + if (i >= rcrtc->vsp->num_planes) > > + return -EINVAL; > > + } else { > > + return -EINVAL; > > + } > > + > > + *values_cnt = 1; > > + > > + /* Perform an atomic commit to set the CRC source. */ > > + drm_modeset_acquire_init(&ctx, 0); > > + > > + state = drm_atomic_state_alloc(crtc->dev); > > + if (!state) { > > + ret = -ENOMEM; > > + goto unlock; > > + } > > + > > + state->acquire_ctx = &ctx; > > + > > +retry: > > + crtc_state = drm_atomic_get_crtc_state(state, crtc); > > + if (!IS_ERR(crtc_state)) { > > + struct rcar_du_crtc_state *rcrtc_state; > > + > > + rcrtc_state = to_rcar_crtc_state(crtc_state); > > + rcrtc_state->crc.source = source; > > + rcrtc_state->crc.index = index; > > + > > + ret = drm_atomic_commit(state); > > Does this 'cost' a vblank ? (as in - does this action being performed from > userspace have the capability to cause flicker, or loss of frame?) It shouldn't cause flicker, but it could delay atomic commits queued by userspace by one frame. It's not ideal, but given that changing the CRC source requires a pipeline update on the VSP side, creating an atomic commit internally in the driver was the easiest solution. Now that the BRU/BRS series has created infrastructure on the VSP side to perform pipeline reconfiguration we could also take advantage of that, but it would still incur a delay of one frame, so I don't think that would really help. > > + } else { > > + ret = PTR_ERR(crtc_state); > > + } > > + > > + if (ret == -EDEADLK) { > > + drm_atomic_state_clear(state); > > + drm_modeset_backoff(&ctx); > > + goto retry; > > Not knowing what the -EDEADLK represents yet, this isn't an infinite loop > opportunity is it ? (I assume the state_clear(),backoff() clean up and > prevent that.) -EDEADLK comes from the drm_atomic_get_crtc_state() or drm_atomic_commit() calls trying to lock a ww-mutex in a way that would cause a deadlock. In that case a backoff sequence is needed to release all locks that have been successfully taken, followed by a retry. The ww-mutex API should prevent infinite loops by ensuring fairness between the contenders. > > + } > > + > > + drm_atomic_state_put(state); > > + > > +unlock: > > + drm_modeset_drop_locks(&ctx); > > + drm_modeset_acquire_fini(&ctx); > > + > > + return 0; > > +} [snip] > > diff --git a/drivers/gpu/drm/rcar-du/rcar_du_crtc.h > > b/drivers/gpu/drm/rcar-du/rcar_du_crtc.h index fdc2bf99bda1..518ee2c60eb8 > > 100644 > > --- a/drivers/gpu/drm/rcar-du/rcar_du_crtc.h > > +++ b/drivers/gpu/drm/rcar-du/rcar_du_crtc.h > > @@ -21,6 +21,8 @@ > > #include > > #include > > > > +#include > > + > > struct rcar_du_group; > > struct rcar_du_vsp; > > > > @@ -69,6 +71,23 @@ struct rcar_du_crtc { > > > > #define to_rcar_crtc(c) container_of(c, struct rcar_du_crtc, crtc) > > > > +/** > > + * struct rcar_du_crtc_state - Driver-specific CRTC state > > + * @state: base DRM CRTC state > > + * @crc.source: source for CRC calculation > > + * @crc.index: index of the CRC source plane (when crc.source is set to > > plane) > > + */ > > +struct rcar_du_crtc_state { > > + struct drm_crtc_state state; > > + > > + struct { > > + enum vsp1_du_crc_source source; > > + unsigned int index; > > + } crc; > > Another definition of this structure ... (is this the third?) do we need to > replicate it each time ? (I know it's small ... but I love to keep things > DRY) I'll fix that as I've introduced a vsp1_du_crc_config structure in response to your review of patch 7/8. > > +}; > > + > > +#define to_rcar_crtc_state(s) container_of(s, struct rcar_du_crtc_state, > > state) > > + > > enum rcar_du_output { > > RCAR_DU_OUTPUT_DPAD0, > > RCAR_DU_OUTPUT_DPAD1, -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH v2 8/8] drm: rcar-du: Add support for CRC computation Date: Sat, 28 Apr 2018 23:15:42 +0300 Message-ID: <5006409.6GS1l2aLKO@avalon> References: <20180422223430.16407-1-laurent.pinchart+renesas@ideasonboard.com> <20180422223430.16407-9-laurent.pinchart+renesas@ideasonboard.com> <2d89cb02-6df2-0240-82ab-c6b51ef129ac@ideasonboard.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [IPv6:2001:4b98:dc2:55:216:3eff:fef7:d647]) by gabe.freedesktop.org (Postfix) with ESMTPS id 3226B6E0EA for ; Sat, 28 Apr 2018 20:15:27 +0000 (UTC) In-Reply-To: <2d89cb02-6df2-0240-82ab-c6b51ef129ac@ideasonboard.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Kieran Bingham Cc: linux-renesas-soc@vger.kernel.org, Laurent Pinchart , dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org SGkgS2llcmFuLAoKT24gU2F0dXJkYXksIDI4IEFwcmlsIDIwMTggMjI6MTY6NDggRUVTVCBLaWVy YW4gQmluZ2hhbSB3cm90ZToKPiBPbiAyMi8wNC8xOCAyMzozNCwgTGF1cmVudCBQaW5jaGFydCB3 cm90ZToKPiA+IEltcGxlbWVudCBDUkMgY29tcHV0YXRpb24gY29uZmlndXJhdGlvbiBhbmQgcmVw b3J0aW5nIHRocm91Z2ggdGhlIERSTQo+ID4gZGVidWdmcy1iYXNlZCBDUkMgQVBJLiBUaGUgQ1JD IHNvdXJjZSBjYW4gYmUgY29uZmlndXJlZCB0byBhbnkgaW5wdXQKPiA+IHBsYW5lIG9yIHRoZSBw aXBlbGluZSBvdXRwdXQuCj4gPiAKPiA+IFNpZ25lZC1vZmYtYnk6IExhdXJlbnQgUGluY2hhcnQK PiA+IDxsYXVyZW50LnBpbmNoYXJ0K3JlbmVzYXNAaWRlYXNvbmJvYXJkLmNvbT4KPiAKPiBJIGRv bid0IHRoaW5rIEkgaGF2ZSBhbnkgYWN0dWFsIGJsb2NraW5nIHF1ZXN0aW9ucyBoZXJlLCBzbyBm ZWVsIGZyZWUgdG8gYWRkCj4gYQo+IAo+IFJldmlld2VkLWJ5OiBLaWVyYW4gQmluZ2hhbSA8a2ll cmFuLmJpbmdoYW0rcmVuZXNhc0BpZGVhc29uYm9hcmQuY29tPgo+IAo+IEknbGwgbm90IGJlIGlu IGRpc3RyZXNzIGlmIHRoZSBDUkMgc3RydWN0dXJlcyByZW1haW4gZHVwbGljYXRlZCAoYWx0aG91 Z2ggSQo+IHNlZSBmcm9tIHlvdXIgb3RoZXIgbWFpbCB5b3UndmUgY29uc2lkZXJlZCBkZWZpbmlu ZyB0aGUgc3RydWN0dXJlCj4gbm9uLWFub255bW91c2x5Cj4gCj4gPiAtLS0KPiA+IENoYW5nZXMg c2luY2UgdjE6Cj4gPiAKPiA+IC0gRm9ybWF0IHRoZSBzb3VyY2UgbmFtZXMgdXNpbmcgcGxhbmUg SURzIGluc3RlYWQgb2YgcGxhbmUgaW5kaWNlcwo+ID4gLS0tCj4gPiAKPiA+ICBkcml2ZXJzL2dw dS9kcm0vcmNhci1kdS9yY2FyX2R1X2NydGMuYyB8IDE1NiArKysrKysrKysrKysrKysrKysrKysr KysrKy0tCj4gPiAgZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9jcnRjLmggfCAgMTkg KysrKwo+ID4gIGRyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfdnNwLmMgIHwgICA3ICsr Cj4gPiAgMyBmaWxlcyBjaGFuZ2VkLCAxNzYgaW5zZXJ0aW9ucygrKSwgNiBkZWxldGlvbnMoLSkK PiA+IAo+ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfY3J0 Yy5jCj4gPiBiL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfY3J0Yy5jIGluZGV4IGM0 NDIwNTM4ZWM4NS4uZDcxZDcwOWZlM2Q5Cj4gPiAxMDA2NDQKPiA+IC0tLSBhL2RyaXZlcnMvZ3B1 L2RybS9yY2FyLWR1L3JjYXJfZHVfY3J0Yy5jCj4gPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vcmNh ci1kdS9yY2FyX2R1X2NydGMuYwoKW3NuaXBdCgo+ID4gQEAgLTcxMCwxNSArNzU2LDExMSBAQCBz dGF0aWMgdm9pZCByY2FyX2R1X2NydGNfZGlzYWJsZV92Ymxhbmsoc3RydWN0Cj4gPiBkcm1fY3J0 YyAqY3J0YykKPiA+ICAJcmNydGMtPnZibGFua19lbmFibGUgPSBmYWxzZTsKPiA+ICB9Cj4gPiAK PiA+IC1zdGF0aWMgY29uc3Qgc3RydWN0IGRybV9jcnRjX2Z1bmNzIGNydGNfZnVuY3MgPSB7Cj4g PiAtCS5yZXNldCA9IGRybV9hdG9taWNfaGVscGVyX2NydGNfcmVzZXQsCj4gPiArc3RhdGljIGlu dCByY2FyX2R1X2NydGNfc2V0X2NyY19zb3VyY2Uoc3RydWN0IGRybV9jcnRjICpjcnRjLAo+ID4g KwkJCQkgICAgICAgY29uc3QgY2hhciAqc291cmNlX25hbWUsCj4gPiArCQkJCSAgICAgICBzaXpl X3QgKnZhbHVlc19jbnQpCj4gPiArewo+ID4gKwlzdHJ1Y3QgcmNhcl9kdV9jcnRjICpyY3J0YyA9 IHRvX3JjYXJfY3J0YyhjcnRjKTsKPiA+ICsJc3RydWN0IGRybV9tb2Rlc2V0X2FjcXVpcmVfY3R4 IGN0eDsKPiA+ICsJc3RydWN0IGRybV9jcnRjX3N0YXRlICpjcnRjX3N0YXRlOwo+ID4gKwlzdHJ1 Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGU7Cj4gPiArCWVudW0gdnNwMV9kdV9jcmNfc291cmNl IHNvdXJjZTsKPiA+ICsJdW5zaWduZWQgaW50IGluZGV4ID0gMDsKPiA+ICsJdW5zaWduZWQgaW50 IGk7Cj4gPiArCWludCByZXQ7Cj4gPiArCj4gPiArCS8qCj4gPiArCSAqIFBhcnNlIHRoZSBzb3Vy Y2UgbmFtZS4gU3VwcG9ydGVkIHZhbHVlcyBhcmUgInBsYW5lJXUiIHRvIGNvbXB1dGUgdGhlCj4g PiArCSAqIENSQyBvbiBhbiBpbnB1dCBwbGFuZSAoJXUgaXMgdGhlIHBsYW5lIElEKSwgYW5kICJh dXRvIiB0byBjb21wdXRlCj4gPiB0aGUKPiA+ICsJICogQ1JDIG9uIHRoZSBjb21wb3NlciAoVlNQ KSBvdXRwdXQuCj4gPiArCSAqLwo+ID4gKwlpZiAoIXNvdXJjZV9uYW1lKSB7Cj4gPiArCQlzb3Vy Y2UgPSBWU1AxX0RVX0NSQ19OT05FOwo+ID4gKwl9IGVsc2UgaWYgKCFzdHJjbXAoc291cmNlX25h bWUsICJhdXRvIikpIHsKPiA+ICsJCXNvdXJjZSA9IFZTUDFfRFVfQ1JDX09VVFBVVDsKPiA+ICsJ fSBlbHNlIGlmIChzdHJzdGFydHMoc291cmNlX25hbWUsICJwbGFuZSIpKSB7Cj4gPiArCQlzb3Vy Y2UgPSBWU1AxX0RVX0NSQ19QTEFORTsKPiA+ICsKPiA+ICsJCXJldCA9IGtzdHJ0b3VpbnQoc291 cmNlX25hbWUgKyBzdHJsZW4oInBsYW5lIiksIDEwLCAmaW5kZXgpOwo+ID4gKwkJaWYgKHJldCA8 IDApCj4gPiArCQkJcmV0dXJuIHJldDsKPiA+ICsKPiA+ICsJCWZvciAoaSA9IDA7IGkgPCByY3J0 Yy0+dnNwLT5udW1fcGxhbmVzOyArK2kpIHsKPiA+ICsJCQlpZiAoaW5kZXggPT0gcmNydGMtPnZz cC0+cGxhbmVzW2ldLnBsYW5lLmJhc2UuaWQpIHsKPiA+ICsJCQkJaW5kZXggPSBpOwo+ID4gKwkJ CQlicmVhazsKPiA+ICsJCQl9Cj4gPiArCQl9Cj4gPiArCj4gPiArCQlpZiAoaSA+PSByY3J0Yy0+ dnNwLT5udW1fcGxhbmVzKQo+ID4gKwkJCXJldHVybiAtRUlOVkFMOwo+ID4gKwl9IGVsc2Ugewo+ ID4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gPiArCX0KPiA+ICsKPiA+ICsJKnZhbHVlc19jbnQgPSAx Owo+ID4gKwo+ID4gKwkvKiBQZXJmb3JtIGFuIGF0b21pYyBjb21taXQgdG8gc2V0IHRoZSBDUkMg c291cmNlLiAqLwo+ID4gKwlkcm1fbW9kZXNldF9hY3F1aXJlX2luaXQoJmN0eCwgMCk7Cj4gPiAr Cj4gPiArCXN0YXRlID0gZHJtX2F0b21pY19zdGF0ZV9hbGxvYyhjcnRjLT5kZXYpOwo+ID4gKwlp ZiAoIXN0YXRlKSB7Cj4gPiArCQlyZXQgPSAtRU5PTUVNOwo+ID4gKwkJZ290byB1bmxvY2s7Cj4g PiArCX0KPiA+ICsKPiA+ICsJc3RhdGUtPmFjcXVpcmVfY3R4ID0gJmN0eDsKPiA+ICsKPiA+ICty ZXRyeToKPiA+ICsJY3J0Y19zdGF0ZSA9IGRybV9hdG9taWNfZ2V0X2NydGNfc3RhdGUoc3RhdGUs IGNydGMpOwo+ID4gKwlpZiAoIUlTX0VSUihjcnRjX3N0YXRlKSkgewo+ID4gKwkJc3RydWN0IHJj YXJfZHVfY3J0Y19zdGF0ZSAqcmNydGNfc3RhdGU7Cj4gPiArCj4gPiArCQlyY3J0Y19zdGF0ZSA9 IHRvX3JjYXJfY3J0Y19zdGF0ZShjcnRjX3N0YXRlKTsKPiA+ICsJCXJjcnRjX3N0YXRlLT5jcmMu c291cmNlID0gc291cmNlOwo+ID4gKwkJcmNydGNfc3RhdGUtPmNyYy5pbmRleCA9IGluZGV4Owo+ ID4gKwo+ID4gKwkJcmV0ID0gZHJtX2F0b21pY19jb21taXQoc3RhdGUpOwo+IAo+IERvZXMgdGhp cyAnY29zdCcgYSB2YmxhbmsgPyAoYXMgaW4gLSBkb2VzIHRoaXMgYWN0aW9uIGJlaW5nIHBlcmZv cm1lZCBmcm9tCj4gdXNlcnNwYWNlIGhhdmUgdGhlIGNhcGFiaWxpdHkgdG8gY2F1c2UgZmxpY2tl ciwgb3IgbG9zcyBvZiBmcmFtZT8pCgpJdCBzaG91bGRuJ3QgY2F1c2UgZmxpY2tlciwgYnV0IGl0 IGNvdWxkIGRlbGF5IGF0b21pYyBjb21taXRzIHF1ZXVlZCBieSAKdXNlcnNwYWNlIGJ5IG9uZSBm cmFtZS4gSXQncyBub3QgaWRlYWwsIGJ1dCBnaXZlbiB0aGF0IGNoYW5naW5nIHRoZSBDUkMgc291 cmNlIApyZXF1aXJlcyBhIHBpcGVsaW5lIHVwZGF0ZSBvbiB0aGUgVlNQIHNpZGUsIGNyZWF0aW5n IGFuIGF0b21pYyBjb21taXQgCmludGVybmFsbHkgaW4gdGhlIGRyaXZlciB3YXMgdGhlIGVhc2ll c3Qgc29sdXRpb24uCgpOb3cgdGhhdCB0aGUgQlJVL0JSUyBzZXJpZXMgaGFzIGNyZWF0ZWQgaW5m cmFzdHJ1Y3R1cmUgb24gdGhlIFZTUCBzaWRlIHRvIApwZXJmb3JtIHBpcGVsaW5lIHJlY29uZmln dXJhdGlvbiB3ZSBjb3VsZCBhbHNvIHRha2UgYWR2YW50YWdlIG9mIHRoYXQsIGJ1dCBpdCAKd291 bGQgc3RpbGwgaW5jdXIgYSBkZWxheSBvZiBvbmUgZnJhbWUsIHNvIEkgZG9uJ3QgdGhpbmsgdGhh dCB3b3VsZCByZWFsbHkgCmhlbHAuCgo+ID4gKwl9IGVsc2Ugewo+ID4gKwkJcmV0ID0gUFRSX0VS UihjcnRjX3N0YXRlKTsKPiA+ICsJfQo+ID4gKwo+ID4gKwlpZiAocmV0ID09IC1FREVBRExLKSB7 Cj4gPiArCQlkcm1fYXRvbWljX3N0YXRlX2NsZWFyKHN0YXRlKTsKPiA+ICsJCWRybV9tb2Rlc2V0 X2JhY2tvZmYoJmN0eCk7Cj4gPiArCQlnb3RvIHJldHJ5Owo+IAo+IE5vdCBrbm93aW5nIHdoYXQg dGhlIC1FREVBRExLIHJlcHJlc2VudHMgeWV0LCB0aGlzIGlzbid0IGFuIGluZmluaXRlIGxvb3AK PiBvcHBvcnR1bml0eSBpcyBpdCA/IChJIGFzc3VtZSB0aGUgc3RhdGVfY2xlYXIoKSxiYWNrb2Zm KCkgY2xlYW4gdXAgYW5kCj4gcHJldmVudCB0aGF0LikKCi1FREVBRExLIGNvbWVzIGZyb20gdGhl IGRybV9hdG9taWNfZ2V0X2NydGNfc3RhdGUoKSBvciBkcm1fYXRvbWljX2NvbW1pdCgpIApjYWxs cyB0cnlpbmcgdG8gbG9jayBhIHd3LW11dGV4IGluIGEgd2F5IHRoYXQgd291bGQgY2F1c2UgYSBk ZWFkbG9jay4gSW4gdGhhdCAKY2FzZSBhIGJhY2tvZmYgc2VxdWVuY2UgaXMgbmVlZGVkIHRvIHJl bGVhc2UgYWxsIGxvY2tzIHRoYXQgaGF2ZSBiZWVuIApzdWNjZXNzZnVsbHkgdGFrZW4sIGZvbGxv d2VkIGJ5IGEgcmV0cnkuIFRoZSB3dy1tdXRleCBBUEkgc2hvdWxkIHByZXZlbnQgCmluZmluaXRl IGxvb3BzIGJ5IGVuc3VyaW5nIGZhaXJuZXNzIGJldHdlZW4gdGhlIGNvbnRlbmRlcnMuCgo+ID4g Kwl9Cj4gPiArCj4gPiArCWRybV9hdG9taWNfc3RhdGVfcHV0KHN0YXRlKTsKPiA+ICsKPiA+ICt1 bmxvY2s6Cj4gPiArCWRybV9tb2Rlc2V0X2Ryb3BfbG9ja3MoJmN0eCk7Cj4gPiArCWRybV9tb2Rl c2V0X2FjcXVpcmVfZmluaSgmY3R4KTsKPiA+ICsKPiA+ICsJcmV0dXJuIDA7Cj4gPiArfQoKW3Nu aXBdCgo+ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfY3J0 Yy5oCj4gPiBiL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfY3J0Yy5oIGluZGV4IGZk YzJiZjk5YmRhMS4uNTE4ZWUyYzYwZWI4Cj4gPiAxMDA2NDQKPiA+IC0tLSBhL2RyaXZlcnMvZ3B1 L2RybS9yY2FyLWR1L3JjYXJfZHVfY3J0Yy5oCj4gPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vcmNh ci1kdS9yY2FyX2R1X2NydGMuaAo+ID4gQEAgLTIxLDYgKzIxLDggQEAKPiA+ICAjaW5jbHVkZSA8 ZHJtL2RybVAuaD4KPiA+ICAjaW5jbHVkZSA8ZHJtL2RybV9jcnRjLmg+Cj4gPiAKPiA+ICsjaW5j bHVkZSA8bWVkaWEvdnNwMS5oPgo+ID4gKwo+ID4gIHN0cnVjdCByY2FyX2R1X2dyb3VwOwo+ID4g IHN0cnVjdCByY2FyX2R1X3ZzcDsKPiA+IAo+ID4gQEAgLTY5LDYgKzcxLDIzIEBAIHN0cnVjdCBy Y2FyX2R1X2NydGMgewo+ID4gCj4gPiAgI2RlZmluZSB0b19yY2FyX2NydGMoYykJY29udGFpbmVy X29mKGMsIHN0cnVjdCByY2FyX2R1X2NydGMsIGNydGMpCj4gPiAKPiA+ICsvKioKPiA+ICsgKiBz dHJ1Y3QgcmNhcl9kdV9jcnRjX3N0YXRlIC0gRHJpdmVyLXNwZWNpZmljIENSVEMgc3RhdGUKPiA+ ICsgKiBAc3RhdGU6IGJhc2UgRFJNIENSVEMgc3RhdGUKPiA+ICsgKiBAY3JjLnNvdXJjZTogc291 cmNlIGZvciBDUkMgY2FsY3VsYXRpb24KPiA+ICsgKiBAY3JjLmluZGV4OiBpbmRleCBvZiB0aGUg Q1JDIHNvdXJjZSBwbGFuZSAod2hlbiBjcmMuc291cmNlIGlzIHNldCB0bwo+ID4gcGxhbmUpCj4g PiArICovCj4gPiArc3RydWN0IHJjYXJfZHVfY3J0Y19zdGF0ZSB7Cj4gPiArCXN0cnVjdCBkcm1f Y3J0Y19zdGF0ZSBzdGF0ZTsKPiA+ICsKPiA+ICsJc3RydWN0IHsKPiA+ICsJCWVudW0gdnNwMV9k dV9jcmNfc291cmNlIHNvdXJjZTsKPiA+ICsJCXVuc2lnbmVkIGludCBpbmRleDsKPiA+ICsJfSBj cmM7Cj4gCj4gQW5vdGhlciBkZWZpbml0aW9uIG9mIHRoaXMgc3RydWN0dXJlIC4uLiAoaXMgdGhp cyB0aGUgdGhpcmQ/KSBkbyB3ZSBuZWVkIHRvCj4gcmVwbGljYXRlIGl0IGVhY2ggdGltZSA/IChJ IGtub3cgaXQncyBzbWFsbCAuLi4gYnV0IEkgbG92ZSB0byBrZWVwIHRoaW5ncwo+IERSWSkKCkkn bGwgZml4IHRoYXQgYXMgSSd2ZSBpbnRyb2R1Y2VkIGEgdnNwMV9kdV9jcmNfY29uZmlnIHN0cnVj dHVyZSBpbiByZXNwb25zZSB0byAKeW91ciByZXZpZXcgb2YgcGF0Y2ggNy84LgoKPiA+ICt9Owo+ ID4gKwo+ID4gKyNkZWZpbmUgdG9fcmNhcl9jcnRjX3N0YXRlKHMpIGNvbnRhaW5lcl9vZihzLCBz dHJ1Y3QgcmNhcl9kdV9jcnRjX3N0YXRlLAo+ID4gc3RhdGUpCj4gPiArCj4gPiAgZW51bSByY2Fy X2R1X291dHB1dCB7Cj4gPiAgCVJDQVJfRFVfT1VUUFVUX0RQQUQwLAo+ID4gIAlSQ0FSX0RVX09V VFBVVF9EUEFEMSwKCi0tIApSZWdhcmRzLAoKTGF1cmVudCBQaW5jaGFydAoKCgpfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBs aXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVz a3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK