From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from perceval.ideasonboard.com ([213.167.242.64]:60762 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726791AbeHCAg6 (ORCPT ); Thu, 2 Aug 2018 20:36:58 -0400 From: Laurent Pinchart To: Kieran Bingham Cc: Kieran Bingham , linux-renesas-soc@vger.kernel.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, Kieran Bingham Subject: Re: [PATCH v5 10/11] media: vsp1: Support Interlaced display pipelines Date: Fri, 03 Aug 2018 01:44:21 +0300 Message-ID: <3826962.GFlSaplMp3@avalon> In-Reply-To: <6d3afb327daf3941c84db9e16a4d7b3ba4faedf6.1531857988.git-series.kieran.bingham+renesas@ideasonboard.com> References: <6d3afb327daf3941c84db9e16a4d7b3ba4faedf6.1531857988.git-series.kieran.bingham+renesas@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, Thank you for the patch. On Tuesday, 17 July 2018 23:35:52 EEST Kieran Bingham wrote: > From: Kieran Bingham > > Calculate the top and bottom fields for the interlaced frames and > utilise the extended display list command feature to implement the > auto-field operations. This allows the DU to update the VSP2 registers > dynamically based upon the currently processing field. > > Signed-off-by: Kieran Bingham > > --- > > v2: > - fix erroneous BIT value which enabled interlaced > - fix field handling at frame_end interrupt > > v3: > - Pass DL through partition calls to allow autocmd's to be retrieved > - Document interlaced field in struct vsp1_du_atomic_config > > v5: > - Obtain autofld cmd in vsp1_rpf_configure_autofld() > - Move VSP1_DL_EXT_AUTOFLD_INT to vsp1_regs.h > - Rename VSP1_DL_EXT_AUTOFLD_INT -> VI6_DL_EXT_AUTOFLD_INT > - move interlaced configuration parameter to pipe object > - autofld: Set cmd->flags in one single expression. > > drivers/media/platform/vsp1/vsp1_dl.c | 10 ++++- > drivers/media/platform/vsp1/vsp1_drm.c | 16 +++++- > drivers/media/platform/vsp1/vsp1_pipe.h | 2 +- > drivers/media/platform/vsp1/vsp1_regs.h | 3 +- > drivers/media/platform/vsp1/vsp1_rpf.c | 72 ++++++++++++++++++++++++-- > include/media/vsp1.h | 2 +- > 6 files changed, 100 insertions(+), 5 deletions(-) > > diff --git a/drivers/media/platform/vsp1/vsp1_dl.c > b/drivers/media/platform/vsp1/vsp1_dl.c index d5b3c24d160c..4963acac73f8 > 100644 > --- a/drivers/media/platform/vsp1/vsp1_dl.c > +++ b/drivers/media/platform/vsp1/vsp1_dl.c > @@ -946,6 +946,8 @@ void vsp1_dl_list_commit(struct vsp1_dl_list *dl, bool > internal) */ > unsigned int vsp1_dlm_irq_frame_end(struct vsp1_dl_manager *dlm) > { > + struct vsp1_device *vsp1 = dlm->vsp1; > + u32 status = vsp1_read(vsp1, VI6_STATUS); > unsigned int flags = 0; > > spin_lock(&dlm->lock); > @@ -971,6 +973,14 @@ unsigned int vsp1_dlm_irq_frame_end(struct > vsp1_dl_manager *dlm) goto done; > > /* > + * Progressive streams report only TOP fields. If we have a BOTTOM > + * field, we are interlaced, and expect the frame to complete on the > + * next frame end interrupt. > + */ > + if (status & VI6_STATUS_FLD_STD(dlm->index)) > + goto done; > + > + /* > * The device starts processing the queued display list right after the > * frame end interrupt. The display list thus becomes active. > */ > diff --git a/drivers/media/platform/vsp1/vsp1_drm.c > b/drivers/media/platform/vsp1/vsp1_drm.c index a16856856789..efdc9a676728 > 100644 > --- a/drivers/media/platform/vsp1/vsp1_drm.c > +++ b/drivers/media/platform/vsp1/vsp1_drm.c > @@ -671,8 +671,20 @@ int vsp1_du_setup_lif(struct device *dev, unsigned int > pipe_index, drm_pipe->width = cfg->width; > drm_pipe->height = cfg->height; > > - dev_dbg(vsp1->dev, "%s: configuring LIF%u with format %ux%u\n", > - __func__, pipe_index, cfg->width, cfg->height); > + if (cfg->interlaced && !vsp1_feature(vsp1, VSP1_HAS_EXT_DL)) { > + /* > + * Interlaced support requires extended display lists to > + * provide the auto-fld feature with the DU. > + */ > + dev_dbg(vsp1->dev, "Interlaced unsupported on this pipeline\n"); > + return -EINVAL; > + } As mentioned in the v4 review, this check should be moved to the DRM driver, in the atomic check handler. > + > + pipe->interlaced = cfg->interlaced; > + > + dev_dbg(vsp1->dev, "%s: configuring LIF%u with format %ux%u%s\n", > + __func__, pipe_index, cfg->width, cfg->height, > + pipe->interlaced ? "i" : ""); > > mutex_lock(&vsp1->drm->lock); > > diff --git a/drivers/media/platform/vsp1/vsp1_pipe.h > b/drivers/media/platform/vsp1/vsp1_pipe.h index 743d8f0db45c..ae646c9ef337 > 100644 > --- a/drivers/media/platform/vsp1/vsp1_pipe.h > +++ b/drivers/media/platform/vsp1/vsp1_pipe.h > @@ -104,6 +104,7 @@ struct vsp1_partition { > * @entities: list of entities in the pipeline > * @stream_config: cached stream configuration for video pipelines > * @configured: when false the @stream_config shall be written to the > hardware + * @interlaced: True when the pipeline is configured in > interlaced mode * @partitions: The number of partitions used to process one > frame * @partition: The current partition for configuration to process * > @part_table: The pre-calculated partitions used by the pipeline @@ -142,6 > +143,7 @@ struct vsp1_pipeline { > > struct vsp1_dl_body *stream_config; > bool configured; > + bool interlaced; > > unsigned int partitions; > struct vsp1_partition *partition; > diff --git a/drivers/media/platform/vsp1/vsp1_regs.h > b/drivers/media/platform/vsp1/vsp1_regs.h index 5ea9f9070cf3..3738ff2f7b85 > 100644 > --- a/drivers/media/platform/vsp1/vsp1_regs.h > +++ b/drivers/media/platform/vsp1/vsp1_regs.h > @@ -28,6 +28,7 @@ > #define VI6_SRESET_SRTS(n) (1 << (n)) > > #define VI6_STATUS 0x0038 > +#define VI6_STATUS_FLD_STD(n) (1 << ((n) + 28)) > #define VI6_STATUS_SYS_ACT(n) (1 << ((n) + 8)) > > #define VI6_WPF_IRQ_ENB(n) (0x0048 + (n) * 12) > @@ -80,6 +81,8 @@ > #define VI6_DL_EXT_CTRL_EXPRI (1 << 4) > #define VI6_DL_EXT_CTRL_EXT (1 << 0) > > +#define VI6_DL_EXT_AUTOFLD_INT BIT(0) > + > #define VI6_DL_BODY_SIZE 0x0120 > #define VI6_DL_BODY_SIZE_UPD (1 << 24) > #define VI6_DL_BODY_SIZE_BS_MASK (0x1ffff << 0) > diff --git a/drivers/media/platform/vsp1/vsp1_rpf.c > b/drivers/media/platform/vsp1/vsp1_rpf.c index 69e5fe6e6b50..c728c193e09c > 100644 > --- a/drivers/media/platform/vsp1/vsp1_rpf.c > +++ b/drivers/media/platform/vsp1/vsp1_rpf.c > @@ -20,6 +20,18 @@ > #define RPF_MAX_WIDTH 8190 > #define RPF_MAX_HEIGHT 8190 > > +/* Pre extended display list command data structure. */ > +struct vsp1_extcmd_auto_fld_body { > + u32 top_y0; > + u32 bottom_y0; > + u32 top_c0; > + u32 bottom_c0; > + u32 top_c1; > + u32 bottom_c1; > + u32 reserved0; > + u32 reserved1; > +}; > + > /* > --------------------------------------------------------------------------- > -- * Device Access > */ > @@ -64,6 +76,14 @@ static void rpf_configure_stream(struct vsp1_entity > *entity, pstride |= format->plane_fmt[1].bytesperline > << VI6_RPF_SRCM_PSTRIDE_C_SHIFT; > > + /* > + * pstride has both STRIDE_Y and STRIDE_C, but multiplying the whole > + * of pstride by 2 is conveniently OK here as we are multiplying both > + * values. > + */ > + if (pipe->interlaced) > + pstride *= 2; > + > vsp1_rpf_write(rpf, dlb, VI6_RPF_SRCM_PSTRIDE, pstride); > > /* Format */ > @@ -100,6 +120,9 @@ static void rpf_configure_stream(struct vsp1_entity > *entity, top = compose->top; > } > > + if (pipe->interlaced) > + top /= 2; > + > vsp1_rpf_write(rpf, dlb, VI6_RPF_LOC, > (left << VI6_RPF_LOC_HCOORD_SHIFT) | > (top << VI6_RPF_LOC_VCOORD_SHIFT)); > @@ -169,6 +192,36 @@ static void rpf_configure_stream(struct vsp1_entity > *entity, > > } > > +static void vsp1_rpf_configure_autofld(struct vsp1_rwpf *rpf, > + struct vsp1_dl_list *dl) > +{ > + const struct v4l2_pix_format_mplane *format = &rpf->format; > + struct vsp1_dl_ext_cmd *cmd; > + struct vsp1_extcmd_auto_fld_body *auto_fld; > + u32 offset_y, offset_c; > + > + cmd = vsp1_dl_get_pre_cmd(dl); > + if (WARN_ONCE(!cmd, "Failed to obtain an autofld cmd")) > + return; > + > + /* Re-index our auto_fld to match the current RPF. */ > + auto_fld = cmd->data; > + auto_fld = &auto_fld[rpf->entity.index]; > + > + auto_fld->top_y0 = rpf->mem.addr[0]; > + auto_fld->top_c0 = rpf->mem.addr[1]; > + auto_fld->top_c1 = rpf->mem.addr[2]; > + > + offset_y = format->plane_fmt[0].bytesperline; > + offset_c = format->plane_fmt[1].bytesperline; > + > + auto_fld->bottom_y0 = rpf->mem.addr[0] + offset_y; > + auto_fld->bottom_c0 = rpf->mem.addr[1] + offset_c; > + auto_fld->bottom_c1 = rpf->mem.addr[2] + offset_c; > + > + cmd->flags |= VI6_DL_EXT_AUTOFLD_INT | BIT(16 + rpf->entity.index); > +} > + > static void rpf_configure_frame(struct vsp1_entity *entity, > struct vsp1_pipeline *pipe, > struct vsp1_dl_list *dl, > @@ -221,6 +274,11 @@ static void rpf_configure_partition(struct vsp1_entity > *entity, crop.left += pipe->partition->rpf.left; > } > > + if (pipe->interlaced) { > + crop.height = round_down(crop.height / 2, fmtinfo->vsub); > + crop.top = round_down(crop.top / 2, fmtinfo->vsub); > + } > + > vsp1_rpf_write(rpf, dlb, VI6_RPF_SRC_BSIZE, > (crop.width << VI6_RPF_SRC_BSIZE_BHSIZE_SHIFT) | > (crop.height << VI6_RPF_SRC_BSIZE_BVSIZE_SHIFT)); > @@ -249,9 +307,17 @@ static void rpf_configure_partition(struct vsp1_entity > *entity, fmtinfo->swap_uv) > swap(mem.addr[1], mem.addr[2]); > > - vsp1_rpf_write(rpf, dlb, VI6_RPF_SRCM_ADDR_Y, mem.addr[0]); > - vsp1_rpf_write(rpf, dlb, VI6_RPF_SRCM_ADDR_C0, mem.addr[1]); > - vsp1_rpf_write(rpf, dlb, VI6_RPF_SRCM_ADDR_C1, mem.addr[2]); > + /* > + * Interlaced pipelines will use the extended pre-cmd to process > + * SRCM_ADDR_{Y,C0,C1} > + */ > + if (pipe->interlaced) { > + vsp1_rpf_configure_autofld(rpf, dl); > + } else { > + vsp1_rpf_write(rpf, dlb, VI6_RPF_SRCM_ADDR_Y, mem.addr[0]); > + vsp1_rpf_write(rpf, dlb, VI6_RPF_SRCM_ADDR_C0, mem.addr[1]); > + vsp1_rpf_write(rpf, dlb, VI6_RPF_SRCM_ADDR_C1, mem.addr[2]); > + } > } > > static void rpf_partition(struct vsp1_entity *entity, > diff --git a/include/media/vsp1.h b/include/media/vsp1.h > index 678c24de1ac6..3093b9cb9067 100644 > --- a/include/media/vsp1.h > +++ b/include/media/vsp1.h > @@ -25,6 +25,7 @@ int vsp1_du_init(struct device *dev); > * struct vsp1_du_lif_config - VSP LIF configuration > * @width: output frame width > * @height: output frame height > + * @interlaced: true for interlaced pipelines > * @callback: frame completion callback function (optional). When a > callback * is provided, the VSP driver guarantees that it will be > called once * and only once for each vsp1_du_atomic_flush() call. > @@ -33,6 +34,7 @@ int vsp1_du_init(struct device *dev); > struct vsp1_du_lif_config { > unsigned int width; > unsigned int height; > + bool interlaced; > > void (*callback)(void *data, bool completed, u32 crc); > void *callback_data; -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH v5 10/11] media: vsp1: Support Interlaced display pipelines Date: Fri, 03 Aug 2018 01:44:21 +0300 Message-ID: <3826962.GFlSaplMp3@avalon> References: <6d3afb327daf3941c84db9e16a4d7b3ba4faedf6.1531857988.git-series.kieran.bingham+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 [213.167.242.64]) by gabe.freedesktop.org (Postfix) with ESMTPS id BA2146E646 for ; Thu, 2 Aug 2018 22:43:42 +0000 (UTC) In-Reply-To: <6d3afb327daf3941c84db9e16a4d7b3ba4faedf6.1531857988.git-series.kieran.bingham+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: Kieran Bingham Cc: linux-renesas-soc@vger.kernel.org, Kieran Bingham , Kieran Bingham , dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org SGkgS2llcmFuLAoKVGhhbmsgeW91IGZvciB0aGUgcGF0Y2guCgpPbiBUdWVzZGF5LCAxNyBKdWx5 IDIwMTggMjM6MzU6NTIgRUVTVCBLaWVyYW4gQmluZ2hhbSB3cm90ZToKPiBGcm9tOiBLaWVyYW4g QmluZ2hhbSA8a2llcmFuLmJpbmdoYW0rcmVuZXNhc0BpZGVhc29uYm9hcmQuY29tPgo+IAo+IENh bGN1bGF0ZSB0aGUgdG9wIGFuZCBib3R0b20gZmllbGRzIGZvciB0aGUgaW50ZXJsYWNlZCBmcmFt ZXMgYW5kCj4gdXRpbGlzZSB0aGUgZXh0ZW5kZWQgZGlzcGxheSBsaXN0IGNvbW1hbmQgZmVhdHVy ZSB0byBpbXBsZW1lbnQgdGhlCj4gYXV0by1maWVsZCBvcGVyYXRpb25zLiBUaGlzIGFsbG93cyB0 aGUgRFUgdG8gdXBkYXRlIHRoZSBWU1AyIHJlZ2lzdGVycwo+IGR5bmFtaWNhbGx5IGJhc2VkIHVw b24gdGhlIGN1cnJlbnRseSBwcm9jZXNzaW5nIGZpZWxkLgo+IAo+IFNpZ25lZC1vZmYtYnk6IEtp ZXJhbiBCaW5naGFtIDxraWVyYW4uYmluZ2hhbStyZW5lc2FzQGlkZWFzb25ib2FyZC5jb20+Cj4g Cj4gLS0tCj4gCj4gdjI6Cj4gIC0gZml4IGVycm9uZW91cyBCSVQgdmFsdWUgd2hpY2ggZW5hYmxl ZCBpbnRlcmxhY2VkCj4gIC0gZml4IGZpZWxkIGhhbmRsaW5nIGF0IGZyYW1lX2VuZCBpbnRlcnJ1 cHQKPiAKPiB2MzoKPiAgLSBQYXNzIERMIHRocm91Z2ggcGFydGl0aW9uIGNhbGxzIHRvIGFsbG93 IGF1dG9jbWQncyB0byBiZSByZXRyaWV2ZWQKPiAgLSBEb2N1bWVudCBpbnRlcmxhY2VkIGZpZWxk IGluIHN0cnVjdCB2c3AxX2R1X2F0b21pY19jb25maWcKPiAKPiB2NToKPiAgLSBPYnRhaW4gYXV0 b2ZsZCBjbWQgaW4gdnNwMV9ycGZfY29uZmlndXJlX2F1dG9mbGQoKQo+ICAtIE1vdmUgVlNQMV9E TF9FWFRfQVVUT0ZMRF9JTlQgdG8gdnNwMV9yZWdzLmgKPiAgLSBSZW5hbWUgVlNQMV9ETF9FWFRf QVVUT0ZMRF9JTlQgLT4gVkk2X0RMX0VYVF9BVVRPRkxEX0lOVAo+ICAtIG1vdmUgaW50ZXJsYWNl ZCBjb25maWd1cmF0aW9uIHBhcmFtZXRlciB0byBwaXBlIG9iamVjdAo+ICAtIGF1dG9mbGQ6IFNl dCBjbWQtPmZsYWdzIGluIG9uZSBzaW5nbGUgZXhwcmVzc2lvbi4KPiAKPiAgZHJpdmVycy9tZWRp YS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwuYyAgIHwgMTAgKysrKy0KPiAgZHJpdmVycy9tZWRpYS9w bGF0Zm9ybS92c3AxL3ZzcDFfZHJtLmMgIHwgMTYgKysrKystCj4gIGRyaXZlcnMvbWVkaWEvcGxh dGZvcm0vdnNwMS92c3AxX3BpcGUuaCB8ICAyICstCj4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0v dnNwMS92c3AxX3JlZ3MuaCB8ICAzICstCj4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92 c3AxX3JwZi5jICB8IDcyICsrKysrKysrKysrKysrKysrKysrKysrKy0tCj4gIGluY2x1ZGUvbWVk aWEvdnNwMS5oICAgICAgICAgICAgICAgICAgICB8ICAyICstCj4gIDYgZmlsZXMgY2hhbmdlZCwg MTAwIGluc2VydGlvbnMoKyksIDUgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZl cnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmMKPiBiL2RyaXZlcnMvbWVkaWEvcGxhdGZv cm0vdnNwMS92c3AxX2RsLmMgaW5kZXggZDViM2MyNGQxNjBjLi40OTYzYWNhYzczZjgKPiAxMDA2 NDQKPiAtLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kbC5jCj4gKysrIGIv ZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwuYwo+IEBAIC05NDYsNiArOTQ2LDgg QEAgdm9pZCB2c3AxX2RsX2xpc3RfY29tbWl0KHN0cnVjdCB2c3AxX2RsX2xpc3QgKmRsLCBib29s Cj4gaW50ZXJuYWwpICovCj4gIHVuc2lnbmVkIGludCB2c3AxX2RsbV9pcnFfZnJhbWVfZW5kKHN0 cnVjdCB2c3AxX2RsX21hbmFnZXIgKmRsbSkKPiAgewo+ICsJc3RydWN0IHZzcDFfZGV2aWNlICp2 c3AxID0gZGxtLT52c3AxOwo+ICsJdTMyIHN0YXR1cyA9IHZzcDFfcmVhZCh2c3AxLCBWSTZfU1RB VFVTKTsKPiAgCXVuc2lnbmVkIGludCBmbGFncyA9IDA7Cj4gCj4gIAlzcGluX2xvY2soJmRsbS0+ bG9jayk7Cj4gQEAgLTk3MSw2ICs5NzMsMTQgQEAgdW5zaWduZWQgaW50IHZzcDFfZGxtX2lycV9m cmFtZV9lbmQoc3RydWN0Cj4gdnNwMV9kbF9tYW5hZ2VyICpkbG0pIGdvdG8gZG9uZTsKPiAKPiAg CS8qCj4gKwkgKiBQcm9ncmVzc2l2ZSBzdHJlYW1zIHJlcG9ydCBvbmx5IFRPUCBmaWVsZHMuIElm IHdlIGhhdmUgYSBCT1RUT00KPiArCSAqIGZpZWxkLCB3ZSBhcmUgaW50ZXJsYWNlZCwgYW5kIGV4 cGVjdCB0aGUgZnJhbWUgdG8gY29tcGxldGUgb24gdGhlCj4gKwkgKiBuZXh0IGZyYW1lIGVuZCBp bnRlcnJ1cHQuCj4gKwkgKi8KPiArCWlmIChzdGF0dXMgJiBWSTZfU1RBVFVTX0ZMRF9TVEQoZGxt LT5pbmRleCkpCj4gKwkJZ290byBkb25lOwo+ICsKPiArCS8qCj4gIAkgKiBUaGUgZGV2aWNlIHN0 YXJ0cyBwcm9jZXNzaW5nIHRoZSBxdWV1ZWQgZGlzcGxheSBsaXN0IHJpZ2h0IGFmdGVyIHRoZQo+ ICAJICogZnJhbWUgZW5kIGludGVycnVwdC4gVGhlIGRpc3BsYXkgbGlzdCB0aHVzIGJlY29tZXMg YWN0aXZlLgo+ICAJICovCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNw MS92c3AxX2RybS5jCj4gYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kcm0uYyBp bmRleCBhMTY4NTY4NTY3ODkuLmVmZGM5YTY3NjcyOAo+IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMv bWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RybS5jCj4gKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0 Zm9ybS92c3AxL3ZzcDFfZHJtLmMKPiBAQCAtNjcxLDggKzY3MSwyMCBAQCBpbnQgdnNwMV9kdV9z ZXR1cF9saWYoc3RydWN0IGRldmljZSAqZGV2LCB1bnNpZ25lZCBpbnQKPiBwaXBlX2luZGV4LCBk cm1fcGlwZS0+d2lkdGggPSBjZmctPndpZHRoOwo+ICAJZHJtX3BpcGUtPmhlaWdodCA9IGNmZy0+ aGVpZ2h0Owo+IAo+IC0JZGV2X2RiZyh2c3AxLT5kZXYsICIlczogY29uZmlndXJpbmcgTElGJXUg d2l0aCBmb3JtYXQgJXV4JXVcbiIsCj4gLQkJX19mdW5jX18sIHBpcGVfaW5kZXgsIGNmZy0+d2lk dGgsIGNmZy0+aGVpZ2h0KTsKPiArCWlmIChjZmctPmludGVybGFjZWQgJiYgIXZzcDFfZmVhdHVy ZSh2c3AxLCBWU1AxX0hBU19FWFRfREwpKSB7Cj4gKwkJLyoKPiArCQkgKiBJbnRlcmxhY2VkIHN1 cHBvcnQgcmVxdWlyZXMgZXh0ZW5kZWQgZGlzcGxheSBsaXN0cyB0bwo+ICsJCSAqIHByb3ZpZGUg dGhlIGF1dG8tZmxkIGZlYXR1cmUgd2l0aCB0aGUgRFUuCj4gKwkJICovCj4gKwkJZGV2X2RiZyh2 c3AxLT5kZXYsICJJbnRlcmxhY2VkIHVuc3VwcG9ydGVkIG9uIHRoaXMgcGlwZWxpbmVcbiIpOwo+ ICsJCXJldHVybiAtRUlOVkFMOwo+ICsJfQoKQXMgbWVudGlvbmVkIGluIHRoZSB2NCByZXZpZXcs IHRoaXMgY2hlY2sgc2hvdWxkIGJlIG1vdmVkIHRvIHRoZSBEUk0gZHJpdmVyLCAKaW4gdGhlIGF0 b21pYyBjaGVjayBoYW5kbGVyLgoKPiArCj4gKwlwaXBlLT5pbnRlcmxhY2VkID0gY2ZnLT5pbnRl cmxhY2VkOwo+ICsKPiArCWRldl9kYmcodnNwMS0+ZGV2LCAiJXM6IGNvbmZpZ3VyaW5nIExJRiV1 IHdpdGggZm9ybWF0ICV1eCV1JXNcbiIsCj4gKwkJX19mdW5jX18sIHBpcGVfaW5kZXgsIGNmZy0+ d2lkdGgsIGNmZy0+aGVpZ2h0LAo+ICsJCXBpcGUtPmludGVybGFjZWQgPyAiaSIgOiAiIik7Cj4g Cj4gIAltdXRleF9sb2NrKCZ2c3AxLT5kcm0tPmxvY2spOwo+IAo+IGRpZmYgLS1naXQgYS9kcml2 ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9waXBlLmgKPiBiL2RyaXZlcnMvbWVkaWEvcGxh dGZvcm0vdnNwMS92c3AxX3BpcGUuaCBpbmRleCA3NDNkOGYwZGI0NWMuLmFlNjQ2YzllZjMzNwo+ IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3BpcGUuaAo+ ICsrKyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3BpcGUuaAo+IEBAIC0xMDQs NiArMTA0LDcgQEAgc3RydWN0IHZzcDFfcGFydGl0aW9uIHsKPiAgICogQGVudGl0aWVzOiBsaXN0 IG9mIGVudGl0aWVzIGluIHRoZSBwaXBlbGluZQo+ICAgKiBAc3RyZWFtX2NvbmZpZzogY2FjaGVk IHN0cmVhbSBjb25maWd1cmF0aW9uIGZvciB2aWRlbyBwaXBlbGluZXMKPiAgICogQGNvbmZpZ3Vy ZWQ6IHdoZW4gZmFsc2UgdGhlIEBzdHJlYW1fY29uZmlnIHNoYWxsIGJlIHdyaXR0ZW4gdG8gdGhl Cj4gaGFyZHdhcmUgKyAqIEBpbnRlcmxhY2VkOiBUcnVlIHdoZW4gdGhlIHBpcGVsaW5lIGlzIGNv bmZpZ3VyZWQgaW4KPiBpbnRlcmxhY2VkIG1vZGUgKiBAcGFydGl0aW9uczogVGhlIG51bWJlciBv ZiBwYXJ0aXRpb25zIHVzZWQgdG8gcHJvY2VzcyBvbmUKPiBmcmFtZSAqIEBwYXJ0aXRpb246IFRo ZSBjdXJyZW50IHBhcnRpdGlvbiBmb3IgY29uZmlndXJhdGlvbiB0byBwcm9jZXNzICoKPiBAcGFy dF90YWJsZTogVGhlIHByZS1jYWxjdWxhdGVkIHBhcnRpdGlvbnMgdXNlZCBieSB0aGUgcGlwZWxp bmUgQEAgLTE0Miw2Cj4gKzE0Myw3IEBAIHN0cnVjdCB2c3AxX3BpcGVsaW5lIHsKPiAKPiAgCXN0 cnVjdCB2c3AxX2RsX2JvZHkgKnN0cmVhbV9jb25maWc7Cj4gIAlib29sIGNvbmZpZ3VyZWQ7Cj4g Kwlib29sIGludGVybGFjZWQ7Cj4gCj4gIAl1bnNpZ25lZCBpbnQgcGFydGl0aW9uczsKPiAgCXN0 cnVjdCB2c3AxX3BhcnRpdGlvbiAqcGFydGl0aW9uOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21l ZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9yZWdzLmgKPiBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0v dnNwMS92c3AxX3JlZ3MuaCBpbmRleCA1ZWE5ZjkwNzBjZjMuLjM3MzhmZjJmN2I4NQo+IDEwMDY0 NAo+IC0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3JlZ3MuaAo+ICsrKyBi L2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3JlZ3MuaAo+IEBAIC0yOCw2ICsyOCw3 IEBACj4gICNkZWZpbmUgVkk2X1NSRVNFVF9TUlRTKG4pCQkoMSA8PCAobikpCj4gCj4gICNkZWZp bmUgVkk2X1NUQVRVUwkJCTB4MDAzOAo+ICsjZGVmaW5lIFZJNl9TVEFUVVNfRkxEX1NURChuKQkJ KDEgPDwgKChuKSArIDI4KSkKPiAgI2RlZmluZSBWSTZfU1RBVFVTX1NZU19BQ1QobikJCSgxIDw8 ICgobikgKyA4KSkKPiAKPiAgI2RlZmluZSBWSTZfV1BGX0lSUV9FTkIobikJCSgweDAwNDggKyAo bikgKiAxMikKPiBAQCAtODAsNiArODEsOCBAQAo+ICAjZGVmaW5lIFZJNl9ETF9FWFRfQ1RSTF9F WFBSSQkJKDEgPDwgNCkKPiAgI2RlZmluZSBWSTZfRExfRVhUX0NUUkxfRVhUCQkoMSA8PCAwKQo+ IAo+ICsjZGVmaW5lIFZJNl9ETF9FWFRfQVVUT0ZMRF9JTlQJCUJJVCgwKQo+ICsKPiAgI2RlZmlu ZSBWSTZfRExfQk9EWV9TSVpFCQkweDAxMjAKPiAgI2RlZmluZSBWSTZfRExfQk9EWV9TSVpFX1VQ RAkJKDEgPDwgMjQpCj4gICNkZWZpbmUgVkk2X0RMX0JPRFlfU0laRV9CU19NQVNLCSgweDFmZmZm IDw8IDApCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3Jw Zi5jCj4gYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9ycGYuYyBpbmRleCA2OWU1 ZmU2ZTZiNTAuLmM3MjhjMTkzZTA5Ywo+IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvbWVkaWEvcGxh dGZvcm0vdnNwMS92c3AxX3JwZi5jCj4gKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3Ax L3ZzcDFfcnBmLmMKPiBAQCAtMjAsNiArMjAsMTggQEAKPiAgI2RlZmluZSBSUEZfTUFYX1dJRFRI CQkJCTgxOTAKPiAgI2RlZmluZSBSUEZfTUFYX0hFSUdIVAkJCQk4MTkwCj4gCj4gKy8qIFByZSBl eHRlbmRlZCBkaXNwbGF5IGxpc3QgY29tbWFuZCBkYXRhIHN0cnVjdHVyZS4gKi8KPiArc3RydWN0 IHZzcDFfZXh0Y21kX2F1dG9fZmxkX2JvZHkgewo+ICsJdTMyIHRvcF95MDsKPiArCXUzMiBib3R0 b21feTA7Cj4gKwl1MzIgdG9wX2MwOwo+ICsJdTMyIGJvdHRvbV9jMDsKPiArCXUzMiB0b3BfYzE7 Cj4gKwl1MzIgYm90dG9tX2MxOwo+ICsJdTMyIHJlc2VydmVkMDsKPiArCXUzMiByZXNlcnZlZDE7 Cj4gK307Cj4gKwo+ICAvKgo+IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+IC0tICogRGV2aWNlIEFjY2Vz cwo+ICAgKi8KPiBAQCAtNjQsNiArNzYsMTQgQEAgc3RhdGljIHZvaWQgcnBmX2NvbmZpZ3VyZV9z dHJlYW0oc3RydWN0IHZzcDFfZW50aXR5Cj4gKmVudGl0eSwgcHN0cmlkZSB8PSBmb3JtYXQtPnBs YW5lX2ZtdFsxXS5ieXRlc3BlcmxpbmUKPiAgCQkJPDwgVkk2X1JQRl9TUkNNX1BTVFJJREVfQ19T SElGVDsKPiAKPiArCS8qCj4gKwkgKiBwc3RyaWRlIGhhcyBib3RoIFNUUklERV9ZIGFuZCBTVFJJ REVfQywgYnV0IG11bHRpcGx5aW5nIHRoZSB3aG9sZQo+ICsJICogb2YgcHN0cmlkZSBieSAyIGlz IGNvbnZlbmllbnRseSBPSyBoZXJlIGFzIHdlIGFyZSBtdWx0aXBseWluZyBib3RoCj4gKwkgKiB2 YWx1ZXMuCj4gKwkgKi8KPiArCWlmIChwaXBlLT5pbnRlcmxhY2VkKQo+ICsJCXBzdHJpZGUgKj0g MjsKPiArCj4gIAl2c3AxX3JwZl93cml0ZShycGYsIGRsYiwgVkk2X1JQRl9TUkNNX1BTVFJJREUs IHBzdHJpZGUpOwo+IAo+ICAJLyogRm9ybWF0ICovCj4gQEAgLTEwMCw2ICsxMjAsOSBAQCBzdGF0 aWMgdm9pZCBycGZfY29uZmlndXJlX3N0cmVhbShzdHJ1Y3QgdnNwMV9lbnRpdHkKPiAqZW50aXR5 LCB0b3AgPSBjb21wb3NlLT50b3A7Cj4gIAl9Cj4gCj4gKwlpZiAocGlwZS0+aW50ZXJsYWNlZCkK PiArCQl0b3AgLz0gMjsKPiArCj4gIAl2c3AxX3JwZl93cml0ZShycGYsIGRsYiwgVkk2X1JQRl9M T0MsCj4gIAkJICAgICAgIChsZWZ0IDw8IFZJNl9SUEZfTE9DX0hDT09SRF9TSElGVCkgfAo+ICAJ CSAgICAgICAodG9wIDw8IFZJNl9SUEZfTE9DX1ZDT09SRF9TSElGVCkpOwo+IEBAIC0xNjksNiAr MTkyLDM2IEBAIHN0YXRpYyB2b2lkIHJwZl9jb25maWd1cmVfc3RyZWFtKHN0cnVjdCB2c3AxX2Vu dGl0eQo+ICplbnRpdHksCj4gCj4gIH0KPiAKPiArc3RhdGljIHZvaWQgdnNwMV9ycGZfY29uZmln dXJlX2F1dG9mbGQoc3RydWN0IHZzcDFfcndwZiAqcnBmLAo+ICsJCQkJICAgICAgIHN0cnVjdCB2 c3AxX2RsX2xpc3QgKmRsKQo+ICt7Cj4gKwljb25zdCBzdHJ1Y3QgdjRsMl9waXhfZm9ybWF0X21w bGFuZSAqZm9ybWF0ID0gJnJwZi0+Zm9ybWF0Owo+ICsJc3RydWN0IHZzcDFfZGxfZXh0X2NtZCAq Y21kOwo+ICsJc3RydWN0IHZzcDFfZXh0Y21kX2F1dG9fZmxkX2JvZHkgKmF1dG9fZmxkOwo+ICsJ dTMyIG9mZnNldF95LCBvZmZzZXRfYzsKPiArCj4gKwljbWQgPSB2c3AxX2RsX2dldF9wcmVfY21k KGRsKTsKPiArCWlmIChXQVJOX09OQ0UoIWNtZCwgIkZhaWxlZCB0byBvYnRhaW4gYW4gYXV0b2Zs ZCBjbWQiKSkKPiArCQlyZXR1cm47Cj4gKwo+ICsJLyogUmUtaW5kZXggb3VyIGF1dG9fZmxkIHRv IG1hdGNoIHRoZSBjdXJyZW50IFJQRi4gKi8KPiArCWF1dG9fZmxkID0gY21kLT5kYXRhOwo+ICsJ YXV0b19mbGQgPSAmYXV0b19mbGRbcnBmLT5lbnRpdHkuaW5kZXhdOwo+ICsKPiArCWF1dG9fZmxk LT50b3BfeTAgPSBycGYtPm1lbS5hZGRyWzBdOwo+ICsJYXV0b19mbGQtPnRvcF9jMCA9IHJwZi0+ bWVtLmFkZHJbMV07Cj4gKwlhdXRvX2ZsZC0+dG9wX2MxID0gcnBmLT5tZW0uYWRkclsyXTsKPiAr Cj4gKwlvZmZzZXRfeSA9IGZvcm1hdC0+cGxhbmVfZm10WzBdLmJ5dGVzcGVybGluZTsKPiArCW9m ZnNldF9jID0gZm9ybWF0LT5wbGFuZV9mbXRbMV0uYnl0ZXNwZXJsaW5lOwo+ICsKPiArCWF1dG9f ZmxkLT5ib3R0b21feTAgPSBycGYtPm1lbS5hZGRyWzBdICsgb2Zmc2V0X3k7Cj4gKwlhdXRvX2Zs ZC0+Ym90dG9tX2MwID0gcnBmLT5tZW0uYWRkclsxXSArIG9mZnNldF9jOwo+ICsJYXV0b19mbGQt PmJvdHRvbV9jMSA9IHJwZi0+bWVtLmFkZHJbMl0gKyBvZmZzZXRfYzsKPiArCj4gKwljbWQtPmZs YWdzIHw9IFZJNl9ETF9FWFRfQVVUT0ZMRF9JTlQgfCBCSVQoMTYgKyBycGYtPmVudGl0eS5pbmRl eCk7Cj4gK30KPiArCj4gIHN0YXRpYyB2b2lkIHJwZl9jb25maWd1cmVfZnJhbWUoc3RydWN0IHZz cDFfZW50aXR5ICplbnRpdHksCj4gIAkJCQlzdHJ1Y3QgdnNwMV9waXBlbGluZSAqcGlwZSwKPiAg CQkJCXN0cnVjdCB2c3AxX2RsX2xpc3QgKmRsLAo+IEBAIC0yMjEsNiArMjc0LDExIEBAIHN0YXRp YyB2b2lkIHJwZl9jb25maWd1cmVfcGFydGl0aW9uKHN0cnVjdCB2c3AxX2VudGl0eQo+ICplbnRp dHksIGNyb3AubGVmdCArPSBwaXBlLT5wYXJ0aXRpb24tPnJwZi5sZWZ0Owo+ICAJfQo+IAo+ICsJ aWYgKHBpcGUtPmludGVybGFjZWQpIHsKPiArCQljcm9wLmhlaWdodCA9IHJvdW5kX2Rvd24oY3Jv cC5oZWlnaHQgLyAyLCBmbXRpbmZvLT52c3ViKTsKPiArCQljcm9wLnRvcCA9IHJvdW5kX2Rvd24o Y3JvcC50b3AgLyAyLCBmbXRpbmZvLT52c3ViKTsKPiArCX0KPiArCj4gIAl2c3AxX3JwZl93cml0 ZShycGYsIGRsYiwgVkk2X1JQRl9TUkNfQlNJWkUsCj4gIAkJICAgICAgIChjcm9wLndpZHRoIDw8 IFZJNl9SUEZfU1JDX0JTSVpFX0JIU0laRV9TSElGVCkgfAo+ICAJCSAgICAgICAoY3JvcC5oZWln aHQgPDwgVkk2X1JQRl9TUkNfQlNJWkVfQlZTSVpFX1NISUZUKSk7Cj4gQEAgLTI0OSw5ICszMDcs MTcgQEAgc3RhdGljIHZvaWQgcnBmX2NvbmZpZ3VyZV9wYXJ0aXRpb24oc3RydWN0IHZzcDFfZW50 aXR5Cj4gKmVudGl0eSwgZm10aW5mby0+c3dhcF91dikKPiAgCQlzd2FwKG1lbS5hZGRyWzFdLCBt ZW0uYWRkclsyXSk7Cj4gCj4gLQl2c3AxX3JwZl93cml0ZShycGYsIGRsYiwgVkk2X1JQRl9TUkNN X0FERFJfWSwgbWVtLmFkZHJbMF0pOwo+IC0JdnNwMV9ycGZfd3JpdGUocnBmLCBkbGIsIFZJNl9S UEZfU1JDTV9BRERSX0MwLCBtZW0uYWRkclsxXSk7Cj4gLQl2c3AxX3JwZl93cml0ZShycGYsIGRs YiwgVkk2X1JQRl9TUkNNX0FERFJfQzEsIG1lbS5hZGRyWzJdKTsKPiArCS8qCj4gKwkgKiBJbnRl cmxhY2VkIHBpcGVsaW5lcyB3aWxsIHVzZSB0aGUgZXh0ZW5kZWQgcHJlLWNtZCB0byBwcm9jZXNz Cj4gKwkgKiBTUkNNX0FERFJfe1ksQzAsQzF9Cj4gKwkgKi8KPiArCWlmIChwaXBlLT5pbnRlcmxh Y2VkKSB7Cj4gKwkJdnNwMV9ycGZfY29uZmlndXJlX2F1dG9mbGQocnBmLCBkbCk7Cj4gKwl9IGVs c2Ugewo+ICsJCXZzcDFfcnBmX3dyaXRlKHJwZiwgZGxiLCBWSTZfUlBGX1NSQ01fQUREUl9ZLCBt ZW0uYWRkclswXSk7Cj4gKwkJdnNwMV9ycGZfd3JpdGUocnBmLCBkbGIsIFZJNl9SUEZfU1JDTV9B RERSX0MwLCBtZW0uYWRkclsxXSk7Cj4gKwkJdnNwMV9ycGZfd3JpdGUocnBmLCBkbGIsIFZJNl9S UEZfU1JDTV9BRERSX0MxLCBtZW0uYWRkclsyXSk7Cj4gKwl9Cj4gIH0KPiAKPiAgc3RhdGljIHZv aWQgcnBmX3BhcnRpdGlvbihzdHJ1Y3QgdnNwMV9lbnRpdHkgKmVudGl0eSwKPiBkaWZmIC0tZ2l0 IGEvaW5jbHVkZS9tZWRpYS92c3AxLmggYi9pbmNsdWRlL21lZGlhL3ZzcDEuaAo+IGluZGV4IDY3 OGMyNGRlMWFjNi4uMzA5M2I5Y2I5MDY3IDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvbWVkaWEvdnNw MS5oCj4gKysrIGIvaW5jbHVkZS9tZWRpYS92c3AxLmgKPiBAQCAtMjUsNiArMjUsNyBAQCBpbnQg dnNwMV9kdV9pbml0KHN0cnVjdCBkZXZpY2UgKmRldik7Cj4gICAqIHN0cnVjdCB2c3AxX2R1X2xp Zl9jb25maWcgLSBWU1AgTElGIGNvbmZpZ3VyYXRpb24KPiAgICogQHdpZHRoOiBvdXRwdXQgZnJh bWUgd2lkdGgKPiAgICogQGhlaWdodDogb3V0cHV0IGZyYW1lIGhlaWdodAo+ICsgKiBAaW50ZXJs YWNlZDogdHJ1ZSBmb3IgaW50ZXJsYWNlZCBwaXBlbGluZXMKPiAgICogQGNhbGxiYWNrOiBmcmFt ZSBjb21wbGV0aW9uIGNhbGxiYWNrIGZ1bmN0aW9uIChvcHRpb25hbCkuIFdoZW4gYQo+IGNhbGxi YWNrICoJICAgICAgaXMgcHJvdmlkZWQsIHRoZSBWU1AgZHJpdmVyIGd1YXJhbnRlZXMgdGhhdCBp dCB3aWxsIGJlCj4gY2FsbGVkIG9uY2UgKgkgICAgICBhbmQgb25seSBvbmNlIGZvciBlYWNoIHZz cDFfZHVfYXRvbWljX2ZsdXNoKCkgY2FsbC4KPiBAQCAtMzMsNiArMzQsNyBAQCBpbnQgdnNwMV9k dV9pbml0KHN0cnVjdCBkZXZpY2UgKmRldik7Cj4gIHN0cnVjdCB2c3AxX2R1X2xpZl9jb25maWcg ewo+ICAJdW5zaWduZWQgaW50IHdpZHRoOwo+ICAJdW5zaWduZWQgaW50IGhlaWdodDsKPiArCWJv b2wgaW50ZXJsYWNlZDsKPiAKPiAgCXZvaWQgKCpjYWxsYmFjaykodm9pZCAqZGF0YSwgYm9vbCBj b21wbGV0ZWQsIHUzMiBjcmMpOwo+ICAJdm9pZCAqY2FsbGJhY2tfZGF0YTsKCi0tIApSZWdhcmRz LAoKTGF1cmVudCBQaW5jaGFydAoKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVl ZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5m by9kcmktZGV2ZWwK