From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from perceval.ideasonboard.com ([213.167.242.64]:46480 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753782AbeDVWe0 (ORCPT ); Sun, 22 Apr 2018 18:34:26 -0400 From: Laurent Pinchart To: linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org Cc: linux-renesas-soc@vger.kernel.org, Kieran Bingham Subject: [PATCH v2 2/8] v4l: vsp1: Share the CLU, LIF and LUT set_fmt pad operation code Date: Mon, 23 Apr 2018 01:34:24 +0300 Message-Id: <20180422223430.16407-3-laurent.pinchart+renesas@ideasonboard.com> In-Reply-To: <20180422223430.16407-1-laurent.pinchart+renesas@ideasonboard.com> References: <20180422223430.16407-1-laurent.pinchart+renesas@ideasonboard.com> Sender: linux-media-owner@vger.kernel.org List-ID: 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; - - 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) { + /* 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; + } + + 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; +} + /* ----------------------------------------------------------------------------- * Media Operations */ diff --git a/drivers/media/platform/vsp1/vsp1_entity.h b/drivers/media/platform/vsp1/vsp1_entity.h index fb20a1578f3b..0839a62cfa71 100644 --- a/drivers/media/platform/vsp1/vsp1_entity.h +++ b/drivers/media/platform/vsp1/vsp1_entity.h @@ -160,6 +160,12 @@ struct media_pad *vsp1_entity_remote_pad(struct media_pad *pad); int vsp1_subdev_get_pad_format(struct v4l2_subdev *subdev, struct v4l2_subdev_pad_config *cfg, struct v4l2_subdev_format *fmt); +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); int vsp1_subdev_enum_mbus_code(struct v4l2_subdev *subdev, struct v4l2_subdev_pad_config *cfg, struct v4l2_subdev_mbus_code_enum *code, diff --git a/drivers/media/platform/vsp1/vsp1_lif.c b/drivers/media/platform/vsp1/vsp1_lif.c index b20b842f06ba..fbdd5715f829 100644 --- a/drivers/media/platform/vsp1/vsp1_lif.c +++ b/drivers/media/platform/vsp1/vsp1_lif.c @@ -33,17 +33,17 @@ static inline void vsp1_lif_write(struct vsp1_lif *lif, struct vsp1_dl_list *dl, * V4L2 Subdevice Operations */ +static const unsigned int lif_codes[] = { + MEDIA_BUS_FMT_ARGB8888_1X32, + MEDIA_BUS_FMT_AYUV8_1X32, +}; + static int lif_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_AYUV8_1X32, - }; - - return vsp1_subdev_enum_mbus_code(subdev, cfg, code, codes, - ARRAY_SIZE(codes)); + return vsp1_subdev_enum_mbus_code(subdev, cfg, code, lif_codes, + ARRAY_SIZE(lif_codes)); } static int lif_enum_frame_size(struct v4l2_subdev *subdev, @@ -59,53 +59,10 @@ static int lif_set_format(struct v4l2_subdev *subdev, struct v4l2_subdev_pad_config *cfg, struct v4l2_subdev_format *fmt) { - struct vsp1_lif *lif = to_lif(subdev); - struct v4l2_subdev_pad_config *config; - struct v4l2_mbus_framefmt *format; - int ret = 0; - - mutex_lock(&lif->entity.lock); - - config = vsp1_entity_get_pad_config(&lif->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_AYUV8_1X32) - fmt->format.code = MEDIA_BUS_FMT_AYUV8_1X32; - - format = vsp1_entity_get_pad_format(&lif->entity, config, fmt->pad); - - if (fmt->pad == LIF_PAD_SOURCE) { - /* - * The LIF source format is always identical to its sink - * format. - */ - fmt->format = *format; - goto done; - } - - format->code = fmt->format.code; - format->width = clamp_t(unsigned int, fmt->format.width, - LIF_MIN_SIZE, LIF_MAX_SIZE); - format->height = clamp_t(unsigned int, fmt->format.height, - LIF_MIN_SIZE, LIF_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(&lif->entity, config, - LIF_PAD_SOURCE); - *format = fmt->format; - -done: - mutex_unlock(&lif->entity.lock); - return ret; + return vsp1_subdev_set_pad_format(subdev, cfg, fmt, lif_codes, + ARRAY_SIZE(lif_codes), + LIF_MIN_SIZE, LIF_MIN_SIZE, + LIF_MAX_SIZE, LIF_MAX_SIZE); } static const struct v4l2_subdev_pad_ops lif_pad_ops = { diff --git a/drivers/media/platform/vsp1/vsp1_lut.c b/drivers/media/platform/vsp1/vsp1_lut.c index 7bdabb311c6c..f2e48a02ca7d 100644 --- a/drivers/media/platform/vsp1/vsp1_lut.c +++ b/drivers/media/platform/vsp1/vsp1_lut.c @@ -90,18 +90,18 @@ static const struct v4l2_ctrl_config lut_table_control = { * V4L2 Subdevice Pad Operations */ +static const unsigned int lut_codes[] = { + MEDIA_BUS_FMT_ARGB8888_1X32, + MEDIA_BUS_FMT_AHSV8888_1X32, + MEDIA_BUS_FMT_AYUV8_1X32, +}; + static int lut_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, lut_codes, + ARRAY_SIZE(lut_codes)); } static int lut_enum_frame_size(struct v4l2_subdev *subdev, @@ -117,51 +117,10 @@ static int lut_set_format(struct v4l2_subdev *subdev, struct v4l2_subdev_pad_config *cfg, struct v4l2_subdev_format *fmt) { - struct vsp1_lut *lut = to_lut(subdev); - struct v4l2_subdev_pad_config *config; - struct v4l2_mbus_framefmt *format; - int ret = 0; - - mutex_lock(&lut->entity.lock); - - config = vsp1_entity_get_pad_config(&lut->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; - - format = vsp1_entity_get_pad_format(&lut->entity, config, fmt->pad); - - if (fmt->pad == LUT_PAD_SOURCE) { - /* The LUT 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, - LUT_MIN_SIZE, LUT_MAX_SIZE); - format->height = clamp_t(unsigned int, fmt->format.height, - LUT_MIN_SIZE, LUT_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(&lut->entity, config, - LUT_PAD_SOURCE); - *format = fmt->format; - -done: - mutex_unlock(&lut->entity.lock); - return ret; + return vsp1_subdev_set_pad_format(subdev, cfg, fmt, lut_codes, + ARRAY_SIZE(lut_codes), + LUT_MIN_SIZE, LUT_MIN_SIZE, + LUT_MAX_SIZE, LUT_MAX_SIZE); } /* ----------------------------------------------------------------------------- -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: [PATCH v2 2/8] v4l: vsp1: Share the CLU, LIF and LUT set_fmt pad operation code Date: Mon, 23 Apr 2018 01:34:24 +0300 Message-ID: <20180422223430.16407-3-laurent.pinchart+renesas@ideasonboard.com> References: <20180422223430.16407-1-laurent.pinchart+renesas@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 EDC406E06C for ; Sun, 22 Apr 2018 22:34:28 +0000 (UTC) In-Reply-To: <20180422223430.16407-1-laurent.pinchart+renesas@ideasonboard.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org Cc: linux-renesas-soc@vger.kernel.org, Kieran Bingham List-Id: dri-devel@lists.freedesktop.org VGhlIGltcGxlbWVudGF0aW9uIG9mIHRoZSBzZXRfZm10IHBhZCBvcGVyYXRpb24gaXMgaWRlbnRp Y2FsIGluIHRoZQp0aHJlZSBtb2R1bGVzLiBNb3ZlIGl0IHRvIGEgZ2VuZXJpYyBoZWxwZXIgZnVu Y3Rpb24uCgpTaWduZWQtb2ZmLWJ5OiBMYXVyZW50IFBpbmNoYXJ0IDxsYXVyZW50LnBpbmNoYXJ0 K3JlbmVzYXNAaWRlYXNvbmJvYXJkLmNvbT4KLS0tCiBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3Zz cDEvdnNwMV9jbHUuYyAgICB8IDY1ICsrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVy cy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZW50aXR5LmMgfCA3NSArKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrCiBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9lbnRpdHku aCB8ICA2ICsrKwogZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfbGlmLmMgICAgfCA2 NSArKysrKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNw MS92c3AxX2x1dC5jICAgIHwgNjUgKysrKystLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiA1IGZpbGVz IGNoYW5nZWQsIDExNiBpbnNlcnRpb25zKCspLCAxNjAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfY2x1LmMgYi9kcml2ZXJzL21lZGlh L3BsYXRmb3JtL3ZzcDEvdnNwMV9jbHUuYwppbmRleCA5NjI2YjYzMDg1ODUuLjk2YTQ0OGUxNTA0 YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfY2x1LmMKKysr IGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfY2x1LmMKQEAgLTExNCwxOCArMTE0 LDE4IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgdjRsMl9jdHJsX2NvbmZpZyBjbHVfbW9kZV9jb250 cm9sID0gewogICogVjRMMiBTdWJkZXZpY2UgUGFkIE9wZXJhdGlvbnMKICAqLwogCitzdGF0aWMg Y29uc3QgdW5zaWduZWQgaW50IGNsdV9jb2Rlc1tdID0geworCU1FRElBX0JVU19GTVRfQVJHQjg4 ODhfMVgzMiwKKwlNRURJQV9CVVNfRk1UX0FIU1Y4ODg4XzFYMzIsCisJTUVESUFfQlVTX0ZNVF9B WVVWOF8xWDMyLAorfTsKKwogc3RhdGljIGludCBjbHVfZW51bV9tYnVzX2NvZGUoc3RydWN0IHY0 bDJfc3ViZGV2ICpzdWJkZXYsCiAJCQkgICAgICBzdHJ1Y3QgdjRsMl9zdWJkZXZfcGFkX2NvbmZp ZyAqY2ZnLAogCQkJICAgICAgc3RydWN0IHY0bDJfc3ViZGV2X21idXNfY29kZV9lbnVtICpjb2Rl KQogewotCXN0YXRpYyBjb25zdCB1bnNpZ25lZCBpbnQgY29kZXNbXSA9IHsKLQkJTUVESUFfQlVT X0ZNVF9BUkdCODg4OF8xWDMyLAotCQlNRURJQV9CVVNfRk1UX0FIU1Y4ODg4XzFYMzIsCi0JCU1F RElBX0JVU19GTVRfQVlVVjhfMVgzMiwKLQl9OwotCi0JcmV0dXJuIHZzcDFfc3ViZGV2X2VudW1f bWJ1c19jb2RlKHN1YmRldiwgY2ZnLCBjb2RlLCBjb2RlcywKLQkJCQkJICBBUlJBWV9TSVpFKGNv ZGVzKSk7CisJcmV0dXJuIHZzcDFfc3ViZGV2X2VudW1fbWJ1c19jb2RlKHN1YmRldiwgY2ZnLCBj b2RlLCBjbHVfY29kZXMsCisJCQkJCSAgQVJSQVlfU0laRShjbHVfY29kZXMpKTsKIH0KIAogc3Rh dGljIGludCBjbHVfZW51bV9mcmFtZV9zaXplKHN0cnVjdCB2NGwyX3N1YmRldiAqc3ViZGV2LApA QCAtMTQxLDUxICsxNDEsMTAgQEAgc3RhdGljIGludCBjbHVfc2V0X2Zvcm1hdChzdHJ1Y3QgdjRs Ml9zdWJkZXYgKnN1YmRldiwKIAkJCSAgc3RydWN0IHY0bDJfc3ViZGV2X3BhZF9jb25maWcgKmNm ZywKIAkJCSAgc3RydWN0IHY0bDJfc3ViZGV2X2Zvcm1hdCAqZm10KQogewotCXN0cnVjdCB2c3Ax X2NsdSAqY2x1ID0gdG9fY2x1KHN1YmRldik7Ci0Jc3RydWN0IHY0bDJfc3ViZGV2X3BhZF9jb25m aWcgKmNvbmZpZzsKLQlzdHJ1Y3QgdjRsMl9tYnVzX2ZyYW1lZm10ICpmb3JtYXQ7Ci0JaW50IHJl dCA9IDA7Ci0KLQltdXRleF9sb2NrKCZjbHUtPmVudGl0eS5sb2NrKTsKLQotCWNvbmZpZyA9IHZz cDFfZW50aXR5X2dldF9wYWRfY29uZmlnKCZjbHUtPmVudGl0eSwgY2ZnLCBmbXQtPndoaWNoKTsK LQlpZiAoIWNvbmZpZykgewotCQlyZXQgPSAtRUlOVkFMOwotCQlnb3RvIGRvbmU7Ci0JfQotCi0J LyogRGVmYXVsdCB0byBZVVYgaWYgdGhlIHJlcXVlc3RlZCBmb3JtYXQgaXMgbm90IHN1cHBvcnRl ZC4gKi8KLQlpZiAoZm10LT5mb3JtYXQuY29kZSAhPSBNRURJQV9CVVNfRk1UX0FSR0I4ODg4XzFY MzIgJiYKLQkgICAgZm10LT5mb3JtYXQuY29kZSAhPSBNRURJQV9CVVNfRk1UX0FIU1Y4ODg4XzFY MzIgJiYKLQkgICAgZm10LT5mb3JtYXQuY29kZSAhPSBNRURJQV9CVVNfRk1UX0FZVVY4XzFYMzIp Ci0JCWZtdC0+Zm9ybWF0LmNvZGUgPSBNRURJQV9CVVNfRk1UX0FZVVY4XzFYMzI7Ci0KLQlmb3Jt YXQgPSB2c3AxX2VudGl0eV9nZXRfcGFkX2Zvcm1hdCgmY2x1LT5lbnRpdHksIGNvbmZpZywgZm10 LT5wYWQpOwotCi0JaWYgKGZtdC0+cGFkID09IENMVV9QQURfU09VUkNFKSB7Ci0JCS8qIFRoZSBD TFUgb3V0cHV0IGZvcm1hdCBjYW4ndCBiZSBtb2RpZmllZC4gKi8KLQkJZm10LT5mb3JtYXQgPSAq Zm9ybWF0OwotCQlnb3RvIGRvbmU7Ci0JfQotCi0JZm9ybWF0LT5jb2RlID0gZm10LT5mb3JtYXQu Y29kZTsKLQlmb3JtYXQtPndpZHRoID0gY2xhbXBfdCh1bnNpZ25lZCBpbnQsIGZtdC0+Zm9ybWF0 LndpZHRoLAotCQkJCUNMVV9NSU5fU0laRSwgQ0xVX01BWF9TSVpFKTsKLQlmb3JtYXQtPmhlaWdo dCA9IGNsYW1wX3QodW5zaWduZWQgaW50LCBmbXQtPmZvcm1hdC5oZWlnaHQsCi0JCQkJIENMVV9N SU5fU0laRSwgQ0xVX01BWF9TSVpFKTsKLQlmb3JtYXQtPmZpZWxkID0gVjRMMl9GSUVMRF9OT05F OwotCWZvcm1hdC0+Y29sb3JzcGFjZSA9IFY0TDJfQ09MT1JTUEFDRV9TUkdCOwotCi0JZm10LT5m b3JtYXQgPSAqZm9ybWF0OwotCi0JLyogUHJvcGFnYXRlIHRoZSBmb3JtYXQgdG8gdGhlIHNvdXJj ZSBwYWQuICovCi0JZm9ybWF0ID0gdnNwMV9lbnRpdHlfZ2V0X3BhZF9mb3JtYXQoJmNsdS0+ZW50 aXR5LCBjb25maWcsCi0JCQkJCSAgICBDTFVfUEFEX1NPVVJDRSk7Ci0JKmZvcm1hdCA9IGZtdC0+ Zm9ybWF0OwotCi1kb25lOgotCW11dGV4X3VubG9jaygmY2x1LT5lbnRpdHkubG9jayk7Ci0JcmV0 dXJuIHJldDsKKwlyZXR1cm4gdnNwMV9zdWJkZXZfc2V0X3BhZF9mb3JtYXQoc3ViZGV2LCBjZmcs IGZtdCwgY2x1X2NvZGVzLAorCQkJCQkgIEFSUkFZX1NJWkUoY2x1X2NvZGVzKSwKKwkJCQkJICBD TFVfTUlOX1NJWkUsIENMVV9NSU5fU0laRSwKKwkJCQkJICBDTFVfTUFYX1NJWkUsIENMVV9NQVhf U0laRSk7CiB9CiAKIC8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCmRpZmYgLS1naXQgYS9kcml2ZXJz L21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9lbnRpdHkuYyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZv cm0vdnNwMS92c3AxX2VudGl0eS5jCmluZGV4IDcyMzU0Y2FmNTc0Ni4uMjM5ZGYwNDdlZmQwIDEw MDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9lbnRpdHkuYworKysg Yi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9lbnRpdHkuYwpAQCAtMzA3LDYgKzMw Nyw4MSBAQCBpbnQgdnNwMV9zdWJkZXZfZW51bV9mcmFtZV9zaXplKHN0cnVjdCB2NGwyX3N1YmRl diAqc3ViZGV2LAogCXJldHVybiByZXQ7CiB9CiAKKy8qCisgKiB2c3AxX3N1YmRldl9zZXRfcGFk X2Zvcm1hdCAtIFN1YmRldiBwYWQgc2V0X2ZtdCBoYW5kbGVyCisgKiBAc3ViZGV2OiBWNEwyIHN1 YmRldmljZQorICogQGNmZzogVjRMMiBzdWJkZXYgcGFkIGNvbmZpZ3VyYXRpb24KKyAqIEBmbXQ6 IFY0TDIgc3ViZGV2IGZvcm1hdAorICogQGNvZGVzOiBBcnJheSBvZiBzdXBwb3J0ZWQgbWVkaWEg YnVzIGNvZGVzCisgKiBAbmNvZGVzOiBOdW1iZXIgb2Ygc3VwcG9ydGVkIG1lZGlhIGJ1cyBjb2Rl cworICogQG1pbl93aWR0aDogTWluaW11bSBpbWFnZSB3aWR0aAorICogQG1pbl9oZWlnaHQ6IE1p bmltdW0gaW1hZ2UgaGVpZ2h0CisgKiBAbWF4X3dpZHRoOiBNYXhpbXVtIGltYWdlIHdpZHRoCisg KiBAbWF4X2hlaWdodDogTWF4aW11bSBpbWFnZSBoZWlnaHQKKyAqCisgKiBUaGlzIGZ1bmN0aW9u IGltcGxlbWVudHMgdGhlIHN1YmRldiBzZXRfZm10IHBhZCBvcGVyYXRpb24gZm9yIGVudGl0aWVz IHRoYXQKKyAqIGRvIG5vdCBzdXBwb3J0IHNjYWxpbmcgb3IgY3JvcHBpbmcuIEl0IGRlZmF1bHRz IHRvIHRoZSBmaXJzdCBzdXBwbGllZCBtZWRpYQorICogYnVzIGNvZGUgaWYgdGhlIHJlcXVlc3Rl ZCBjb2RlIGlzbid0IHN1cHBvcnRlZCwgY2xhbXBzIHRoZSBzaXplIHRvIHRoZQorICogc3VwcGxp ZWQgbWluaW11bSBhbmQgbWF4aW11bSwgYW5kIHByb3BhZ2F0ZXMgdGhlIHNpbmsgcGFkIGZvcm1h dCB0byB0aGUKKyAqIHNvdXJjZSBwYWQuCisgKi8KK2ludCB2c3AxX3N1YmRldl9zZXRfcGFkX2Zv cm1hdChzdHJ1Y3QgdjRsMl9zdWJkZXYgKnN1YmRldiwKKwkJCSAgICAgICBzdHJ1Y3QgdjRsMl9z dWJkZXZfcGFkX2NvbmZpZyAqY2ZnLAorCQkJICAgICAgIHN0cnVjdCB2NGwyX3N1YmRldl9mb3Jt YXQgKmZtdCwKKwkJCSAgICAgICBjb25zdCB1bnNpZ25lZCBpbnQgKmNvZGVzLCB1bnNpZ25lZCBp bnQgbmNvZGVzLAorCQkJICAgICAgIHVuc2lnbmVkIGludCBtaW5fd2lkdGgsIHVuc2lnbmVkIGlu dCBtaW5faGVpZ2h0LAorCQkJICAgICAgIHVuc2lnbmVkIGludCBtYXhfd2lkdGgsIHVuc2lnbmVk IGludCBtYXhfaGVpZ2h0KQoreworCXN0cnVjdCB2c3AxX2VudGl0eSAqZW50aXR5ID0gdG9fdnNw MV9lbnRpdHkoc3ViZGV2KTsKKwlzdHJ1Y3QgdjRsMl9zdWJkZXZfcGFkX2NvbmZpZyAqY29uZmln OworCXN0cnVjdCB2NGwyX21idXNfZnJhbWVmbXQgKmZvcm1hdDsKKwl1bnNpZ25lZCBpbnQgaTsK KwlpbnQgcmV0ID0gMDsKKworCW11dGV4X2xvY2soJmVudGl0eS0+bG9jayk7CisKKwljb25maWcg PSB2c3AxX2VudGl0eV9nZXRfcGFkX2NvbmZpZyhlbnRpdHksIGNmZywgZm10LT53aGljaCk7CisJ aWYgKCFjb25maWcpIHsKKwkJcmV0ID0gLUVJTlZBTDsKKwkJZ290byBkb25lOworCX0KKworCWZv cm1hdCA9IHZzcDFfZW50aXR5X2dldF9wYWRfZm9ybWF0KGVudGl0eSwgY29uZmlnLCBmbXQtPnBh ZCk7CisKKwlpZiAoZm10LT5wYWQgIT0gMCkgeworCQkvKiBUaGUgb3V0cHV0IGZvcm1hdCBjYW4n dCBiZSBtb2RpZmllZC4gKi8KKwkJZm10LT5mb3JtYXQgPSAqZm9ybWF0OworCQlnb3RvIGRvbmU7 CisJfQorCisJLyoKKwkgKiBEZWZhdWx0IHRvIHRoZSBmaXJzdCBtZWRpYSBidXMgY29kZSBpZiB0 aGUgcmVxdWVzdGVkIGZvcm1hdCBpcyBub3QKKwkgKiBzdXBwb3J0ZWQuCisJICovCisJZm9yIChp ID0gMDsgaSA8IG5jb2RlczsgKytpKSB7CisJCWlmIChmbXQtPmZvcm1hdC5jb2RlID09IGNvZGVz W2ldKQorCQkJYnJlYWs7CisJfQorCisJZm9ybWF0LT5jb2RlID0gaSA8IG5jb2RlcyA/IGNvZGVz W2ldIDogY29kZXNbMF07CisJZm9ybWF0LT53aWR0aCA9IGNsYW1wX3QodW5zaWduZWQgaW50LCBm bXQtPmZvcm1hdC53aWR0aCwKKwkJCQltaW5fd2lkdGgsIG1heF93aWR0aCk7CisJZm9ybWF0LT5o ZWlnaHQgPSBjbGFtcF90KHVuc2lnbmVkIGludCwgZm10LT5mb3JtYXQuaGVpZ2h0LAorCQkJCSBt aW5faGVpZ2h0LCBtYXhfaGVpZ2h0KTsKKwlmb3JtYXQtPmZpZWxkID0gVjRMMl9GSUVMRF9OT05F OworCWZvcm1hdC0+Y29sb3JzcGFjZSA9IFY0TDJfQ09MT1JTUEFDRV9TUkdCOworCisJZm10LT5m b3JtYXQgPSAqZm9ybWF0OworCisJLyogUHJvcGFnYXRlIHRoZSBmb3JtYXQgdG8gdGhlIHNvdXJj ZSBwYWQuICovCisJZm9ybWF0ID0gdnNwMV9lbnRpdHlfZ2V0X3BhZF9mb3JtYXQoZW50aXR5LCBj b25maWcsIDEpOworCSpmb3JtYXQgPSBmbXQtPmZvcm1hdDsKKworZG9uZToKKwltdXRleF91bmxv Y2soJmVudGl0eS0+bG9jayk7CisJcmV0dXJuIHJldDsKK30KKwogLyogLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0KICAqIE1lZGlhIE9wZXJhdGlvbnMKICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRp YS9wbGF0Zm9ybS92c3AxL3ZzcDFfZW50aXR5LmggYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3Zz cDEvdnNwMV9lbnRpdHkuaAppbmRleCBmYjIwYTE1NzhmM2IuLjA4MzlhNjJjZmE3MSAxMDA2NDQK LS0tIGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZW50aXR5LmgKKysrIGIvZHJp dmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZW50aXR5LmgKQEAgLTE2MCw2ICsxNjAsMTIg QEAgc3RydWN0IG1lZGlhX3BhZCAqdnNwMV9lbnRpdHlfcmVtb3RlX3BhZChzdHJ1Y3QgbWVkaWFf cGFkICpwYWQpOwogaW50IHZzcDFfc3ViZGV2X2dldF9wYWRfZm9ybWF0KHN0cnVjdCB2NGwyX3N1 YmRldiAqc3ViZGV2LAogCQkJICAgICAgIHN0cnVjdCB2NGwyX3N1YmRldl9wYWRfY29uZmlnICpj ZmcsCiAJCQkgICAgICAgc3RydWN0IHY0bDJfc3ViZGV2X2Zvcm1hdCAqZm10KTsKK2ludCB2c3Ax X3N1YmRldl9zZXRfcGFkX2Zvcm1hdChzdHJ1Y3QgdjRsMl9zdWJkZXYgKnN1YmRldiwKKwkJCSAg ICAgICBzdHJ1Y3QgdjRsMl9zdWJkZXZfcGFkX2NvbmZpZyAqY2ZnLAorCQkJICAgICAgIHN0cnVj dCB2NGwyX3N1YmRldl9mb3JtYXQgKmZtdCwKKwkJCSAgICAgICBjb25zdCB1bnNpZ25lZCBpbnQg KmNvZGVzLCB1bnNpZ25lZCBpbnQgbmNvZGVzLAorCQkJICAgICAgIHVuc2lnbmVkIGludCBtaW5f d2lkdGgsIHVuc2lnbmVkIGludCBtaW5faGVpZ2h0LAorCQkJICAgICAgIHVuc2lnbmVkIGludCBt YXhfd2lkdGgsIHVuc2lnbmVkIGludCBtYXhfaGVpZ2h0KTsKIGludCB2c3AxX3N1YmRldl9lbnVt X21idXNfY29kZShzdHJ1Y3QgdjRsMl9zdWJkZXYgKnN1YmRldiwKIAkJCSAgICAgICBzdHJ1Y3Qg djRsMl9zdWJkZXZfcGFkX2NvbmZpZyAqY2ZnLAogCQkJICAgICAgIHN0cnVjdCB2NGwyX3N1YmRl dl9tYnVzX2NvZGVfZW51bSAqY29kZSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZv cm0vdnNwMS92c3AxX2xpZi5jIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfbGlm LmMKaW5kZXggYjIwYjg0MmYwNmJhLi5mYmRkNTcxNWY4MjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv bWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2xpZi5jCisrKyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZv cm0vdnNwMS92c3AxX2xpZi5jCkBAIC0zMywxNyArMzMsMTcgQEAgc3RhdGljIGlubGluZSB2b2lk IHZzcDFfbGlmX3dyaXRlKHN0cnVjdCB2c3AxX2xpZiAqbGlmLCBzdHJ1Y3QgdnNwMV9kbF9saXN0 ICpkbCwKICAqIFY0TDIgU3ViZGV2aWNlIE9wZXJhdGlvbnMKICAqLwogCitzdGF0aWMgY29uc3Qg dW5zaWduZWQgaW50IGxpZl9jb2Rlc1tdID0geworCU1FRElBX0JVU19GTVRfQVJHQjg4ODhfMVgz MiwKKwlNRURJQV9CVVNfRk1UX0FZVVY4XzFYMzIsCit9OworCiBzdGF0aWMgaW50IGxpZl9lbnVt X21idXNfY29kZShzdHJ1Y3QgdjRsMl9zdWJkZXYgKnN1YmRldiwKIAkJCSAgICAgIHN0cnVjdCB2 NGwyX3N1YmRldl9wYWRfY29uZmlnICpjZmcsCiAJCQkgICAgICBzdHJ1Y3QgdjRsMl9zdWJkZXZf bWJ1c19jb2RlX2VudW0gKmNvZGUpCiB7Ci0Jc3RhdGljIGNvbnN0IHVuc2lnbmVkIGludCBjb2Rl c1tdID0gewotCQlNRURJQV9CVVNfRk1UX0FSR0I4ODg4XzFYMzIsCi0JCU1FRElBX0JVU19GTVRf QVlVVjhfMVgzMiwKLQl9OwotCi0JcmV0dXJuIHZzcDFfc3ViZGV2X2VudW1fbWJ1c19jb2RlKHN1 YmRldiwgY2ZnLCBjb2RlLCBjb2RlcywKLQkJCQkJICBBUlJBWV9TSVpFKGNvZGVzKSk7CisJcmV0 dXJuIHZzcDFfc3ViZGV2X2VudW1fbWJ1c19jb2RlKHN1YmRldiwgY2ZnLCBjb2RlLCBsaWZfY29k ZXMsCisJCQkJCSAgQVJSQVlfU0laRShsaWZfY29kZXMpKTsKIH0KIAogc3RhdGljIGludCBsaWZf ZW51bV9mcmFtZV9zaXplKHN0cnVjdCB2NGwyX3N1YmRldiAqc3ViZGV2LApAQCAtNTksNTMgKzU5 LDEwIEBAIHN0YXRpYyBpbnQgbGlmX3NldF9mb3JtYXQoc3RydWN0IHY0bDJfc3ViZGV2ICpzdWJk ZXYsCiAJCQkgIHN0cnVjdCB2NGwyX3N1YmRldl9wYWRfY29uZmlnICpjZmcsCiAJCQkgIHN0cnVj dCB2NGwyX3N1YmRldl9mb3JtYXQgKmZtdCkKIHsKLQlzdHJ1Y3QgdnNwMV9saWYgKmxpZiA9IHRv X2xpZihzdWJkZXYpOwotCXN0cnVjdCB2NGwyX3N1YmRldl9wYWRfY29uZmlnICpjb25maWc7Ci0J c3RydWN0IHY0bDJfbWJ1c19mcmFtZWZtdCAqZm9ybWF0OwotCWludCByZXQgPSAwOwotCi0JbXV0 ZXhfbG9jaygmbGlmLT5lbnRpdHkubG9jayk7Ci0KLQljb25maWcgPSB2c3AxX2VudGl0eV9nZXRf cGFkX2NvbmZpZygmbGlmLT5lbnRpdHksIGNmZywgZm10LT53aGljaCk7Ci0JaWYgKCFjb25maWcp IHsKLQkJcmV0ID0gLUVJTlZBTDsKLQkJZ290byBkb25lOwotCX0KLQotCS8qIERlZmF1bHQgdG8g WVVWIGlmIHRoZSByZXF1ZXN0ZWQgZm9ybWF0IGlzIG5vdCBzdXBwb3J0ZWQuICovCi0JaWYgKGZt dC0+Zm9ybWF0LmNvZGUgIT0gTUVESUFfQlVTX0ZNVF9BUkdCODg4OF8xWDMyICYmCi0JICAgIGZt dC0+Zm9ybWF0LmNvZGUgIT0gTUVESUFfQlVTX0ZNVF9BWVVWOF8xWDMyKQotCQlmbXQtPmZvcm1h dC5jb2RlID0gTUVESUFfQlVTX0ZNVF9BWVVWOF8xWDMyOwotCi0JZm9ybWF0ID0gdnNwMV9lbnRp dHlfZ2V0X3BhZF9mb3JtYXQoJmxpZi0+ZW50aXR5LCBjb25maWcsIGZtdC0+cGFkKTsKLQotCWlm IChmbXQtPnBhZCA9PSBMSUZfUEFEX1NPVVJDRSkgewotCQkvKgotCQkgKiBUaGUgTElGIHNvdXJj ZSBmb3JtYXQgaXMgYWx3YXlzIGlkZW50aWNhbCB0byBpdHMgc2luawotCQkgKiBmb3JtYXQuCi0J CSAqLwotCQlmbXQtPmZvcm1hdCA9ICpmb3JtYXQ7Ci0JCWdvdG8gZG9uZTsKLQl9Ci0KLQlmb3Jt YXQtPmNvZGUgPSBmbXQtPmZvcm1hdC5jb2RlOwotCWZvcm1hdC0+d2lkdGggPSBjbGFtcF90KHVu c2lnbmVkIGludCwgZm10LT5mb3JtYXQud2lkdGgsCi0JCQkJTElGX01JTl9TSVpFLCBMSUZfTUFY X1NJWkUpOwotCWZvcm1hdC0+aGVpZ2h0ID0gY2xhbXBfdCh1bnNpZ25lZCBpbnQsIGZtdC0+Zm9y bWF0LmhlaWdodCwKLQkJCQkgTElGX01JTl9TSVpFLCBMSUZfTUFYX1NJWkUpOwotCWZvcm1hdC0+ ZmllbGQgPSBWNEwyX0ZJRUxEX05PTkU7Ci0JZm9ybWF0LT5jb2xvcnNwYWNlID0gVjRMMl9DT0xP UlNQQUNFX1NSR0I7Ci0KLQlmbXQtPmZvcm1hdCA9ICpmb3JtYXQ7Ci0KLQkvKiBQcm9wYWdhdGUg dGhlIGZvcm1hdCB0byB0aGUgc291cmNlIHBhZC4gKi8KLQlmb3JtYXQgPSB2c3AxX2VudGl0eV9n ZXRfcGFkX2Zvcm1hdCgmbGlmLT5lbnRpdHksIGNvbmZpZywKLQkJCQkJICAgIExJRl9QQURfU09V UkNFKTsKLQkqZm9ybWF0ID0gZm10LT5mb3JtYXQ7Ci0KLWRvbmU6Ci0JbXV0ZXhfdW5sb2NrKCZs aWYtPmVudGl0eS5sb2NrKTsKLQlyZXR1cm4gcmV0OworCXJldHVybiB2c3AxX3N1YmRldl9zZXRf cGFkX2Zvcm1hdChzdWJkZXYsIGNmZywgZm10LCBsaWZfY29kZXMsCisJCQkJCSAgQVJSQVlfU0la RShsaWZfY29kZXMpLAorCQkJCQkgIExJRl9NSU5fU0laRSwgTElGX01JTl9TSVpFLAorCQkJCQkg IExJRl9NQVhfU0laRSwgTElGX01BWF9TSVpFKTsKIH0KIAogc3RhdGljIGNvbnN0IHN0cnVjdCB2 NGwyX3N1YmRldl9wYWRfb3BzIGxpZl9wYWRfb3BzID0gewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9t ZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfbHV0LmMgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3Zz cDEvdnNwMV9sdXQuYwppbmRleCA3YmRhYmIzMTFjNmMuLmYyZTQ4YTAyY2E3ZCAxMDA2NDQKLS0t IGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfbHV0LmMKKysrIGIvZHJpdmVycy9t ZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfbHV0LmMKQEAgLTkwLDE4ICs5MCwxOCBAQCBzdGF0aWMg Y29uc3Qgc3RydWN0IHY0bDJfY3RybF9jb25maWcgbHV0X3RhYmxlX2NvbnRyb2wgPSB7CiAgKiBW NEwyIFN1YmRldmljZSBQYWQgT3BlcmF0aW9ucwogICovCiAKK3N0YXRpYyBjb25zdCB1bnNpZ25l ZCBpbnQgbHV0X2NvZGVzW10gPSB7CisJTUVESUFfQlVTX0ZNVF9BUkdCODg4OF8xWDMyLAorCU1F RElBX0JVU19GTVRfQUhTVjg4ODhfMVgzMiwKKwlNRURJQV9CVVNfRk1UX0FZVVY4XzFYMzIsCit9 OworCiBzdGF0aWMgaW50IGx1dF9lbnVtX21idXNfY29kZShzdHJ1Y3QgdjRsMl9zdWJkZXYgKnN1 YmRldiwKIAkJCSAgICAgIHN0cnVjdCB2NGwyX3N1YmRldl9wYWRfY29uZmlnICpjZmcsCiAJCQkg ICAgICBzdHJ1Y3QgdjRsMl9zdWJkZXZfbWJ1c19jb2RlX2VudW0gKmNvZGUpCiB7Ci0Jc3RhdGlj IGNvbnN0IHVuc2lnbmVkIGludCBjb2Rlc1tdID0gewotCQlNRURJQV9CVVNfRk1UX0FSR0I4ODg4 XzFYMzIsCi0JCU1FRElBX0JVU19GTVRfQUhTVjg4ODhfMVgzMiwKLQkJTUVESUFfQlVTX0ZNVF9B WVVWOF8xWDMyLAotCX07Ci0KLQlyZXR1cm4gdnNwMV9zdWJkZXZfZW51bV9tYnVzX2NvZGUoc3Vi ZGV2LCBjZmcsIGNvZGUsIGNvZGVzLAotCQkJCQkgIEFSUkFZX1NJWkUoY29kZXMpKTsKKwlyZXR1 cm4gdnNwMV9zdWJkZXZfZW51bV9tYnVzX2NvZGUoc3ViZGV2LCBjZmcsIGNvZGUsIGx1dF9jb2Rl cywKKwkJCQkJICBBUlJBWV9TSVpFKGx1dF9jb2RlcykpOwogfQogCiBzdGF0aWMgaW50IGx1dF9l bnVtX2ZyYW1lX3NpemUoc3RydWN0IHY0bDJfc3ViZGV2ICpzdWJkZXYsCkBAIC0xMTcsNTEgKzEx NywxMCBAQCBzdGF0aWMgaW50IGx1dF9zZXRfZm9ybWF0KHN0cnVjdCB2NGwyX3N1YmRldiAqc3Vi ZGV2LAogCQkJICBzdHJ1Y3QgdjRsMl9zdWJkZXZfcGFkX2NvbmZpZyAqY2ZnLAogCQkJICBzdHJ1 Y3QgdjRsMl9zdWJkZXZfZm9ybWF0ICpmbXQpCiB7Ci0Jc3RydWN0IHZzcDFfbHV0ICpsdXQgPSB0 b19sdXQoc3ViZGV2KTsKLQlzdHJ1Y3QgdjRsMl9zdWJkZXZfcGFkX2NvbmZpZyAqY29uZmlnOwot CXN0cnVjdCB2NGwyX21idXNfZnJhbWVmbXQgKmZvcm1hdDsKLQlpbnQgcmV0ID0gMDsKLQotCW11 dGV4X2xvY2soJmx1dC0+ZW50aXR5LmxvY2spOwotCi0JY29uZmlnID0gdnNwMV9lbnRpdHlfZ2V0 X3BhZF9jb25maWcoJmx1dC0+ZW50aXR5LCBjZmcsIGZtdC0+d2hpY2gpOwotCWlmICghY29uZmln KSB7Ci0JCXJldCA9IC1FSU5WQUw7Ci0JCWdvdG8gZG9uZTsKLQl9Ci0KLQkvKiBEZWZhdWx0IHRv IFlVViBpZiB0aGUgcmVxdWVzdGVkIGZvcm1hdCBpcyBub3Qgc3VwcG9ydGVkLiAqLwotCWlmIChm bXQtPmZvcm1hdC5jb2RlICE9IE1FRElBX0JVU19GTVRfQVJHQjg4ODhfMVgzMiAmJgotCSAgICBm bXQtPmZvcm1hdC5jb2RlICE9IE1FRElBX0JVU19GTVRfQUhTVjg4ODhfMVgzMiAmJgotCSAgICBm bXQtPmZvcm1hdC5jb2RlICE9IE1FRElBX0JVU19GTVRfQVlVVjhfMVgzMikKLQkJZm10LT5mb3Jt YXQuY29kZSA9IE1FRElBX0JVU19GTVRfQVlVVjhfMVgzMjsKLQotCWZvcm1hdCA9IHZzcDFfZW50 aXR5X2dldF9wYWRfZm9ybWF0KCZsdXQtPmVudGl0eSwgY29uZmlnLCBmbXQtPnBhZCk7Ci0KLQlp ZiAoZm10LT5wYWQgPT0gTFVUX1BBRF9TT1VSQ0UpIHsKLQkJLyogVGhlIExVVCBvdXRwdXQgZm9y bWF0IGNhbid0IGJlIG1vZGlmaWVkLiAqLwotCQlmbXQtPmZvcm1hdCA9ICpmb3JtYXQ7Ci0JCWdv dG8gZG9uZTsKLQl9Ci0KLQlmb3JtYXQtPmNvZGUgPSBmbXQtPmZvcm1hdC5jb2RlOwotCWZvcm1h dC0+d2lkdGggPSBjbGFtcF90KHVuc2lnbmVkIGludCwgZm10LT5mb3JtYXQud2lkdGgsCi0JCQkJ TFVUX01JTl9TSVpFLCBMVVRfTUFYX1NJWkUpOwotCWZvcm1hdC0+aGVpZ2h0ID0gY2xhbXBfdCh1 bnNpZ25lZCBpbnQsIGZtdC0+Zm9ybWF0LmhlaWdodCwKLQkJCQkgTFVUX01JTl9TSVpFLCBMVVRf TUFYX1NJWkUpOwotCWZvcm1hdC0+ZmllbGQgPSBWNEwyX0ZJRUxEX05PTkU7Ci0JZm9ybWF0LT5j b2xvcnNwYWNlID0gVjRMMl9DT0xPUlNQQUNFX1NSR0I7Ci0KLQlmbXQtPmZvcm1hdCA9ICpmb3Jt YXQ7Ci0KLQkvKiBQcm9wYWdhdGUgdGhlIGZvcm1hdCB0byB0aGUgc291cmNlIHBhZC4gKi8KLQlm b3JtYXQgPSB2c3AxX2VudGl0eV9nZXRfcGFkX2Zvcm1hdCgmbHV0LT5lbnRpdHksIGNvbmZpZywK LQkJCQkJICAgIExVVF9QQURfU09VUkNFKTsKLQkqZm9ybWF0ID0gZm10LT5mb3JtYXQ7Ci0KLWRv bmU6Ci0JbXV0ZXhfdW5sb2NrKCZsdXQtPmVudGl0eS5sb2NrKTsKLQlyZXR1cm4gcmV0OworCXJl dHVybiB2c3AxX3N1YmRldl9zZXRfcGFkX2Zvcm1hdChzdWJkZXYsIGNmZywgZm10LCBsdXRfY29k ZXMsCisJCQkJCSAgQVJSQVlfU0laRShsdXRfY29kZXMpLAorCQkJCQkgIExVVF9NSU5fU0laRSwg TFVUX01JTl9TSVpFLAorCQkJCQkgIExVVF9NQVhfU0laRSwgTFVUX01BWF9TSVpFKTsKIH0KIAog LyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLS0gClJlZ2FyZHMsCgpMYXVyZW50IFBpbmNoYXJ0Cgpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwg bWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0 cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK