From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from perceval.ideasonboard.com ([213.167.242.64]:50668 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751354AbeD1QHc (ORCPT ); Sat, 28 Apr 2018 12:07:32 -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 2/8] v4l: vsp1: Share the CLU, LIF and LUT set_fmt pad operation code Date: Sat, 28 Apr 2018 19:07:47 +0300 Message-ID: <17550874.WPgDx0BBl0@avalon> In-Reply-To: <20180428095048.GA18201@w540> References: <20180422223430.16407-1-laurent.pinchart+renesas@ideasonboard.com> <20180422223430.16407-3-laurent.pinchart+renesas@ideasonboard.com> <20180428095048.GA18201@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 12:50:48 EEST jacopo mondi wrote: > Hi Laurent, > very minor comments below > > On Mon, Apr 23, 2018 at 01:34:24AM +0300, Laurent Pinchart wrote: > > The implementation of the set_fmt pad operation is identical in the > > three modules. Move it to a generic helper function. > > > > Signed-off-by: Laurent Pinchart > > > > --- > > > > drivers/media/platform/vsp1/vsp1_clu.c | 65 +++++-------------------- > > drivers/media/platform/vsp1/vsp1_entity.c | 75 ++++++++++++++++++++++++++ > > drivers/media/platform/vsp1/vsp1_entity.h | 6 +++ > > drivers/media/platform/vsp1/vsp1_lif.c | 65 +++++-------------------- > > drivers/media/platform/vsp1/vsp1_lut.c | 65 +++++-------------------- > > 5 files changed, 116 insertions(+), 160 deletions(-) > > > > diff --git a/drivers/media/platform/vsp1/vsp1_clu.c > > b/drivers/media/platform/vsp1/vsp1_clu.c index 9626b6308585..96a448e1504c > > 100644 > > --- a/drivers/media/platform/vsp1/vsp1_clu.c > > +++ b/drivers/media/platform/vsp1/vsp1_clu.c > > @@ -114,18 +114,18 @@ static const struct v4l2_ctrl_config > > clu_mode_control = { > > * V4L2 Subdevice Pad Operations > > */ > > > > +static const unsigned int clu_codes[] = { > > + MEDIA_BUS_FMT_ARGB8888_1X32, > > + MEDIA_BUS_FMT_AHSV8888_1X32, > > + MEDIA_BUS_FMT_AYUV8_1X32, > > +}; > > + > > static int clu_enum_mbus_code(struct v4l2_subdev *subdev, > > struct v4l2_subdev_pad_config *cfg, > > struct v4l2_subdev_mbus_code_enum *code) > > { > > - static const unsigned int codes[] = { > > - MEDIA_BUS_FMT_ARGB8888_1X32, > > - MEDIA_BUS_FMT_AHSV8888_1X32, > > - MEDIA_BUS_FMT_AYUV8_1X32, > > - }; > > - > > - return vsp1_subdev_enum_mbus_code(subdev, cfg, code, codes, > > - ARRAY_SIZE(codes)); > > + return vsp1_subdev_enum_mbus_code(subdev, cfg, code, clu_codes, > > + ARRAY_SIZE(clu_codes)); > > } > > > > static int clu_enum_frame_size(struct v4l2_subdev *subdev, > > @@ -141,51 +141,10 @@ static int clu_set_format(struct v4l2_subdev > > *subdev, > > struct v4l2_subdev_pad_config *cfg, > > struct v4l2_subdev_format *fmt) > > { > > - struct vsp1_clu *clu = to_clu(subdev); > > - struct v4l2_subdev_pad_config *config; > > - struct v4l2_mbus_framefmt *format; > > - int ret = 0; > > - > > - mutex_lock(&clu->entity.lock); > > - > > - config = vsp1_entity_get_pad_config(&clu->entity, cfg, fmt->which); > > - if (!config) { > > - ret = -EINVAL; > > - goto done; > > - } > > - > > - /* Default to YUV if the requested format is not supported. */ > > - if (fmt->format.code != MEDIA_BUS_FMT_ARGB8888_1X32 && > > - fmt->format.code != MEDIA_BUS_FMT_AHSV8888_1X32 && > > - fmt->format.code != MEDIA_BUS_FMT_AYUV8_1X32) > > - fmt->format.code = MEDIA_BUS_FMT_AYUV8_1X32; > > The newly implemented vsp1_subdev_set_pad_format defaults to the first > clu_codes[] member (ARGB888_1x32), while here the code chose the AYUV8_1x32 > format. Is it ok? Should you revers the clu_codes[] order? But that would then change the order of the format enumeration. I don't think it's a big deal, the change here will only affect the format returned if userspace tries to pick a format that is not supported (and thus not returned by the enumeration). This shouldn't happen in the first place, and if it does, the driver has never guaranteed that a specific format would be returned. > > - > > - format = vsp1_entity_get_pad_format(&clu->entity, config, fmt->pad); > > - > > - if (fmt->pad == CLU_PAD_SOURCE) { > > - /* The CLU output format can't be modified. */ > > - fmt->format = *format; > > - goto done; > > - } > > - > > - format->code = fmt->format.code; > > - format->width = clamp_t(unsigned int, fmt->format.width, > > - CLU_MIN_SIZE, CLU_MAX_SIZE); > > - format->height = clamp_t(unsigned int, fmt->format.height, > > - CLU_MIN_SIZE, CLU_MAX_SIZE); > > - format->field = V4L2_FIELD_NONE; > > - format->colorspace = V4L2_COLORSPACE_SRGB; > > - > > - fmt->format = *format; > > - > > - /* Propagate the format to the source pad. */ > > - format = vsp1_entity_get_pad_format(&clu->entity, config, > > - CLU_PAD_SOURCE); > > - *format = fmt->format; > > - > > -done: > > - mutex_unlock(&clu->entity.lock); > > - return ret; > > + return vsp1_subdev_set_pad_format(subdev, cfg, fmt, clu_codes, > > + ARRAY_SIZE(clu_codes), > > + CLU_MIN_SIZE, CLU_MIN_SIZE, > > + CLU_MAX_SIZE, CLU_MAX_SIZE); > > } > > > > /* ---------------------------------------------------------------------- > > diff --git a/drivers/media/platform/vsp1/vsp1_entity.c > > b/drivers/media/platform/vsp1/vsp1_entity.c index > > 72354caf5746..239df047efd0 100644 > > --- a/drivers/media/platform/vsp1/vsp1_entity.c > > +++ b/drivers/media/platform/vsp1/vsp1_entity.c > > @@ -307,6 +307,81 @@ int vsp1_subdev_enum_frame_size(struct v4l2_subdev > > *subdev, > > return ret; > > } > > > > +/* > > + * vsp1_subdev_set_pad_format - Subdev pad set_fmt handler > > + * @subdev: V4L2 subdevice > > + * @cfg: V4L2 subdev pad configuration > > + * @fmt: V4L2 subdev format > > + * @codes: Array of supported media bus codes > > + * @ncodes: Number of supported media bus codes > > + * @min_width: Minimum image width > > + * @min_height: Minimum image height > > + * @max_width: Maximum image width > > + * @max_height: Maximum image height > > + * > > + * This function implements the subdev set_fmt pad operation for entities > > that > > + * do not support scaling or cropping. It defaults to the first supplied > > media > > + * bus code if the requested code isn't supported, clamps the size to the > > + * supplied minimum and maximum, and propagates the sink pad format to > > the > > + * source pad. > > + */ > > +int vsp1_subdev_set_pad_format(struct v4l2_subdev *subdev, > > + struct v4l2_subdev_pad_config *cfg, > > + struct v4l2_subdev_format *fmt, > > + const unsigned int *codes, unsigned int ncodes, > > + unsigned int min_width, unsigned int min_height, > > + unsigned int max_width, unsigned int max_height) > > +{ > > + struct vsp1_entity *entity = to_vsp1_entity(subdev); > > + struct v4l2_subdev_pad_config *config; > > + struct v4l2_mbus_framefmt *format; > > + unsigned int i; > > + int ret = 0; > > + > > + mutex_lock(&entity->lock); > > + > > + config = vsp1_entity_get_pad_config(entity, cfg, fmt->which); > > + if (!config) { > > + ret = -EINVAL; > > + goto done; > > + } > > + > > + format = vsp1_entity_get_pad_format(entity, config, fmt->pad); > > + > > + if (fmt->pad != 0) { > > This assumes the SINK pad is always 0, which indeed is the case for > CLU, LIF and LUT entities. > > > + /* The output format can't be modified. */ > > + fmt->format = *format; > > + goto done; > > + } > > + > > + /* > > + * Default to the first media bus code if the requested format is not > > + * supported. > > + */ > > + for (i = 0; i < ncodes; ++i) { > > + if (fmt->format.code == codes[i]) > > + break; > > + } > > Braces not needed? Not strictly required but I find it more readable. > > + > > + format->code = i < ncodes ? codes[i] : codes[0]; > > + format->width = clamp_t(unsigned int, fmt->format.width, > > + min_width, max_width); > > + format->height = clamp_t(unsigned int, fmt->format.height, > > + min_height, max_height); > > + format->field = V4L2_FIELD_NONE; > > + format->colorspace = V4L2_COLORSPACE_SRGB; > > + > > + fmt->format = *format; > > + > > + /* Propagate the format to the source pad. */ > > + format = vsp1_entity_get_pad_format(entity, config, 1); > > + *format = fmt->format; > > + > > +done: > > + mutex_unlock(&entity->lock); > > + return ret; > > +} [snip] -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH v2 2/8] v4l: vsp1: Share the CLU, LIF and LUT set_fmt pad operation code Date: Sat, 28 Apr 2018 19:07:47 +0300 Message-ID: <17550874.WPgDx0BBl0@avalon> References: <20180422223430.16407-1-laurent.pinchart+renesas@ideasonboard.com> <20180422223430.16407-3-laurent.pinchart+renesas@ideasonboard.com> <20180428095048.GA18201@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 0F4556E18E for ; Sat, 28 Apr 2018 16:07:33 +0000 (UTC) In-Reply-To: <20180428095048.GA18201@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 SGkgSmFjb3BvLAoKT24gU2F0dXJkYXksIDI4IEFwcmlsIDIwMTggMTI6NTA6NDggRUVTVCBqYWNv cG8gbW9uZGkgd3JvdGU6Cj4gSGkgTGF1cmVudCwKPiAgICB2ZXJ5IG1pbm9yIGNvbW1lbnRzIGJl bG93Cj4gCj4gT24gTW9uLCBBcHIgMjMsIDIwMTggYXQgMDE6MzQ6MjRBTSArMDMwMCwgTGF1cmVu dCBQaW5jaGFydCB3cm90ZToKPiA+IFRoZSBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgc2V0X2ZtdCBw YWQgb3BlcmF0aW9uIGlzIGlkZW50aWNhbCBpbiB0aGUKPiA+IHRocmVlIG1vZHVsZXMuIE1vdmUg aXQgdG8gYSBnZW5lcmljIGhlbHBlciBmdW5jdGlvbi4KPiA+IAo+ID4gU2lnbmVkLW9mZi1ieTog TGF1cmVudCBQaW5jaGFydAo+ID4gPGxhdXJlbnQucGluY2hhcnQrcmVuZXNhc0BpZGVhc29uYm9h cmQuY29tPgo+ID4gLS0tCj4gPiAKPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNw MV9jbHUuYyAgICB8IDY1ICsrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0KPiA+ICBkcml2ZXJzL21l ZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9lbnRpdHkuYyB8IDc1ICsrKysrKysrKysrKysrKysrKysr KysrKysrCj4gPiAgZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZW50aXR5LmggfCAg NiArKysKPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9saWYuYyAgICB8IDY1 ICsrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0KPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3Zz cDEvdnNwMV9sdXQuYyAgICB8IDY1ICsrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0KPiA+ICA1IGZp bGVzIGNoYW5nZWQsIDExNiBpbnNlcnRpb25zKCspLCAxNjAgZGVsZXRpb25zKC0pCj4gPiAKPiA+ IGRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9jbHUuYwo+ID4g Yi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9jbHUuYyBpbmRleCA5NjI2YjYzMDg1 ODUuLjk2YTQ0OGUxNTA0Ywo+ID4gMTAwNjQ0Cj4gPiAtLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRm b3JtL3ZzcDEvdnNwMV9jbHUuYwo+ID4gKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3Ax L3ZzcDFfY2x1LmMKPiA+IEBAIC0xMTQsMTggKzExNCwxOCBAQCBzdGF0aWMgY29uc3Qgc3RydWN0 IHY0bDJfY3RybF9jb25maWcKPiA+IGNsdV9tb2RlX2NvbnRyb2wgPSB7Cj4gPiAgICogVjRMMiBT dWJkZXZpY2UgUGFkIE9wZXJhdGlvbnMKPiA+ICAgKi8KPiA+IAo+ID4gK3N0YXRpYyBjb25zdCB1 bnNpZ25lZCBpbnQgY2x1X2NvZGVzW10gPSB7Cj4gPiArCU1FRElBX0JVU19GTVRfQVJHQjg4ODhf MVgzMiwKPiA+ICsJTUVESUFfQlVTX0ZNVF9BSFNWODg4OF8xWDMyLAo+ID4gKwlNRURJQV9CVVNf Rk1UX0FZVVY4XzFYMzIsCj4gPiArfTsKPiA+ICsKPiA+ICBzdGF0aWMgaW50IGNsdV9lbnVtX21i dXNfY29kZShzdHJ1Y3QgdjRsMl9zdWJkZXYgKnN1YmRldiwKPiA+ICAJCQkgICAgICBzdHJ1Y3Qg djRsMl9zdWJkZXZfcGFkX2NvbmZpZyAqY2ZnLAo+ID4gIAkJCSAgICAgIHN0cnVjdCB2NGwyX3N1 YmRldl9tYnVzX2NvZGVfZW51bSAqY29kZSkKPiA+ICB7Cj4gPiAtCXN0YXRpYyBjb25zdCB1bnNp Z25lZCBpbnQgY29kZXNbXSA9IHsKPiA+IC0JCU1FRElBX0JVU19GTVRfQVJHQjg4ODhfMVgzMiwK PiA+IC0JCU1FRElBX0JVU19GTVRfQUhTVjg4ODhfMVgzMiwKPiA+IC0JCU1FRElBX0JVU19GTVRf QVlVVjhfMVgzMiwKPiA+IC0JfTsKPiA+IC0KPiA+IC0JcmV0dXJuIHZzcDFfc3ViZGV2X2VudW1f bWJ1c19jb2RlKHN1YmRldiwgY2ZnLCBjb2RlLCBjb2RlcywKPiA+IC0JCQkJCSAgQVJSQVlfU0la RShjb2RlcykpOwo+ID4gKwlyZXR1cm4gdnNwMV9zdWJkZXZfZW51bV9tYnVzX2NvZGUoc3ViZGV2 LCBjZmcsIGNvZGUsIGNsdV9jb2RlcywKPiA+ICsJCQkJCSAgQVJSQVlfU0laRShjbHVfY29kZXMp KTsKPiA+ICB9Cj4gPiAgCj4gPiAgc3RhdGljIGludCBjbHVfZW51bV9mcmFtZV9zaXplKHN0cnVj dCB2NGwyX3N1YmRldiAqc3ViZGV2LAo+ID4gQEAgLTE0MSw1MSArMTQxLDEwIEBAIHN0YXRpYyBp bnQgY2x1X3NldF9mb3JtYXQoc3RydWN0IHY0bDJfc3ViZGV2Cj4gPiAqc3ViZGV2LAo+ID4gIAkJ CSAgc3RydWN0IHY0bDJfc3ViZGV2X3BhZF9jb25maWcgKmNmZywKPiA+ICAJCQkgIHN0cnVjdCB2 NGwyX3N1YmRldl9mb3JtYXQgKmZtdCkKPiA+ICB7Cj4gPiAtCXN0cnVjdCB2c3AxX2NsdSAqY2x1 ID0gdG9fY2x1KHN1YmRldik7Cj4gPiAtCXN0cnVjdCB2NGwyX3N1YmRldl9wYWRfY29uZmlnICpj b25maWc7Cj4gPiAtCXN0cnVjdCB2NGwyX21idXNfZnJhbWVmbXQgKmZvcm1hdDsKPiA+IC0JaW50 IHJldCA9IDA7Cj4gPiAtCj4gPiAtCW11dGV4X2xvY2soJmNsdS0+ZW50aXR5LmxvY2spOwo+ID4g LQo+ID4gLQljb25maWcgPSB2c3AxX2VudGl0eV9nZXRfcGFkX2NvbmZpZygmY2x1LT5lbnRpdHks IGNmZywgZm10LT53aGljaCk7Cj4gPiAtCWlmICghY29uZmlnKSB7Cj4gPiAtCQlyZXQgPSAtRUlO VkFMOwo+ID4gLQkJZ290byBkb25lOwo+ID4gLQl9Cj4gPiAtCj4gPiAtCS8qIERlZmF1bHQgdG8g WVVWIGlmIHRoZSByZXF1ZXN0ZWQgZm9ybWF0IGlzIG5vdCBzdXBwb3J0ZWQuICovCj4gPiAtCWlm IChmbXQtPmZvcm1hdC5jb2RlICE9IE1FRElBX0JVU19GTVRfQVJHQjg4ODhfMVgzMiAmJgo+ID4g LQkgICAgZm10LT5mb3JtYXQuY29kZSAhPSBNRURJQV9CVVNfRk1UX0FIU1Y4ODg4XzFYMzIgJiYK PiA+IC0JICAgIGZtdC0+Zm9ybWF0LmNvZGUgIT0gTUVESUFfQlVTX0ZNVF9BWVVWOF8xWDMyKQo+ ID4gLQkJZm10LT5mb3JtYXQuY29kZSA9IE1FRElBX0JVU19GTVRfQVlVVjhfMVgzMjsKPiAKPiBU aGUgbmV3bHkgaW1wbGVtZW50ZWQgdnNwMV9zdWJkZXZfc2V0X3BhZF9mb3JtYXQgZGVmYXVsdHMg dG8gdGhlIGZpcnN0Cj4gY2x1X2NvZGVzW10gbWVtYmVyIChBUkdCODg4XzF4MzIpLCB3aGlsZSBo ZXJlIHRoZSBjb2RlIGNob3NlIHRoZSBBWVVWOF8xeDMyCj4gZm9ybWF0LiBJcyBpdCBvaz8gU2hv dWxkIHlvdSByZXZlcnMgdGhlIGNsdV9jb2Rlc1tdIG9yZGVyPwoKQnV0IHRoYXQgd291bGQgdGhl biBjaGFuZ2UgdGhlIG9yZGVyIG9mIHRoZSBmb3JtYXQgZW51bWVyYXRpb24uCgpJIGRvbid0IHRo aW5rIGl0J3MgYSBiaWcgZGVhbCwgdGhlIGNoYW5nZSBoZXJlIHdpbGwgb25seSBhZmZlY3QgdGhl IGZvcm1hdCAKcmV0dXJuZWQgaWYgdXNlcnNwYWNlIHRyaWVzIHRvIHBpY2sgYSBmb3JtYXQgdGhh dCBpcyBub3Qgc3VwcG9ydGVkIChhbmQgdGh1cyAKbm90IHJldHVybmVkIGJ5IHRoZSBlbnVtZXJh dGlvbikuIFRoaXMgc2hvdWxkbid0IGhhcHBlbiBpbiB0aGUgZmlyc3QgcGxhY2UsIAphbmQgaWYg aXQgZG9lcywgdGhlIGRyaXZlciBoYXMgbmV2ZXIgZ3VhcmFudGVlZCB0aGF0IGEgc3BlY2lmaWMg Zm9ybWF0IHdvdWxkIApiZSByZXR1cm5lZC4KCj4gPiAtCj4gPiAtCWZvcm1hdCA9IHZzcDFfZW50 aXR5X2dldF9wYWRfZm9ybWF0KCZjbHUtPmVudGl0eSwgY29uZmlnLCBmbXQtPnBhZCk7Cj4gPiAt Cj4gPiAtCWlmIChmbXQtPnBhZCA9PSBDTFVfUEFEX1NPVVJDRSkgewo+ID4gLQkJLyogVGhlIENM VSBvdXRwdXQgZm9ybWF0IGNhbid0IGJlIG1vZGlmaWVkLiAqLwo+ID4gLQkJZm10LT5mb3JtYXQg PSAqZm9ybWF0Owo+ID4gLQkJZ290byBkb25lOwo+ID4gLQl9Cj4gPiAtCj4gPiAtCWZvcm1hdC0+ Y29kZSA9IGZtdC0+Zm9ybWF0LmNvZGU7Cj4gPiAtCWZvcm1hdC0+d2lkdGggPSBjbGFtcF90KHVu c2lnbmVkIGludCwgZm10LT5mb3JtYXQud2lkdGgsCj4gPiAtCQkJCUNMVV9NSU5fU0laRSwgQ0xV X01BWF9TSVpFKTsKPiA+IC0JZm9ybWF0LT5oZWlnaHQgPSBjbGFtcF90KHVuc2lnbmVkIGludCwg Zm10LT5mb3JtYXQuaGVpZ2h0LAo+ID4gLQkJCQkgQ0xVX01JTl9TSVpFLCBDTFVfTUFYX1NJWkUp Owo+ID4gLQlmb3JtYXQtPmZpZWxkID0gVjRMMl9GSUVMRF9OT05FOwo+ID4gLQlmb3JtYXQtPmNv bG9yc3BhY2UgPSBWNEwyX0NPTE9SU1BBQ0VfU1JHQjsKPiA+IC0KPiA+IC0JZm10LT5mb3JtYXQg PSAqZm9ybWF0Owo+ID4gLQo+ID4gLQkvKiBQcm9wYWdhdGUgdGhlIGZvcm1hdCB0byB0aGUgc291 cmNlIHBhZC4gKi8KPiA+IC0JZm9ybWF0ID0gdnNwMV9lbnRpdHlfZ2V0X3BhZF9mb3JtYXQoJmNs dS0+ZW50aXR5LCBjb25maWcsCj4gPiAtCQkJCQkgICAgQ0xVX1BBRF9TT1VSQ0UpOwo+ID4gLQkq Zm9ybWF0ID0gZm10LT5mb3JtYXQ7Cj4gPiAtCj4gPiAtZG9uZToKPiA+IC0JbXV0ZXhfdW5sb2Nr KCZjbHUtPmVudGl0eS5sb2NrKTsKPiA+IC0JcmV0dXJuIHJldDsKPiA+ICsJcmV0dXJuIHZzcDFf c3ViZGV2X3NldF9wYWRfZm9ybWF0KHN1YmRldiwgY2ZnLCBmbXQsIGNsdV9jb2RlcywKPiA+ICsJ CQkJCSAgQVJSQVlfU0laRShjbHVfY29kZXMpLAo+ID4gKwkJCQkJICBDTFVfTUlOX1NJWkUsIENM VV9NSU5fU0laRSwKPiA+ICsJCQkJCSAgQ0xVX01BWF9TSVpFLCBDTFVfTUFYX1NJWkUpOwo+ID4g IH0KPiA+ICAKPiA+ICAvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9t ZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZW50aXR5LmMKPiA+IGIvZHJpdmVycy9tZWRpYS9wbGF0 Zm9ybS92c3AxL3ZzcDFfZW50aXR5LmMgaW5kZXgKPiA+IDcyMzU0Y2FmNTc0Ni4uMjM5ZGYwNDdl ZmQwIDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZW50 aXR5LmMKPiA+ICsrKyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2VudGl0eS5j Cj4gPiBAQCAtMzA3LDYgKzMwNyw4MSBAQCBpbnQgdnNwMV9zdWJkZXZfZW51bV9mcmFtZV9zaXpl KHN0cnVjdCB2NGwyX3N1YmRldgo+ID4gKnN1YmRldiwKPiA+ICAJcmV0dXJuIHJldDsKPiA+ICB9 Cj4gPiAKPiA+ICsvKgo+ID4gKyAqIHZzcDFfc3ViZGV2X3NldF9wYWRfZm9ybWF0IC0gU3ViZGV2 IHBhZCBzZXRfZm10IGhhbmRsZXIKPiA+ICsgKiBAc3ViZGV2OiBWNEwyIHN1YmRldmljZQo+ID4g KyAqIEBjZmc6IFY0TDIgc3ViZGV2IHBhZCBjb25maWd1cmF0aW9uCj4gPiArICogQGZtdDogVjRM MiBzdWJkZXYgZm9ybWF0Cj4gPiArICogQGNvZGVzOiBBcnJheSBvZiBzdXBwb3J0ZWQgbWVkaWEg YnVzIGNvZGVzCj4gPiArICogQG5jb2RlczogTnVtYmVyIG9mIHN1cHBvcnRlZCBtZWRpYSBidXMg Y29kZXMKPiA+ICsgKiBAbWluX3dpZHRoOiBNaW5pbXVtIGltYWdlIHdpZHRoCj4gPiArICogQG1p bl9oZWlnaHQ6IE1pbmltdW0gaW1hZ2UgaGVpZ2h0Cj4gPiArICogQG1heF93aWR0aDogTWF4aW11 bSBpbWFnZSB3aWR0aAo+ID4gKyAqIEBtYXhfaGVpZ2h0OiBNYXhpbXVtIGltYWdlIGhlaWdodAo+ ID4gKyAqCj4gPiArICogVGhpcyBmdW5jdGlvbiBpbXBsZW1lbnRzIHRoZSBzdWJkZXYgc2V0X2Zt dCBwYWQgb3BlcmF0aW9uIGZvciBlbnRpdGllcwo+ID4gdGhhdAo+ID4gKyAqIGRvIG5vdCBzdXBw b3J0IHNjYWxpbmcgb3IgY3JvcHBpbmcuIEl0IGRlZmF1bHRzIHRvIHRoZSBmaXJzdCBzdXBwbGll ZAo+ID4gbWVkaWEKPiA+ICsgKiBidXMgY29kZSBpZiB0aGUgcmVxdWVzdGVkIGNvZGUgaXNuJ3Qg c3VwcG9ydGVkLCBjbGFtcHMgdGhlIHNpemUgdG8gdGhlCj4gPiArICogc3VwcGxpZWQgbWluaW11 bSBhbmQgbWF4aW11bSwgYW5kIHByb3BhZ2F0ZXMgdGhlIHNpbmsgcGFkIGZvcm1hdCB0bwo+ID4g dGhlCj4gPiArICogc291cmNlIHBhZC4KPiA+ICsgKi8KPiA+ICtpbnQgdnNwMV9zdWJkZXZfc2V0 X3BhZF9mb3JtYXQoc3RydWN0IHY0bDJfc3ViZGV2ICpzdWJkZXYsCj4gPiArCQkJICAgICAgIHN0 cnVjdCB2NGwyX3N1YmRldl9wYWRfY29uZmlnICpjZmcsCj4gPiArCQkJICAgICAgIHN0cnVjdCB2 NGwyX3N1YmRldl9mb3JtYXQgKmZtdCwKPiA+ICsJCQkgICAgICAgY29uc3QgdW5zaWduZWQgaW50 ICpjb2RlcywgdW5zaWduZWQgaW50IG5jb2RlcywKPiA+ICsJCQkgICAgICAgdW5zaWduZWQgaW50 IG1pbl93aWR0aCwgdW5zaWduZWQgaW50IG1pbl9oZWlnaHQsCj4gPiArCQkJICAgICAgIHVuc2ln bmVkIGludCBtYXhfd2lkdGgsIHVuc2lnbmVkIGludCBtYXhfaGVpZ2h0KQo+ID4gK3sKPiA+ICsJ c3RydWN0IHZzcDFfZW50aXR5ICplbnRpdHkgPSB0b192c3AxX2VudGl0eShzdWJkZXYpOwo+ID4g KwlzdHJ1Y3QgdjRsMl9zdWJkZXZfcGFkX2NvbmZpZyAqY29uZmlnOwo+ID4gKwlzdHJ1Y3QgdjRs Ml9tYnVzX2ZyYW1lZm10ICpmb3JtYXQ7Cj4gPiArCXVuc2lnbmVkIGludCBpOwo+ID4gKwlpbnQg cmV0ID0gMDsKPiA+ICsKPiA+ICsJbXV0ZXhfbG9jaygmZW50aXR5LT5sb2NrKTsKPiA+ICsKPiA+ ICsJY29uZmlnID0gdnNwMV9lbnRpdHlfZ2V0X3BhZF9jb25maWcoZW50aXR5LCBjZmcsIGZtdC0+ d2hpY2gpOwo+ID4gKwlpZiAoIWNvbmZpZykgewo+ID4gKwkJcmV0ID0gLUVJTlZBTDsKPiA+ICsJ CWdvdG8gZG9uZTsKPiA+ICsJfQo+ID4gKwo+ID4gKwlmb3JtYXQgPSB2c3AxX2VudGl0eV9nZXRf cGFkX2Zvcm1hdChlbnRpdHksIGNvbmZpZywgZm10LT5wYWQpOwo+ID4gKwo+ID4gKwlpZiAoZm10 LT5wYWQgIT0gMCkgewo+IAo+IFRoaXMgYXNzdW1lcyB0aGUgU0lOSyBwYWQgaXMgYWx3YXlzIDAs IHdoaWNoIGluZGVlZCBpcyB0aGUgY2FzZSBmb3IKPiBDTFUsIExJRiBhbmQgTFVUIGVudGl0aWVz Lgo+IAo+ID4gKwkJLyogVGhlIG91dHB1dCBmb3JtYXQgY2FuJ3QgYmUgbW9kaWZpZWQuICovCj4g PiArCQlmbXQtPmZvcm1hdCA9ICpmb3JtYXQ7Cj4gPiArCQlnb3RvIGRvbmU7Cj4gPiArCX0KPiA+ ICsKPiA+ICsJLyoKPiA+ICsJICogRGVmYXVsdCB0byB0aGUgZmlyc3QgbWVkaWEgYnVzIGNvZGUg aWYgdGhlIHJlcXVlc3RlZCBmb3JtYXQgaXMgbm90Cj4gPiArCSAqIHN1cHBvcnRlZC4KPiA+ICsJ ICovCj4gPiArCWZvciAoaSA9IDA7IGkgPCBuY29kZXM7ICsraSkgewo+ID4gKwkJaWYgKGZtdC0+ Zm9ybWF0LmNvZGUgPT0gY29kZXNbaV0pCj4gPiArCQkJYnJlYWs7Cj4gPiArCX0KPiAKPiBCcmFj ZXMgbm90IG5lZWRlZD8KCk5vdCBzdHJpY3RseSByZXF1aXJlZCBidXQgSSBmaW5kIGl0IG1vcmUg cmVhZGFibGUuCgo+ID4gKwo+ID4gKwlmb3JtYXQtPmNvZGUgPSBpIDwgbmNvZGVzID8gY29kZXNb aV0gOiBjb2Rlc1swXTsKPiA+ICsJZm9ybWF0LT53aWR0aCA9IGNsYW1wX3QodW5zaWduZWQgaW50 LCBmbXQtPmZvcm1hdC53aWR0aCwKPiA+ICsJCQkJbWluX3dpZHRoLCBtYXhfd2lkdGgpOwo+ID4g Kwlmb3JtYXQtPmhlaWdodCA9IGNsYW1wX3QodW5zaWduZWQgaW50LCBmbXQtPmZvcm1hdC5oZWln aHQsCj4gPiArCQkJCSBtaW5faGVpZ2h0LCBtYXhfaGVpZ2h0KTsKPiA+ICsJZm9ybWF0LT5maWVs ZCA9IFY0TDJfRklFTERfTk9ORTsKPiA+ICsJZm9ybWF0LT5jb2xvcnNwYWNlID0gVjRMMl9DT0xP UlNQQUNFX1NSR0I7Cj4gPiArCj4gPiArCWZtdC0+Zm9ybWF0ID0gKmZvcm1hdDsKPiA+ICsKPiA+ ICsJLyogUHJvcGFnYXRlIHRoZSBmb3JtYXQgdG8gdGhlIHNvdXJjZSBwYWQuICovCj4gPiArCWZv cm1hdCA9IHZzcDFfZW50aXR5X2dldF9wYWRfZm9ybWF0KGVudGl0eSwgY29uZmlnLCAxKTsKPiA+ ICsJKmZvcm1hdCA9IGZtdC0+Zm9ybWF0Owo+ID4gKwo+ID4gK2RvbmU6Cj4gPiArCW11dGV4X3Vu bG9jaygmZW50aXR5LT5sb2NrKTsKPiA+ICsJcmV0dXJuIHJldDsKPiA+ICt9Cgpbc25pcF0KCi0t IApSZWdhcmRzLAoKTGF1cmVudCBQaW5jaGFydAoKCgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBs aXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1h bi9saXN0aW5mby9kcmktZGV2ZWwK