From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from perceval.ideasonboard.com ([213.167.242.64]:52332 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1758175AbeD1Q5E (ORCPT ); Sat, 28 Apr 2018 12:57:04 -0400 From: Laurent Pinchart To: jacopo mondi Cc: Laurent Pinchart , linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-renesas-soc@vger.kernel.org, Kieran Bingham Subject: Re: [PATCH v2 7/8] v4l: vsp1: Integrate DISCOM in display pipeline Date: Sat, 28 Apr 2018 19:57:19 +0300 Message-ID: <5979699.LE7rGvgjD7@avalon> In-Reply-To: <20180428110026.GE18201@w540> References: <20180422223430.16407-1-laurent.pinchart+renesas@ideasonboard.com> <20180422223430.16407-8-laurent.pinchart+renesas@ideasonboard.com> <20180428110026.GE18201@w540> 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 Jacopo, On Saturday, 28 April 2018 14:00:26 EEST jacopo mondi wrote: > On Mon, Apr 23, 2018 at 01:34:29AM +0300, Laurent Pinchart wrote: > > The DISCOM is used to compute CRCs on display frames. Integrate it in > > the display pipeline at the output of the blending unit to process > > output frames. > > > > Computing CRCs on input frames is possible by positioning the DISCOM at > > a different point in the pipeline. This use case isn't supported at the > > moment and could be implemented by extending the API between the VSP1 > > and DU drivers if needed. > > > > Signed-off-by: Laurent Pinchart > > > > --- > > > > drivers/media/platform/vsp1/vsp1_drm.c | 115 +++++++++++++++++++++++++++- > > drivers/media/platform/vsp1/vsp1_drm.h | 12 ++++ > > 2 files changed, 124 insertions(+), 3 deletions(-) > > > > diff --git a/drivers/media/platform/vsp1/vsp1_drm.c > > b/drivers/media/platform/vsp1/vsp1_drm.c index 5fc31578f9b0..7864b43a90e1 > > 100644 > > --- a/drivers/media/platform/vsp1/vsp1_drm.c > > +++ b/drivers/media/platform/vsp1/vsp1_drm.c [snip] > > @@ -48,10 +54,65 @@ static void vsp1_du_pipeline_frame_end(struct > > vsp1_pipeline *pipe,> > > * Pipeline Configuration > > */ > > > > +/* > > + * Insert the UIF in the pipeline between the prev and next entities. If > > no UIF + * is available connect the two entities directly. > > + */ > > +static int vsp1_du_insert_uif(struct vsp1_device *vsp1, > > + struct vsp1_pipeline *pipe, > > + struct vsp1_entity *uif, > > + struct vsp1_entity *prev, unsigned int prev_pad, > > + struct vsp1_entity *next, unsigned int next_pad) > > +{ > > + int ret; > > + > > + if (uif) { > > + struct v4l2_subdev_format format; > > + > > + prev->sink = uif; > > + prev->sink_pad = UIF_PAD_SINK; > > + > > + memset(&format, 0, sizeof(format)); > > + format.which = V4L2_SUBDEV_FORMAT_ACTIVE; > > + format.pad = prev_pad; > > + > > + ret = v4l2_subdev_call(&prev->subdev, pad, get_fmt, NULL, > > + &format); > > + if (ret < 0) > > + return ret; > > + > > + format.pad = UIF_PAD_SINK; > > + > > + ret = v4l2_subdev_call(&uif->subdev, pad, set_fmt, NULL, > > + &format); > > + if (ret < 0) > > + return ret; > > + > > + dev_dbg(vsp1->dev, "%s: set format %ux%u (%x) on UIF sink\n", > > + __func__, format.format.width, format.format.height, > > + format.format.code); > > + > > + /* > > + * The UIF doesn't mangle the format between its sink and > > + * source pads, so there is no need to retrieve the format on > > + * its source pad. > > + */ > > + > > + uif->sink = next; > > + uif->sink_pad = next_pad; > > + } else { > > + prev->sink = next; > > + prev->sink_pad = next_pad; > > Isn't the !uif case better handled in the caller? See below... > Or otherwise, if you prefer handling it here, shouldn't the > indentation be reduced with I don't think it's better handled in the caller, I prefer keeping the entities linking code in a single place. I'll reduce the indentation. > if (!uif) { > prev->sink = next; > prev->sink_pad = next_pad; > return 0; > } > > > + } > > + > > + return 0; > > +} [snip] > > @@ -367,6 +441,31 @@ static int vsp1_du_pipeline_setup_inputs(struct > > vsp1_device *vsp1, > > } > > } > > > > + /* Insert and configure the UIF at the BRx output if available. */ > > + uif = drm_pipe->crc.source == VSP1_DU_CRC_OUTPUT ? drm_pipe->uif : NULL; > > + if (uif) > > + use_uif = true; > > + ret = vsp1_du_insert_uif(vsp1, pipe, uif, > > + pipe->brx, pipe->brx->source_pad, > > + &pipe->output->entity, 0); > > + if (ret < 0) > > + dev_err(vsp1->dev, "%s: failed to setup UIF after %s\n", > > + __func__, BRX_NAME(pipe->brx)); > > + > > + /* > > + * If the UIF is not in use schedule it for removal by setting its pipe > > + * pointer to NULL, vsp1_du_pipeline_configure() will remove it from the > > + * hardware pipeline and from the pipeline's list of entities. Otherwise > > + * make sure it is present in the pipeline's list of entities if it > > + * wasn't already. > > + */ > > + if (!use_uif) { > > ... here. If you don't use uif, don't call vspi1_du_insert_uif(). > True, you have to link entities explicitly here if there is not uif, > but I may be missing where this was happening before this code was > added. > > > + drm_pipe->uif->pipe = NULL; > > + } else if (!drm_pipe->uif->pipe) { > > + drm_pipe->uif->pipe = pipe; > > + list_add_tail(&drm_pipe->uif->list_pipe, &pipe->entities); > > + } > > + > > return 0; > > } > > > > @@ -748,6 +847,9 @@ void vsp1_du_atomic_flush(struct device *dev, unsigned > > int pipe_index,> > > struct vsp1_drm_pipeline *drm_pipe = &vsp1->drm->pipe[pipe_index]; > > struct vsp1_pipeline *pipe = &drm_pipe->pipe; > > > > + drm_pipe->crc.source = cfg->crc.source; > > + drm_pipe->crc.index = cfg->crc.index; > > + > > vsp1_du_pipeline_setup_inputs(vsp1, pipe); > > vsp1_du_pipeline_configure(pipe); > > mutex_unlock(&vsp1->drm->lock); > > @@ -816,6 +918,13 @@ int vsp1_drm_init(struct vsp1_device *vsp1) > > > > pipe->lif->pipe = pipe; > > list_add_tail(&pipe->lif->list_pipe, &pipe->entities); > > + > > + /* > > + * CRC computation is initially disabled, don't add the UIF to > > + * the pipeline. > > + */ > > + if (i < vsp1->info->uif_count) > > Why 'initially disabled'? This seems to me to conditionally enable the > UIF unit. Or is the lif count always the same as the uif count? Setting drm_pipe->uif isn't adding the UIF to the pipeline, that would be done by adding it to the pipe->entities list and setting the uif->pipe pointer. > > + drm_pipe->uif = &vsp1->uif[i]->entity; > > } -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH v2 7/8] v4l: vsp1: Integrate DISCOM in display pipeline Date: Sat, 28 Apr 2018 19:57:19 +0300 Message-ID: <5979699.LE7rGvgjD7@avalon> References: <20180422223430.16407-1-laurent.pinchart+renesas@ideasonboard.com> <20180422223430.16407-8-laurent.pinchart+renesas@ideasonboard.com> <20180428110026.GE18201@w540> 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 C46696E0AC for ; Sat, 28 Apr 2018 16:57:04 +0000 (UTC) In-Reply-To: <20180428110026.GE18201@w540> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: jacopo mondi Cc: linux-renesas-soc@vger.kernel.org, Laurent Pinchart , Kieran Bingham , dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org SGkgSmFjb3BvLAoKT24gU2F0dXJkYXksIDI4IEFwcmlsIDIwMTggMTQ6MDA6MjYgRUVTVCBqYWNv cG8gbW9uZGkgd3JvdGU6Cj4gT24gTW9uLCBBcHIgMjMsIDIwMTggYXQgMDE6MzQ6MjlBTSArMDMw MCwgTGF1cmVudCBQaW5jaGFydCB3cm90ZToKPiA+IFRoZSBESVNDT00gaXMgdXNlZCB0byBjb21w dXRlIENSQ3Mgb24gZGlzcGxheSBmcmFtZXMuIEludGVncmF0ZSBpdCBpbgo+ID4gdGhlIGRpc3Bs YXkgcGlwZWxpbmUgYXQgdGhlIG91dHB1dCBvZiB0aGUgYmxlbmRpbmcgdW5pdCB0byBwcm9jZXNz Cj4gPiBvdXRwdXQgZnJhbWVzLgo+ID4gCj4gPiBDb21wdXRpbmcgQ1JDcyBvbiBpbnB1dCBmcmFt ZXMgaXMgcG9zc2libGUgYnkgcG9zaXRpb25pbmcgdGhlIERJU0NPTSBhdAo+ID4gYSBkaWZmZXJl bnQgcG9pbnQgaW4gdGhlIHBpcGVsaW5lLiBUaGlzIHVzZSBjYXNlIGlzbid0IHN1cHBvcnRlZCBh dCB0aGUKPiA+IG1vbWVudCBhbmQgY291bGQgYmUgaW1wbGVtZW50ZWQgYnkgZXh0ZW5kaW5nIHRo ZSBBUEkgYmV0d2VlbiB0aGUgVlNQMQo+ID4gYW5kIERVIGRyaXZlcnMgaWYgbmVlZGVkLgo+ID4g Cj4gPiBTaWduZWQtb2ZmLWJ5OiBMYXVyZW50IFBpbmNoYXJ0Cj4gPiA8bGF1cmVudC5waW5jaGFy dCtyZW5lc2FzQGlkZWFzb25ib2FyZC5jb20+Cj4gPiAtLS0KPiA+IAo+ID4gIGRyaXZlcnMvbWVk aWEvcGxhdGZvcm0vdnNwMS92c3AxX2RybS5jIHwgMTE1ICsrKysrKysrKysrKysrKysrKysrKysr KysrKy0KPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kcm0uaCB8ICAxMiAr KysrCj4gPiAgMiBmaWxlcyBjaGFuZ2VkLCAxMjQgaW5zZXJ0aW9ucygrKSwgMyBkZWxldGlvbnMo LSkKPiA+IAo+ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3Ax X2RybS5jCj4gPiBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RybS5jIGluZGV4 IDVmYzMxNTc4ZjliMC4uNzg2NGI0M2E5MGUxCj4gPiAxMDA2NDQKPiA+IC0tLSBhL2RyaXZlcnMv bWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RybS5jCj4gPiArKysgYi9kcml2ZXJzL21lZGlhL3Bs YXRmb3JtL3ZzcDEvdnNwMV9kcm0uYwoKW3NuaXBdCgo+ID4gQEAgLTQ4LDEwICs1NCw2NSBAQCBz dGF0aWMgdm9pZCB2c3AxX2R1X3BpcGVsaW5lX2ZyYW1lX2VuZChzdHJ1Y3QKPiA+IHZzcDFfcGlw ZWxpbmUgKnBpcGUsPiAKPiA+ICAgKiBQaXBlbGluZSBDb25maWd1cmF0aW9uCj4gPiAgICovCj4g PiAKPiA+ICsvKgo+ID4gKyAqIEluc2VydCB0aGUgVUlGIGluIHRoZSBwaXBlbGluZSBiZXR3ZWVu IHRoZSBwcmV2IGFuZCBuZXh0IGVudGl0aWVzLiBJZgo+ID4gbm8gVUlGICsgKiBpcyBhdmFpbGFi bGUgY29ubmVjdCB0aGUgdHdvIGVudGl0aWVzIGRpcmVjdGx5Lgo+ID4gKyAqLwo+ID4gK3N0YXRp YyBpbnQgdnNwMV9kdV9pbnNlcnRfdWlmKHN0cnVjdCB2c3AxX2RldmljZSAqdnNwMSwKPiA+ICsJ CQkgICAgICBzdHJ1Y3QgdnNwMV9waXBlbGluZSAqcGlwZSwKPiA+ICsJCQkgICAgICBzdHJ1Y3Qg dnNwMV9lbnRpdHkgKnVpZiwKPiA+ICsJCQkgICAgICBzdHJ1Y3QgdnNwMV9lbnRpdHkgKnByZXYs IHVuc2lnbmVkIGludCBwcmV2X3BhZCwKPiA+ICsJCQkgICAgICBzdHJ1Y3QgdnNwMV9lbnRpdHkg Km5leHQsIHVuc2lnbmVkIGludCBuZXh0X3BhZCkKPiA+ICt7Cj4gPiArCWludCByZXQ7Cj4gPiAr Cj4gPiArCWlmICh1aWYpIHsKPiA+ICsJCXN0cnVjdCB2NGwyX3N1YmRldl9mb3JtYXQgZm9ybWF0 Owo+ID4gKwo+ID4gKwkJcHJldi0+c2luayA9IHVpZjsKPiA+ICsJCXByZXYtPnNpbmtfcGFkID0g VUlGX1BBRF9TSU5LOwo+ID4gKwo+ID4gKwkJbWVtc2V0KCZmb3JtYXQsIDAsIHNpemVvZihmb3Jt YXQpKTsKPiA+ICsJCWZvcm1hdC53aGljaCA9IFY0TDJfU1VCREVWX0ZPUk1BVF9BQ1RJVkU7Cj4g PiArCQlmb3JtYXQucGFkID0gcHJldl9wYWQ7Cj4gPiArCj4gPiArCQlyZXQgPSB2NGwyX3N1YmRl dl9jYWxsKCZwcmV2LT5zdWJkZXYsIHBhZCwgZ2V0X2ZtdCwgTlVMTCwKPiA+ICsJCQkJICAgICAg ICZmb3JtYXQpOwo+ID4gKwkJaWYgKHJldCA8IDApCj4gPiArCQkJcmV0dXJuIHJldDsKPiA+ICsK PiA+ICsJCWZvcm1hdC5wYWQgPSBVSUZfUEFEX1NJTks7Cj4gPiArCj4gPiArCQlyZXQgPSB2NGwy X3N1YmRldl9jYWxsKCZ1aWYtPnN1YmRldiwgcGFkLCBzZXRfZm10LCBOVUxMLAo+ID4gKwkJCQkg ICAgICAgJmZvcm1hdCk7Cj4gPiArCQlpZiAocmV0IDwgMCkKPiA+ICsJCQlyZXR1cm4gcmV0Owo+ ID4gKwo+ID4gKwkJZGV2X2RiZyh2c3AxLT5kZXYsICIlczogc2V0IGZvcm1hdCAldXgldSAoJXgp IG9uIFVJRiBzaW5rXG4iLAo+ID4gKwkJCV9fZnVuY19fLCBmb3JtYXQuZm9ybWF0LndpZHRoLCBm b3JtYXQuZm9ybWF0LmhlaWdodCwKPiA+ICsJCQlmb3JtYXQuZm9ybWF0LmNvZGUpOwo+ID4gKwo+ ID4gKwkJLyoKPiA+ICsJCSAqIFRoZSBVSUYgZG9lc24ndCBtYW5nbGUgdGhlIGZvcm1hdCBiZXR3 ZWVuIGl0cyBzaW5rIGFuZAo+ID4gKwkJICogc291cmNlIHBhZHMsIHNvIHRoZXJlIGlzIG5vIG5l ZWQgdG8gcmV0cmlldmUgdGhlIGZvcm1hdCBvbgo+ID4gKwkJICogaXRzIHNvdXJjZSBwYWQuCj4g PiArCQkgKi8KPiA+ICsKPiA+ICsJCXVpZi0+c2luayA9IG5leHQ7Cj4gPiArCQl1aWYtPnNpbmtf cGFkID0gbmV4dF9wYWQ7Cj4gPiArCX0gZWxzZSB7Cj4gPiArCQlwcmV2LT5zaW5rID0gbmV4dDsK PiA+ICsJCXByZXYtPnNpbmtfcGFkID0gbmV4dF9wYWQ7Cj4gCj4gSXNuJ3QgdGhlICF1aWYgY2Fz ZSBiZXR0ZXIgaGFuZGxlZCBpbiB0aGUgY2FsbGVyPyBTZWUgYmVsb3cuLi4KPiBPciBvdGhlcndp c2UsIGlmIHlvdSBwcmVmZXIgaGFuZGxpbmcgaXQgaGVyZSwgc2hvdWxkbid0IHRoZQo+IGluZGVu dGF0aW9uIGJlIHJlZHVjZWQgd2l0aAoKSSBkb24ndCB0aGluayBpdCdzIGJldHRlciBoYW5kbGVk IGluIHRoZSBjYWxsZXIsIEkgcHJlZmVyIGtlZXBpbmcgdGhlIGVudGl0aWVzIApsaW5raW5nIGNv ZGUgaW4gYSBzaW5nbGUgcGxhY2UuIEknbGwgcmVkdWNlIHRoZSBpbmRlbnRhdGlvbi4KCj4gICAg ICAgICBpZiAoIXVpZikgewo+IAkJcHJldi0+c2luayA9IG5leHQ7Cj4gCQlwcmV2LT5zaW5rX3Bh ZCA9IG5leHRfcGFkOwo+ICAgICAgICAgICAgICAgICByZXR1cm4gMDsKPiAgICAgICAgIH0KPiAK PiA+ICsJfQo+ID4gKwo+ID4gKwlyZXR1cm4gMDsKPiA+ICt9Cgpbc25pcF0KCj4gPiBAQCAtMzY3 LDYgKzQ0MSwzMSBAQCBzdGF0aWMgaW50IHZzcDFfZHVfcGlwZWxpbmVfc2V0dXBfaW5wdXRzKHN0 cnVjdAo+ID4gdnNwMV9kZXZpY2UgKnZzcDEsCj4gPiAgCQl9Cj4gPiAgCX0KPiA+IAo+ID4gKwkv KiBJbnNlcnQgYW5kIGNvbmZpZ3VyZSB0aGUgVUlGIGF0IHRoZSBCUnggb3V0cHV0IGlmIGF2YWls YWJsZS4gKi8KPiA+ICsJdWlmID0gZHJtX3BpcGUtPmNyYy5zb3VyY2UgPT0gVlNQMV9EVV9DUkNf T1VUUFVUID8gZHJtX3BpcGUtPnVpZiA6IApOVUxMOwo+ID4gKwlpZiAodWlmKQo+ID4gKwkJdXNl X3VpZiA9IHRydWU7Cj4gPiArCXJldCA9IHZzcDFfZHVfaW5zZXJ0X3VpZih2c3AxLCBwaXBlLCB1 aWYsCj4gPiArCQkJCSBwaXBlLT5icngsIHBpcGUtPmJyeC0+c291cmNlX3BhZCwKPiA+ICsJCQkJ ICZwaXBlLT5vdXRwdXQtPmVudGl0eSwgMCk7Cj4gPiArCWlmIChyZXQgPCAwKQo+ID4gKwkJZGV2 X2Vycih2c3AxLT5kZXYsICIlczogZmFpbGVkIHRvIHNldHVwIFVJRiBhZnRlciAlc1xuIiwKPiA+ ICsJCQlfX2Z1bmNfXywgQlJYX05BTUUocGlwZS0+YnJ4KSk7Cj4gPiArCj4gPiArCS8qCj4gPiAr CSAqIElmIHRoZSBVSUYgaXMgbm90IGluIHVzZSBzY2hlZHVsZSBpdCBmb3IgcmVtb3ZhbCBieSBz ZXR0aW5nIGl0cyBwaXBlCj4gPiArCSAqIHBvaW50ZXIgdG8gTlVMTCwgdnNwMV9kdV9waXBlbGlu ZV9jb25maWd1cmUoKSB3aWxsIHJlbW92ZSBpdCBmcm9tIAp0aGUKPiA+ICsJICogaGFyZHdhcmUg cGlwZWxpbmUgYW5kIGZyb20gdGhlIHBpcGVsaW5lJ3MgbGlzdCBvZiBlbnRpdGllcy4gCk90aGVy d2lzZQo+ID4gKwkgKiBtYWtlIHN1cmUgaXQgaXMgcHJlc2VudCBpbiB0aGUgcGlwZWxpbmUncyBs aXN0IG9mIGVudGl0aWVzIGlmIGl0Cj4gPiArCSAqIHdhc24ndCBhbHJlYWR5Lgo+ID4gKwkgKi8K PiA+ICsJaWYgKCF1c2VfdWlmKSB7Cj4gCj4gLi4uIGhlcmUuIElmIHlvdSBkb24ndCB1c2UgdWlm LCBkb24ndCBjYWxsIHZzcGkxX2R1X2luc2VydF91aWYoKS4KPiBUcnVlLCB5b3UgaGF2ZSB0byBs aW5rIGVudGl0aWVzIGV4cGxpY2l0bHkgaGVyZSBpZiB0aGVyZSBpcyBub3QgdWlmLAo+IGJ1dCBJ IG1heSBiZSBtaXNzaW5nIHdoZXJlIHRoaXMgd2FzIGhhcHBlbmluZyBiZWZvcmUgdGhpcyBjb2Rl IHdhcwo+IGFkZGVkLgo+IAo+ID4gKwkJZHJtX3BpcGUtPnVpZi0+cGlwZSA9IE5VTEw7Cj4gPiAr CX0gZWxzZSBpZiAoIWRybV9waXBlLT51aWYtPnBpcGUpIHsKPiA+ICsJCWRybV9waXBlLT51aWYt PnBpcGUgPSBwaXBlOwo+ID4gKwkJbGlzdF9hZGRfdGFpbCgmZHJtX3BpcGUtPnVpZi0+bGlzdF9w aXBlLCAmcGlwZS0+ZW50aXRpZXMpOwo+ID4gKwl9Cj4gPiArCj4gPiAgCXJldHVybiAwOwo+ID4g IH0KPiA+IAo+ID4gQEAgLTc0OCw2ICs4NDcsOSBAQCB2b2lkIHZzcDFfZHVfYXRvbWljX2ZsdXNo KHN0cnVjdCBkZXZpY2UgKmRldiwgdW5zaWduZWQKPiA+IGludCBwaXBlX2luZGV4LD4gCj4gPiAg CXN0cnVjdCB2c3AxX2RybV9waXBlbGluZSAqZHJtX3BpcGUgPSAmdnNwMS0+ZHJtLT5waXBlW3Bp cGVfaW5kZXhdOwo+ID4gIAlzdHJ1Y3QgdnNwMV9waXBlbGluZSAqcGlwZSA9ICZkcm1fcGlwZS0+ cGlwZTsKPiA+IAo+ID4gKwlkcm1fcGlwZS0+Y3JjLnNvdXJjZSA9IGNmZy0+Y3JjLnNvdXJjZTsK PiA+ICsJZHJtX3BpcGUtPmNyYy5pbmRleCA9IGNmZy0+Y3JjLmluZGV4Owo+ID4gKwo+ID4gIAl2 c3AxX2R1X3BpcGVsaW5lX3NldHVwX2lucHV0cyh2c3AxLCBwaXBlKTsKPiA+ICAJdnNwMV9kdV9w aXBlbGluZV9jb25maWd1cmUocGlwZSk7Cj4gPiAgCW11dGV4X3VubG9jaygmdnNwMS0+ZHJtLT5s b2NrKTsKPiA+IEBAIC04MTYsNiArOTE4LDEzIEBAIGludCB2c3AxX2RybV9pbml0KHN0cnVjdCB2 c3AxX2RldmljZSAqdnNwMSkKPiA+IAo+ID4gIAkJcGlwZS0+bGlmLT5waXBlID0gcGlwZTsKPiA+ ICAJCWxpc3RfYWRkX3RhaWwoJnBpcGUtPmxpZi0+bGlzdF9waXBlLCAmcGlwZS0+ZW50aXRpZXMp Owo+ID4gKwo+ID4gKwkJLyoKPiA+ICsJCSAqIENSQyBjb21wdXRhdGlvbiBpcyBpbml0aWFsbHkg ZGlzYWJsZWQsIGRvbid0IGFkZCB0aGUgVUlGIHRvCj4gPiArCQkgKiB0aGUgcGlwZWxpbmUuCj4g PiArCQkgKi8KPiA+ICsJCWlmIChpIDwgdnNwMS0+aW5mby0+dWlmX2NvdW50KQo+IAo+IFdoeSAn aW5pdGlhbGx5IGRpc2FibGVkJz8gVGhpcyBzZWVtcyB0byBtZSB0byBjb25kaXRpb25hbGx5IGVu YWJsZSB0aGUKPiBVSUYgdW5pdC4gT3IgaXMgdGhlIGxpZiBjb3VudCBhbHdheXMgdGhlIHNhbWUg YXMgdGhlIHVpZiBjb3VudD8KClNldHRpbmcgZHJtX3BpcGUtPnVpZiBpc24ndCBhZGRpbmcgdGhl IFVJRiB0byB0aGUgcGlwZWxpbmUsIHRoYXQgd291bGQgYmUgZG9uZSAKYnkgYWRkaW5nIGl0IHRv IHRoZSBwaXBlLT5lbnRpdGllcyBsaXN0IGFuZCBzZXR0aW5nIHRoZSB1aWYtPnBpcGUgcG9pbnRl ci4KCj4gPiArCQkJZHJtX3BpcGUtPnVpZiA9ICZ2c3AxLT51aWZbaV0tPmVudGl0eTsKPiA+ICAJ fQoKLS0gClJlZ2FyZHMsCgpMYXVyZW50IFBpbmNoYXJ0CgoKCl9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRl dmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9t YWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=