From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from perceval.ideasonboard.com ([213.167.242.64]:32790 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750930AbeECLMu (ORCPT ); Thu, 3 May 2018 07:12:50 -0400 From: Laurent Pinchart To: kieran.bingham@ideasonboard.com Cc: dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org, linux-renesas-soc@vger.kernel.org Subject: Re: [PATCH v3 10/11] media: vsp1: Support Interlaced display pipelines Date: Thu, 03 May 2018 14:13:03 +0300 Message-ID: <1784754.iAtk829Up8@avalon> In-Reply-To: <42ad373a-6beb-5821-6334-1feffd816dd8@ideasonboard.com> References: <42ad373a-6beb-5821-6334-1feffd816dd8@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 Thursday, 3 May 2018 12:04:30 EEST Kieran Bingham wrote: > Hi Reviewers ... > > Comments inline ... > > On 03/05/18 09:44, Kieran Bingham wrote: > > Calculate the top and bottom fields for the interlaced frames and > > utilise the extended display list command feature to implement the > > auto-field operations. This allows the DU to update the VSP2 registers > > dynamically based upon the currently processing field. > > > > Signed-off-by: Kieran Bingham > > > > --- > > > > v3: > > - Pass DL through partition calls to allow autocmd's to be retrieved > > This change itself could actually be folded into the TLB-Optimise series, > but I posted this in v3 here to show why it is necessary (currently). > > I'll take suggestions on alternative implementations here too ... I think it would make sense to move this to the tlb-optimise series indeed. Provided this change is actually needed, which I will comment on when reviewing this series in details :-) > > - Document interlaced field in struct vsp1_du_atomic_config > > > > v2: > > - fix erroneous BIT value which enabled interlaced > > - fix field handling at frame_end interrupt > > > > drivers/media/platform/vsp1/vsp1_dl.c | 10 +++- > > drivers/media/platform/vsp1/vsp1_drm.c | 13 +++- > > drivers/media/platform/vsp1/vsp1_entity.c | 3 +- > > drivers/media/platform/vsp1/vsp1_entity.h | 2 +- > > drivers/media/platform/vsp1/vsp1_regs.h | 1 +- > > drivers/media/platform/vsp1/vsp1_rpf.c | 73 +++++++++++++++++++++++- > > drivers/media/platform/vsp1/vsp1_rwpf.h | 1 +- > > drivers/media/platform/vsp1/vsp1_uds.c | 1 +- > > drivers/media/platform/vsp1/vsp1_video.c | 2 +- > > drivers/media/platform/vsp1/vsp1_wpf.c | 1 +- > > include/media/vsp1.h | 2 +- > > 11 files changed, 103 insertions(+), 6 deletions(-) > > > > diff --git a/drivers/media/platform/vsp1/vsp1_dl.c > > b/drivers/media/platform/vsp1/vsp1_dl.c index 6366a1fc92b9..f3e75cff5ab3 > > 100644 > > --- a/drivers/media/platform/vsp1/vsp1_dl.c > > +++ b/drivers/media/platform/vsp1/vsp1_dl.c > > @@ -906,6 +906,8 @@ void vsp1_dl_list_commit(struct vsp1_dl_list *dl, bool > > internal) > > */ > > unsigned int vsp1_dlm_irq_frame_end(struct vsp1_dl_manager *dlm) > > { > > + struct vsp1_device *vsp1 = dlm->vsp1; > > + u32 status = vsp1_read(vsp1, VI6_STATUS); In theory it would be nice to read this is early as possible, and thus pass it down the call stack to this function, but I suppose that if the interrupt handler ends up blocking for more than the duration of one field we'll have other problems anyway. > > unsigned int flags = 0; > > > > spin_lock(&dlm->lock); > > @@ -931,6 +933,14 @@ unsigned int vsp1_dlm_irq_frame_end(struct > > vsp1_dl_manager *dlm) > > goto done; > > > > /* > > + * Progressive streams report only TOP fields. If we have a BOTTOM > > + * field, we are interlaced, and expect the frame to complete on the > > + * next frame end interrupt. > > + */ > > + if (status & VI6_STATUS_FLD_STD(dlm->index)) > > + goto done; > > + > > + /* > > * The device starts processing the queued display list right after the > > * frame end interrupt. The display list thus becomes active. > > */ > > diff --git a/drivers/media/platform/vsp1/vsp1_drm.c > > b/drivers/media/platform/vsp1/vsp1_drm.c index 7714be7f50af..cc29c9d96bb7 > > 100644 > > --- a/drivers/media/platform/vsp1/vsp1_drm.c > > +++ b/drivers/media/platform/vsp1/vsp1_drm.c > > @@ -556,7 +556,7 @@ static void vsp1_du_pipeline_configure(struct > > vsp1_pipeline *pipe)> > > vsp1_entity_route_setup(entity, pipe, dlb); > > vsp1_entity_configure_stream(entity, pipe, dlb); > > vsp1_entity_configure_frame(entity, pipe, dl, dlb); > > - vsp1_entity_configure_partition(entity, pipe, dlb); > > + vsp1_entity_configure_partition(entity, pipe, dl, dlb); > > This change, and other changes to vsp1_entity_configure_partition() could be > performed in tlb-optimise when the corresponding change is made to > vsp1_entity_configure_frame() > > > } > > > > vsp1_dl_list_commit(dl, drm_pipe->force_brx_release); > > @@ -811,6 +811,17 @@ int vsp1_du_atomic_update(struct device *dev, > > unsigned int pipe_index, > > return -EINVAL; > > } > > > > + if (!(vsp1_feature(vsp1, VSP1_HAS_EXT_DL)) && cfg->interlaced) { > > + /* > > + * Interlaced support requires extended display lists to > > + * provide the auto-fld feature with the DU. > > + */ > > + dev_dbg(vsp1->dev, "Interlaced unsupported on this output\n"); > > + return -EINVAL; > > + } > > + > > + rpf->interlaced = cfg->interlaced; > > + > > rpf->fmtinfo = fmtinfo; > > rpf->format.num_planes = fmtinfo->planes; > > rpf->format.plane_fmt[0].bytesperline = cfg->pitch; [snip] > > b/drivers/media/platform/vsp1/vsp1_rpf.c index a948670121a4..c1de22398423 > > 100644 > > --- a/drivers/media/platform/vsp1/vsp1_rpf.c > > +++ b/drivers/media/platform/vsp1/vsp1_rpf.c > > @@ -20,6 +20,20 @@ > > #define RPF_MAX_WIDTH 8190 > > #define RPF_MAX_HEIGHT 8190 > > > > +/* Pre extended display list command data structure */ > > +struct vsp1_extcmd_auto_fld_body { > > + u32 top_y0; > > + u32 bottom_y0; > > + u32 top_c0; > > + u32 bottom_c0; > > + u32 top_c1; > > + u32 bottom_c1; > > + u32 reserved0; > > + u32 reserved1; > > +} __packed; > > + > > +#define VSP1_DL_EXT_AUTOFLD_INT BIT(0) > > + > > /* ---------------------------------------------------------------------- > > * Device Access > > */ > > @@ -64,6 +78,14 @@ static void rpf_configure_stream(struct vsp1_entity > > *entity, > > pstride |= format->plane_fmt[1].bytesperline > > << VI6_RPF_SRCM_PSTRIDE_C_SHIFT; > > > > + /* > > + * pstride has both STRIDE_Y and STRIDE_C, but multiplying the whole > > + * of pstride by 2 is conveniently OK here as we are multiplying both > > + * values. > > + */ > > + if (rpf->interlaced) > > + pstride *= 2; > > + > > vsp1_rpf_write(rpf, dlb, VI6_RPF_SRCM_PSTRIDE, pstride); > > > > /* Format */ > > @@ -100,6 +122,9 @@ static void rpf_configure_stream(struct vsp1_entity > > *entity, > > top = compose->top; > > } > > > > + if (rpf->interlaced) > > + top /= 2; > > + > > vsp1_rpf_write(rpf, dlb, VI6_RPF_LOC, > > (left << VI6_RPF_LOC_HCOORD_SHIFT) | > > (top << VI6_RPF_LOC_VCOORD_SHIFT)); > > @@ -169,6 +194,31 @@ static void rpf_configure_stream(struct vsp1_entity > > *entity, > > } > > > > +static void vsp1_rpf_configure_autofld(struct vsp1_rwpf *rpf, > > + struct vsp1_dl_ext_cmd *cmd) > > +{ > > + const struct v4l2_pix_format_mplane *format = &rpf->format; > > + struct vsp1_extcmd_auto_fld_body *auto_fld = cmd->data; > > + u32 offset_y, offset_c; > > + > > + /* Re-index our auto_fld to match the current RPF */ > > + auto_fld = &auto_fld[rpf->entity.index]; > > + > > + auto_fld->top_y0 = rpf->mem.addr[0]; > > + auto_fld->top_c0 = rpf->mem.addr[1]; > > + auto_fld->top_c1 = rpf->mem.addr[2]; > > + > > + offset_y = format->plane_fmt[0].bytesperline; > > + offset_c = format->plane_fmt[1].bytesperline; > > + > > + auto_fld->bottom_y0 = rpf->mem.addr[0] + offset_y; > > + auto_fld->bottom_c0 = rpf->mem.addr[1] + offset_c; > > + auto_fld->bottom_c1 = rpf->mem.addr[2] + offset_c; > > + > > + cmd->flags |= VSP1_DL_EXT_AUTOFLD_INT; > > + cmd->flags |= BIT(16 + rpf->entity.index); > > +} > > + > > static void rpf_configure_frame(struct vsp1_entity *entity, > > struct vsp1_pipeline *pipe, > > struct vsp1_dl_list *dl, > > @@ -186,11 +236,13 @@ static void rpf_configure_frame(struct vsp1_entity > > *entity, > > static void rpf_configure_partition(struct vsp1_entity *entity, > > struct vsp1_pipeline *pipe, > > + struct vsp1_dl_list *dl, > > struct vsp1_dl_body *dlb) > > { > > struct vsp1_rwpf *rpf = to_rwpf(&entity->subdev); > > struct vsp1_rwpf_memory mem = rpf->mem; > > struct vsp1_device *vsp1 = rpf->entity.vsp1; > > + struct vsp1_dl_ext_cmd *cmd; > > const struct vsp1_format_info *fmtinfo = rpf->fmtinfo; > > const struct v4l2_pix_format_mplane *format = &rpf->format; > > struct v4l2_rect crop; > > @@ -219,6 +271,11 @@ static void rpf_configure_partition(struct > > vsp1_entity *entity, > > crop.left += pipe->partition->rpf.left; > > } > > > > + if (rpf->interlaced) { > > + crop.height = round_down(crop.height / 2, fmtinfo->vsub); > > + crop.top = round_down(crop.top / 2, fmtinfo->vsub); > > + } > > + > > vsp1_rpf_write(rpf, dlb, VI6_RPF_SRC_BSIZE, > > (crop.width << VI6_RPF_SRC_BSIZE_BHSIZE_SHIFT) | > > (crop.height << VI6_RPF_SRC_BSIZE_BVSIZE_SHIFT)); > > @@ -247,11 +304,21 @@ static void rpf_configure_partition(struct > > vsp1_entity *entity, > > fmtinfo->swap_uv) > > > > swap(mem.addr[1], mem.addr[2]); > > > > - vsp1_rpf_write(rpf, dlb, VI6_RPF_SRCM_ADDR_Y, mem.addr[0]); > > - vsp1_rpf_write(rpf, dlb, VI6_RPF_SRCM_ADDR_C0, mem.addr[1]); > > - vsp1_rpf_write(rpf, dlb, VI6_RPF_SRCM_ADDR_C1, mem.addr[2]); > > + /* > > + * Interlaced pipelines will use the extended pre-cmd to process > > + * SRCM_ADDR_{Y,C0,C1} > > + */ > > + if (rpf->interlaced) { > > + cmd = vsp1_dlm_get_autofld_cmd(dl); > > + vsp1_rpf_configure_autofld(rpf, cmd); > > Technically - if (rpf->interlaced) can only evaluate to true on DRM > pipelines, which don't use the image partitioning. So it might be possible > to argue that the vsp1_rpf_configure_autofld() call should be done in > rpf_configure_frame(). Except I think it's reasonable to consider that the > addresses and configuration of the frame are still just the 'first and only > partition' - thus I think it's better to leave this here - and instead > ensure that the requried DL is passed through. I agree with you, that makes sense. > Unless there's a better way to get the cmd object ? There's none that immediately occurs to me. > > + } else { > > + vsp1_rpf_write(rpf, dlb, VI6_RPF_SRCM_ADDR_Y, mem.addr[0]); > > + vsp1_rpf_write(rpf, dlb, VI6_RPF_SRCM_ADDR_C0, mem.addr[1]); > > + vsp1_rpf_write(rpf, dlb, VI6_RPF_SRCM_ADDR_C1, mem.addr[2]); > > + } > > } > > + > > static void rpf_partition(struct vsp1_entity *entity, > > struct vsp1_pipeline *pipe, > > struct vsp1_partition *partition, > > diff --git a/drivers/media/platform/vsp1/vsp1_rwpf.h > > b/drivers/media/platform/vsp1/vsp1_rwpf.h index > > 70742ecf766f..8d6e42f27908 100644 > > --- a/drivers/media/platform/vsp1/vsp1_rwpf.h > > +++ b/drivers/media/platform/vsp1/vsp1_rwpf.h > > @@ -42,6 +42,7 @@ struct vsp1_rwpf { > > struct v4l2_pix_format_mplane format; > > const struct vsp1_format_info *fmtinfo; > > unsigned int brx_input; > > + bool interlaced; kerneldoc might be nice :-) > > > > unsigned int alpha; > > [snip] > > diff --git a/include/media/vsp1.h b/include/media/vsp1.h > > index 678c24de1ac6..c10883f30980 100644 > > --- a/include/media/vsp1.h > > +++ b/include/media/vsp1.h > > @@ -50,6 +50,7 @@ int vsp1_du_setup_lif(struct device *dev, unsigned int > > pipe_index,> > > * @dst: destination rectangle on the display (integer coordinates) > > * @alpha: alpha value (0: fully transparent, 255: fully opaque) > > * @zpos: Z position of the plane (from 0 to number of planes minus 1) > > + * @interlaced: true for interlaced pipelines Maybe "true if the pipeline outputs an interlaced stream" ? > > */ > > struct vsp1_du_atomic_config { > > u32 pixelformat; > > -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH v3 10/11] media: vsp1: Support Interlaced display pipelines Date: Thu, 03 May 2018 14:13:03 +0300 Message-ID: <1784754.iAtk829Up8@avalon> References: <42ad373a-6beb-5821-6334-1feffd816dd8@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 037A46E5AC for ; Thu, 3 May 2018 11:12:49 +0000 (UTC) In-Reply-To: <42ad373a-6beb-5821-6334-1feffd816dd8@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@ideasonboard.com Cc: linux-renesas-soc@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org SGkgS2llcmFuLAoKT24gVGh1cnNkYXksIDMgTWF5IDIwMTggMTI6MDQ6MzAgRUVTVCBLaWVyYW4g QmluZ2hhbSB3cm90ZToKPiBIaSBSZXZpZXdlcnMgLi4uCj4gCj4gQ29tbWVudHMgaW5saW5lIC4u Lgo+IAo+IE9uIDAzLzA1LzE4IDA5OjQ0LCBLaWVyYW4gQmluZ2hhbSB3cm90ZToKPiA+IENhbGN1 bGF0ZSB0aGUgdG9wIGFuZCBib3R0b20gZmllbGRzIGZvciB0aGUgaW50ZXJsYWNlZCBmcmFtZXMg YW5kCj4gPiB1dGlsaXNlIHRoZSBleHRlbmRlZCBkaXNwbGF5IGxpc3QgY29tbWFuZCBmZWF0dXJl IHRvIGltcGxlbWVudCB0aGUKPiA+IGF1dG8tZmllbGQgb3BlcmF0aW9ucy4gVGhpcyBhbGxvd3Mg dGhlIERVIHRvIHVwZGF0ZSB0aGUgVlNQMiByZWdpc3RlcnMKPiA+IGR5bmFtaWNhbGx5IGJhc2Vk IHVwb24gdGhlIGN1cnJlbnRseSBwcm9jZXNzaW5nIGZpZWxkLgo+ID4gCj4gPiBTaWduZWQtb2Zm LWJ5OiBLaWVyYW4gQmluZ2hhbSA8a2llcmFuLmJpbmdoYW0rcmVuZXNhc0BpZGVhc29uYm9hcmQu Y29tPgo+ID4gCj4gPiAtLS0KPiA+IAo+ID4gdjM6Cj4gPiAgLSBQYXNzIERMIHRocm91Z2ggcGFy dGl0aW9uIGNhbGxzIHRvIGFsbG93IGF1dG9jbWQncyB0byBiZSByZXRyaWV2ZWQKPiAKPiBUaGlz IGNoYW5nZSBpdHNlbGYgY291bGQgYWN0dWFsbHkgYmUgZm9sZGVkIGludG8gdGhlIFRMQi1PcHRp bWlzZSBzZXJpZXMsCj4gYnV0IEkgcG9zdGVkIHRoaXMgaW4gdjMgaGVyZSB0byBzaG93IHdoeSBp dCBpcyBuZWNlc3NhcnkgKGN1cnJlbnRseSkuCj4gCj4gSSdsbCB0YWtlIHN1Z2dlc3Rpb25zIG9u IGFsdGVybmF0aXZlIGltcGxlbWVudGF0aW9ucyBoZXJlIHRvbyAuLi4KCkkgdGhpbmsgaXQgd291 bGQgbWFrZSBzZW5zZSB0byBtb3ZlIHRoaXMgdG8gdGhlIHRsYi1vcHRpbWlzZSBzZXJpZXMgaW5k ZWVkLiAKUHJvdmlkZWQgdGhpcyBjaGFuZ2UgaXMgYWN0dWFsbHkgbmVlZGVkLCB3aGljaCBJIHdp bGwgY29tbWVudCBvbiB3aGVuIApyZXZpZXdpbmcgdGhpcyBzZXJpZXMgaW4gZGV0YWlscyA6LSkK Cj4gPiAgLSBEb2N1bWVudCBpbnRlcmxhY2VkIGZpZWxkIGluIHN0cnVjdCB2c3AxX2R1X2F0b21p Y19jb25maWcKPiA+IAo+ID4gdjI6Cj4gPiAgLSBmaXggZXJyb25lb3VzIEJJVCB2YWx1ZSB3aGlj aCBlbmFibGVkIGludGVybGFjZWQKPiA+ICAtIGZpeCBmaWVsZCBoYW5kbGluZyBhdCBmcmFtZV9l bmQgaW50ZXJydXB0Cj4gPiAgCj4gPiAgZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFf ZGwuYyAgICAgfCAxMCArKystCj4gPiAgZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFf ZHJtLmMgICAgfCAxMyArKystCj4gPiAgZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFf ZW50aXR5LmMgfCAgMyArLQo+ID4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2Vu dGl0eS5oIHwgIDIgKy0KPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9yZWdz LmggICB8ICAxICstCj4gPiAgZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfcnBmLmMg ICAgfCA3MyArKysrKysrKysrKysrKysrKysrKysrKy0KPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRm b3JtL3ZzcDEvdnNwMV9yd3BmLmggICB8ICAxICstCj4gPiAgZHJpdmVycy9tZWRpYS9wbGF0Zm9y bS92c3AxL3ZzcDFfdWRzLmMgICAgfCAgMSArLQo+ID4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0v dnNwMS92c3AxX3ZpZGVvLmMgIHwgIDIgKy0KPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3Zz cDEvdnNwMV93cGYuYyAgICB8ICAxICstCj4gPiAgaW5jbHVkZS9tZWRpYS92c3AxLmggICAgICAg ICAgICAgICAgICAgICAgfCAgMiArLQo+ID4gIDExIGZpbGVzIGNoYW5nZWQsIDEwMyBpbnNlcnRp b25zKCspLCA2IGRlbGV0aW9ucygtKQo+ID4gCj4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRp YS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwuYwo+ID4gYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3Zz cDEvdnNwMV9kbC5jIGluZGV4IDYzNjZhMWZjOTJiOS4uZjNlNzVjZmY1YWIzCj4gPiAxMDA2NDQK PiA+IC0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmMKPiA+ICsrKyBi L2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmMKPiA+IEBAIC05MDYsNiArOTA2 LDggQEAgdm9pZCB2c3AxX2RsX2xpc3RfY29tbWl0KHN0cnVjdCB2c3AxX2RsX2xpc3QgKmRsLCBi b29sCj4gPiBpbnRlcm5hbCkKPiA+ICAgKi8KPiA+ICB1bnNpZ25lZCBpbnQgdnNwMV9kbG1faXJx X2ZyYW1lX2VuZChzdHJ1Y3QgdnNwMV9kbF9tYW5hZ2VyICpkbG0pCj4gPiAgewo+ID4gKwlzdHJ1 Y3QgdnNwMV9kZXZpY2UgKnZzcDEgPSBkbG0tPnZzcDE7Cj4gPiArCXUzMiBzdGF0dXMgPSB2c3Ax X3JlYWQodnNwMSwgVkk2X1NUQVRVUyk7CgpJbiB0aGVvcnkgaXQgd291bGQgYmUgbmljZSB0byBy ZWFkIHRoaXMgaXMgZWFybHkgYXMgcG9zc2libGUsIGFuZCB0aHVzIHBhc3MgaXQgCmRvd24gdGhl IGNhbGwgc3RhY2sgdG8gdGhpcyBmdW5jdGlvbiwgYnV0IEkgc3VwcG9zZSB0aGF0IGlmIHRoZSBp bnRlcnJ1cHQgCmhhbmRsZXIgZW5kcyB1cCBibG9ja2luZyBmb3IgbW9yZSB0aGFuIHRoZSBkdXJh dGlvbiBvZiBvbmUgZmllbGQgd2UnbGwgaGF2ZSAKb3RoZXIgcHJvYmxlbXMgYW55d2F5LgoKPiA+ ICAJdW5zaWduZWQgaW50IGZsYWdzID0gMDsKPiA+ICAJCj4gPiAgCXNwaW5fbG9jaygmZGxtLT5s b2NrKTsKPiA+IEBAIC05MzEsNiArOTMzLDE0IEBAIHVuc2lnbmVkIGludCB2c3AxX2RsbV9pcnFf ZnJhbWVfZW5kKHN0cnVjdAo+ID4gdnNwMV9kbF9tYW5hZ2VyICpkbG0pCj4gPiAgCQlnb3RvIGRv bmU7Cj4gPiAgCQo+ID4gIAkvKgo+ID4gKwkgKiBQcm9ncmVzc2l2ZSBzdHJlYW1zIHJlcG9ydCBv bmx5IFRPUCBmaWVsZHMuIElmIHdlIGhhdmUgYSBCT1RUT00KPiA+ICsJICogZmllbGQsIHdlIGFy ZSBpbnRlcmxhY2VkLCBhbmQgZXhwZWN0IHRoZSBmcmFtZSB0byBjb21wbGV0ZSBvbiB0aGUKPiA+ ICsJICogbmV4dCBmcmFtZSBlbmQgaW50ZXJydXB0Lgo+ID4gKwkgKi8KPiA+ICsJaWYgKHN0YXR1 cyAmIFZJNl9TVEFUVVNfRkxEX1NURChkbG0tPmluZGV4KSkKPiA+ICsJCWdvdG8gZG9uZTsKPiA+ ICsKPiA+ICsJLyoKPiA+ICAJICogVGhlIGRldmljZSBzdGFydHMgcHJvY2Vzc2luZyB0aGUgcXVl dWVkIGRpc3BsYXkgbGlzdCByaWdodCBhZnRlciB0aGUKPiA+ICAJICogZnJhbWUgZW5kIGludGVy cnVwdC4gVGhlIGRpc3BsYXkgbGlzdCB0aHVzIGJlY29tZXMgYWN0aXZlLgo+ID4gIAkgKi8KPiA+ IGRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kcm0uYwo+ID4g Yi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kcm0uYyBpbmRleCA3NzE0YmU3ZjUw YWYuLmNjMjljOWQ5NmJiNwo+ID4gMTAwNjQ0Cj4gPiAtLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRm b3JtL3ZzcDEvdnNwMV9kcm0uYwo+ID4gKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3Ax L3ZzcDFfZHJtLmMKPiA+IEBAIC01NTYsNyArNTU2LDcgQEAgc3RhdGljIHZvaWQgdnNwMV9kdV9w aXBlbGluZV9jb25maWd1cmUoc3RydWN0Cj4gPiB2c3AxX3BpcGVsaW5lICpwaXBlKT4gCj4gPiAg CQl2c3AxX2VudGl0eV9yb3V0ZV9zZXR1cChlbnRpdHksIHBpcGUsIGRsYik7Cj4gPiAgCQl2c3Ax X2VudGl0eV9jb25maWd1cmVfc3RyZWFtKGVudGl0eSwgcGlwZSwgZGxiKTsKPiA+ICAJCXZzcDFf ZW50aXR5X2NvbmZpZ3VyZV9mcmFtZShlbnRpdHksIHBpcGUsIGRsLCBkbGIpOwo+ID4gLQkJdnNw MV9lbnRpdHlfY29uZmlndXJlX3BhcnRpdGlvbihlbnRpdHksIHBpcGUsIGRsYik7Cj4gPiArCQl2 c3AxX2VudGl0eV9jb25maWd1cmVfcGFydGl0aW9uKGVudGl0eSwgcGlwZSwgZGwsIGRsYik7Cj4g Cj4gVGhpcyBjaGFuZ2UsIGFuZCBvdGhlciBjaGFuZ2VzIHRvIHZzcDFfZW50aXR5X2NvbmZpZ3Vy ZV9wYXJ0aXRpb24oKSBjb3VsZCBiZQo+IHBlcmZvcm1lZCBpbiB0bGItb3B0aW1pc2Ugd2hlbiB0 aGUgY29ycmVzcG9uZGluZyBjaGFuZ2UgaXMgbWFkZSB0bwo+IHZzcDFfZW50aXR5X2NvbmZpZ3Vy ZV9mcmFtZSgpCj4gCj4gPiAgCX0KPiA+ICAJCj4gPiAgCXZzcDFfZGxfbGlzdF9jb21taXQoZGws IGRybV9waXBlLT5mb3JjZV9icnhfcmVsZWFzZSk7Cj4gPiBAQCAtODExLDYgKzgxMSwxNyBAQCBp bnQgdnNwMV9kdV9hdG9taWNfdXBkYXRlKHN0cnVjdCBkZXZpY2UgKmRldiwKPiA+IHVuc2lnbmVk IGludCBwaXBlX2luZGV4LAo+ID4gIAkJcmV0dXJuIC1FSU5WQUw7Cj4gPiAgCX0KPiA+IAo+ID4g KwlpZiAoISh2c3AxX2ZlYXR1cmUodnNwMSwgVlNQMV9IQVNfRVhUX0RMKSkgJiYgY2ZnLT5pbnRl cmxhY2VkKSB7Cj4gPiArCQkvKgo+ID4gKwkJICogSW50ZXJsYWNlZCBzdXBwb3J0IHJlcXVpcmVz IGV4dGVuZGVkIGRpc3BsYXkgbGlzdHMgdG8KPiA+ICsJCSAqIHByb3ZpZGUgdGhlIGF1dG8tZmxk IGZlYXR1cmUgd2l0aCB0aGUgRFUuCj4gPiArCQkgKi8KPiA+ICsJCWRldl9kYmcodnNwMS0+ZGV2 LCAiSW50ZXJsYWNlZCB1bnN1cHBvcnRlZCBvbiB0aGlzIG91dHB1dFxuIik7Cj4gPiArCQlyZXR1 cm4gLUVJTlZBTDsKPiA+ICsJfQo+ID4gKwo+ID4gKwlycGYtPmludGVybGFjZWQgPSBjZmctPmlu dGVybGFjZWQ7Cj4gPiArCj4gPiAgCXJwZi0+Zm10aW5mbyA9IGZtdGluZm87Cj4gPiAgCXJwZi0+ Zm9ybWF0Lm51bV9wbGFuZXMgPSBmbXRpbmZvLT5wbGFuZXM7Cj4gPiAgCXJwZi0+Zm9ybWF0LnBs YW5lX2ZtdFswXS5ieXRlc3BlcmxpbmUgPSBjZmctPnBpdGNoOwoKW3NuaXBdCgo+ID4gYi9kcml2 ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9ycGYuYyBpbmRleCBhOTQ4NjcwMTIxYTQuLmMx ZGUyMjM5ODQyMwo+ID4gMTAwNjQ0Cj4gPiAtLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3Zz cDEvdnNwMV9ycGYuYwo+ID4gKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFf cnBmLmMKPiA+IEBAIC0yMCw2ICsyMCwyMCBAQAo+ID4gICNkZWZpbmUgUlBGX01BWF9XSURUSAkJ CQk4MTkwCj4gPiAgI2RlZmluZSBSUEZfTUFYX0hFSUdIVAkJCQk4MTkwCj4gPiAKPiA+ICsvKiBQ cmUgZXh0ZW5kZWQgZGlzcGxheSBsaXN0IGNvbW1hbmQgZGF0YSBzdHJ1Y3R1cmUgKi8KPiA+ICtz dHJ1Y3QgdnNwMV9leHRjbWRfYXV0b19mbGRfYm9keSB7Cj4gPiArCXUzMiB0b3BfeTA7Cj4gPiAr CXUzMiBib3R0b21feTA7Cj4gPiArCXUzMiB0b3BfYzA7Cj4gPiArCXUzMiBib3R0b21fYzA7Cj4g PiArCXUzMiB0b3BfYzE7Cj4gPiArCXUzMiBib3R0b21fYzE7Cj4gPiArCXUzMiByZXNlcnZlZDA7 Cj4gPiArCXUzMiByZXNlcnZlZDE7Cj4gPiArfSBfX3BhY2tlZDsKPiA+ICsKPiA+ICsjZGVmaW5l IFZTUDFfRExfRVhUX0FVVE9GTERfSU5UCQlCSVQoMCkKPiA+ICsKPiA+ICAvKiAtLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tCj4gPiAgICogRGV2aWNlIEFjY2Vzcwo+ID4gICAqLwo+ID4gQEAgLTY0LDYgKzc4LDE0IEBA IHN0YXRpYyB2b2lkIHJwZl9jb25maWd1cmVfc3RyZWFtKHN0cnVjdCB2c3AxX2VudGl0eQo+ID4g KmVudGl0eSwKPiA+ICAJCXBzdHJpZGUgfD0gZm9ybWF0LT5wbGFuZV9mbXRbMV0uYnl0ZXNwZXJs aW5lCj4gPiAgCQkJPDwgVkk2X1JQRl9TUkNNX1BTVFJJREVfQ19TSElGVDsKPiA+IAo+ID4gKwkv Kgo+ID4gKwkgKiBwc3RyaWRlIGhhcyBib3RoIFNUUklERV9ZIGFuZCBTVFJJREVfQywgYnV0IG11 bHRpcGx5aW5nIHRoZSB3aG9sZQo+ID4gKwkgKiBvZiBwc3RyaWRlIGJ5IDIgaXMgY29udmVuaWVu dGx5IE9LIGhlcmUgYXMgd2UgYXJlIG11bHRpcGx5aW5nIGJvdGgKPiA+ICsJICogdmFsdWVzLgo+ ID4gKwkgKi8KPiA+ICsJaWYgKHJwZi0+aW50ZXJsYWNlZCkKPiA+ICsJCXBzdHJpZGUgKj0gMjsK PiA+ICsKPiA+ICAJdnNwMV9ycGZfd3JpdGUocnBmLCBkbGIsIFZJNl9SUEZfU1JDTV9QU1RSSURF LCBwc3RyaWRlKTsKPiA+ICAJCj4gPiAgCS8qIEZvcm1hdCAqLwo+ID4gQEAgLTEwMCw2ICsxMjIs OSBAQCBzdGF0aWMgdm9pZCBycGZfY29uZmlndXJlX3N0cmVhbShzdHJ1Y3QgdnNwMV9lbnRpdHkK PiA+ICplbnRpdHksCj4gPiAgCQl0b3AgPSBjb21wb3NlLT50b3A7Cj4gPiAgCX0KPiA+IAo+ID4g KwlpZiAocnBmLT5pbnRlcmxhY2VkKQo+ID4gKwkJdG9wIC89IDI7Cj4gPiArCj4gPiAgCXZzcDFf cnBmX3dyaXRlKHJwZiwgZGxiLCBWSTZfUlBGX0xPQywKPiA+ICAJCSAgICAgICAobGVmdCA8PCBW STZfUlBGX0xPQ19IQ09PUkRfU0hJRlQpIHwKPiA+ICAJCSAgICAgICAodG9wIDw8IFZJNl9SUEZf TE9DX1ZDT09SRF9TSElGVCkpOwo+ID4gQEAgLTE2OSw2ICsxOTQsMzEgQEAgc3RhdGljIHZvaWQg cnBmX2NvbmZpZ3VyZV9zdHJlYW0oc3RydWN0IHZzcDFfZW50aXR5Cj4gPiAqZW50aXR5LAo+ID4g IH0KPiA+IAo+ID4gK3N0YXRpYyB2b2lkIHZzcDFfcnBmX2NvbmZpZ3VyZV9hdXRvZmxkKHN0cnVj dCB2c3AxX3J3cGYgKnJwZiwKPiA+ICsJCQkJICAgICAgIHN0cnVjdCB2c3AxX2RsX2V4dF9jbWQg KmNtZCkKPiA+ICt7Cj4gPiArCWNvbnN0IHN0cnVjdCB2NGwyX3BpeF9mb3JtYXRfbXBsYW5lICpm b3JtYXQgPSAmcnBmLT5mb3JtYXQ7Cj4gPiArCXN0cnVjdCB2c3AxX2V4dGNtZF9hdXRvX2ZsZF9i b2R5ICphdXRvX2ZsZCA9IGNtZC0+ZGF0YTsKPiA+ICsJdTMyIG9mZnNldF95LCBvZmZzZXRfYzsK PiA+ICsKPiA+ICsJLyogUmUtaW5kZXggb3VyIGF1dG9fZmxkIHRvIG1hdGNoIHRoZSBjdXJyZW50 IFJQRiAqLwo+ID4gKwlhdXRvX2ZsZCA9ICZhdXRvX2ZsZFtycGYtPmVudGl0eS5pbmRleF07Cj4g PiArCj4gPiArCWF1dG9fZmxkLT50b3BfeTAgPSBycGYtPm1lbS5hZGRyWzBdOwo+ID4gKwlhdXRv X2ZsZC0+dG9wX2MwID0gcnBmLT5tZW0uYWRkclsxXTsKPiA+ICsJYXV0b19mbGQtPnRvcF9jMSA9 IHJwZi0+bWVtLmFkZHJbMl07Cj4gPiArCj4gPiArCW9mZnNldF95ID0gZm9ybWF0LT5wbGFuZV9m bXRbMF0uYnl0ZXNwZXJsaW5lOwo+ID4gKwlvZmZzZXRfYyA9IGZvcm1hdC0+cGxhbmVfZm10WzFd LmJ5dGVzcGVybGluZTsKPiA+ICsKPiA+ICsJYXV0b19mbGQtPmJvdHRvbV95MCA9IHJwZi0+bWVt LmFkZHJbMF0gKyBvZmZzZXRfeTsKPiA+ICsJYXV0b19mbGQtPmJvdHRvbV9jMCA9IHJwZi0+bWVt LmFkZHJbMV0gKyBvZmZzZXRfYzsKPiA+ICsJYXV0b19mbGQtPmJvdHRvbV9jMSA9IHJwZi0+bWVt LmFkZHJbMl0gKyBvZmZzZXRfYzsKPiA+ICsKPiA+ICsJY21kLT5mbGFncyB8PSBWU1AxX0RMX0VY VF9BVVRPRkxEX0lOVDsKPiA+ICsJY21kLT5mbGFncyB8PSBCSVQoMTYgKyBycGYtPmVudGl0eS5p bmRleCk7Cj4gPiArfQo+ID4gKwo+ID4gIHN0YXRpYyB2b2lkIHJwZl9jb25maWd1cmVfZnJhbWUo c3RydWN0IHZzcDFfZW50aXR5ICplbnRpdHksCj4gPiAgCQkJCXN0cnVjdCB2c3AxX3BpcGVsaW5l ICpwaXBlLAo+ID4gIAkJCQlzdHJ1Y3QgdnNwMV9kbF9saXN0ICpkbCwKPiA+IEBAIC0xODYsMTEg KzIzNiwxMyBAQCBzdGF0aWMgdm9pZCBycGZfY29uZmlndXJlX2ZyYW1lKHN0cnVjdCB2c3AxX2Vu dGl0eQo+ID4gKmVudGl0eSwKPiA+ICBzdGF0aWMgdm9pZCBycGZfY29uZmlndXJlX3BhcnRpdGlv bihzdHJ1Y3QgdnNwMV9lbnRpdHkgKmVudGl0eSwKPiA+ICAJCQkJICAgIHN0cnVjdCB2c3AxX3Bp cGVsaW5lICpwaXBlLAo+ID4gKwkJCQkgICAgc3RydWN0IHZzcDFfZGxfbGlzdCAqZGwsCj4gPiAg CQkJCSAgICBzdHJ1Y3QgdnNwMV9kbF9ib2R5ICpkbGIpCj4gPiAgewo+ID4gIAlzdHJ1Y3QgdnNw MV9yd3BmICpycGYgPSB0b19yd3BmKCZlbnRpdHktPnN1YmRldik7Cj4gPiAgCXN0cnVjdCB2c3Ax X3J3cGZfbWVtb3J5IG1lbSA9IHJwZi0+bWVtOwo+ID4gIAlzdHJ1Y3QgdnNwMV9kZXZpY2UgKnZz cDEgPSBycGYtPmVudGl0eS52c3AxOwo+ID4gKwlzdHJ1Y3QgdnNwMV9kbF9leHRfY21kICpjbWQ7 Cj4gPiAgCWNvbnN0IHN0cnVjdCB2c3AxX2Zvcm1hdF9pbmZvICpmbXRpbmZvID0gcnBmLT5mbXRp bmZvOwo+ID4gIAljb25zdCBzdHJ1Y3QgdjRsMl9waXhfZm9ybWF0X21wbGFuZSAqZm9ybWF0ID0g JnJwZi0+Zm9ybWF0Owo+ID4gIAlzdHJ1Y3QgdjRsMl9yZWN0IGNyb3A7Cj4gPiBAQCAtMjE5LDYg KzI3MSwxMSBAQCBzdGF0aWMgdm9pZCBycGZfY29uZmlndXJlX3BhcnRpdGlvbihzdHJ1Y3QKPiA+ IHZzcDFfZW50aXR5ICplbnRpdHksCj4gPiAgCQljcm9wLmxlZnQgKz0gcGlwZS0+cGFydGl0aW9u LT5ycGYubGVmdDsKPiA+ICAJfQo+ID4gCj4gPiArCWlmIChycGYtPmludGVybGFjZWQpIHsKPiA+ ICsJCWNyb3AuaGVpZ2h0ID0gcm91bmRfZG93bihjcm9wLmhlaWdodCAvIDIsIGZtdGluZm8tPnZz dWIpOwo+ID4gKwkJY3JvcC50b3AgPSByb3VuZF9kb3duKGNyb3AudG9wIC8gMiwgZm10aW5mby0+ dnN1Yik7Cj4gPiArCX0KPiA+ICsKPiA+ICAJdnNwMV9ycGZfd3JpdGUocnBmLCBkbGIsIFZJNl9S UEZfU1JDX0JTSVpFLAo+ID4gIAkJICAgICAgIChjcm9wLndpZHRoIDw8IFZJNl9SUEZfU1JDX0JT SVpFX0JIU0laRV9TSElGVCkgfAo+ID4gIAkJICAgICAgIChjcm9wLmhlaWdodCA8PCBWSTZfUlBG X1NSQ19CU0laRV9CVlNJWkVfU0hJRlQpKTsKPiA+IEBAIC0yNDcsMTEgKzMwNCwyMSBAQCBzdGF0 aWMgdm9pZCBycGZfY29uZmlndXJlX3BhcnRpdGlvbihzdHJ1Y3QKPiA+IHZzcDFfZW50aXR5ICpl bnRpdHksCj4gPiAgCSAgICBmbXRpbmZvLT5zd2FwX3V2KQo+ID4gIAkJCj4gPiAgCQlzd2FwKG1l bS5hZGRyWzFdLCBtZW0uYWRkclsyXSk7Cj4gPiAKPiA+IC0JdnNwMV9ycGZfd3JpdGUocnBmLCBk bGIsIFZJNl9SUEZfU1JDTV9BRERSX1ksIG1lbS5hZGRyWzBdKTsKPiA+IC0JdnNwMV9ycGZfd3Jp dGUocnBmLCBkbGIsIFZJNl9SUEZfU1JDTV9BRERSX0MwLCBtZW0uYWRkclsxXSk7Cj4gPiAtCXZz cDFfcnBmX3dyaXRlKHJwZiwgZGxiLCBWSTZfUlBGX1NSQ01fQUREUl9DMSwgbWVtLmFkZHJbMl0p Owo+ID4gKwkvKgo+ID4gKwkgKiBJbnRlcmxhY2VkIHBpcGVsaW5lcyB3aWxsIHVzZSB0aGUgZXh0 ZW5kZWQgcHJlLWNtZCB0byBwcm9jZXNzCj4gPiArCSAqIFNSQ01fQUREUl97WSxDMCxDMX0KPiA+ ICsJICovCj4gPiArCWlmIChycGYtPmludGVybGFjZWQpIHsKPiA+ICsJCWNtZCA9IHZzcDFfZGxt X2dldF9hdXRvZmxkX2NtZChkbCk7Cj4gPiArCQl2c3AxX3JwZl9jb25maWd1cmVfYXV0b2ZsZChy cGYsIGNtZCk7Cj4gCj4gVGVjaG5pY2FsbHkgLSBpZiAocnBmLT5pbnRlcmxhY2VkKSBjYW4gb25s eSBldmFsdWF0ZSB0byB0cnVlIG9uIERSTQo+IHBpcGVsaW5lcywgd2hpY2ggZG9uJ3QgdXNlIHRo ZSBpbWFnZSBwYXJ0aXRpb25pbmcuIFNvIGl0IG1pZ2h0IGJlIHBvc3NpYmxlCj4gdG8gYXJndWUg dGhhdCB0aGUgdnNwMV9ycGZfY29uZmlndXJlX2F1dG9mbGQoKSBjYWxsIHNob3VsZCBiZSBkb25l IGluCj4gcnBmX2NvbmZpZ3VyZV9mcmFtZSgpLiBFeGNlcHQgSSB0aGluayBpdCdzIHJlYXNvbmFi bGUgdG8gY29uc2lkZXIgdGhhdCB0aGUKPiBhZGRyZXNzZXMgYW5kIGNvbmZpZ3VyYXRpb24gb2Yg dGhlIGZyYW1lIGFyZSBzdGlsbCBqdXN0IHRoZSAnZmlyc3QgYW5kIG9ubHkKPiBwYXJ0aXRpb24n IC0gdGh1cyBJIHRoaW5rIGl0J3MgYmV0dGVyIHRvIGxlYXZlIHRoaXMgaGVyZSAtIGFuZCBpbnN0 ZWFkCj4gZW5zdXJlIHRoYXQgdGhlIHJlcXVyaWVkIERMIGlzIHBhc3NlZCB0aHJvdWdoLgoKSSBh Z3JlZSB3aXRoIHlvdSwgdGhhdCBtYWtlcyBzZW5zZS4KCj4gVW5sZXNzIHRoZXJlJ3MgYSBiZXR0 ZXIgd2F5IHRvIGdldCB0aGUgY21kIG9iamVjdCA/CgpUaGVyZSdzIG5vbmUgdGhhdCBpbW1lZGlh dGVseSBvY2N1cnMgdG8gbWUuCgo+ID4gKwl9IGVsc2Ugewo+ID4gKwkJdnNwMV9ycGZfd3JpdGUo cnBmLCBkbGIsIFZJNl9SUEZfU1JDTV9BRERSX1ksIG1lbS5hZGRyWzBdKTsKPiA+ICsJCXZzcDFf cnBmX3dyaXRlKHJwZiwgZGxiLCBWSTZfUlBGX1NSQ01fQUREUl9DMCwgbWVtLmFkZHJbMV0pOwo+ ID4gKwkJdnNwMV9ycGZfd3JpdGUocnBmLCBkbGIsIFZJNl9SUEZfU1JDTV9BRERSX0MxLCBtZW0u YWRkclsyXSk7Cj4gPiArCX0KPiA+ICB9Cj4gPiArCj4gPiAgc3RhdGljIHZvaWQgcnBmX3BhcnRp dGlvbihzdHJ1Y3QgdnNwMV9lbnRpdHkgKmVudGl0eSwKPiA+ICAJCQkgIHN0cnVjdCB2c3AxX3Bp cGVsaW5lICpwaXBlLAo+ID4gIAkJCSAgc3RydWN0IHZzcDFfcGFydGl0aW9uICpwYXJ0aXRpb24s Cj4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfcndwZi5o Cj4gPiBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3J3cGYuaCBpbmRleAo+ID4g NzA3NDJlY2Y3NjZmLi44ZDZlNDJmMjc5MDggMTAwNjQ0Cj4gPiAtLS0gYS9kcml2ZXJzL21lZGlh L3BsYXRmb3JtL3ZzcDEvdnNwMV9yd3BmLmgKPiA+ICsrKyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZv cm0vdnNwMS92c3AxX3J3cGYuaAo+ID4gQEAgLTQyLDYgKzQyLDcgQEAgc3RydWN0IHZzcDFfcndw ZiB7Cj4gPiAgCXN0cnVjdCB2NGwyX3BpeF9mb3JtYXRfbXBsYW5lIGZvcm1hdDsKPiA+ICAJY29u c3Qgc3RydWN0IHZzcDFfZm9ybWF0X2luZm8gKmZtdGluZm87Cj4gPiAgCXVuc2lnbmVkIGludCBi cnhfaW5wdXQ7Cj4gPiArCWJvb2wgaW50ZXJsYWNlZDsKCmtlcm5lbGRvYyBtaWdodCBiZSBuaWNl IDotKQoKPiA+IAo+ID4gIAl1bnNpZ25lZCBpbnQgYWxwaGE7Cj4gPiAKCltzbmlwXQoKPiA+IGRp ZmYgLS1naXQgYS9pbmNsdWRlL21lZGlhL3ZzcDEuaCBiL2luY2x1ZGUvbWVkaWEvdnNwMS5oCj4g PiBpbmRleCA2NzhjMjRkZTFhYzYuLmMxMDg4M2YzMDk4MCAxMDA2NDQKPiA+IC0tLSBhL2luY2x1 ZGUvbWVkaWEvdnNwMS5oCj4gPiArKysgYi9pbmNsdWRlL21lZGlhL3ZzcDEuaAo+ID4gQEAgLTUw LDYgKzUwLDcgQEAgaW50IHZzcDFfZHVfc2V0dXBfbGlmKHN0cnVjdCBkZXZpY2UgKmRldiwgdW5z aWduZWQgaW50Cj4gPiBwaXBlX2luZGV4LD4gCj4gPiAgICogQGRzdDogZGVzdGluYXRpb24gcmVj dGFuZ2xlIG9uIHRoZSBkaXNwbGF5IChpbnRlZ2VyIGNvb3JkaW5hdGVzKQo+ID4gICAqIEBhbHBo YTogYWxwaGEgdmFsdWUgKDA6IGZ1bGx5IHRyYW5zcGFyZW50LCAyNTU6IGZ1bGx5IG9wYXF1ZSkK PiA+ICAgKiBAenBvczogWiBwb3NpdGlvbiBvZiB0aGUgcGxhbmUgKGZyb20gMCB0byBudW1iZXIg b2YgcGxhbmVzIG1pbnVzIDEpCj4gPiArICogQGludGVybGFjZWQ6IHRydWUgZm9yIGludGVybGFj ZWQgcGlwZWxpbmVzCgpNYXliZSAidHJ1ZSBpZiB0aGUgcGlwZWxpbmUgb3V0cHV0cyBhbiBpbnRl cmxhY2VkIHN0cmVhbSIgPwoKPiA+ICAgKi8KPiA+ICBzdHJ1Y3QgdnNwMV9kdV9hdG9taWNfY29u ZmlnIHsKPiA+ICAJdTMyIHBpeGVsZm9ybWF0Owo+ID4gCgotLSAKUmVnYXJkcywKCkxhdXJlbnQg UGluY2hhcnQKCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3Jn Cmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVs Cg==