From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from galahad.ideasonboard.com ([185.26.127.97]:48562 "EHLO galahad.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752219AbeDDV5O (ORCPT ); Wed, 4 Apr 2018 17:57:14 -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 13/15] v4l: vsp1: Assign BRU and BRS to pipelines dynamically Date: Thu, 05 Apr 2018 00:57:23 +0300 Message-ID: <47593337.LS3i7tY9ab@avalon> In-Reply-To: <48239272-4f3f-1245-5ad9-c54c1413c1c2@ideasonboard.com> References: <20180226214516.11559-1-laurent.pinchart+renesas@ideasonboard.com> <20180226214516.11559-14-laurent.pinchart+renesas@ideasonboard.com> <48239272-4f3f-1245-5ad9-c54c1413c1c2@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 Wednesday, 4 April 2018 19:00:10 EEST Kieran Bingham wrote: > Hi Laurent, > > Thank you for the patch. > > I don't envy you on having to deal with this one ... it's a bit of a pain > ... Yes it was a bit painful :-/ The devil was both in the big picture and the details this time. > On 26/02/18 21:45, Laurent Pinchart wrote: > > The VSPDL variant drives two DU channels through two LIF and two > > blenders, BRU and BRS. The DU channels thus share the five available > > VSPDL inputs and expose them as five KMS planes. > > > > The current implementation assigns the BRS to the second LIF and thus > > artificially limits the number of planes for the second display channel > > to two at most. > > > > Lift this artificial limitation by assigning the BRU and BRS to the > > display pipelines on demand based on the number of planes used by each > > pipeline. When a display pipeline needs more than two inputs and the BRU > > is already in use by the other pipeline, this requires reconfiguring the > > other pipeline to free the BRU before processing, which can result in > > frame drop on both pipelines. > > So this is a hard one! > - Having to dynamically reconfigure "someone else's" pipes ... > > > Signed-off-by: Laurent Pinchart > > > > Except for the recursion, which is unavoidable, and the lock handling across > function calls which is ... unavoidable I think as well (at least for the > moment), my only quibble is the naming of the 'notify' variable, which is > not particularly clear in terms of who it notifies. (Internal, vs DRM) > > I'll leave it up to you to decide whether or not to rename it though, and if > you're happy with the naming then fine. I agree with you, please see below. > Reviewed-by: Kieran Bingham > > > --- > > > > drivers/media/platform/vsp1/vsp1_drm.c | 160 ++++++++++++++++++++++------ > > drivers/media/platform/vsp1/vsp1_drm.h | 9 ++ > > 2 files changed, 144 insertions(+), 25 deletions(-) > > > > diff --git a/drivers/media/platform/vsp1/vsp1_drm.c > > b/drivers/media/platform/vsp1/vsp1_drm.c index 6c60b72b6f50..87e31ba0ddf5 > > 100644 > > --- a/drivers/media/platform/vsp1/vsp1_drm.c > > +++ b/drivers/media/platform/vsp1/vsp1_drm.c > > @@ -39,7 +39,13 @@ static void vsp1_du_pipeline_frame_end(struct > > vsp1_pipeline *pipe,> > > struct vsp1_drm_pipeline *drm_pipe = to_vsp1_drm_pipeline(pipe); > > > > if (drm_pipe->du_complete) > > > > - drm_pipe->du_complete(drm_pipe->du_private, completed); > > + drm_pipe->du_complete(drm_pipe->du_private, > > + completed && !notify); > > + > > + if (notify) { > > + drm_pipe->force_bru_release = false; > > + wake_up(&drm_pipe->wait_queue); > > + } > > Notify seems such a nondescript verb to use here, and confuses me against > who we are notifying - and why (it's an internal notification, but notify > makes me think we are 'notifying' the DU - which is exactly the opposite). > > (Perhaps this is actually a comment for the previous patch, but I've gone > out-of-order, due to the complexities here...) > > Could this be 'internal', 'released' or 'reconfigured', or something to > distinguish that this frame-end is not a normal frame-completion event ? I think internal is a better name than notify. I'll pick that. > > } > > > > /* ---------------------------------------------------------------------- > > @@ -149,6 +155,10 @@ static int vsp1_du_pipeline_setup_rpf(struct > > vsp1_device *vsp1, > > } > > > > /* Setup the BRU source pad. */ > > +static int vsp1_du_pipeline_setup_input(struct vsp1_device *vsp1, > > + struct vsp1_pipeline *pipe); > > +static void vsp1_du_pipeline_configure(struct vsp1_pipeline *pipe); > > + > > Ohhh lovely, recursion... > Ohhh lovely, recursion... I wanted to avoid it but haven't found a better way. > > static int vsp1_du_pipeline_setup_bru(struct vsp1_device *vsp1, > > struct vsp1_pipeline *pipe) > > { > > @@ -156,8 +166,93 @@ static int vsp1_du_pipeline_setup_bru(struct > > vsp1_device *vsp1, > > struct v4l2_subdev_format format = { > > .which = V4L2_SUBDEV_FORMAT_ACTIVE, > > }; > > + struct vsp1_entity *bru; > > int ret; > > > > + /* > > + * Pick a BRU: > > + * - If we need more than two inputs, use the main BRU. > > + * - Otherwise, if we are not forced to release our BRU, keep it. > > + * - Else, use any free BRU (randomly starting with the main BRU). > > + */ > > + if (pipe->num_inputs > 2) > > + bru = &vsp1->bru->entity; > > + else if (pipe->bru && !drm_pipe->force_bru_release) > > + bru = pipe->bru; > > + else if (!vsp1->bru->entity.pipe) > > + bru = &vsp1->bru->entity; > > + else > > + bru = &vsp1->brs->entity; > > Ok - that tooks some iterations to go through - but I think it covers all > the bases. > > > + > > + /* Switch BRU if needed. */ > > + if (bru != pipe->bru) { > > + struct vsp1_entity *released_bru = NULL; > > + > > + /* Release our BRU if we have one. */ > > + if (pipe->bru) { > > + /* > > + * The BRU might be acquired by the other pipeline in > > + * the next step. We must thus remove it from the list > > + * of entities for this pipeline. The other pipeline's > > + * hardware configuration will reconfigure the BRU > > + * routing. > > + * > > + * However, if the other pipeline doesn't acquire our > > + * BRU, we need to keep it in the list, otherwise the > > + * hardware configuration step won't disconnect it from > > + * the pipeline. To solve this, store the released BRU > > + * pointer to add it back to the list of entities later > > + * if it isn't acquired by the other pipeline. > > + */ > > + released_bru = pipe->bru; > > + > > + list_del(&pipe->bru->list_pipe); > > + pipe->bru->sink = NULL; > > + pipe->bru->pipe = NULL; > > + pipe->bru = NULL; > > + } > > + > > + /* > > + * If the BRU we need is in use, force the owner pipeline to > > + * switch to the other BRU and wait until the switch completes. > > + */ > > + if (bru->pipe) { > > + struct vsp1_drm_pipeline *owner_pipe; > > + > > + owner_pipe = to_vsp1_drm_pipeline(bru->pipe); > > + owner_pipe->force_bru_release = true; > > + > > + vsp1_du_pipeline_setup_input(vsp1, &owner_pipe->pipe); > > + vsp1_du_pipeline_configure(&owner_pipe->pipe); > > + > > + ret = wait_event_timeout(owner_pipe->wait_queue, > > + !owner_pipe->force_bru_release, > > + msecs_to_jiffies(500)); > > + if (ret == 0) > > + dev_warn(vsp1->dev, > > + "DRM pipeline %u reconfiguration timeout\n", > > + owner_pipe->pipe.lif->index); > > + } > > + > > + /* > > + * If the BRU we have released previously hasn't been acquired > > + * by the other pipeline, add it back to the entities list (with > > + * the pipe pointer NULL) to let vsp1_du_pipeline_configure() > > + * disconnect it from the hardware pipeline. > > + */ > > + if (released_bru && !released_bru->pipe) > > + list_add_tail(&released_bru->list_pipe, > > + &pipe->entities); > > + > > + /* Add the BRU to the pipeline. */ > > + pipe->bru = bru; > > + pipe->bru->pipe = pipe; > > + pipe->bru->sink = &pipe->output->entity; > > + pipe->bru->sink_pad = 0; > > + > > + list_add_tail(&pipe->bru->list_pipe, &pipe->entities); > > + } > > + > > Phew ... that's quite some chunk of interacting code ... > > I've gone through it with the combinations of two pipes, 1 and 2, then > swapping them around when say pipe 2 has 3 inputs. > > It seems to scan through OK in my head ... but I think I've gone a bit > cross-eyed now :D > > Have we got some tests in place for the various combinations of paths > through here ? Maybe not for all combinations, but there's a kms-test-brxalloc.py test in the bru-brs branch of git://git.ideasonboard.com/renesas/kms-tests.git > > /* > > * Configure the format on the BRU source and verify that it matches the > > * requested format. We don't set the media bus code as it is configured [snip] > > @@ -516,6 +623,9 @@ EXPORT_SYMBOL_GPL(vsp1_du_setup_lif); > > */ > > > > void vsp1_du_atomic_begin(struct device *dev, unsigned int pipe_index) > > { > > + struct vsp1_device *vsp1 = dev_get_drvdata(dev); > > + > > + mutex_lock(&vsp1->drm->lock); > > Ouch ... we have to lock ... > > > } > > EXPORT_SYMBOL_GPL(vsp1_du_atomic_begin); > > > > @@ -629,6 +739,7 @@ void vsp1_du_atomic_flush(struct device *dev, unsigned > > int pipe_index) > > vsp1_du_pipeline_setup_input(vsp1, pipe); > > vsp1_du_pipeline_configure(pipe); > > > > + mutex_unlock(&vsp1->drm->lock); > > And unlock in different functions ? :-( > > (Yes, I see that we do - because we are crossing pipes...) That's also something I would have liked to avoid :-/ > > > } > > EXPORT_SYMBOL_GPL(vsp1_du_atomic_flush); [snip] -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH 13/15] v4l: vsp1: Assign BRU and BRS to pipelines dynamically Date: Thu, 05 Apr 2018 00:57:23 +0300 Message-ID: <47593337.LS3i7tY9ab@avalon> References: <20180226214516.11559-1-laurent.pinchart+renesas@ideasonboard.com> <20180226214516.11559-14-laurent.pinchart+renesas@ideasonboard.com> <48239272-4f3f-1245-5ad9-c54c1413c1c2@ideasonboard.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from galahad.ideasonboard.com (galahad.ideasonboard.com [185.26.127.97]) by gabe.freedesktop.org (Postfix) with ESMTPS id 2D3136E638 for ; Wed, 4 Apr 2018 21:57:13 +0000 (UTC) In-Reply-To: <48239272-4f3f-1245-5ad9-c54c1413c1c2@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 SGkgS2llcmFuLAoKT24gV2VkbmVzZGF5LCA0IEFwcmlsIDIwMTggMTk6MDA6MTAgRUVTVCBLaWVy YW4gQmluZ2hhbSB3cm90ZToKPiBIaSBMYXVyZW50LAo+IAo+IFRoYW5rIHlvdSBmb3IgdGhlIHBh dGNoLgo+IAo+IEkgZG9uJ3QgZW52eSB5b3Ugb24gaGF2aW5nIHRvIGRlYWwgd2l0aCB0aGlzIG9u ZSAuLi4gaXQncyBhIGJpdCBvZiBhIHBhaW4KPiAuLi4KClllcyBpdCB3YXMgYSBiaXQgcGFpbmZ1 bCA6LS8gVGhlIGRldmlsIHdhcyBib3RoIGluIHRoZSBiaWcgcGljdHVyZSBhbmQgdGhlIApkZXRh aWxzIHRoaXMgdGltZS4KCj4gT24gMjYvMDIvMTggMjE6NDUsIExhdXJlbnQgUGluY2hhcnQgd3Jv dGU6Cj4gPiBUaGUgVlNQREwgdmFyaWFudCBkcml2ZXMgdHdvIERVIGNoYW5uZWxzIHRocm91Z2gg dHdvIExJRiBhbmQgdHdvCj4gPiBibGVuZGVycywgQlJVIGFuZCBCUlMuIFRoZSBEVSBjaGFubmVs cyB0aHVzIHNoYXJlIHRoZSBmaXZlIGF2YWlsYWJsZQo+ID4gVlNQREwgaW5wdXRzIGFuZCBleHBv c2UgdGhlbSBhcyBmaXZlIEtNUyBwbGFuZXMuCj4gPiAKPiA+IFRoZSBjdXJyZW50IGltcGxlbWVu dGF0aW9uIGFzc2lnbnMgdGhlIEJSUyB0byB0aGUgc2Vjb25kIExJRiBhbmQgdGh1cwo+ID4gYXJ0 aWZpY2lhbGx5IGxpbWl0cyB0aGUgbnVtYmVyIG9mIHBsYW5lcyBmb3IgdGhlIHNlY29uZCBkaXNw bGF5IGNoYW5uZWwKPiA+IHRvIHR3byBhdCBtb3N0Lgo+ID4gCj4gPiBMaWZ0IHRoaXMgYXJ0aWZp Y2lhbCBsaW1pdGF0aW9uIGJ5IGFzc2lnbmluZyB0aGUgQlJVIGFuZCBCUlMgdG8gdGhlCj4gPiBk aXNwbGF5IHBpcGVsaW5lcyBvbiBkZW1hbmQgYmFzZWQgb24gdGhlIG51bWJlciBvZiBwbGFuZXMg dXNlZCBieSBlYWNoCj4gPiBwaXBlbGluZS4gV2hlbiBhIGRpc3BsYXkgcGlwZWxpbmUgbmVlZHMg bW9yZSB0aGFuIHR3byBpbnB1dHMgYW5kIHRoZSBCUlUKPiA+IGlzIGFscmVhZHkgaW4gdXNlIGJ5 IHRoZSBvdGhlciBwaXBlbGluZSwgdGhpcyByZXF1aXJlcyByZWNvbmZpZ3VyaW5nIHRoZQo+ID4g b3RoZXIgcGlwZWxpbmUgdG8gZnJlZSB0aGUgQlJVIGJlZm9yZSBwcm9jZXNzaW5nLCB3aGljaCBj YW4gcmVzdWx0IGluCj4gPiBmcmFtZSBkcm9wIG9uIGJvdGggcGlwZWxpbmVzLgo+IAo+IFNvIHRo aXMgaXMgYSBoYXJkIG9uZSEKPiAgLSBIYXZpbmcgdG8gZHluYW1pY2FsbHkgcmVjb25maWd1cmUg InNvbWVvbmUgZWxzZSdzIiBwaXBlcyAuLi4KPiAKPiA+IFNpZ25lZC1vZmYtYnk6IExhdXJlbnQg UGluY2hhcnQKPiA+IDxsYXVyZW50LnBpbmNoYXJ0K3JlbmVzYXNAaWRlYXNvbmJvYXJkLmNvbT4K PiAKPiBFeGNlcHQgZm9yIHRoZSByZWN1cnNpb24sIHdoaWNoIGlzIHVuYXZvaWRhYmxlLCBhbmQg dGhlIGxvY2sgaGFuZGxpbmcgYWNyb3NzCj4gZnVuY3Rpb24gY2FsbHMgd2hpY2ggaXMgLi4uIHVu YXZvaWRhYmxlIEkgdGhpbmsgYXMgd2VsbCAoYXQgbGVhc3QgZm9yIHRoZQo+IG1vbWVudCksIG15 IG9ubHkgcXVpYmJsZSBpcyB0aGUgbmFtaW5nIG9mIHRoZSAnbm90aWZ5JyB2YXJpYWJsZSwgd2hp Y2ggaXMKPiBub3QgcGFydGljdWxhcmx5IGNsZWFyIGluIHRlcm1zIG9mIHdobyBpdCBub3RpZmll cy4gKEludGVybmFsLCB2cyBEUk0pCj4gCj4gSSdsbCBsZWF2ZSBpdCB1cCB0byB5b3UgdG8gZGVj aWRlIHdoZXRoZXIgb3Igbm90IHRvIHJlbmFtZSBpdCB0aG91Z2gsIGFuZCBpZgo+IHlvdSdyZSBo YXBweSB3aXRoIHRoZSBuYW1pbmcgdGhlbiBmaW5lLgoKSSBhZ3JlZSB3aXRoIHlvdSwgcGxlYXNl IHNlZSBiZWxvdy4KCj4gUmV2aWV3ZWQtYnk6IEtpZXJhbiBCaW5naGFtIDxraWVyYW4uYmluZ2hh bStyZW5lc2FzQGlkZWFzb25ib2FyZC5jb20+Cj4gCj4gPiAtLS0KPiA+IAo+ID4gIGRyaXZlcnMv bWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RybS5jIHwgMTYwICsrKysrKysrKysrKysrKysrKysr KystLS0tLS0KPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kcm0uaCB8ICAg OSArKwo+ID4gIDIgZmlsZXMgY2hhbmdlZCwgMTQ0IGluc2VydGlvbnMoKyksIDI1IGRlbGV0aW9u cygtKQo+ID4gCj4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3Zz cDFfZHJtLmMKPiA+IGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZHJtLmMgaW5k ZXggNmM2MGI3MmI2ZjUwLi44N2UzMWJhMGRkZjUKPiA+IDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVy cy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZHJtLmMKPiA+ICsrKyBiL2RyaXZlcnMvbWVkaWEv cGxhdGZvcm0vdnNwMS92c3AxX2RybS5jCj4gPiBAQCAtMzksNyArMzksMTMgQEAgc3RhdGljIHZv aWQgdnNwMV9kdV9waXBlbGluZV9mcmFtZV9lbmQoc3RydWN0Cj4gPiB2c3AxX3BpcGVsaW5lICpw aXBlLD4gCj4gPiAgCXN0cnVjdCB2c3AxX2RybV9waXBlbGluZSAqZHJtX3BpcGUgPSB0b192c3Ax X2RybV9waXBlbGluZShwaXBlKTsKPiA+ICAJCj4gPiAgCWlmIChkcm1fcGlwZS0+ZHVfY29tcGxl dGUpCj4gPiAKPiA+IC0JCWRybV9waXBlLT5kdV9jb21wbGV0ZShkcm1fcGlwZS0+ZHVfcHJpdmF0 ZSwgY29tcGxldGVkKTsKPiA+ICsJCWRybV9waXBlLT5kdV9jb21wbGV0ZShkcm1fcGlwZS0+ZHVf cHJpdmF0ZSwKPiA+ICsJCQkJICAgICAgY29tcGxldGVkICYmICFub3RpZnkpOwo+ID4gKwo+ID4g KwlpZiAobm90aWZ5KSB7Cj4gPiArCQlkcm1fcGlwZS0+Zm9yY2VfYnJ1X3JlbGVhc2UgPSBmYWxz ZTsKPiA+ICsJCXdha2VfdXAoJmRybV9waXBlLT53YWl0X3F1ZXVlKTsKPiA+ICsJfQo+IAo+IE5v dGlmeSBzZWVtcyBzdWNoIGEgbm9uZGVzY3JpcHQgdmVyYiB0byB1c2UgaGVyZSwgYW5kIGNvbmZ1 c2VzIG1lIGFnYWluc3QKPiB3aG8gd2UgYXJlIG5vdGlmeWluZyAgLSBhbmQgd2h5IChpdCdzIGFu IGludGVybmFsIG5vdGlmaWNhdGlvbiwgYnV0IG5vdGlmeQo+IG1ha2VzIG1lIHRoaW5rIHdlIGFy ZSAnbm90aWZ5aW5nJyB0aGUgRFUgLSB3aGljaCBpcyBleGFjdGx5IHRoZSBvcHBvc2l0ZSkuCj4g Cj4gKFBlcmhhcHMgdGhpcyBpcyBhY3R1YWxseSBhIGNvbW1lbnQgZm9yIHRoZSBwcmV2aW91cyBw YXRjaCwgYnV0IEkndmUgZ29uZQo+IG91dC1vZi1vcmRlciwgZHVlIHRvIHRoZSBjb21wbGV4aXRp ZXMgaGVyZS4uLikKPiAKPiBDb3VsZCB0aGlzIGJlICdpbnRlcm5hbCcsICdyZWxlYXNlZCcgb3Ig J3JlY29uZmlndXJlZCcsIG9yIHNvbWV0aGluZyB0bwo+IGRpc3Rpbmd1aXNoIHRoYXQgdGhpcyBm cmFtZS1lbmQgaXMgbm90IGEgbm9ybWFsIGZyYW1lLWNvbXBsZXRpb24gZXZlbnQgPwoKSSB0aGlu ayBpbnRlcm5hbCBpcyBhIGJldHRlciBuYW1lIHRoYW4gbm90aWZ5LiBJJ2xsIHBpY2sgdGhhdC4K Cj4gPiAgfQo+ID4gIAo+ID4gIC8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KPiA+IEBAIC0xNDksNiArMTU1LDEw IEBAIHN0YXRpYyBpbnQgdnNwMV9kdV9waXBlbGluZV9zZXR1cF9ycGYoc3RydWN0Cj4gPiB2c3Ax X2RldmljZSAqdnNwMSwKPiA+ICB9Cj4gPiAgCj4gPiAgLyogU2V0dXAgdGhlIEJSVSBzb3VyY2Ug cGFkLiAqLwo+ID4gK3N0YXRpYyBpbnQgdnNwMV9kdV9waXBlbGluZV9zZXR1cF9pbnB1dChzdHJ1 Y3QgdnNwMV9kZXZpY2UgKnZzcDEsCj4gPiArCQkJCQlzdHJ1Y3QgdnNwMV9waXBlbGluZSAqcGlw ZSk7Cj4gPiArc3RhdGljIHZvaWQgdnNwMV9kdV9waXBlbGluZV9jb25maWd1cmUoc3RydWN0IHZz cDFfcGlwZWxpbmUgKnBpcGUpOwo+ID4gKwo+IAo+IE9oaGggbG92ZWx5LCByZWN1cnNpb24uLi4K PiBPaGhoIGxvdmVseSwgcmVjdXJzaW9uLi4uCgpJIHdhbnRlZCB0byBhdm9pZCBpdCBidXQgaGF2 ZW4ndCBmb3VuZCBhIGJldHRlciB3YXkuCgo+ID4gIHN0YXRpYyBpbnQgdnNwMV9kdV9waXBlbGlu ZV9zZXR1cF9icnUoc3RydWN0IHZzcDFfZGV2aWNlICp2c3AxLAo+ID4gIAkJCQkgICAgICBzdHJ1 Y3QgdnNwMV9waXBlbGluZSAqcGlwZSkKPiA+ICB7Cj4gPiBAQCAtMTU2LDggKzE2Niw5MyBAQCBz dGF0aWMgaW50IHZzcDFfZHVfcGlwZWxpbmVfc2V0dXBfYnJ1KHN0cnVjdAo+ID4gdnNwMV9kZXZp Y2UgKnZzcDEsCj4gPiAgCXN0cnVjdCB2NGwyX3N1YmRldl9mb3JtYXQgZm9ybWF0ID0gewo+ID4g IAkJLndoaWNoID0gVjRMMl9TVUJERVZfRk9STUFUX0FDVElWRSwKPiA+ICAJfTsKPiA+ICsJc3Ry dWN0IHZzcDFfZW50aXR5ICpicnU7Cj4gPiAgCWludCByZXQ7Cj4gPiAKPiA+ICsJLyoKPiA+ICsJ ICogUGljayBhIEJSVToKPiA+ICsJICogLSBJZiB3ZSBuZWVkIG1vcmUgdGhhbiB0d28gaW5wdXRz LCB1c2UgdGhlIG1haW4gQlJVLgo+ID4gKwkgKiAtIE90aGVyd2lzZSwgaWYgd2UgYXJlIG5vdCBm b3JjZWQgdG8gcmVsZWFzZSBvdXIgQlJVLCBrZWVwIGl0Lgo+ID4gKwkgKiAtIEVsc2UsIHVzZSBh bnkgZnJlZSBCUlUgKHJhbmRvbWx5IHN0YXJ0aW5nIHdpdGggdGhlIG1haW4gQlJVKS4KPiA+ICsJ ICovCj4gPiArCWlmIChwaXBlLT5udW1faW5wdXRzID4gMikKPiA+ICsJCWJydSA9ICZ2c3AxLT5i cnUtPmVudGl0eTsKPiA+ICsJZWxzZSBpZiAocGlwZS0+YnJ1ICYmICFkcm1fcGlwZS0+Zm9yY2Vf YnJ1X3JlbGVhc2UpCj4gPiArCQlicnUgPSBwaXBlLT5icnU7Cj4gPiArCWVsc2UgaWYgKCF2c3Ax LT5icnUtPmVudGl0eS5waXBlKQo+ID4gKwkJYnJ1ID0gJnZzcDEtPmJydS0+ZW50aXR5Owo+ID4g KwllbHNlCj4gPiArCQlicnUgPSAmdnNwMS0+YnJzLT5lbnRpdHk7Cj4gCj4gT2sgLSB0aGF0IHRv b2tzIHNvbWUgaXRlcmF0aW9ucyB0byBnbyB0aHJvdWdoIC0gYnV0IEkgdGhpbmsgaXQgY292ZXJz IGFsbAo+IHRoZSBiYXNlcy4KPiAKPiA+ICsKPiA+ICsJLyogU3dpdGNoIEJSVSBpZiBuZWVkZWQu ICovCj4gPiArCWlmIChicnUgIT0gcGlwZS0+YnJ1KSB7Cj4gPiArCQlzdHJ1Y3QgdnNwMV9lbnRp dHkgKnJlbGVhc2VkX2JydSA9IE5VTEw7Cj4gPiArCj4gPiArCQkvKiBSZWxlYXNlIG91ciBCUlUg aWYgd2UgaGF2ZSBvbmUuICovCj4gPiArCQlpZiAocGlwZS0+YnJ1KSB7Cj4gPiArCQkJLyoKPiA+ ICsJCQkgKiBUaGUgQlJVIG1pZ2h0IGJlIGFjcXVpcmVkIGJ5IHRoZSBvdGhlciBwaXBlbGluZSBp bgo+ID4gKwkJCSAqIHRoZSBuZXh0IHN0ZXAuIFdlIG11c3QgdGh1cyByZW1vdmUgaXQgZnJvbSB0 aGUgbGlzdAo+ID4gKwkJCSAqIG9mIGVudGl0aWVzIGZvciB0aGlzIHBpcGVsaW5lLiBUaGUgb3Ro ZXIgcGlwZWxpbmUncwo+ID4gKwkJCSAqIGhhcmR3YXJlIGNvbmZpZ3VyYXRpb24gd2lsbCByZWNv bmZpZ3VyZSB0aGUgQlJVCj4gPiArCQkJICogcm91dGluZy4KPiA+ICsJCQkgKgo+ID4gKwkJCSAq IEhvd2V2ZXIsIGlmIHRoZSBvdGhlciBwaXBlbGluZSBkb2Vzbid0IGFjcXVpcmUgb3VyCj4gPiAr CQkJICogQlJVLCB3ZSBuZWVkIHRvIGtlZXAgaXQgaW4gdGhlIGxpc3QsIG90aGVyd2lzZSB0aGUK PiA+ICsJCQkgKiBoYXJkd2FyZSBjb25maWd1cmF0aW9uIHN0ZXAgd29uJ3QgZGlzY29ubmVjdCBp dCBmcm9tCj4gPiArCQkJICogdGhlIHBpcGVsaW5lLiBUbyBzb2x2ZSB0aGlzLCBzdG9yZSB0aGUg cmVsZWFzZWQgQlJVCj4gPiArCQkJICogcG9pbnRlciB0byBhZGQgaXQgYmFjayB0byB0aGUgbGlz dCBvZiBlbnRpdGllcyBsYXRlcgo+ID4gKwkJCSAqIGlmIGl0IGlzbid0IGFjcXVpcmVkIGJ5IHRo ZSBvdGhlciBwaXBlbGluZS4KPiA+ICsJCQkgKi8KPiA+ICsJCQlyZWxlYXNlZF9icnUgPSBwaXBl LT5icnU7Cj4gPiArCj4gPiArCQkJbGlzdF9kZWwoJnBpcGUtPmJydS0+bGlzdF9waXBlKTsKPiA+ ICsJCQlwaXBlLT5icnUtPnNpbmsgPSBOVUxMOwo+ID4gKwkJCXBpcGUtPmJydS0+cGlwZSA9IE5V TEw7Cj4gPiArCQkJcGlwZS0+YnJ1ID0gTlVMTDsKPiA+ICsJCX0KPiA+ICsKPiA+ICsJCS8qCj4g PiArCQkgKiBJZiB0aGUgQlJVIHdlIG5lZWQgaXMgaW4gdXNlLCBmb3JjZSB0aGUgb3duZXIgcGlw ZWxpbmUgdG8KPiA+ICsJCSAqIHN3aXRjaCB0byB0aGUgb3RoZXIgQlJVIGFuZCB3YWl0IHVudGls IHRoZSBzd2l0Y2ggY29tcGxldGVzLgo+ID4gKwkJICovCj4gPiArCQlpZiAoYnJ1LT5waXBlKSB7 Cj4gPiArCQkJc3RydWN0IHZzcDFfZHJtX3BpcGVsaW5lICpvd25lcl9waXBlOwo+ID4gKwo+ID4g KwkJCW93bmVyX3BpcGUgPSB0b192c3AxX2RybV9waXBlbGluZShicnUtPnBpcGUpOwo+ID4gKwkJ CW93bmVyX3BpcGUtPmZvcmNlX2JydV9yZWxlYXNlID0gdHJ1ZTsKPiA+ICsKPiA+ICsJCQl2c3Ax X2R1X3BpcGVsaW5lX3NldHVwX2lucHV0KHZzcDEsICZvd25lcl9waXBlLT5waXBlKTsKPiA+ICsJ CQl2c3AxX2R1X3BpcGVsaW5lX2NvbmZpZ3VyZSgmb3duZXJfcGlwZS0+cGlwZSk7Cj4gPiArCj4g PiArCQkJcmV0ID0gd2FpdF9ldmVudF90aW1lb3V0KG93bmVyX3BpcGUtPndhaXRfcXVldWUsCj4g PiArCQkJCQkJICFvd25lcl9waXBlLT5mb3JjZV9icnVfcmVsZWFzZSwKPiA+ICsJCQkJCQkgbXNl Y3NfdG9famlmZmllcyg1MDApKTsKPiA+ICsJCQlpZiAocmV0ID09IDApCj4gPiArCQkJCWRldl93 YXJuKHZzcDEtPmRldiwKPiA+ICsJCQkJCSAiRFJNIHBpcGVsaW5lICV1IHJlY29uZmlndXJhdGlv biB0aW1lb3V0XG4iLAo+ID4gKwkJCQkJIG93bmVyX3BpcGUtPnBpcGUubGlmLT5pbmRleCk7Cj4g PiArCQl9Cj4gPiArCj4gPiArCQkvKgo+ID4gKwkJICogSWYgdGhlIEJSVSB3ZSBoYXZlIHJlbGVh c2VkIHByZXZpb3VzbHkgaGFzbid0IGJlZW4gYWNxdWlyZWQKPiA+ICsJCSAqIGJ5IHRoZSBvdGhl ciBwaXBlbGluZSwgYWRkIGl0IGJhY2sgdG8gdGhlIGVudGl0aWVzIGxpc3QgKHdpdGgKPiA+ICsJ CSAqIHRoZSBwaXBlIHBvaW50ZXIgTlVMTCkgdG8gbGV0IHZzcDFfZHVfcGlwZWxpbmVfY29uZmln dXJlKCkKPiA+ICsJCSAqIGRpc2Nvbm5lY3QgaXQgZnJvbSB0aGUgaGFyZHdhcmUgcGlwZWxpbmUu Cj4gPiArCQkgKi8KPiA+ICsJCWlmIChyZWxlYXNlZF9icnUgJiYgIXJlbGVhc2VkX2JydS0+cGlw ZSkKPiA+ICsJCQlsaXN0X2FkZF90YWlsKCZyZWxlYXNlZF9icnUtPmxpc3RfcGlwZSwKPiA+ICsJ CQkJICAgICAgJnBpcGUtPmVudGl0aWVzKTsKPiA+ICsKPiA+ICsJCS8qIEFkZCB0aGUgQlJVIHRv IHRoZSBwaXBlbGluZS4gKi8KPiA+ICsJCXBpcGUtPmJydSA9IGJydTsKPiA+ICsJCXBpcGUtPmJy dS0+cGlwZSA9IHBpcGU7Cj4gPiArCQlwaXBlLT5icnUtPnNpbmsgPSAmcGlwZS0+b3V0cHV0LT5l bnRpdHk7Cj4gPiArCQlwaXBlLT5icnUtPnNpbmtfcGFkID0gMDsKPiA+ICsKPiA+ICsJCWxpc3Rf YWRkX3RhaWwoJnBpcGUtPmJydS0+bGlzdF9waXBlLCAmcGlwZS0+ZW50aXRpZXMpOwo+ID4gKwl9 Cj4gPiArCj4gCj4gUGhldyAuLi4gdGhhdCdzIHF1aXRlIHNvbWUgY2h1bmsgb2YgaW50ZXJhY3Rp bmcgY29kZSAuLi4KPiAKPiBJJ3ZlIGdvbmUgdGhyb3VnaCBpdCB3aXRoIHRoZSBjb21iaW5hdGlv bnMgb2YgdHdvIHBpcGVzLCAxIGFuZCAyLCB0aGVuCj4gc3dhcHBpbmcgdGhlbSBhcm91bmQgd2hl biBzYXkgcGlwZSAyIGhhcyAzIGlucHV0cy4KPiAKPiBJdCBzZWVtcyB0byBzY2FuIHRocm91Z2gg T0sgaW4gbXkgaGVhZCAuLi4gYnV0IEkgdGhpbmsgSSd2ZSBnb25lIGEgYml0Cj4gY3Jvc3MtZXll ZCBub3cgOkQKPiAKPiBIYXZlIHdlIGdvdCBzb21lIHRlc3RzIGluIHBsYWNlIGZvciB0aGUgdmFy aW91cyBjb21iaW5hdGlvbnMgb2YgcGF0aHMKPiB0aHJvdWdoIGhlcmUgPwoKTWF5YmUgbm90IGZv ciBhbGwgY29tYmluYXRpb25zLCBidXQgdGhlcmUncyBhIGttcy10ZXN0LWJyeGFsbG9jLnB5IHRl c3QgaW4gdGhlIApicnUtYnJzIGJyYW5jaCBvZiBnaXQ6Ly9naXQuaWRlYXNvbmJvYXJkLmNvbS9y ZW5lc2FzL2ttcy10ZXN0cy5naXQKCj4gPiAgCS8qCj4gPiAgCSAqIENvbmZpZ3VyZSB0aGUgZm9y bWF0IG9uIHRoZSBCUlUgc291cmNlIGFuZCB2ZXJpZnkgdGhhdCBpdCBtYXRjaGVzIAp0aGUKPiA+ ICAJICogcmVxdWVzdGVkIGZvcm1hdC4gV2UgZG9uJ3Qgc2V0IHRoZSBtZWRpYSBidXMgY29kZSBh cyBpdCBpcyAKY29uZmlndXJlZAoKW3NuaXBdCgo+ID4gQEAgLTUxNiw2ICs2MjMsOSBAQCBFWFBP UlRfU1lNQk9MX0dQTCh2c3AxX2R1X3NldHVwX2xpZik7Cj4gPiAgICovCj4gPiAgCj4gPiAgdm9p ZCB2c3AxX2R1X2F0b21pY19iZWdpbihzdHJ1Y3QgZGV2aWNlICpkZXYsIHVuc2lnbmVkIGludCBw aXBlX2luZGV4KQo+ID4gIHsKPiA+ICsJc3RydWN0IHZzcDFfZGV2aWNlICp2c3AxID0gZGV2X2dl dF9kcnZkYXRhKGRldik7Cj4gPiArCj4gPiArCW11dGV4X2xvY2soJnZzcDEtPmRybS0+bG9jayk7 Cj4gCj4gT3VjaCAuLi4gd2UgaGF2ZSB0byBsb2NrIC4uLgo+IAo+ID4gIH0KPiA+ICBFWFBPUlRf U1lNQk9MX0dQTCh2c3AxX2R1X2F0b21pY19iZWdpbik7Cj4gPiAKPiA+IEBAIC02MjksNiArNzM5 LDcgQEAgdm9pZCB2c3AxX2R1X2F0b21pY19mbHVzaChzdHJ1Y3QgZGV2aWNlICpkZXYsIHVuc2ln bmVkCj4gPiBpbnQgcGlwZV9pbmRleCkKPiA+ICAJdnNwMV9kdV9waXBlbGluZV9zZXR1cF9pbnB1 dCh2c3AxLCBwaXBlKTsKPiA+ICAJdnNwMV9kdV9waXBlbGluZV9jb25maWd1cmUocGlwZSk7Cj4g PiAKPiA+ICsJbXV0ZXhfdW5sb2NrKCZ2c3AxLT5kcm0tPmxvY2spOwo+IAo+IEFuZCB1bmxvY2sg aW4gZGlmZmVyZW50IGZ1bmN0aW9ucyA/IDotKAo+IAo+IChZZXMsIEkgc2VlIHRoYXQgd2UgZG8g LSBiZWNhdXNlIHdlIGFyZSBjcm9zc2luZyBwaXBlcy4uLikKClRoYXQncyBhbHNvIHNvbWV0aGlu ZyBJIHdvdWxkIGhhdmUgbGlrZWQgdG8gYXZvaWQgOi0vCgo+IAo+ID4gIH0KPiA+ICBFWFBPUlRf U1lNQk9MX0dQTCh2c3AxX2R1X2F0b21pY19mbHVzaCk7Cgpbc25pcF0KCi0tIApSZWdhcmRzLAoK TGF1cmVudCBQaW5jaGFydAoKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVz a3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9k cmktZGV2ZWwK