From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from perceval.ideasonboard.com ([213.167.242.64]:52040 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726225AbeLIUjd (ORCPT ); Sun, 9 Dec 2018 15:39:33 -0500 From: Laurent Pinchart To: kieran.bingham@ideasonboard.com Cc: Laurent Pinchart , dri-devel@lists.freedesktop.org, linux-renesas-soc@vger.kernel.org Subject: Re: [PATCH 2/5] drm: rcar-du: Move CRTC outputs bitmask to private CRTC state Date: Sun, 09 Dec 2018 22:40:10 +0200 Message-ID: <2458620.yafjqRnD4N@avalon> In-Reply-To: References: <20181125144031.4407-1-laurent.pinchart+renesas@ideasonboard.com> <20181125144031.4407-3-laurent.pinchart+renesas@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 Friday, 7 December 2018 14:34:58 EET Kieran Bingham wrote: > On 25/11/2018 14:40, Laurent Pinchart wrote: > > The rcar_du_crtc outputs field stores a bitmask of the outputs driven by > > the CRTC. This changes based on the configuration requested by > > userspace, and is used for the sole purpose of configuring the hardware. > > The field thus belongs to the CRTC state. Move it to the > > rcar_du_crtc_state structure. > > > > As a result the rcar_du_crtc_route_output() function loses most of its > > purpose. In order to remove it, move dpad0_source calculation to > > rcar_du_atomic_commit_tail(), until the field gets moved to a state > > structure. In order to simplify the rcar_du_group_set_routing() > > implementation, we also store the DPAD1 source in a new dpad1_source > > field which will move to a state structure with dpad0_source. > > > > Signed-off-by: Laurent Pinchart > > > > that was a fairly tough read - but aside from one comment near the > bottom regarding initialising dpad0 which I'm sure you can handle > correctly, and another comment which I think we could improve things > outside of this patch: > > Reviewed-by: Kieran Bingham > > > --- > > > > drivers/gpu/drm/rcar-du/rcar_du_crtc.c | 42 +++++++++++------------ > > drivers/gpu/drm/rcar-du/rcar_du_crtc.h | 7 ++-- > > drivers/gpu/drm/rcar-du/rcar_du_drv.h | 1 + > > drivers/gpu/drm/rcar-du/rcar_du_encoder.c | 10 ------ > > drivers/gpu/drm/rcar-du/rcar_du_group.c | 4 +-- > > drivers/gpu/drm/rcar-du/rcar_du_kms.c | 22 ++++++++++++ > > 6 files changed, 47 insertions(+), 39 deletions(-) > > +8 ... It's a good job you bought -13 lines in the previous patch ;) > > > diff --git a/drivers/gpu/drm/rcar-du/rcar_du_crtc.c > > b/drivers/gpu/drm/rcar-du/rcar_du_crtc.c index 90dacab67be5..40b7f17159b0 > > 100644 > > --- a/drivers/gpu/drm/rcar-du/rcar_du_crtc.c > > +++ b/drivers/gpu/drm/rcar-du/rcar_du_crtc.c > > @@ -22,6 +22,7 @@ > > > > #include "rcar_du_crtc.h" > > #include "rcar_du_drv.h" > > +#include "rcar_du_encoder.h" > > #include "rcar_du_kms.h" > > #include "rcar_du_plane.h" > > #include "rcar_du_regs.h" > > @@ -316,26 +317,6 @@ static void rcar_du_crtc_set_display_timing(struct > > rcar_du_crtc *rcrtc) > > rcar_du_crtc_write(rcrtc, DEWR, mode->hdisplay); > > } > > > > -void rcar_du_crtc_route_output(struct drm_crtc *crtc, > > - enum rcar_du_output output) > > -{ > > - struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc); > > - struct rcar_du_device *rcdu = rcrtc->group->dev; > > - > > - /* > > - * Store the route from the CRTC output to the DU output. The DU will be > > - * configured when starting the CRTC. > > - */ > > - rcrtc->outputs |= BIT(output); > > - > > - /* > > - * Store RGB routing to DPAD0, the hardware will be configured when > > - * starting the CRTC. > > - */ > > - if (output == RCAR_DU_OUTPUT_DPAD0) > > - rcdu->dpad0_source = rcrtc->index; > > -} > > - > > static unsigned int plane_zpos(struct rcar_du_plane *plane) > > { > > return plane->plane.state->normalized_zpos; > > @@ -655,6 +636,24 @@ static void rcar_du_crtc_stop(struct rcar_du_crtc > > *rcrtc) > > * CRTC Functions > > */ > > > > +static int rcar_du_crtc_atomic_check(struct drm_crtc *crtc, > > + struct drm_crtc_state *state) > > +{ > > + struct rcar_du_crtc_state *rstate = to_rcar_crtc_state(state); > > + struct drm_encoder *encoder; > > + > > + /* Store the routes from the CRTC output to the DU outputs. */ > > + rstate->outputs = 0; > > + > > + drm_for_each_encoder_mask(encoder, crtc->dev, state->encoder_mask) { > > + struct rcar_du_encoder *renc = to_rcar_encoder(encoder); > > + > > + rstate->outputs |= BIT(renc->output); > > + } > > + > > + return 0; > > +} > > + > > static void rcar_du_crtc_atomic_enable(struct drm_crtc *crtc, > > struct drm_crtc_state *old_state) > > { > > @@ -678,8 +677,6 @@ static void rcar_du_crtc_atomic_disable(struct > > drm_crtc *crtc, > > crtc->state->event = NULL; > > } > > spin_unlock_irq(&crtc->dev->event_lock); > > - > > - rcrtc->outputs = 0; > > } > > > > static void rcar_du_crtc_atomic_begin(struct drm_crtc *crtc, > > @@ -755,6 +752,7 @@ enum drm_mode_status rcar_du_crtc_mode_valid(struct > > drm_crtc *crtc, > > } > > > > static const struct drm_crtc_helper_funcs crtc_helper_funcs = { > > + .atomic_check = rcar_du_crtc_atomic_check, > > .atomic_begin = rcar_du_crtc_atomic_begin, > > .atomic_flush = rcar_du_crtc_atomic_flush, > > .atomic_enable = rcar_du_crtc_atomic_enable, > > diff --git a/drivers/gpu/drm/rcar-du/rcar_du_crtc.h > > b/drivers/gpu/drm/rcar-du/rcar_du_crtc.h index 59ac6e7d22c9..ec47f164e69b > > 100644 > > --- a/drivers/gpu/drm/rcar-du/rcar_du_crtc.h > > +++ b/drivers/gpu/drm/rcar-du/rcar_du_crtc.h > > @@ -37,7 +37,6 @@ struct rcar_du_vsp; > > * @vblank_lock: protects vblank_wait and vblank_count > > * @vblank_wait: wait queue used to signal vertical blanking > > * @vblank_count: number of vertical blanking interrupts to wait for > > - * @outputs: bitmask of the outputs (enum rcar_du_output) driven by this > > CRTC > > * @group: CRTC group this CRTC belongs to > > * @vsp: VSP feeding video to this CRTC > > * @vsp_pipe: index of the VSP pipeline feeding video to this CRTC > > @@ -61,8 +60,6 @@ struct rcar_du_crtc { > > wait_queue_head_t vblank_wait; > > unsigned int vblank_count; > > > > - unsigned int outputs; > > - > > struct rcar_du_group *group; > > struct rcar_du_vsp *vsp; > > unsigned int vsp_pipe; > > > > @@ -77,11 +74,13 @@ struct rcar_du_crtc { > > * struct rcar_du_crtc_state - Driver-specific CRTC state > > * @state: base DRM CRTC state > > * @crc: CRC computation configuration > > + * @outputs: bitmask of the outputs (enum rcar_du_output) driven by this > > CRTC > > */ > > struct rcar_du_crtc_state { > struct drm_crtc_state state; > > struct vsp1_du_crc_config crc; > > + unsigned int outputs; > > }; > > > > #define to_rcar_crtc_state(s) container_of(s, struct rcar_du_crtc_state, > > state) > > @@ -102,8 +101,6 @@ int rcar_du_crtc_create(struct rcar_du_group *rgrp, > > unsigned int swindex, > > void rcar_du_crtc_suspend(struct rcar_du_crtc *rcrtc); > > void rcar_du_crtc_resume(struct rcar_du_crtc *rcrtc); > > > > -void rcar_du_crtc_route_output(struct drm_crtc *crtc, > > - enum rcar_du_output output); > > void rcar_du_crtc_finish_page_flip(struct rcar_du_crtc *rcrtc); > > > > void rcar_du_crtc_dsysr_clr_set(struct rcar_du_crtc *rcrtc, u32 clr, u32 > > set); > > diff --git a/drivers/gpu/drm/rcar-du/rcar_du_drv.h > > b/drivers/gpu/drm/rcar-du/rcar_du_drv.h index 8ef9165957cb..8b47b8546fc8 > > 100644 > > --- a/drivers/gpu/drm/rcar-du/rcar_du_drv.h > > +++ b/drivers/gpu/drm/rcar-du/rcar_du_drv.h > > @@ -90,6 +90,7 @@ struct rcar_du_device { > > } props; > > > > unsigned int dpad0_source; > > + unsigned int dpad1_source; > > unsigned int vspd1_sink; > > }; > > > > diff --git a/drivers/gpu/drm/rcar-du/rcar_du_encoder.c > > b/drivers/gpu/drm/rcar-du/rcar_du_encoder.c index > > 1877764bd6d9..a123c28ea6ed 100644 > > --- a/drivers/gpu/drm/rcar-du/rcar_du_encoder.c > > +++ b/drivers/gpu/drm/rcar-du/rcar_du_encoder.c > > @@ -22,17 +22,7 @@ > > * Encoder > > */ > > > > -static void rcar_du_encoder_mode_set(struct drm_encoder *encoder, > > - struct drm_crtc_state *crtc_state, > > - struct drm_connector_state *conn_state) > > -{ > > - struct rcar_du_encoder *renc = to_rcar_encoder(encoder); > > - > > - rcar_du_crtc_route_output(crtc_state->crtc, renc->output); > > -} > > - > > static const struct drm_encoder_helper_funcs encoder_helper_funcs = { > > - .atomic_mode_set = rcar_du_encoder_mode_set, > > }; > > > > static const struct drm_encoder_funcs encoder_funcs = { > > diff --git a/drivers/gpu/drm/rcar-du/rcar_du_group.c > > b/drivers/gpu/drm/rcar-du/rcar_du_group.c index > > 3366cda6086c..7e440f61977f 100644 > > --- a/drivers/gpu/drm/rcar-du/rcar_du_group.c > > +++ b/drivers/gpu/drm/rcar-du/rcar_du_group.c > > @@ -289,7 +289,7 @@ int rcar_du_set_dpad0_vsp1_routing(struct > > rcar_du_device *rcdu) > > int rcar_du_group_set_routing(struct rcar_du_group *rgrp) > > { > > > > - struct rcar_du_crtc *crtc0 = &rgrp->dev->crtcs[rgrp->index * 2]; > > + struct rcar_du_device *rcdu = rgrp->dev; > > u32 dorcr = rcar_du_group_read(rgrp, DORCR); > > > > dorcr &= ~(DORCR_PG2T | DORCR_DK2S | DORCR_PG2D_MASK); > > @@ -299,7 +299,7 @@ int rcar_du_group_set_routing(struct rcar_du_group > > *rgrp) > > * CRTC 1 in all other cases to avoid cloning CRTC 0 to DPAD0 and DPAD1 > > * by default. > > */ > > - if (crtc0->outputs & BIT(RCAR_DU_OUTPUT_DPAD1)) > > + if (rcdu->dpad1_source == rgrp->index * 2) > > The magic of getting (rgrp->index * 2) is a little bit ... magic ... > > The what is happening ( ({0,1} => {0,2}) ) is clear - but not the why. > > This happens a bit throughout as a means to convert from CRTC to Group > indexes, and back. But it could be clearer with a helper. > (not in this patch) I agree. Let's see what happens first, a helper function or a complete rewrite of group handling based on atomic states :-) > > dorcr |= DORCR_PG2D_DS1; > > else > > dorcr |= DORCR_PG2T | DORCR_DK2S | DORCR_PG2D_DS2; > > diff --git a/drivers/gpu/drm/rcar-du/rcar_du_kms.c > > b/drivers/gpu/drm/rcar-du/rcar_du_kms.c index fe6f65c94eef..bd3c2c5ea66f > > 100644 > > --- a/drivers/gpu/drm/rcar-du/rcar_du_kms.c > > +++ b/drivers/gpu/drm/rcar-du/rcar_du_kms.c > > @@ -285,6 +285,28 @@ static int rcar_du_atomic_check(struct drm_device > > *dev, > > static void rcar_du_atomic_commit_tail(struct drm_atomic_state > > *old_state) > > { > > struct drm_device *dev = old_state->dev; > > + struct rcar_du_device *rcdu = dev->dev_private; > > + struct drm_crtc_state *crtc_state; > > + struct drm_crtc *crtc; > > + unsigned int i; > > + > > + /* > > + * Store RGB routing to DPAD0 and DPAD1, the hardware will be configured > > + * when starting the CRTCs. > > + */ > > + rcdu->dpad1_source = -1; > > Why do we initialise dpad1_source but not dpad0_source? > > Are we *guaranteed* to always have RCAR_DU_OUTPUT_DPAD0 set in one of > the rcrtc_state->outputs ? > > If so - then this isn't an issue. No, there's no guarantee, but it's still not an issue :-) If none of the CRTCs in this commit output to DPAD0, the value of rcdu->dpad0_source will remain unchanged, which is what we want. For DPAD1 the situation is a bit different. The only R-Car SoCs to have DPAD1 are H1, V2H and E2, and they all have fixed output routing (DU0 to DPAD0 and DU1 to DPAD1). There's however a way to route the output of the composer inside DU0 to the DU1 output, and vice-versa. The DU driver uses this feature to configure the routing of the DPAD1 on H1 only (I don't remember the historical reason, or perhaps the historical mistake). We need to only route DU0 to DPAD1 when explicitly requested (as explained in rcar_du_group_set_routing()) and DU1 to DPAD1 in all other cases. Initializing dpad1_source to -1 will ensure that. The group code really needs to be rewritten to use atomic states (and I wonder whether the DU0 -> DPAD1 routing should be kept). > > + > > + for_each_new_crtc_in_state(old_state, crtc, crtc_state, i) { > > + struct rcar_du_crtc_state *rcrtc_state = > > + to_rcar_crtc_state(crtc_state); > > + struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc); > > + > > + if (rcrtc_state->outputs & BIT(RCAR_DU_OUTPUT_DPAD0)) > > + rcdu->dpad0_source = rcrtc->index; > > + > > + if (rcrtc_state->outputs & BIT(RCAR_DU_OUTPUT_DPAD1)) > > + rcdu->dpad1_source = rcrtc->index; > > + } > > > > /* Apply the atomic update. */ > > drm_atomic_helper_commit_modeset_disables(dev, old_state); -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH 2/5] drm: rcar-du: Move CRTC outputs bitmask to private CRTC state Date: Sun, 09 Dec 2018 22:40:10 +0200 Message-ID: <2458620.yafjqRnD4N@avalon> References: <20181125144031.4407-1-laurent.pinchart+renesas@ideasonboard.com> <20181125144031.4407-3-laurent.pinchart+renesas@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 085F56E271 for ; Sun, 9 Dec 2018 20:39:33 +0000 (UTC) In-Reply-To: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: kieran.bingham@ideasonboard.com Cc: linux-renesas-soc@vger.kernel.org, Laurent Pinchart , dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org SGkgS2llcmFuLAoKT24gRnJpZGF5LCA3IERlY2VtYmVyIDIwMTggMTQ6MzQ6NTggRUVUIEtpZXJh biBCaW5naGFtIHdyb3RlOgo+IE9uIDI1LzExLzIwMTggMTQ6NDAsIExhdXJlbnQgUGluY2hhcnQg d3JvdGU6Cj4gPiBUaGUgcmNhcl9kdV9jcnRjIG91dHB1dHMgZmllbGQgc3RvcmVzIGEgYml0bWFz ayBvZiB0aGUgb3V0cHV0cyBkcml2ZW4gYnkKPiA+IHRoZSBDUlRDLiBUaGlzIGNoYW5nZXMgYmFz ZWQgb24gdGhlIGNvbmZpZ3VyYXRpb24gcmVxdWVzdGVkIGJ5Cj4gPiB1c2Vyc3BhY2UsIGFuZCBp cyB1c2VkIGZvciB0aGUgc29sZSBwdXJwb3NlIG9mIGNvbmZpZ3VyaW5nIHRoZSBoYXJkd2FyZS4K PiA+IFRoZSBmaWVsZCB0aHVzIGJlbG9uZ3MgdG8gdGhlIENSVEMgc3RhdGUuIE1vdmUgaXQgdG8g dGhlCj4gPiByY2FyX2R1X2NydGNfc3RhdGUgc3RydWN0dXJlLgo+ID4gCj4gPiBBcyBhIHJlc3Vs dCB0aGUgcmNhcl9kdV9jcnRjX3JvdXRlX291dHB1dCgpIGZ1bmN0aW9uIGxvc2VzIG1vc3Qgb2Yg aXRzCj4gPiBwdXJwb3NlLiBJbiBvcmRlciB0byByZW1vdmUgaXQsIG1vdmUgZHBhZDBfc291cmNl IGNhbGN1bGF0aW9uIHRvCj4gPiByY2FyX2R1X2F0b21pY19jb21taXRfdGFpbCgpLCB1bnRpbCB0 aGUgZmllbGQgZ2V0cyBtb3ZlZCB0byBhIHN0YXRlCj4gPiBzdHJ1Y3R1cmUuIEluIG9yZGVyIHRv IHNpbXBsaWZ5IHRoZSByY2FyX2R1X2dyb3VwX3NldF9yb3V0aW5nKCkKPiA+IGltcGxlbWVudGF0 aW9uLCB3ZSBhbHNvIHN0b3JlIHRoZSBEUEFEMSBzb3VyY2UgaW4gYSBuZXcgZHBhZDFfc291cmNl Cj4gPiBmaWVsZCB3aGljaCB3aWxsIG1vdmUgdG8gYSBzdGF0ZSBzdHJ1Y3R1cmUgd2l0aCBkcGFk MF9zb3VyY2UuCj4gPiAKPiA+IFNpZ25lZC1vZmYtYnk6IExhdXJlbnQgUGluY2hhcnQKPiA+IDxs YXVyZW50LnBpbmNoYXJ0K3JlbmVzYXNAaWRlYXNvbmJvYXJkLmNvbT4KPiAKPiB0aGF0IHdhcyBh IGZhaXJseSB0b3VnaCByZWFkIC0gYnV0IGFzaWRlIGZyb20gb25lIGNvbW1lbnQgbmVhciB0aGUK PiBib3R0b20gcmVnYXJkaW5nIGluaXRpYWxpc2luZyBkcGFkMCB3aGljaCBJJ20gc3VyZSB5b3Ug Y2FuIGhhbmRsZQo+IGNvcnJlY3RseSwgYW5kIGFub3RoZXIgY29tbWVudCB3aGljaCBJIHRoaW5r IHdlIGNvdWxkIGltcHJvdmUgdGhpbmdzCj4gb3V0c2lkZSBvZiB0aGlzIHBhdGNoOgo+IAo+IFJl dmlld2VkLWJ5OiBLaWVyYW4gQmluZ2hhbSA8a2llcmFuLmJpbmdoYW0rcmVuZXNhc0BpZGVhc29u Ym9hcmQuY29tPgo+IAo+ID4gLS0tCj4gPiAKPiA+ICBkcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9y Y2FyX2R1X2NydGMuYyAgICB8IDQyICsrKysrKysrKysrLS0tLS0tLS0tLS0tCj4gPiAgZHJpdmVy cy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9jcnRjLmggICAgfCAgNyArKy0tCj4gPiAgZHJpdmVy cy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9kcnYuaCAgICAgfCAgMSArCj4gPiAgZHJpdmVycy9n cHUvZHJtL3JjYXItZHUvcmNhcl9kdV9lbmNvZGVyLmMgfCAxMCAtLS0tLS0KPiA+ICBkcml2ZXJz L2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X2dyb3VwLmMgICB8ICA0ICstLQo+ID4gIGRyaXZlcnMv Z3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfa21zLmMgICAgIHwgMjIgKysrKysrKysrKysrCj4gPiAg NiBmaWxlcyBjaGFuZ2VkLCA0NyBpbnNlcnRpb25zKCspLCAzOSBkZWxldGlvbnMoLSkKPiAKPiAr OCAuLi4gSXQncyBhIGdvb2Qgam9iIHlvdSBib3VnaHQgLTEzIGxpbmVzIGluIHRoZSBwcmV2aW91 cyBwYXRjaCA7KQo+IAo+ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3Jj YXJfZHVfY3J0Yy5jCj4gPiBiL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfY3J0Yy5j IGluZGV4IDkwZGFjYWI2N2JlNS4uNDBiN2YxNzE1OWIwCj4gPiAxMDA2NDQKPiA+IC0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfY3J0Yy5jCj4gPiArKysgYi9kcml2ZXJzL2dw dS9kcm0vcmNhci1kdS9yY2FyX2R1X2NydGMuYwo+ID4gQEAgLTIyLDYgKzIyLDcgQEAKPiA+IAo+ ID4gICNpbmNsdWRlICJyY2FyX2R1X2NydGMuaCIKPiA+ICAjaW5jbHVkZSAicmNhcl9kdV9kcnYu aCIKPiA+ICsjaW5jbHVkZSAicmNhcl9kdV9lbmNvZGVyLmgiCj4gPiAgI2luY2x1ZGUgInJjYXJf ZHVfa21zLmgiCj4gPiAgI2luY2x1ZGUgInJjYXJfZHVfcGxhbmUuaCIKPiA+ICAjaW5jbHVkZSAi cmNhcl9kdV9yZWdzLmgiCj4gPiBAQCAtMzE2LDI2ICszMTcsNiBAQCBzdGF0aWMgdm9pZCByY2Fy X2R1X2NydGNfc2V0X2Rpc3BsYXlfdGltaW5nKHN0cnVjdAo+ID4gcmNhcl9kdV9jcnRjICpyY3J0 YykKPiA+ICAJcmNhcl9kdV9jcnRjX3dyaXRlKHJjcnRjLCBERVdSLCAgbW9kZS0+aGRpc3BsYXkp Owo+ID4gIH0KPiA+IAo+ID4gLXZvaWQgcmNhcl9kdV9jcnRjX3JvdXRlX291dHB1dChzdHJ1Y3Qg ZHJtX2NydGMgKmNydGMsCj4gPiAtCQkJICAgICAgIGVudW0gcmNhcl9kdV9vdXRwdXQgb3V0cHV0 KQo+ID4gLXsKPiA+IC0Jc3RydWN0IHJjYXJfZHVfY3J0YyAqcmNydGMgPSB0b19yY2FyX2NydGMo Y3J0Yyk7Cj4gPiAtCXN0cnVjdCByY2FyX2R1X2RldmljZSAqcmNkdSA9IHJjcnRjLT5ncm91cC0+ ZGV2Owo+ID4gLQo+ID4gLQkvKgo+ID4gLQkgKiBTdG9yZSB0aGUgcm91dGUgZnJvbSB0aGUgQ1JU QyBvdXRwdXQgdG8gdGhlIERVIG91dHB1dC4gVGhlIERVIHdpbGwgCmJlCj4gPiAtCSAqIGNvbmZp Z3VyZWQgd2hlbiBzdGFydGluZyB0aGUgQ1JUQy4KPiA+IC0JICovCj4gPiAtCXJjcnRjLT5vdXRw dXRzIHw9IEJJVChvdXRwdXQpOwo+ID4gLQo+ID4gLQkvKgo+ID4gLQkgKiBTdG9yZSBSR0Igcm91 dGluZyB0byBEUEFEMCwgdGhlIGhhcmR3YXJlIHdpbGwgYmUgY29uZmlndXJlZCB3aGVuCj4gPiAt CSAqIHN0YXJ0aW5nIHRoZSBDUlRDLgo+ID4gLQkgKi8KPiA+IC0JaWYgKG91dHB1dCA9PSBSQ0FS X0RVX09VVFBVVF9EUEFEMCkKPiA+IC0JCXJjZHUtPmRwYWQwX3NvdXJjZSA9IHJjcnRjLT5pbmRl eDsKPiA+IC19Cj4gPiAtCj4gPiAgc3RhdGljIHVuc2lnbmVkIGludCBwbGFuZV96cG9zKHN0cnVj dCByY2FyX2R1X3BsYW5lICpwbGFuZSkKPiA+ICB7Cj4gPiAgCXJldHVybiBwbGFuZS0+cGxhbmUu c3RhdGUtPm5vcm1hbGl6ZWRfenBvczsKPiA+IEBAIC02NTUsNiArNjM2LDI0IEBAIHN0YXRpYyB2 b2lkIHJjYXJfZHVfY3J0Y19zdG9wKHN0cnVjdCByY2FyX2R1X2NydGMKPiA+ICpyY3J0YykKPiA+ ICAgKiBDUlRDIEZ1bmN0aW9ucwo+ID4gICAqLwo+ID4gCj4gPiArc3RhdGljIGludCByY2FyX2R1 X2NydGNfYXRvbWljX2NoZWNrKHN0cnVjdCBkcm1fY3J0YyAqY3J0YywKPiA+ICsJCQkJICAgICBz dHJ1Y3QgZHJtX2NydGNfc3RhdGUgKnN0YXRlKQo+ID4gK3sKPiA+ICsJc3RydWN0IHJjYXJfZHVf Y3J0Y19zdGF0ZSAqcnN0YXRlID0gdG9fcmNhcl9jcnRjX3N0YXRlKHN0YXRlKTsKPiA+ICsJc3Ry dWN0IGRybV9lbmNvZGVyICplbmNvZGVyOwo+ID4gKwo+ID4gKwkvKiBTdG9yZSB0aGUgcm91dGVz IGZyb20gdGhlIENSVEMgb3V0cHV0IHRvIHRoZSBEVSBvdXRwdXRzLiAqLwo+ID4gKwlyc3RhdGUt Pm91dHB1dHMgPSAwOwo+ID4gKwo+ID4gKwlkcm1fZm9yX2VhY2hfZW5jb2Rlcl9tYXNrKGVuY29k ZXIsIGNydGMtPmRldiwgc3RhdGUtPmVuY29kZXJfbWFzaykgewo+ID4gKwkJc3RydWN0IHJjYXJf ZHVfZW5jb2RlciAqcmVuYyA9IHRvX3JjYXJfZW5jb2RlcihlbmNvZGVyKTsKPiA+ICsKPiA+ICsJ CXJzdGF0ZS0+b3V0cHV0cyB8PSBCSVQocmVuYy0+b3V0cHV0KTsKPiA+ICsJfQo+ID4gKwo+ID4g KwlyZXR1cm4gMDsKPiA+ICt9Cj4gPiArCj4gPiAgc3RhdGljIHZvaWQgcmNhcl9kdV9jcnRjX2F0 b21pY19lbmFibGUoc3RydWN0IGRybV9jcnRjICpjcnRjLAo+ID4gIAkJCQkgICAgICAgc3RydWN0 IGRybV9jcnRjX3N0YXRlICpvbGRfc3RhdGUpCj4gPiAgewo+ID4gQEAgLTY3OCw4ICs2NzcsNiBA QCBzdGF0aWMgdm9pZCByY2FyX2R1X2NydGNfYXRvbWljX2Rpc2FibGUoc3RydWN0Cj4gPiBkcm1f Y3J0YyAqY3J0YywKPiA+ICAJCWNydGMtPnN0YXRlLT5ldmVudCA9IE5VTEw7Cj4gPiAgCX0KPiA+ ICAJc3Bpbl91bmxvY2tfaXJxKCZjcnRjLT5kZXYtPmV2ZW50X2xvY2spOwo+ID4gLQo+ID4gLQly Y3J0Yy0+b3V0cHV0cyA9IDA7Cj4gPiAgfQo+ID4gIAo+ID4gIHN0YXRpYyB2b2lkIHJjYXJfZHVf Y3J0Y19hdG9taWNfYmVnaW4oc3RydWN0IGRybV9jcnRjICpjcnRjLAo+ID4gQEAgLTc1NSw2ICs3 NTIsNyBAQCBlbnVtIGRybV9tb2RlX3N0YXR1cyByY2FyX2R1X2NydGNfbW9kZV92YWxpZChzdHJ1 Y3QKPiA+IGRybV9jcnRjICpjcnRjLAo+ID4gIH0KPiA+ICAKPiA+ICBzdGF0aWMgY29uc3Qgc3Ry dWN0IGRybV9jcnRjX2hlbHBlcl9mdW5jcyBjcnRjX2hlbHBlcl9mdW5jcyA9IHsKPiA+ICsJLmF0 b21pY19jaGVjayA9IHJjYXJfZHVfY3J0Y19hdG9taWNfY2hlY2ssCj4gPiAgCS5hdG9taWNfYmVn aW4gPSByY2FyX2R1X2NydGNfYXRvbWljX2JlZ2luLAo+ID4gIAkuYXRvbWljX2ZsdXNoID0gcmNh cl9kdV9jcnRjX2F0b21pY19mbHVzaCwKPiA+ICAJLmF0b21pY19lbmFibGUgPSByY2FyX2R1X2Ny dGNfYXRvbWljX2VuYWJsZSwKPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmNhci1k dS9yY2FyX2R1X2NydGMuaAo+ID4gYi9kcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X2Ny dGMuaCBpbmRleCA1OWFjNmU3ZDIyYzkuLmVjNDdmMTY0ZTY5Ygo+ID4gMTAwNjQ0Cj4gPiAtLS0g YS9kcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X2NydGMuaAo+ID4gKysrIGIvZHJpdmVy cy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9jcnRjLmgKPiA+IEBAIC0zNyw3ICszNyw2IEBAIHN0 cnVjdCByY2FyX2R1X3ZzcDsKPiA+ICAgKiBAdmJsYW5rX2xvY2s6IHByb3RlY3RzIHZibGFua193 YWl0IGFuZCB2YmxhbmtfY291bnQKPiA+ICAgKiBAdmJsYW5rX3dhaXQ6IHdhaXQgcXVldWUgdXNl ZCB0byBzaWduYWwgdmVydGljYWwgYmxhbmtpbmcKPiA+ICAgKiBAdmJsYW5rX2NvdW50OiBudW1i ZXIgb2YgdmVydGljYWwgYmxhbmtpbmcgaW50ZXJydXB0cyB0byB3YWl0IGZvcgo+ID4gLSAqIEBv dXRwdXRzOiBiaXRtYXNrIG9mIHRoZSBvdXRwdXRzIChlbnVtIHJjYXJfZHVfb3V0cHV0KSBkcml2 ZW4gYnkgdGhpcwo+ID4gQ1JUQwo+ID4gICAqIEBncm91cDogQ1JUQyBncm91cCB0aGlzIENSVEMg YmVsb25ncyB0bwo+ID4gICAqIEB2c3A6IFZTUCBmZWVkaW5nIHZpZGVvIHRvIHRoaXMgQ1JUQwo+ ID4gICAqIEB2c3BfcGlwZTogaW5kZXggb2YgdGhlIFZTUCBwaXBlbGluZSBmZWVkaW5nIHZpZGVv IHRvIHRoaXMgQ1JUQwo+ID4gQEAgLTYxLDggKzYwLDYgQEAgc3RydWN0IHJjYXJfZHVfY3J0YyB7 Cj4gPiAgCXdhaXRfcXVldWVfaGVhZF90IHZibGFua193YWl0Owo+ID4gIAl1bnNpZ25lZCBpbnQg dmJsYW5rX2NvdW50Owo+ID4gCj4gPiAtCXVuc2lnbmVkIGludCBvdXRwdXRzOwo+ID4gLQo+ID4g IAlzdHJ1Y3QgcmNhcl9kdV9ncm91cCAqZ3JvdXA7Cj4gPiAgCXN0cnVjdCByY2FyX2R1X3ZzcCAq dnNwOwo+ID4gIAl1bnNpZ25lZCBpbnQgdnNwX3BpcGU7Cj4gPiAKPiA+IEBAIC03NywxMSArNzQs MTMgQEAgc3RydWN0IHJjYXJfZHVfY3J0YyB7Cj4gPiAgICogc3RydWN0IHJjYXJfZHVfY3J0Y19z dGF0ZSAtIERyaXZlci1zcGVjaWZpYyBDUlRDIHN0YXRlCj4gPiAgICogQHN0YXRlOiBiYXNlIERS TSBDUlRDIHN0YXRlCj4gPiAgICogQGNyYzogQ1JDIGNvbXB1dGF0aW9uIGNvbmZpZ3VyYXRpb24K PiA+ICsgKiBAb3V0cHV0czogYml0bWFzayBvZiB0aGUgb3V0cHV0cyAoZW51bSByY2FyX2R1X291 dHB1dCkgZHJpdmVuIGJ5IHRoaXMKPiA+IENSVEMKPiA+ICAgKi8KPiA+ICBzdHJ1Y3QgcmNhcl9k dV9jcnRjX3N0YXRlIHsKID4gIAlzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgc3RhdGU7Cj4gPiAgCXN0 cnVjdCB2c3AxX2R1X2NyY19jb25maWcgY3JjOwo+ID4gKwl1bnNpZ25lZCBpbnQgb3V0cHV0czsK PiA+ICB9Owo+ID4gIAo+ID4gICNkZWZpbmUgdG9fcmNhcl9jcnRjX3N0YXRlKHMpIGNvbnRhaW5l cl9vZihzLCBzdHJ1Y3QgcmNhcl9kdV9jcnRjX3N0YXRlLAo+ID4gIHN0YXRlKQo+ID4gQEAgLTEw Miw4ICsxMDEsNiBAQCBpbnQgcmNhcl9kdV9jcnRjX2NyZWF0ZShzdHJ1Y3QgcmNhcl9kdV9ncm91 cCAqcmdycCwKPiA+IHVuc2lnbmVkIGludCBzd2luZGV4LAo+ID4gIHZvaWQgcmNhcl9kdV9jcnRj X3N1c3BlbmQoc3RydWN0IHJjYXJfZHVfY3J0YyAqcmNydGMpOwo+ID4gIHZvaWQgcmNhcl9kdV9j cnRjX3Jlc3VtZShzdHJ1Y3QgcmNhcl9kdV9jcnRjICpyY3J0Yyk7Cj4gPiAKPiA+IC12b2lkIHJj YXJfZHVfY3J0Y19yb3V0ZV9vdXRwdXQoc3RydWN0IGRybV9jcnRjICpjcnRjLAo+ID4gLQkJCSAg ICAgICBlbnVtIHJjYXJfZHVfb3V0cHV0IG91dHB1dCk7Cj4gPiAgdm9pZCByY2FyX2R1X2NydGNf ZmluaXNoX3BhZ2VfZmxpcChzdHJ1Y3QgcmNhcl9kdV9jcnRjICpyY3J0Yyk7Cj4gPiAgCj4gPiAg dm9pZCByY2FyX2R1X2NydGNfZHN5c3JfY2xyX3NldChzdHJ1Y3QgcmNhcl9kdV9jcnRjICpyY3J0 YywgdTMyIGNsciwgdTMyCj4gPiAgc2V0KTsKPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vcmNhci1kdS9yY2FyX2R1X2Rydi5oCj4gPiBiL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3Jj YXJfZHVfZHJ2LmggaW5kZXggOGVmOTE2NTk1N2NiLi44YjQ3Yjg1NDZmYzgKPiA+IDEwMDY0NAo+ ID4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9kcnYuaAo+ID4gKysrIGIv ZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9kcnYuaAo+ID4gQEAgLTkwLDYgKzkwLDcg QEAgc3RydWN0IHJjYXJfZHVfZGV2aWNlIHsKPiA+ICAJfSBwcm9wczsKPiA+ICAJCj4gPiAgCXVu c2lnbmVkIGludCBkcGFkMF9zb3VyY2U7Cj4gPiArCXVuc2lnbmVkIGludCBkcGFkMV9zb3VyY2U7 Cj4gPiAgCXVuc2lnbmVkIGludCB2c3BkMV9zaW5rOwo+ID4gIH07Cj4gPiAKPiA+IGRpZmYgLS1n aXQgYS9kcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X2VuY29kZXIuYwo+ID4gYi9kcml2 ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X2VuY29kZXIuYyBpbmRleAo+ID4gMTg3Nzc2NGJk NmQ5Li5hMTIzYzI4ZWE2ZWQgMTAwNjQ0Cj4gPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmNhci1k dS9yY2FyX2R1X2VuY29kZXIuYwo+ID4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNh cl9kdV9lbmNvZGVyLmMKPiA+IEBAIC0yMiwxNyArMjIsNyBAQAo+ID4gICAqIEVuY29kZXIKPiA+ ICAgKi8KPiA+IAo+ID4gLXN0YXRpYyB2b2lkIHJjYXJfZHVfZW5jb2Rlcl9tb2RlX3NldChzdHJ1 Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIsCj4gPiAtCQkJCSAgICAgc3RydWN0IGRybV9jcnRjX3N0 YXRlICpjcnRjX3N0YXRlLAo+ID4gLQkJCQkgICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRl ICpjb25uX3N0YXRlKQo+ID4gLXsKPiA+IC0Jc3RydWN0IHJjYXJfZHVfZW5jb2RlciAqcmVuYyA9 IHRvX3JjYXJfZW5jb2RlcihlbmNvZGVyKTsKPiA+IC0KPiA+IC0JcmNhcl9kdV9jcnRjX3JvdXRl X291dHB1dChjcnRjX3N0YXRlLT5jcnRjLCByZW5jLT5vdXRwdXQpOwo+ID4gLX0KPiA+IC0KPiA+ ICBzdGF0aWMgY29uc3Qgc3RydWN0IGRybV9lbmNvZGVyX2hlbHBlcl9mdW5jcyBlbmNvZGVyX2hl bHBlcl9mdW5jcyA9IHsKPiA+IC0JLmF0b21pY19tb2RlX3NldCA9IHJjYXJfZHVfZW5jb2Rlcl9t b2RlX3NldCwKPiA+ICB9Owo+ID4gIAo+ID4gIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2VuY29k ZXJfZnVuY3MgZW5jb2Rlcl9mdW5jcyA9IHsKPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vcmNhci1kdS9yY2FyX2R1X2dyb3VwLmMKPiA+IGIvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUv cmNhcl9kdV9ncm91cC5jIGluZGV4Cj4gPiAzMzY2Y2RhNjA4NmMuLjdlNDQwZjYxOTc3ZiAxMDA2 NDQKPiA+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfZ3JvdXAuYwo+ID4g KysrIGIvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9ncm91cC5jCj4gPiBAQCAtMjg5 LDcgKzI4OSw3IEBAIGludCByY2FyX2R1X3NldF9kcGFkMF92c3AxX3JvdXRpbmcoc3RydWN0Cj4g PiByY2FyX2R1X2RldmljZSAqcmNkdSkKPiA+ICBpbnQgcmNhcl9kdV9ncm91cF9zZXRfcm91dGlu ZyhzdHJ1Y3QgcmNhcl9kdV9ncm91cCAqcmdycCkKPiA+ICB7Cj4gPiAKPiA+IC0Jc3RydWN0IHJj YXJfZHVfY3J0YyAqY3J0YzAgPSAmcmdycC0+ZGV2LT5jcnRjc1tyZ3JwLT5pbmRleCAqIDJdOwo+ ID4gKwlzdHJ1Y3QgcmNhcl9kdV9kZXZpY2UgKnJjZHUgPSByZ3JwLT5kZXY7Cj4gPiAgCXUzMiBk b3JjciA9IHJjYXJfZHVfZ3JvdXBfcmVhZChyZ3JwLCBET1JDUik7Cj4gPiAgCQo+ID4gIAlkb3Jj ciAmPSB+KERPUkNSX1BHMlQgfCBET1JDUl9ESzJTIHwgRE9SQ1JfUEcyRF9NQVNLKTsKPiA+IEBA IC0yOTksNyArMjk5LDcgQEAgaW50IHJjYXJfZHVfZ3JvdXBfc2V0X3JvdXRpbmcoc3RydWN0IHJj YXJfZHVfZ3JvdXAKPiA+ICpyZ3JwKQo+ID4gIAkgKiBDUlRDIDEgaW4gYWxsIG90aGVyIGNhc2Vz IHRvIGF2b2lkIGNsb25pbmcgQ1JUQyAwIHRvIERQQUQwIGFuZCBEUEFEMQo+ID4gIAkgKiBieSBk ZWZhdWx0Lgo+ID4gIAkgKi8KPiA+IC0JaWYgKGNydGMwLT5vdXRwdXRzICYgQklUKFJDQVJfRFVf T1VUUFVUX0RQQUQxKSkKPiA+ICsJaWYgKHJjZHUtPmRwYWQxX3NvdXJjZSA9PSByZ3JwLT5pbmRl eCAqIDIpCj4gCj4gVGhlIG1hZ2ljIG9mIGdldHRpbmcgKHJncnAtPmluZGV4ICogMikgaXMgYSBs aXR0bGUgYml0IC4uLiBtYWdpYyAuLi4KPiAKPiBUaGUgd2hhdCBpcyBoYXBwZW5pbmcgKCAoezAs MX0gPT4gezAsMn0pICkgaXMgY2xlYXIgLSBidXQgbm90IHRoZSB3aHkuCj4gCj4gVGhpcyBoYXBw ZW5zIGEgYml0IHRocm91Z2hvdXQgYXMgYSBtZWFucyB0byBjb252ZXJ0IGZyb20gQ1JUQyB0byBH cm91cAo+IGluZGV4ZXMsIGFuZCBiYWNrLiBCdXQgaXQgY291bGQgYmUgY2xlYXJlciB3aXRoIGEg aGVscGVyLgo+IAkobm90IGluIHRoaXMgcGF0Y2gpCgpJIGFncmVlLiBMZXQncyBzZWUgd2hhdCBo YXBwZW5zIGZpcnN0LCBhIGhlbHBlciBmdW5jdGlvbiBvciBhIGNvbXBsZXRlIHJld3JpdGUgCm9m IGdyb3VwIGhhbmRsaW5nIGJhc2VkIG9uIGF0b21pYyBzdGF0ZXMgOi0pCgo+ID4gIAkJZG9yY3Ig fD0gRE9SQ1JfUEcyRF9EUzE7Cj4gPiAgCWVsc2UKPiA+ICAJCWRvcmNyIHw9IERPUkNSX1BHMlQg fCBET1JDUl9ESzJTIHwgRE9SQ1JfUEcyRF9EUzI7Cj4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL3JjYXItZHUvcmNhcl9kdV9rbXMuYwo+ID4gYi9kcml2ZXJzL2dwdS9kcm0vcmNhci1k dS9yY2FyX2R1X2ttcy5jIGluZGV4IGZlNmY2NWM5NGVlZi4uYmQzYzJjNWVhNjZmCj4gPiAxMDA2 NDQKPiA+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfa21zLmMKPiA+ICsr KyBiL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfa21zLmMKPiA+IEBAIC0yODUsNiAr Mjg1LDI4IEBAIHN0YXRpYyBpbnQgcmNhcl9kdV9hdG9taWNfY2hlY2soc3RydWN0IGRybV9kZXZp Y2UKPiA+ICpkZXYsCj4gPiAgc3RhdGljIHZvaWQgcmNhcl9kdV9hdG9taWNfY29tbWl0X3RhaWwo c3RydWN0IGRybV9hdG9taWNfc3RhdGUKPiA+ICAqb2xkX3N0YXRlKQo+ID4gIHsKPiA+ICAJc3Ry dWN0IGRybV9kZXZpY2UgKmRldiA9IG9sZF9zdGF0ZS0+ZGV2Owo+ID4gKwlzdHJ1Y3QgcmNhcl9k dV9kZXZpY2UgKnJjZHUgPSBkZXYtPmRldl9wcml2YXRlOwo+ID4gKwlzdHJ1Y3QgZHJtX2NydGNf c3RhdGUgKmNydGNfc3RhdGU7Cj4gPiArCXN0cnVjdCBkcm1fY3J0YyAqY3J0YzsKPiA+ICsJdW5z aWduZWQgaW50IGk7Cj4gPiArCj4gPiArCS8qCj4gPiArCSAqIFN0b3JlIFJHQiByb3V0aW5nIHRv IERQQUQwIGFuZCBEUEFEMSwgdGhlIGhhcmR3YXJlIHdpbGwgYmUgCmNvbmZpZ3VyZWQKPiA+ICsJ ICogd2hlbiBzdGFydGluZyB0aGUgQ1JUQ3MuCj4gPiArCSAqLwo+ID4gKwlyY2R1LT5kcGFkMV9z b3VyY2UgPSAtMTsKPiAKPiBXaHkgZG8gd2UgaW5pdGlhbGlzZSBkcGFkMV9zb3VyY2UgYnV0IG5v dCBkcGFkMF9zb3VyY2U/Cj4gCj4gQXJlIHdlICpndWFyYW50ZWVkKiB0byBhbHdheXMgaGF2ZSBS Q0FSX0RVX09VVFBVVF9EUEFEMCBzZXQgaW4gb25lIG9mCj4gdGhlIHJjcnRjX3N0YXRlLT5vdXRw dXRzID8KPiAKPiBJZiBzbyAtIHRoZW4gdGhpcyBpc24ndCBhbiBpc3N1ZS4KCk5vLCB0aGVyZSdz IG5vIGd1YXJhbnRlZSwgYnV0IGl0J3Mgc3RpbGwgbm90IGFuIGlzc3VlIDotKSBJZiBub25lIG9m IHRoZSBDUlRDcyAKaW4gdGhpcyBjb21taXQgb3V0cHV0IHRvIERQQUQwLCB0aGUgdmFsdWUgb2Yg cmNkdS0+ZHBhZDBfc291cmNlIHdpbGwgcmVtYWluIAp1bmNoYW5nZWQsIHdoaWNoIGlzIHdoYXQg d2Ugd2FudC4KCkZvciBEUEFEMSB0aGUgc2l0dWF0aW9uIGlzIGEgYml0IGRpZmZlcmVudC4gVGhl IG9ubHkgUi1DYXIgU29DcyB0byBoYXZlIERQQUQxIAphcmUgSDEsIFYySCBhbmQgRTIsIGFuZCB0 aGV5IGFsbCBoYXZlIGZpeGVkIG91dHB1dCByb3V0aW5nIChEVTAgdG8gRFBBRDAgYW5kIApEVTEg dG8gRFBBRDEpLiBUaGVyZSdzIGhvd2V2ZXIgYSB3YXkgdG8gcm91dGUgdGhlIG91dHB1dCBvZiB0 aGUgY29tcG9zZXIgCmluc2lkZSBEVTAgdG8gdGhlIERVMSBvdXRwdXQsIGFuZCB2aWNlLXZlcnNh LiBUaGUgRFUgZHJpdmVyIHVzZXMgdGhpcyBmZWF0dXJlIAp0byBjb25maWd1cmUgdGhlIHJvdXRp bmcgb2YgdGhlIERQQUQxIG9uIEgxIG9ubHkgKEkgZG9uJ3QgcmVtZW1iZXIgdGhlIApoaXN0b3Jp Y2FsIHJlYXNvbiwgb3IgcGVyaGFwcyB0aGUgaGlzdG9yaWNhbCBtaXN0YWtlKS4gV2UgbmVlZCB0 byBvbmx5IHJvdXRlIApEVTAgdG8gRFBBRDEgd2hlbiBleHBsaWNpdGx5IHJlcXVlc3RlZCAoYXMg ZXhwbGFpbmVkIGluIApyY2FyX2R1X2dyb3VwX3NldF9yb3V0aW5nKCkpIGFuZCBEVTEgdG8gRFBB RDEgaW4gYWxsIG90aGVyIGNhc2VzLiBJbml0aWFsaXppbmcgCmRwYWQxX3NvdXJjZSB0byAtMSB3 aWxsIGVuc3VyZSB0aGF0LgoKVGhlIGdyb3VwIGNvZGUgcmVhbGx5IG5lZWRzIHRvIGJlIHJld3Jp dHRlbiB0byB1c2UgYXRvbWljIHN0YXRlcyAoYW5kIEkgd29uZGVyIAp3aGV0aGVyIHRoZSBEVTAg LT4gRFBBRDEgcm91dGluZyBzaG91bGQgYmUga2VwdCkuCgo+ID4gKwo+ID4gKwlmb3JfZWFjaF9u ZXdfY3J0Y19pbl9zdGF0ZShvbGRfc3RhdGUsIGNydGMsIGNydGNfc3RhdGUsIGkpIHsKPiA+ICsJ CXN0cnVjdCByY2FyX2R1X2NydGNfc3RhdGUgKnJjcnRjX3N0YXRlID0KPiA+ICsJCQl0b19yY2Fy X2NydGNfc3RhdGUoY3J0Y19zdGF0ZSk7Cj4gPiArCQlzdHJ1Y3QgcmNhcl9kdV9jcnRjICpyY3J0 YyA9IHRvX3JjYXJfY3J0YyhjcnRjKTsKPiA+ICsKPiA+ICsJCWlmIChyY3J0Y19zdGF0ZS0+b3V0 cHV0cyAmIEJJVChSQ0FSX0RVX09VVFBVVF9EUEFEMCkpCj4gPiArCQkJcmNkdS0+ZHBhZDBfc291 cmNlID0gcmNydGMtPmluZGV4Owo+ID4gKwo+ID4gKwkJaWYgKHJjcnRjX3N0YXRlLT5vdXRwdXRz ICYgQklUKFJDQVJfRFVfT1VUUFVUX0RQQUQxKSkKPiA+ICsJCQlyY2R1LT5kcGFkMV9zb3VyY2Ug PSByY3J0Yy0+aW5kZXg7Cj4gPiArCX0KPiA+IAo+ID4gIAkvKiBBcHBseSB0aGUgYXRvbWljIHVw ZGF0ZS4gKi8KPiA+ICAJZHJtX2F0b21pY19oZWxwZXJfY29tbWl0X21vZGVzZXRfZGlzYWJsZXMo ZGV2LCBvbGRfc3RhdGUpOwoKLS0gClJlZ2FyZHMsCgpMYXVyZW50IFBpbmNoYXJ0CgoKCl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWls aW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZy ZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=