From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from perceval.ideasonboard.com ([213.167.242.64]:52304 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752121AbeD1Qu1 (ORCPT ); Sat, 28 Apr 2018 12:50:27 -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 6/8] v4l: vsp1: Add support for the DISCOM entity Date: Sat, 28 Apr 2018 19:50:42 +0300 Message-ID: <56501970.bmiQKbb0Ad@avalon> In-Reply-To: <20180428104002.GD18201@w540> References: <20180422223430.16407-1-laurent.pinchart+renesas@ideasonboard.com> <20180422223430.16407-7-laurent.pinchart+renesas@ideasonboard.com> <20180428104002.GD18201@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 13:40:02 EEST jacopo mondi wrote: > HI Laurent, > a few comments, mostly minor ones... > > On Mon, Apr 23, 2018 at 01:34:28AM +0300, Laurent Pinchart wrote: > > The DISCOM calculates a CRC on a configurable window of the frame. It > > interfaces to the VSP through the UIF glue, hence the name used in the > > code. > > > > The module supports configuration of the CRC window through the crop > > rectangle on the ink pad of the corresponding entity. However, unlike > > sink pad? Oops. Consider it fixed. > > the traditional V4L2 subdevice model, the crop rectangle does not > > influence the format on the source pad. > > > > Modeling the DISCOM as a sink-only entity would allow adhering to the > > V4L2 subdevice model at the expense of more complex code in the driver, > > as at the hardware level the UIF is handled as a sink+source entity. As > > the DISCOM is only present in R-Car Gen3 VSP-D and VSP-DL instances it > > is not exposed to userspace through V4L2 but controlled through the DU > > driver. We can thus change this model later if needed without fear of > > affecting userspace. > > > > Signed-off-by: Laurent Pinchart > > > > --- > > Changes since v1: > > > > - Don't return uninitialized value from uif_set_selection() > > --- > > > > drivers/media/platform/vsp1/Makefile | 2 +- > > drivers/media/platform/vsp1/vsp1.h | 4 + > > drivers/media/platform/vsp1/vsp1_drv.c | 20 +++ > > drivers/media/platform/vsp1/vsp1_entity.c | 6 + > > drivers/media/platform/vsp1/vsp1_entity.h | 1 + > > drivers/media/platform/vsp1/vsp1_regs.h | 41 +++++ > > drivers/media/platform/vsp1/vsp1_uif.c | 271 +++++++++++++++++++++++++ > > drivers/media/platform/vsp1/vsp1_uif.h | 32 ++++ > > 8 files changed, 376 insertions(+), 1 deletion(-) > > create mode 100644 drivers/media/platform/vsp1/vsp1_uif.c > > create mode 100644 drivers/media/platform/vsp1/vsp1_uif.h [snip] > > diff --git a/drivers/media/platform/vsp1/vsp1_uif.c > > b/drivers/media/platform/vsp1/vsp1_uif.c new file mode 100644 > > index 000000000000..6de7e9c801ae > > --- /dev/null > > +++ b/drivers/media/platform/vsp1/vsp1_uif.c > > @@ -0,0 +1,271 @@ [snip] > > +static void uif_configure(struct vsp1_entity *entity, > > + struct vsp1_pipeline *pipe, > > + struct vsp1_dl_list *dl, > > + enum vsp1_entity_params params) > > +{ > > + struct vsp1_uif *uif = to_uif(&entity->subdev); > > + const struct v4l2_rect *crop; > > + unsigned int left; > > + unsigned int width; > > + > > + /* > > + * Per-partition configuration isn't needed as the DISCOM is used in > > + * display pipelines only. > > + */ > > + if (params != VSP1_ENTITY_PARAMS_INIT) > > + return; > > + > > + vsp1_uif_write(uif, dl, VI6_UIF_DISCOM_DOCMPMR, > > + VI6_UIF_DISCOM_DOCMPMR_SEL(9)); > > + > > + crop = vsp1_entity_get_pad_selection(entity, entity->config, > > + UIF_PAD_SINK, V4L2_SEL_TGT_CROP); > > + > > + /* On M3-W the horizontal coordinates are twice the register value. */ > > + if (uif->m3w_quirk) { > > + left = crop->left / 2; > > + width = crop->width / 2; > > + } else { > > + left = crop->left; > > + width = crop->width; > > + } > > I would write this as > > left = crop->left; > width = crop->width; > /* On M3-W the horizontal coordinates are twice the register value. */ > if (uif->m3w_quirk) { > left /= 2; > width /= 2; > } > > But that's really up to you. I prefer my style, but it looks like gcc 6.4.0 generates slightly better code with your version (due to the fact that the crop->left value is converted to unsigned before being divided by 2), so I'll go for it. > > + > > + vsp1_uif_write(uif, dl, VI6_UIF_DISCOM_DOCMSPXR, left); > > + vsp1_uif_write(uif, dl, VI6_UIF_DISCOM_DOCMSPYR, crop->top); > > + vsp1_uif_write(uif, dl, VI6_UIF_DISCOM_DOCMSZXR, width); > > + vsp1_uif_write(uif, dl, VI6_UIF_DISCOM_DOCMSZYR, crop->height); > > + > > + vsp1_uif_write(uif, dl, VI6_UIF_DISCOM_DOCMCR, > > + VI6_UIF_DISCOM_DOCMCR_CMPR); > > +} > > + > > +static const struct vsp1_entity_operations uif_entity_ops = { > > + .configure = uif_configure, > > +}; > > + > > +/* ---------------------------------------------------------------------- > > + * Initialization and Cleanup > > + */ > > + > > +static const struct soc_device_attribute vsp1_r8a7796[] = { > > + { .soc_id = "r8a7796" }, > > + { /* sentinel */ } > > +}; > > + > > +struct vsp1_uif *vsp1_uif_create(struct vsp1_device *vsp1, unsigned int > > index) +{ > > + struct vsp1_uif *uif; > > + char name[6]; > > + int ret; > > + > > + uif = devm_kzalloc(vsp1->dev, sizeof(*uif), GFP_KERNEL); > > + if (uif == NULL) > > if (!uif) > > Otherwise checkpatch complains iirc. Only when run with --strict. Nevertheless, even if both styles are mixed in the driver, the predominant style is !uif, so I'll switch to that. > Those are very minor comments, so feel free to add my reviewed by tag > > Reviewed-by: Jacopo Mondi > > > + return ERR_PTR(-ENOMEM); > > + > > + if (soc_device_match(vsp1_r8a7796)) > > + uif->m3w_quirk = true; > > + > > + uif->entity.ops = &uif_entity_ops; > > + uif->entity.type = VSP1_ENTITY_UIF; > > + uif->entity.index = index; > > + > > + /* The datasheet names the two UIF instances UIF4 and UIF5. */ > > + sprintf(name, "uif.%u", index + 4); > > + ret = vsp1_entity_init(vsp1, &uif->entity, name, 2, &uif_ops, > > + MEDIA_ENT_F_PROC_VIDEO_STATISTICS); > > + if (ret < 0) > > + return ERR_PTR(ret); > > + > > + return uif; > > +} [snip] -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH v2 6/8] v4l: vsp1: Add support for the DISCOM entity Date: Sat, 28 Apr 2018 19:50:42 +0300 Message-ID: <56501970.bmiQKbb0Ad@avalon> References: <20180422223430.16407-1-laurent.pinchart+renesas@ideasonboard.com> <20180422223430.16407-7-laurent.pinchart+renesas@ideasonboard.com> <20180428104002.GD18201@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 [213.167.242.64]) by gabe.freedesktop.org (Postfix) with ESMTPS id B80216E0B8 for ; Sat, 28 Apr 2018 16:50:27 +0000 (UTC) In-Reply-To: <20180428104002.GD18201@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 SGkgSmFjb3BvLAoKT24gU2F0dXJkYXksIDI4IEFwcmlsIDIwMTggMTM6NDA6MDIgRUVTVCBqYWNv cG8gbW9uZGkgd3JvdGU6Cj4gSEkgTGF1cmVudCwKPiAgICBhIGZldyBjb21tZW50cywgbW9zdGx5 IG1pbm9yIG9uZXMuLi4KPiAKPiBPbiBNb24sIEFwciAyMywgMjAxOCBhdCAwMTozNDoyOEFNICsw MzAwLCBMYXVyZW50IFBpbmNoYXJ0IHdyb3RlOgo+ID4gVGhlIERJU0NPTSBjYWxjdWxhdGVzIGEg Q1JDIG9uIGEgY29uZmlndXJhYmxlIHdpbmRvdyBvZiB0aGUgZnJhbWUuIEl0Cj4gPiBpbnRlcmZh Y2VzIHRvIHRoZSBWU1AgdGhyb3VnaCB0aGUgVUlGIGdsdWUsIGhlbmNlIHRoZSBuYW1lIHVzZWQg aW4gdGhlCj4gPiBjb2RlLgo+ID4gCj4gPiBUaGUgbW9kdWxlIHN1cHBvcnRzIGNvbmZpZ3VyYXRp b24gb2YgdGhlIENSQyB3aW5kb3cgdGhyb3VnaCB0aGUgY3JvcAo+ID4gcmVjdGFuZ2xlIG9uIHRo ZSBpbmsgcGFkIG9mIHRoZSBjb3JyZXNwb25kaW5nIGVudGl0eS4gSG93ZXZlciwgdW5saWtlCj4g Cj4gc2luayBwYWQ/CgpPb3BzLiBDb25zaWRlciBpdCBmaXhlZC4KCj4gPiB0aGUgdHJhZGl0aW9u YWwgVjRMMiBzdWJkZXZpY2UgbW9kZWwsIHRoZSBjcm9wIHJlY3RhbmdsZSBkb2VzIG5vdAo+ID4g aW5mbHVlbmNlIHRoZSBmb3JtYXQgb24gdGhlIHNvdXJjZSBwYWQuCj4gPiAKPiA+IE1vZGVsaW5n IHRoZSBESVNDT00gYXMgYSBzaW5rLW9ubHkgZW50aXR5IHdvdWxkIGFsbG93IGFkaGVyaW5nIHRv IHRoZQo+ID4gVjRMMiBzdWJkZXZpY2UgbW9kZWwgYXQgdGhlIGV4cGVuc2Ugb2YgbW9yZSBjb21w bGV4IGNvZGUgaW4gdGhlIGRyaXZlciwKPiA+IGFzIGF0IHRoZSBoYXJkd2FyZSBsZXZlbCB0aGUg VUlGIGlzIGhhbmRsZWQgYXMgYSBzaW5rK3NvdXJjZSBlbnRpdHkuIEFzCj4gPiB0aGUgRElTQ09N IGlzIG9ubHkgcHJlc2VudCBpbiBSLUNhciBHZW4zIFZTUC1EIGFuZCBWU1AtREwgaW5zdGFuY2Vz IGl0Cj4gPiBpcyBub3QgZXhwb3NlZCB0byB1c2Vyc3BhY2UgdGhyb3VnaCBWNEwyIGJ1dCBjb250 cm9sbGVkIHRocm91Z2ggdGhlIERVCj4gPiBkcml2ZXIuIFdlIGNhbiB0aHVzIGNoYW5nZSB0aGlz IG1vZGVsIGxhdGVyIGlmIG5lZWRlZCB3aXRob3V0IGZlYXIgb2YKPiA+IGFmZmVjdGluZyB1c2Vy c3BhY2UuCj4gPiAKPiA+IFNpZ25lZC1vZmYtYnk6IExhdXJlbnQgUGluY2hhcnQKPiA+IDxsYXVy ZW50LnBpbmNoYXJ0K3JlbmVzYXNAaWRlYXNvbmJvYXJkLmNvbT4KPiA+IC0tLQo+ID4gQ2hhbmdl cyBzaW5jZSB2MToKPiA+IAo+ID4gLSBEb24ndCByZXR1cm4gdW5pbml0aWFsaXplZCB2YWx1ZSBm cm9tIHVpZl9zZXRfc2VsZWN0aW9uKCkKPiA+IC0tLQo+ID4gCj4gPiAgZHJpdmVycy9tZWRpYS9w bGF0Zm9ybS92c3AxL01ha2VmaWxlICAgICAgfCAgIDIgKy0KPiA+ICBkcml2ZXJzL21lZGlhL3Bs YXRmb3JtL3ZzcDEvdnNwMS5oICAgICAgICB8ICAgNCArCj4gPiAgZHJpdmVycy9tZWRpYS9wbGF0 Zm9ybS92c3AxL3ZzcDFfZHJ2LmMgICAgfCAgMjAgKysrCj4gPiAgZHJpdmVycy9tZWRpYS9wbGF0 Zm9ybS92c3AxL3ZzcDFfZW50aXR5LmMgfCAgIDYgKwo+ID4gIGRyaXZlcnMvbWVkaWEvcGxhdGZv cm0vdnNwMS92c3AxX2VudGl0eS5oIHwgICAxICsKPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3Jt L3ZzcDEvdnNwMV9yZWdzLmggICB8ICA0MSArKysrKwo+ID4gIGRyaXZlcnMvbWVkaWEvcGxhdGZv cm0vdnNwMS92c3AxX3VpZi5jICAgIHwgMjcxICsrKysrKysrKysrKysrKysrKysrKysrKysKPiA+ ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV91aWYuaCAgICB8ICAzMiArKysrCj4g PiAgOCBmaWxlcyBjaGFuZ2VkLCAzNzYgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQo+ID4g IGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV91aWYu Ywo+ID4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNw MV91aWYuaAoKW3NuaXBdCgo+ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0v dnNwMS92c3AxX3VpZi5jCj4gPiBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3Vp Zi5jIG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gPiBpbmRleCAwMDAwMDAwMDAwMDAuLjZkZTdlOWM4 MDFhZQo+ID4gLS0tIC9kZXYvbnVsbAo+ID4gKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92 c3AxL3ZzcDFfdWlmLmMKPiA+IEBAIC0wLDAgKzEsMjcxIEBACgpbc25pcF0KCj4gPiArc3RhdGlj IHZvaWQgdWlmX2NvbmZpZ3VyZShzdHJ1Y3QgdnNwMV9lbnRpdHkgKmVudGl0eSwKPiA+ICsJCQkg IHN0cnVjdCB2c3AxX3BpcGVsaW5lICpwaXBlLAo+ID4gKwkJCSAgc3RydWN0IHZzcDFfZGxfbGlz dCAqZGwsCj4gPiArCQkJICBlbnVtIHZzcDFfZW50aXR5X3BhcmFtcyBwYXJhbXMpCj4gPiArewo+ ID4gKwlzdHJ1Y3QgdnNwMV91aWYgKnVpZiA9IHRvX3VpZigmZW50aXR5LT5zdWJkZXYpOwo+ID4g Kwljb25zdCBzdHJ1Y3QgdjRsMl9yZWN0ICpjcm9wOwo+ID4gKwl1bnNpZ25lZCBpbnQgbGVmdDsK PiA+ICsJdW5zaWduZWQgaW50IHdpZHRoOwo+ID4gKwo+ID4gKwkvKgo+ID4gKwkgKiBQZXItcGFy dGl0aW9uIGNvbmZpZ3VyYXRpb24gaXNuJ3QgbmVlZGVkIGFzIHRoZSBESVNDT00gaXMgdXNlZCBp bgo+ID4gKwkgKiBkaXNwbGF5IHBpcGVsaW5lcyBvbmx5Lgo+ID4gKwkgKi8KPiA+ICsJaWYgKHBh cmFtcyAhPSBWU1AxX0VOVElUWV9QQVJBTVNfSU5JVCkKPiA+ICsJCXJldHVybjsKPiA+ICsKPiA+ ICsJdnNwMV91aWZfd3JpdGUodWlmLCBkbCwgVkk2X1VJRl9ESVNDT01fRE9DTVBNUiwKPiA+ICsJ CSAgICAgICBWSTZfVUlGX0RJU0NPTV9ET0NNUE1SX1NFTCg5KSk7Cj4gPiArCj4gPiArCWNyb3Ag PSB2c3AxX2VudGl0eV9nZXRfcGFkX3NlbGVjdGlvbihlbnRpdHksIGVudGl0eS0+Y29uZmlnLAo+ ID4gKwkJCQkJICAgICBVSUZfUEFEX1NJTkssIFY0TDJfU0VMX1RHVF9DUk9QKTsKPiA+ICsKPiA+ ICsJLyogT24gTTMtVyB0aGUgaG9yaXpvbnRhbCBjb29yZGluYXRlcyBhcmUgdHdpY2UgdGhlIHJl Z2lzdGVyIHZhbHVlLiAqLwo+ID4gKwlpZiAodWlmLT5tM3dfcXVpcmspIHsKPiA+ICsJCWxlZnQg PSBjcm9wLT5sZWZ0IC8gMjsKPiA+ICsJCXdpZHRoID0gY3JvcC0+d2lkdGggLyAyOwo+ID4gKwl9 IGVsc2Ugewo+ID4gKwkJbGVmdCA9IGNyb3AtPmxlZnQ7Cj4gPiArCQl3aWR0aCA9IGNyb3AtPndp ZHRoOwo+ID4gKwl9Cj4gCj4gSSB3b3VsZCB3cml0ZSB0aGlzIGFzCj4gCj4gICAgICAgICBsZWZ0 ID0gY3JvcC0+bGVmdDsKPiAgICAgICAgIHdpZHRoID0gY3JvcC0+d2lkdGg7Cj4gCS8qIE9uIE0z LVcgdGhlIGhvcml6b250YWwgY29vcmRpbmF0ZXMgYXJlIHR3aWNlIHRoZSByZWdpc3RlciB2YWx1 ZS4gKi8KPiAJaWYgKHVpZi0+bTN3X3F1aXJrKSB7Cj4gCQlsZWZ0IC89IDI7Cj4gCQl3aWR0aCAv PSAyOwo+ICAgICAgICAgfQo+IAo+IEJ1dCB0aGF0J3MgcmVhbGx5IHVwIHRvIHlvdS4KCkkgcHJl ZmVyIG15IHN0eWxlLCBidXQgaXQgbG9va3MgbGlrZSBnY2MgNi40LjAgZ2VuZXJhdGVzIHNsaWdo dGx5IGJldHRlciBjb2RlIAp3aXRoIHlvdXIgdmVyc2lvbiAoZHVlIHRvIHRoZSBmYWN0IHRoYXQg dGhlIGNyb3AtPmxlZnQgdmFsdWUgaXMgY29udmVydGVkIHRvIAp1bnNpZ25lZCBiZWZvcmUgYmVp bmcgZGl2aWRlZCBieSAyKSwgc28gSSdsbCBnbyBmb3IgaXQuCgo+ID4gKwo+ID4gKwl2c3AxX3Vp Zl93cml0ZSh1aWYsIGRsLCBWSTZfVUlGX0RJU0NPTV9ET0NNU1BYUiwgbGVmdCk7Cj4gPiArCXZz cDFfdWlmX3dyaXRlKHVpZiwgZGwsIFZJNl9VSUZfRElTQ09NX0RPQ01TUFlSLCBjcm9wLT50b3Ap Owo+ID4gKwl2c3AxX3VpZl93cml0ZSh1aWYsIGRsLCBWSTZfVUlGX0RJU0NPTV9ET0NNU1pYUiwg d2lkdGgpOwo+ID4gKwl2c3AxX3VpZl93cml0ZSh1aWYsIGRsLCBWSTZfVUlGX0RJU0NPTV9ET0NN U1pZUiwgY3JvcC0+aGVpZ2h0KTsKPiA+ICsKPiA+ICsJdnNwMV91aWZfd3JpdGUodWlmLCBkbCwg Vkk2X1VJRl9ESVNDT01fRE9DTUNSLAo+ID4gKwkJICAgICAgIFZJNl9VSUZfRElTQ09NX0RPQ01D Ul9DTVBSKTsKPiA+ICt9Cj4gPiArCj4gPiArc3RhdGljIGNvbnN0IHN0cnVjdCB2c3AxX2VudGl0 eV9vcGVyYXRpb25zIHVpZl9lbnRpdHlfb3BzID0gewo+ID4gKwkuY29uZmlndXJlID0gdWlmX2Nv bmZpZ3VyZSwKPiA+ICt9Owo+ID4gKwo+ID4gKy8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KPiA+ICsgKiBJbml0 aWFsaXphdGlvbiBhbmQgQ2xlYW51cAo+ID4gKyAqLwo+ID4gKwo+ID4gK3N0YXRpYyBjb25zdCBz dHJ1Y3Qgc29jX2RldmljZV9hdHRyaWJ1dGUgdnNwMV9yOGE3Nzk2W10gPSB7Cj4gPiArCXsgLnNv Y19pZCA9ICJyOGE3Nzk2IiB9LAo+ID4gKwl7IC8qIHNlbnRpbmVsICovIH0KPiA+ICt9Owo+ID4g Kwo+ID4gK3N0cnVjdCB2c3AxX3VpZiAqdnNwMV91aWZfY3JlYXRlKHN0cnVjdCB2c3AxX2Rldmlj ZSAqdnNwMSwgdW5zaWduZWQgaW50Cj4gPiBpbmRleCkgK3sKPiA+ICsJc3RydWN0IHZzcDFfdWlm ICp1aWY7Cj4gPiArCWNoYXIgbmFtZVs2XTsKPiA+ICsJaW50IHJldDsKPiA+ICsKPiA+ICsJdWlm ID0gZGV2bV9remFsbG9jKHZzcDEtPmRldiwgc2l6ZW9mKCp1aWYpLCBHRlBfS0VSTkVMKTsKPiA+ ICsJaWYgKHVpZiA9PSBOVUxMKQo+IAo+ICAgICAgICAgaWYgKCF1aWYpCj4gCj4gT3RoZXJ3aXNl IGNoZWNrcGF0Y2ggY29tcGxhaW5zIGlpcmMuCgpPbmx5IHdoZW4gcnVuIHdpdGggLS1zdHJpY3Qu CgpOZXZlcnRoZWxlc3MsIGV2ZW4gaWYgYm90aCBzdHlsZXMgYXJlIG1peGVkIGluIHRoZSBkcml2 ZXIsIHRoZSBwcmVkb21pbmFudCAKc3R5bGUgaXMgIXVpZiwgc28gSSdsbCBzd2l0Y2ggdG8gdGhh dC4KCj4gVGhvc2UgYXJlIHZlcnkgbWlub3IgY29tbWVudHMsIHNvIGZlZWwgZnJlZSB0byBhZGQg bXkgcmV2aWV3ZWQgYnkgdGFnCj4gCj4gUmV2aWV3ZWQtYnk6IEphY29wbyBNb25kaSA8amFjb3Bv QGptb25kaS5vcmc+Cj4gCj4gPiArCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKPiA+ICsKPiA+ ICsJaWYgKHNvY19kZXZpY2VfbWF0Y2godnNwMV9yOGE3Nzk2KSkKPiA+ICsJCXVpZi0+bTN3X3F1 aXJrID0gdHJ1ZTsKPiA+ICsKPiA+ICsJdWlmLT5lbnRpdHkub3BzID0gJnVpZl9lbnRpdHlfb3Bz Owo+ID4gKwl1aWYtPmVudGl0eS50eXBlID0gVlNQMV9FTlRJVFlfVUlGOwo+ID4gKwl1aWYtPmVu dGl0eS5pbmRleCA9IGluZGV4Owo+ID4gKwo+ID4gKwkvKiBUaGUgZGF0YXNoZWV0IG5hbWVzIHRo ZSB0d28gVUlGIGluc3RhbmNlcyBVSUY0IGFuZCBVSUY1LiAqLwo+ID4gKwlzcHJpbnRmKG5hbWUs ICJ1aWYuJXUiLCBpbmRleCArIDQpOwo+ID4gKwlyZXQgPSB2c3AxX2VudGl0eV9pbml0KHZzcDEs ICZ1aWYtPmVudGl0eSwgbmFtZSwgMiwgJnVpZl9vcHMsCj4gPiArCQkJICAgICAgIE1FRElBX0VO VF9GX1BST0NfVklERU9fU1RBVElTVElDUyk7Cj4gPiArCWlmIChyZXQgPCAwKQo+ID4gKwkJcmV0 dXJuIEVSUl9QVFIocmV0KTsKPiA+ICsKPiA+ICsJcmV0dXJuIHVpZjsKPiA+ICt9Cgpbc25pcF0K Ci0tIApSZWdhcmRzLAoKTGF1cmVudCBQaW5jaGFydAoKCgpfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZl bEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFp bG1hbi9saXN0aW5mby9kcmktZGV2ZWwK