From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from perceval.ideasonboard.com ([213.167.242.64]:45758 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2387494AbeHBQaB (ORCPT ); Thu, 2 Aug 2018 12:30:01 -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 08/11] media: vsp1: Add support for extended display list headers Date: Thu, 02 Aug 2018 17:39:11 +0300 Message-ID: <19660073.SniHlcofiQ@avalon> In-Reply-To: <4c12a88003d585ecc36054a6492357fdd4565d40.1531857988.git-series.kieran.bingham+renesas@ideasonboard.com> References: <4c12a88003d585ecc36054a6492357fdd4565d40.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:50 EEST Kieran Bingham wrote: > From: Kieran Bingham > > Extended display list headers allow pre and post command lists to be > executed by the VSP pipeline. This provides the base support for > features such as AUTO_FLD (for interlaced support) and AUTO_DISP (for > supporting continuous camera preview pipelines. > > Signed-off-by: Kieran Bingham > > --- > > v2: > - remove __packed attributes > > v5: > - Rename vsp1_dl_ext_header field names > - Rename @extended -> @extension > - Remove unnecessary VI6_DL_SWAP changes > - Rename @cmd_opcode -> @opcode > - Drop unused @data_size field > - Move iteration of WPF's inside vsp1_dlm_setup > - Rename vsp1_dl_ext_cmd_header -> vsp1_pre_ext_dl_body > - Rename vsp1_pre_ext_dl_body->cmd to vsp1_pre_ext_dl_body->opcode > - Rename vsp1_dl_ext_header->reserved0 to vsp1_dl_ext_header->padding > - vsp1_pre_ext_dl_body: Rename 'data' to 'address_set' > - vsp1_pre_ext_dl_body: Add struct documentation > - Document ordering of 16bit accesses for flags in vsp1_dl_ext_header > > drivers/media/platform/vsp1/vsp1.h | 1 +- > drivers/media/platform/vsp1/vsp1_dl.c | 104 ++++++++++++++++++++++++- > drivers/media/platform/vsp1/vsp1_dl.h | 25 ++++++- > drivers/media/platform/vsp1/vsp1_drv.c | 4 +- > drivers/media/platform/vsp1/vsp1_regs.h | 2 +- > 5 files changed, 132 insertions(+), 4 deletions(-) > > diff --git a/drivers/media/platform/vsp1/vsp1.h > b/drivers/media/platform/vsp1/vsp1.h index f0d21cc8e9ab..56c62122a81a > 100644 > --- a/drivers/media/platform/vsp1/vsp1.h > +++ b/drivers/media/platform/vsp1/vsp1.h > @@ -53,6 +53,7 @@ struct vsp1_uif; > #define VSP1_HAS_HGO (1 << 7) > #define VSP1_HAS_HGT (1 << 8) > #define VSP1_HAS_BRS (1 << 9) > +#define VSP1_HAS_EXT_DL (1 << 10) > > struct vsp1_device_info { > u32 version; > diff --git a/drivers/media/platform/vsp1/vsp1_dl.c > b/drivers/media/platform/vsp1/vsp1_dl.c index 90e0a11c29b5..2fffe977aa35 > 100644 > --- a/drivers/media/platform/vsp1/vsp1_dl.c > +++ b/drivers/media/platform/vsp1/vsp1_dl.c > @@ -22,6 +22,9 @@ > #define VSP1_DLH_INT_ENABLE (1 << 1) > #define VSP1_DLH_AUTO_START (1 << 0) > > +#define VSP1_DLH_EXT_PRE_CMD_EXEC (1 << 9) > +#define VSP1_DLH_EXT_POST_CMD_EXEC (1 << 8) > + > struct vsp1_dl_header_list { > u32 num_bytes; > u32 addr; > @@ -34,12 +37,59 @@ struct vsp1_dl_header { > u32 flags; > }; > > +/** > + * struct vsp1_dl_ext_header - Extended display list header > + * @padding: padding zero bytes for alignment > + * @pre_ext_dl_num_cmd: number of pre-extended command bodies to parse > + * @flags: enables or disables execution of the pre and post command > + * @pre_ext_dl_plist: start address of pre-extended display list bodies > + * @post_ext_dl_num_cmd: number of post-extended command bodies to parse > + * @post_ext_dl_plist: start address of post-extended display list bodies > + */ > +struct vsp1_dl_ext_header { > + u32 padding; > + > + /* > + * The datasheet represents flags as stored before pre_ext_dl_num_cmd, > + * expecting 32-bit accesses. The flags are appropriate to the whole > + * header, not just the pre_ext command, and thus warrant being > + * separated out. Due to byte ordering, and representing as 16 bit > + * values here, the flags must be positioned after the > + * pre_ext_dl_num_cmd. > + */ > + u16 pre_ext_dl_num_cmd; > + u16 flags; > + u32 pre_ext_dl_plist; > + > + u32 post_ext_dl_num_cmd; > + u32 post_ext_dl_plist; > +}; > + > +struct vsp1_dl_header_extended { > + struct vsp1_dl_header header; > + struct vsp1_dl_ext_header ext; > +}; > + > struct vsp1_dl_entry { > u32 addr; > u32 data; > }; > > /** > + * struct vsp1_pre_ext_dl_body - Pre Extended Display List Body > + * @opcode: Extended display list command operation code > + * @flags: Pre-extended command flags. These are specific to each command > + * @address_set: Source address set pointer. Must have 16 byte alignment s/byte/bytes/ > + * @reserved: Zero bits for alignment. > + */ > +struct vsp1_pre_ext_dl_body { > + u32 opcode; > + u32 flags; > + u32 address_set; > + u32 reserved; > +}; > + > +/** > * struct vsp1_dl_body - Display list body > * @list: entry in the display list list of bodies > * @free: entry in the pool free body list > @@ -95,9 +145,12 @@ struct vsp1_dl_body_pool { > * @list: entry in the display list manager lists > * @dlm: the display list manager > * @header: display list header > + * @extension: extended display list header. NULL for normal lists > * @dma: DMA address for the header > * @body0: first display list body > * @bodies: list of extra display list bodies > + * @pre_cmd: pre command to be issued through extended dl header > + * @post_cmd: post command to be issued through extended dl header > * @has_chain: if true, indicates that there's a partition chain > * @chain: entry in the display list partition chain > * @internal: whether the display list is used for internal purpose > @@ -107,11 +160,15 @@ struct vsp1_dl_list { > struct vsp1_dl_manager *dlm; > > struct vsp1_dl_header *header; > + struct vsp1_dl_ext_header *extension; > dma_addr_t dma; > > struct vsp1_dl_body *body0; > struct list_head bodies; > > + struct vsp1_dl_ext_cmd *pre_cmd; > + struct vsp1_dl_ext_cmd *post_cmd; > + > bool has_chain; > struct list_head chain; > > @@ -495,6 +552,14 @@ int vsp1_dl_list_add_chain(struct vsp1_dl_list *head, > return 0; > } > > +static void vsp1_dl_ext_cmd_fill_header(struct vsp1_dl_ext_cmd *cmd) > +{ > + cmd->cmds[0].opcode = cmd->opcode; > + cmd->cmds[0].flags = cmd->flags; > + cmd->cmds[0].address_set = cmd->data_dma; > + cmd->cmds[0].reserved = 0; > +} > + > static void vsp1_dl_list_fill_header(struct vsp1_dl_list *dl, bool is_last) > { > struct vsp1_dl_manager *dlm = dl->dlm; > @@ -547,6 +612,27 @@ static void vsp1_dl_list_fill_header(struct > vsp1_dl_list *dl, bool is_last) */ > dl->header->flags = VSP1_DLH_INT_ENABLE; > } > + > + if (!dl->extension) > + return; > + > + dl->extension->flags = 0; > + > + if (dl->pre_cmd) { > + dl->extension->pre_ext_dl_plist = dl->pre_cmd->cmd_dma; > + dl->extension->pre_ext_dl_num_cmd = dl->pre_cmd->num_cmds; > + dl->extension->flags |= VSP1_DLH_EXT_PRE_CMD_EXEC; > + > + vsp1_dl_ext_cmd_fill_header(dl->pre_cmd); > + } > + > + if (dl->post_cmd) { > + dl->extension->post_ext_dl_plist = dl->post_cmd->cmd_dma; > + dl->extension->post_ext_dl_num_cmd = dl->post_cmd->num_cmds; > + dl->extension->flags |= VSP1_DLH_EXT_POST_CMD_EXEC; > + > + vsp1_dl_ext_cmd_fill_header(dl->post_cmd); > + } > } > > static bool vsp1_dl_list_hw_update_pending(struct vsp1_dl_manager *dlm) > @@ -736,9 +822,16 @@ unsigned int vsp1_dlm_irq_frame_end(struct > vsp1_dl_manager *dlm) /* Hardware Setup */ > void vsp1_dlm_setup(struct vsp1_device *vsp1) > { > + unsigned int i; > u32 ctrl = (256 << VI6_DL_CTRL_AR_WAIT_SHIFT) > | VI6_DL_CTRL_DC2 | VI6_DL_CTRL_DC1 | VI6_DL_CTRL_DC0 > | VI6_DL_CTRL_DLE; > + u32 ext_dl = (0x02 << VI6_DL_EXT_CTRL_POLINT_SHIFT) | > + VI6_DL_EXT_CTRL_DLPRI | VI6_DL_EXT_CTRL_EXT; To match the style of the file, can you move the trailing | under the = ? > + > + if (vsp1_feature(vsp1, VSP1_HAS_EXT_DL)) > + for (i = 0; i < vsp1->info->wpf_count; ++i) > + vsp1_write(vsp1, VI6_DL_EXT_CTRL(i), ext_dl); And add {} to the if ? With these small updates, Reviewed-by: Laurent Pinchart If there's no other issue with v5 that would require a v6, I'll fix this when applying. > vsp1_write(vsp1, VI6_DL_CTRL, ctrl); > vsp1_write(vsp1, VI6_DL_SWAP, VI6_DL_SWAP_LWS); > @@ -792,7 +885,11 @@ struct vsp1_dl_manager *vsp1_dlm_create(struct > vsp1_device *vsp1, * memory. An extra body is allocated on top of the > prealloc to account * for the cached body used by the vsp1_pipeline object. > */ > - header_size = ALIGN(sizeof(struct vsp1_dl_header), 8); > + header_size = vsp1_feature(vsp1, VSP1_HAS_EXT_DL) ? > + sizeof(struct vsp1_dl_header_extended) : > + sizeof(struct vsp1_dl_header); > + > + header_size = ALIGN(header_size, 8); > > dlm->pool = vsp1_dl_body_pool_create(vsp1, prealloc + 1, > VSP1_DL_NUM_ENTRIES, header_size); > @@ -808,6 +905,11 @@ struct vsp1_dl_manager *vsp1_dlm_create(struct > vsp1_device *vsp1, return NULL; > } > > + /* The extended header immediately follows the header. */ > + if (vsp1_feature(vsp1, VSP1_HAS_EXT_DL)) > + dl->extension = (void *)dl->header > + + sizeof(*dl->header); > + > list_add_tail(&dl->list, &dlm->free); > } > > diff --git a/drivers/media/platform/vsp1/vsp1_dl.h > b/drivers/media/platform/vsp1/vsp1_dl.h index 7dba0469c92e..afefd5bfa136 > 100644 > --- a/drivers/media/platform/vsp1/vsp1_dl.h > +++ b/drivers/media/platform/vsp1/vsp1_dl.h > @@ -20,6 +20,31 @@ struct vsp1_dl_manager; > #define VSP1_DL_FRAME_END_COMPLETED BIT(0) > #define VSP1_DL_FRAME_END_INTERNAL BIT(1) > > +/** > + * struct vsp1_dl_ext_cmd - Extended Display command > + * @free: entry in the pool of free commands list > + * @opcode: command type opcode > + * @flags: flags used by the command > + * @cmds: array of command bodies for this extended cmd > + * @num_cmds: quantity of commands in @cmds array > + * @cmd_dma: DMA address of the command body > + * @data: memory allocation for command-specific data > + * @data_dma: DMA address for command-specific data > + */ > +struct vsp1_dl_ext_cmd { > + struct list_head free; > + > + u8 opcode; > + u32 flags; > + > + struct vsp1_pre_ext_dl_body *cmds; > + unsigned int num_cmds; > + dma_addr_t cmd_dma; > + > + void *data; > + dma_addr_t data_dma; > +}; > + > void vsp1_dlm_setup(struct vsp1_device *vsp1); > > struct vsp1_dl_manager *vsp1_dlm_create(struct vsp1_device *vsp1, > diff --git a/drivers/media/platform/vsp1/vsp1_drv.c > b/drivers/media/platform/vsp1/vsp1_drv.c index 3367c2ba990d..b6619c9c18bb > 100644 > --- a/drivers/media/platform/vsp1/vsp1_drv.c > +++ b/drivers/media/platform/vsp1/vsp1_drv.c > @@ -754,7 +754,7 @@ static const struct vsp1_device_info vsp1_device_infos[] > = { .version = VI6_IP_VERSION_MODEL_VSPD_GEN3, > .model = "VSP2-D", > .gen = 3, > - .features = VSP1_HAS_BRU | VSP1_HAS_WPF_VFLIP, > + .features = VSP1_HAS_BRU | VSP1_HAS_WPF_VFLIP | VSP1_HAS_EXT_DL, > .lif_count = 1, > .rpf_count = 5, > .uif_count = 1, > @@ -774,7 +774,7 @@ static const struct vsp1_device_info vsp1_device_infos[] > = { .version = VI6_IP_VERSION_MODEL_VSPDL_GEN3, > .model = "VSP2-DL", > .gen = 3, > - .features = VSP1_HAS_BRS | VSP1_HAS_BRU, > + .features = VSP1_HAS_BRS | VSP1_HAS_BRU | VSP1_HAS_EXT_DL, > .lif_count = 2, > .rpf_count = 5, > .uif_count = 2, > diff --git a/drivers/media/platform/vsp1/vsp1_regs.h > b/drivers/media/platform/vsp1/vsp1_regs.h index 0d249ff9f564..5ea9f9070cf3 > 100644 > --- a/drivers/media/platform/vsp1/vsp1_regs.h > +++ b/drivers/media/platform/vsp1/vsp1_regs.h > @@ -72,7 +72,7 @@ > #define VI6_DL_SWAP_WDS (1 << 1) > #define VI6_DL_SWAP_BTS (1 << 0) > > -#define VI6_DL_EXT_CTRL 0x011c > +#define VI6_DL_EXT_CTRL(n) (0x011c + (n) * 36) > #define VI6_DL_EXT_CTRL_NWE (1 << 16) > #define VI6_DL_EXT_CTRL_POLINT_MASK (0x3f << 8) > #define VI6_DL_EXT_CTRL_POLINT_SHIFT 8 -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH v5 08/11] media: vsp1: Add support for extended display list headers Date: Thu, 02 Aug 2018 17:39:11 +0300 Message-ID: <19660073.SniHlcofiQ@avalon> References: <4c12a88003d585ecc36054a6492357fdd4565d40.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 [IPv6:2001:4b98:dc2:55:216:3eff:fef7:d647]) by gabe.freedesktop.org (Postfix) with ESMTPS id 08AC36E285 for ; Thu, 2 Aug 2018 14:38:31 +0000 (UTC) In-Reply-To: <4c12a88003d585ecc36054a6492357fdd4565d40.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 IDIwMTggMjM6MzU6NTAgRUVTVCBLaWVyYW4gQmluZ2hhbSB3cm90ZToKPiBGcm9tOiBLaWVyYW4g QmluZ2hhbSA8a2llcmFuLmJpbmdoYW0rcmVuZXNhc0BpZGVhc29uYm9hcmQuY29tPgo+IAo+IEV4 dGVuZGVkIGRpc3BsYXkgbGlzdCBoZWFkZXJzIGFsbG93IHByZSBhbmQgcG9zdCBjb21tYW5kIGxp c3RzIHRvIGJlCj4gZXhlY3V0ZWQgYnkgdGhlIFZTUCBwaXBlbGluZS4gVGhpcyBwcm92aWRlcyB0 aGUgYmFzZSBzdXBwb3J0IGZvcgo+IGZlYXR1cmVzIHN1Y2ggYXMgQVVUT19GTEQgKGZvciBpbnRl cmxhY2VkIHN1cHBvcnQpIGFuZCBBVVRPX0RJU1AgKGZvcgo+IHN1cHBvcnRpbmcgY29udGludW91 cyBjYW1lcmEgcHJldmlldyBwaXBlbGluZXMuCj4gCj4gU2lnbmVkLW9mZi1ieTogS2llcmFuIEJp bmdoYW0gPGtpZXJhbi5iaW5naGFtK3JlbmVzYXNAaWRlYXNvbmJvYXJkLmNvbT4KPiAKPiAtLS0K PiAKPiB2MjoKPiAgLSByZW1vdmUgX19wYWNrZWQgYXR0cmlidXRlcwo+IAo+IHY1Ogo+ICAtIFJl bmFtZSB2c3AxX2RsX2V4dF9oZWFkZXIgZmllbGQgbmFtZXMKPiAgLSBSZW5hbWUgQGV4dGVuZGVk IC0+IEBleHRlbnNpb24KPiAgLSBSZW1vdmUgdW5uZWNlc3NhcnkgVkk2X0RMX1NXQVAgY2hhbmdl cwo+ICAtIFJlbmFtZSBAY21kX29wY29kZSAtPiBAb3Bjb2RlCj4gIC0gRHJvcCB1bnVzZWQgQGRh dGFfc2l6ZSBmaWVsZAo+ICAtIE1vdmUgaXRlcmF0aW9uIG9mIFdQRidzIGluc2lkZSB2c3AxX2Rs bV9zZXR1cAo+ICAtIFJlbmFtZSB2c3AxX2RsX2V4dF9jbWRfaGVhZGVyIC0+IHZzcDFfcHJlX2V4 dF9kbF9ib2R5Cj4gIC0gUmVuYW1lIHZzcDFfcHJlX2V4dF9kbF9ib2R5LT5jbWQgdG8gdnNwMV9w cmVfZXh0X2RsX2JvZHktPm9wY29kZQo+ICAtIFJlbmFtZSB2c3AxX2RsX2V4dF9oZWFkZXItPnJl c2VydmVkMCB0byB2c3AxX2RsX2V4dF9oZWFkZXItPnBhZGRpbmcKPiAgLSB2c3AxX3ByZV9leHRf ZGxfYm9keTogUmVuYW1lICdkYXRhJyB0byAnYWRkcmVzc19zZXQnCj4gIC0gdnNwMV9wcmVfZXh0 X2RsX2JvZHk6IEFkZCBzdHJ1Y3QgZG9jdW1lbnRhdGlvbgo+ICAtIERvY3VtZW50IG9yZGVyaW5n IG9mIDE2Yml0IGFjY2Vzc2VzIGZvciBmbGFncyBpbiB2c3AxX2RsX2V4dF9oZWFkZXIKPiAKPiAg ZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDEuaCAgICAgIHwgICAxICstCj4gIGRyaXZl cnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmMgICB8IDEwNCArKysrKysrKysrKysrKysr KysrKysrKystCj4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmggICB8ICAy NSArKysrKystCj4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2Rydi5jICB8ICAg NCArLQo+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9yZWdzLmggfCAgIDIgKy0K PiAgNSBmaWxlcyBjaGFuZ2VkLCAxMzIgaW5zZXJ0aW9ucygrKSwgNCBkZWxldGlvbnMoLSkKPiAK PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDEuaAo+IGIvZHJp dmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDEuaCBpbmRleCBmMGQyMWNjOGU5YWIuLjU2YzYy MTIyYTgxYQo+IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3Ax LmgKPiArKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMS5oCj4gQEAgLTUzLDYg KzUzLDcgQEAgc3RydWN0IHZzcDFfdWlmOwo+ICAjZGVmaW5lIFZTUDFfSEFTX0hHTwkJKDEgPDwg NykKPiAgI2RlZmluZSBWU1AxX0hBU19IR1QJCSgxIDw8IDgpCj4gICNkZWZpbmUgVlNQMV9IQVNf QlJTCQkoMSA8PCA5KQo+ICsjZGVmaW5lIFZTUDFfSEFTX0VYVF9ETAkJKDEgPDwgMTApCj4gCj4g IHN0cnVjdCB2c3AxX2RldmljZV9pbmZvIHsKPiAgCXUzMiB2ZXJzaW9uOwo+IGRpZmYgLS1naXQg YS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kbC5jCj4gYi9kcml2ZXJzL21lZGlh L3BsYXRmb3JtL3ZzcDEvdnNwMV9kbC5jIGluZGV4IDkwZTBhMTFjMjliNS4uMmZmZmU5NzdhYTM1 Cj4gMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwuYwo+ ICsrKyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmMKPiBAQCAtMjIsNiAr MjIsOSBAQAo+ICAjZGVmaW5lIFZTUDFfRExIX0lOVF9FTkFCTEUJCSgxIDw8IDEpCj4gICNkZWZp bmUgVlNQMV9ETEhfQVVUT19TVEFSVAkJKDEgPDwgMCkKPiAKPiArI2RlZmluZSBWU1AxX0RMSF9F WFRfUFJFX0NNRF9FWEVDCSgxIDw8IDkpCj4gKyNkZWZpbmUgVlNQMV9ETEhfRVhUX1BPU1RfQ01E X0VYRUMJKDEgPDwgOCkKPiArCj4gIHN0cnVjdCB2c3AxX2RsX2hlYWRlcl9saXN0IHsKPiAgCXUz MiBudW1fYnl0ZXM7Cj4gIAl1MzIgYWRkcjsKPiBAQCAtMzQsMTIgKzM3LDU5IEBAIHN0cnVjdCB2 c3AxX2RsX2hlYWRlciB7Cj4gIAl1MzIgZmxhZ3M7Cj4gIH07Cj4gCj4gKy8qKgo+ICsgKiBzdHJ1 Y3QgdnNwMV9kbF9leHRfaGVhZGVyIC0gRXh0ZW5kZWQgZGlzcGxheSBsaXN0IGhlYWRlcgo+ICsg KiBAcGFkZGluZzogcGFkZGluZyB6ZXJvIGJ5dGVzIGZvciBhbGlnbm1lbnQKPiArICogQHByZV9l eHRfZGxfbnVtX2NtZDogbnVtYmVyIG9mIHByZS1leHRlbmRlZCBjb21tYW5kIGJvZGllcyB0byBw YXJzZQo+ICsgKiBAZmxhZ3M6IGVuYWJsZXMgb3IgZGlzYWJsZXMgZXhlY3V0aW9uIG9mIHRoZSBw cmUgYW5kIHBvc3QgY29tbWFuZAo+ICsgKiBAcHJlX2V4dF9kbF9wbGlzdDogc3RhcnQgYWRkcmVz cyBvZiBwcmUtZXh0ZW5kZWQgZGlzcGxheSBsaXN0IGJvZGllcwo+ICsgKiBAcG9zdF9leHRfZGxf bnVtX2NtZDogbnVtYmVyIG9mIHBvc3QtZXh0ZW5kZWQgY29tbWFuZCBib2RpZXMgdG8gcGFyc2UK PiArICogQHBvc3RfZXh0X2RsX3BsaXN0OiBzdGFydCBhZGRyZXNzIG9mIHBvc3QtZXh0ZW5kZWQg ZGlzcGxheSBsaXN0IGJvZGllcwo+ICsgKi8KPiArc3RydWN0IHZzcDFfZGxfZXh0X2hlYWRlciB7 Cj4gKwl1MzIgcGFkZGluZzsKPiArCj4gKwkvKgo+ICsJICogVGhlIGRhdGFzaGVldCByZXByZXNl bnRzIGZsYWdzIGFzIHN0b3JlZCBiZWZvcmUgcHJlX2V4dF9kbF9udW1fY21kLAo+ICsJICogZXhw ZWN0aW5nIDMyLWJpdCBhY2Nlc3Nlcy4gVGhlIGZsYWdzIGFyZSBhcHByb3ByaWF0ZSB0byB0aGUg d2hvbGUKPiArCSAqIGhlYWRlciwgbm90IGp1c3QgdGhlIHByZV9leHQgY29tbWFuZCwgYW5kIHRo dXMgd2FycmFudCBiZWluZwo+ICsJICogc2VwYXJhdGVkIG91dC4gRHVlIHRvIGJ5dGUgb3JkZXJp bmcsIGFuZCByZXByZXNlbnRpbmcgYXMgMTYgYml0Cj4gKwkgKiB2YWx1ZXMgaGVyZSwgdGhlIGZs YWdzIG11c3QgYmUgcG9zaXRpb25lZCBhZnRlciB0aGUKPiArCSAqIHByZV9leHRfZGxfbnVtX2Nt ZC4KPiArCSAqLwo+ICsJdTE2IHByZV9leHRfZGxfbnVtX2NtZDsKPiArCXUxNiBmbGFnczsKPiAr CXUzMiBwcmVfZXh0X2RsX3BsaXN0Owo+ICsKPiArCXUzMiBwb3N0X2V4dF9kbF9udW1fY21kOwo+ ICsJdTMyIHBvc3RfZXh0X2RsX3BsaXN0Owo+ICt9Owo+ICsKPiArc3RydWN0IHZzcDFfZGxfaGVh ZGVyX2V4dGVuZGVkIHsKPiArCXN0cnVjdCB2c3AxX2RsX2hlYWRlciBoZWFkZXI7Cj4gKwlzdHJ1 Y3QgdnNwMV9kbF9leHRfaGVhZGVyIGV4dDsKPiArfTsKPiArCj4gIHN0cnVjdCB2c3AxX2RsX2Vu dHJ5IHsKPiAgCXUzMiBhZGRyOwo+ICAJdTMyIGRhdGE7Cj4gIH07Cj4gCj4gIC8qKgo+ICsgKiBz dHJ1Y3QgdnNwMV9wcmVfZXh0X2RsX2JvZHkgLSBQcmUgRXh0ZW5kZWQgRGlzcGxheSBMaXN0IEJv ZHkKPiArICogQG9wY29kZTogRXh0ZW5kZWQgZGlzcGxheSBsaXN0IGNvbW1hbmQgb3BlcmF0aW9u IGNvZGUKPiArICogQGZsYWdzOiBQcmUtZXh0ZW5kZWQgY29tbWFuZCBmbGFncy4gVGhlc2UgYXJl IHNwZWNpZmljIHRvIGVhY2ggY29tbWFuZAo+ICsgKiBAYWRkcmVzc19zZXQ6IFNvdXJjZSBhZGRy ZXNzIHNldCBwb2ludGVyLiBNdXN0IGhhdmUgMTYgYnl0ZSBhbGlnbm1lbnQKCnMvYnl0ZS9ieXRl cy8KCj4gKyAqIEByZXNlcnZlZDogWmVybyBiaXRzIGZvciBhbGlnbm1lbnQuCj4gKyAqLwo+ICtz dHJ1Y3QgdnNwMV9wcmVfZXh0X2RsX2JvZHkgewo+ICsJdTMyIG9wY29kZTsKPiArCXUzMiBmbGFn czsKPiArCXUzMiBhZGRyZXNzX3NldDsKPiArCXUzMiByZXNlcnZlZDsKPiArfTsKPiArCj4gKy8q Kgo+ICAgKiBzdHJ1Y3QgdnNwMV9kbF9ib2R5IC0gRGlzcGxheSBsaXN0IGJvZHkKPiAgICogQGxp c3Q6IGVudHJ5IGluIHRoZSBkaXNwbGF5IGxpc3QgbGlzdCBvZiBib2RpZXMKPiAgICogQGZyZWU6 IGVudHJ5IGluIHRoZSBwb29sIGZyZWUgYm9keSBsaXN0Cj4gQEAgLTk1LDkgKzE0NSwxMiBAQCBz dHJ1Y3QgdnNwMV9kbF9ib2R5X3Bvb2wgewo+ICAgKiBAbGlzdDogZW50cnkgaW4gdGhlIGRpc3Bs YXkgbGlzdCBtYW5hZ2VyIGxpc3RzCj4gICAqIEBkbG06IHRoZSBkaXNwbGF5IGxpc3QgbWFuYWdl cgo+ICAgKiBAaGVhZGVyOiBkaXNwbGF5IGxpc3QgaGVhZGVyCj4gKyAqIEBleHRlbnNpb246IGV4 dGVuZGVkIGRpc3BsYXkgbGlzdCBoZWFkZXIuIE5VTEwgZm9yIG5vcm1hbCBsaXN0cwo+ICAgKiBA ZG1hOiBETUEgYWRkcmVzcyBmb3IgdGhlIGhlYWRlcgo+ICAgKiBAYm9keTA6IGZpcnN0IGRpc3Bs YXkgbGlzdCBib2R5Cj4gICAqIEBib2RpZXM6IGxpc3Qgb2YgZXh0cmEgZGlzcGxheSBsaXN0IGJv ZGllcwo+ICsgKiBAcHJlX2NtZDogcHJlIGNvbW1hbmQgdG8gYmUgaXNzdWVkIHRocm91Z2ggZXh0 ZW5kZWQgZGwgaGVhZGVyCj4gKyAqIEBwb3N0X2NtZDogcG9zdCBjb21tYW5kIHRvIGJlIGlzc3Vl ZCB0aHJvdWdoIGV4dGVuZGVkIGRsIGhlYWRlcgo+ICAgKiBAaGFzX2NoYWluOiBpZiB0cnVlLCBp bmRpY2F0ZXMgdGhhdCB0aGVyZSdzIGEgcGFydGl0aW9uIGNoYWluCj4gICAqIEBjaGFpbjogZW50 cnkgaW4gdGhlIGRpc3BsYXkgbGlzdCBwYXJ0aXRpb24gY2hhaW4KPiAgICogQGludGVybmFsOiB3 aGV0aGVyIHRoZSBkaXNwbGF5IGxpc3QgaXMgdXNlZCBmb3IgaW50ZXJuYWwgcHVycG9zZQo+IEBA IC0xMDcsMTEgKzE2MCwxNSBAQCBzdHJ1Y3QgdnNwMV9kbF9saXN0IHsKPiAgCXN0cnVjdCB2c3Ax X2RsX21hbmFnZXIgKmRsbTsKPiAKPiAgCXN0cnVjdCB2c3AxX2RsX2hlYWRlciAqaGVhZGVyOwo+ ICsJc3RydWN0IHZzcDFfZGxfZXh0X2hlYWRlciAqZXh0ZW5zaW9uOwo+ICAJZG1hX2FkZHJfdCBk bWE7Cj4gCj4gIAlzdHJ1Y3QgdnNwMV9kbF9ib2R5ICpib2R5MDsKPiAgCXN0cnVjdCBsaXN0X2hl YWQgYm9kaWVzOwo+IAo+ICsJc3RydWN0IHZzcDFfZGxfZXh0X2NtZCAqcHJlX2NtZDsKPiArCXN0 cnVjdCB2c3AxX2RsX2V4dF9jbWQgKnBvc3RfY21kOwo+ICsKPiAgCWJvb2wgaGFzX2NoYWluOwo+ ICAJc3RydWN0IGxpc3RfaGVhZCBjaGFpbjsKPiAKPiBAQCAtNDk1LDYgKzU1MiwxNCBAQCBpbnQg dnNwMV9kbF9saXN0X2FkZF9jaGFpbihzdHJ1Y3QgdnNwMV9kbF9saXN0ICpoZWFkLAo+ICAJcmV0 dXJuIDA7Cj4gIH0KPiAKPiArc3RhdGljIHZvaWQgdnNwMV9kbF9leHRfY21kX2ZpbGxfaGVhZGVy KHN0cnVjdCB2c3AxX2RsX2V4dF9jbWQgKmNtZCkKPiArewo+ICsJY21kLT5jbWRzWzBdLm9wY29k ZSA9IGNtZC0+b3Bjb2RlOwo+ICsJY21kLT5jbWRzWzBdLmZsYWdzID0gY21kLT5mbGFnczsKPiAr CWNtZC0+Y21kc1swXS5hZGRyZXNzX3NldCA9IGNtZC0+ZGF0YV9kbWE7Cj4gKwljbWQtPmNtZHNb MF0ucmVzZXJ2ZWQgPSAwOwo+ICt9Cj4gKwo+ICBzdGF0aWMgdm9pZCB2c3AxX2RsX2xpc3RfZmls bF9oZWFkZXIoc3RydWN0IHZzcDFfZGxfbGlzdCAqZGwsIGJvb2wgaXNfbGFzdCkKPiB7Cj4gIAlz dHJ1Y3QgdnNwMV9kbF9tYW5hZ2VyICpkbG0gPSBkbC0+ZGxtOwo+IEBAIC01NDcsNiArNjEyLDI3 IEBAIHN0YXRpYyB2b2lkIHZzcDFfZGxfbGlzdF9maWxsX2hlYWRlcihzdHJ1Y3QKPiB2c3AxX2Rs X2xpc3QgKmRsLCBib29sIGlzX2xhc3QpICovCj4gIAkJZGwtPmhlYWRlci0+ZmxhZ3MgPSBWU1Ax X0RMSF9JTlRfRU5BQkxFOwo+ICAJfQo+ICsKPiArCWlmICghZGwtPmV4dGVuc2lvbikKPiArCQly ZXR1cm47Cj4gKwo+ICsJZGwtPmV4dGVuc2lvbi0+ZmxhZ3MgPSAwOwo+ICsKPiArCWlmIChkbC0+ cHJlX2NtZCkgewo+ICsJCWRsLT5leHRlbnNpb24tPnByZV9leHRfZGxfcGxpc3QgPSBkbC0+cHJl X2NtZC0+Y21kX2RtYTsKPiArCQlkbC0+ZXh0ZW5zaW9uLT5wcmVfZXh0X2RsX251bV9jbWQgPSBk bC0+cHJlX2NtZC0+bnVtX2NtZHM7Cj4gKwkJZGwtPmV4dGVuc2lvbi0+ZmxhZ3MgfD0gVlNQMV9E TEhfRVhUX1BSRV9DTURfRVhFQzsKPiArCj4gKwkJdnNwMV9kbF9leHRfY21kX2ZpbGxfaGVhZGVy KGRsLT5wcmVfY21kKTsKPiArCX0KPiArCj4gKwlpZiAoZGwtPnBvc3RfY21kKSB7Cj4gKwkJZGwt PmV4dGVuc2lvbi0+cG9zdF9leHRfZGxfcGxpc3QgPSBkbC0+cG9zdF9jbWQtPmNtZF9kbWE7Cj4g KwkJZGwtPmV4dGVuc2lvbi0+cG9zdF9leHRfZGxfbnVtX2NtZCA9IGRsLT5wb3N0X2NtZC0+bnVt X2NtZHM7Cj4gKwkJZGwtPmV4dGVuc2lvbi0+ZmxhZ3MgfD0gVlNQMV9ETEhfRVhUX1BPU1RfQ01E X0VYRUM7Cj4gKwo+ICsJCXZzcDFfZGxfZXh0X2NtZF9maWxsX2hlYWRlcihkbC0+cG9zdF9jbWQp Owo+ICsJfQo+ICB9Cj4gCj4gIHN0YXRpYyBib29sIHZzcDFfZGxfbGlzdF9od191cGRhdGVfcGVu ZGluZyhzdHJ1Y3QgdnNwMV9kbF9tYW5hZ2VyICpkbG0pCj4gQEAgLTczNiw5ICs4MjIsMTYgQEAg dW5zaWduZWQgaW50IHZzcDFfZGxtX2lycV9mcmFtZV9lbmQoc3RydWN0Cj4gdnNwMV9kbF9tYW5h Z2VyICpkbG0pIC8qIEhhcmR3YXJlIFNldHVwICovCj4gIHZvaWQgdnNwMV9kbG1fc2V0dXAoc3Ry dWN0IHZzcDFfZGV2aWNlICp2c3AxKQo+ICB7Cj4gKwl1bnNpZ25lZCBpbnQgaTsKPiAgCXUzMiBj dHJsID0gKDI1NiA8PCBWSTZfRExfQ1RSTF9BUl9XQUlUX1NISUZUKQo+ICAJCSB8IFZJNl9ETF9D VFJMX0RDMiB8IFZJNl9ETF9DVFJMX0RDMSB8IFZJNl9ETF9DVFJMX0RDMAo+ICAJCSB8IFZJNl9E TF9DVFJMX0RMRTsKPiArCXUzMiBleHRfZGwgPSAoMHgwMiA8PCBWSTZfRExfRVhUX0NUUkxfUE9M SU5UX1NISUZUKSB8Cj4gKwkJICAgICAgVkk2X0RMX0VYVF9DVFJMX0RMUFJJIHwgVkk2X0RMX0VY VF9DVFJMX0VYVDsKClRvIG1hdGNoIHRoZSBzdHlsZSBvZiB0aGUgZmlsZSwgY2FuIHlvdSBtb3Zl IHRoZSB0cmFpbGluZyB8IHVuZGVyIHRoZSA9ID8KCj4gKwo+ICsJaWYgKHZzcDFfZmVhdHVyZSh2 c3AxLCBWU1AxX0hBU19FWFRfREwpKQo+ICsJCWZvciAoaSA9IDA7IGkgPCB2c3AxLT5pbmZvLT53 cGZfY291bnQ7ICsraSkKPiArCQkJdnNwMV93cml0ZSh2c3AxLCBWSTZfRExfRVhUX0NUUkwoaSks IGV4dF9kbCk7CgpBbmQgYWRkIHt9IHRvIHRoZSBpZiA/CgpXaXRoIHRoZXNlIHNtYWxsIHVwZGF0 ZXMsCgpSZXZpZXdlZC1ieTogTGF1cmVudCBQaW5jaGFydCA8bGF1cmVudC5waW5jaGFydEBpZGVh c29uYm9hcmQuY29tPgoKSWYgdGhlcmUncyBubyBvdGhlciBpc3N1ZSB3aXRoIHY1IHRoYXQgd291 bGQgcmVxdWlyZSBhIHY2LCBJJ2xsIGZpeCB0aGlzIHdoZW4gCmFwcGx5aW5nLgoKPiAgCXZzcDFf d3JpdGUodnNwMSwgVkk2X0RMX0NUUkwsIGN0cmwpOwo+ICAJdnNwMV93cml0ZSh2c3AxLCBWSTZf RExfU1dBUCwgVkk2X0RMX1NXQVBfTFdTKTsKPiBAQCAtNzkyLDcgKzg4NSwxMSBAQCBzdHJ1Y3Qg dnNwMV9kbF9tYW5hZ2VyICp2c3AxX2RsbV9jcmVhdGUoc3RydWN0Cj4gdnNwMV9kZXZpY2UgKnZz cDEsICogbWVtb3J5LiBBbiBleHRyYSBib2R5IGlzIGFsbG9jYXRlZCBvbiB0b3Agb2YgdGhlCj4g cHJlYWxsb2MgdG8gYWNjb3VudCAqIGZvciB0aGUgY2FjaGVkIGJvZHkgdXNlZCBieSB0aGUgdnNw MV9waXBlbGluZSBvYmplY3QuCj4gIAkgKi8KPiAtCWhlYWRlcl9zaXplID0gQUxJR04oc2l6ZW9m KHN0cnVjdCB2c3AxX2RsX2hlYWRlciksIDgpOwo+ICsJaGVhZGVyX3NpemUgPSB2c3AxX2ZlYXR1 cmUodnNwMSwgVlNQMV9IQVNfRVhUX0RMKSA/Cj4gKwkJCXNpemVvZihzdHJ1Y3QgdnNwMV9kbF9o ZWFkZXJfZXh0ZW5kZWQpIDoKPiArCQkJc2l6ZW9mKHN0cnVjdCB2c3AxX2RsX2hlYWRlcik7Cj4g Kwo+ICsJaGVhZGVyX3NpemUgPSBBTElHTihoZWFkZXJfc2l6ZSwgOCk7Cj4gCj4gIAlkbG0tPnBv b2wgPSB2c3AxX2RsX2JvZHlfcG9vbF9jcmVhdGUodnNwMSwgcHJlYWxsb2MgKyAxLAo+ICAJCQkJ CSAgICAgVlNQMV9ETF9OVU1fRU5UUklFUywgaGVhZGVyX3NpemUpOwo+IEBAIC04MDgsNiArOTA1 LDExIEBAIHN0cnVjdCB2c3AxX2RsX21hbmFnZXIgKnZzcDFfZGxtX2NyZWF0ZShzdHJ1Y3QKPiB2 c3AxX2RldmljZSAqdnNwMSwgcmV0dXJuIE5VTEw7Cj4gIAkJfQo+IAo+ICsJCS8qIFRoZSBleHRl bmRlZCBoZWFkZXIgaW1tZWRpYXRlbHkgZm9sbG93cyB0aGUgaGVhZGVyLiAqLwo+ICsJCWlmICh2 c3AxX2ZlYXR1cmUodnNwMSwgVlNQMV9IQVNfRVhUX0RMKSkKPiArCQkJZGwtPmV4dGVuc2lvbiA9 ICh2b2lkICopZGwtPmhlYWRlcgo+ICsJCQkJICAgICAgKyBzaXplb2YoKmRsLT5oZWFkZXIpOwo+ ICsKPiAgCQlsaXN0X2FkZF90YWlsKCZkbC0+bGlzdCwgJmRsbS0+ZnJlZSk7Cj4gIAl9Cj4gCj4g ZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmgKPiBiL2Ry aXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmggaW5kZXggN2RiYTA0NjljOTJlLi5h ZmVmZDViZmExMzYKPiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEv dnNwMV9kbC5oCj4gKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwuaAo+ IEBAIC0yMCw2ICsyMCwzMSBAQCBzdHJ1Y3QgdnNwMV9kbF9tYW5hZ2VyOwo+ICAjZGVmaW5lIFZT UDFfRExfRlJBTUVfRU5EX0NPTVBMRVRFRAkJQklUKDApCj4gICNkZWZpbmUgVlNQMV9ETF9GUkFN RV9FTkRfSU5URVJOQUwJCUJJVCgxKQo+IAo+ICsvKioKPiArICogc3RydWN0IHZzcDFfZGxfZXh0 X2NtZCAtIEV4dGVuZGVkIERpc3BsYXkgY29tbWFuZAo+ICsgKiBAZnJlZTogZW50cnkgaW4gdGhl IHBvb2wgb2YgZnJlZSBjb21tYW5kcyBsaXN0Cj4gKyAqIEBvcGNvZGU6IGNvbW1hbmQgdHlwZSBv cGNvZGUKPiArICogQGZsYWdzOiBmbGFncyB1c2VkIGJ5IHRoZSBjb21tYW5kCj4gKyAqIEBjbWRz OiBhcnJheSBvZiBjb21tYW5kIGJvZGllcyBmb3IgdGhpcyBleHRlbmRlZCBjbWQKPiArICogQG51 bV9jbWRzOiBxdWFudGl0eSBvZiBjb21tYW5kcyBpbiBAY21kcyBhcnJheQo+ICsgKiBAY21kX2Rt YTogRE1BIGFkZHJlc3Mgb2YgdGhlIGNvbW1hbmQgYm9keQo+ICsgKiBAZGF0YTogbWVtb3J5IGFs bG9jYXRpb24gZm9yIGNvbW1hbmQtc3BlY2lmaWMgZGF0YQo+ICsgKiBAZGF0YV9kbWE6IERNQSBh ZGRyZXNzIGZvciBjb21tYW5kLXNwZWNpZmljIGRhdGEKPiArICovCj4gK3N0cnVjdCB2c3AxX2Rs X2V4dF9jbWQgewo+ICsJc3RydWN0IGxpc3RfaGVhZCBmcmVlOwo+ICsKPiArCXU4IG9wY29kZTsK PiArCXUzMiBmbGFnczsKPiArCj4gKwlzdHJ1Y3QgdnNwMV9wcmVfZXh0X2RsX2JvZHkgKmNtZHM7 Cj4gKwl1bnNpZ25lZCBpbnQgbnVtX2NtZHM7Cj4gKwlkbWFfYWRkcl90IGNtZF9kbWE7Cj4gKwo+ ICsJdm9pZCAqZGF0YTsKPiArCWRtYV9hZGRyX3QgZGF0YV9kbWE7Cj4gK307Cj4gKwo+ICB2b2lk IHZzcDFfZGxtX3NldHVwKHN0cnVjdCB2c3AxX2RldmljZSAqdnNwMSk7Cj4gCj4gIHN0cnVjdCB2 c3AxX2RsX21hbmFnZXIgKnZzcDFfZGxtX2NyZWF0ZShzdHJ1Y3QgdnNwMV9kZXZpY2UgKnZzcDEs Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2Rydi5jCj4g Yi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kcnYuYyBpbmRleCAzMzY3YzJiYTk5 MGQuLmI2NjE5YzljMThiYgo+IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0v dnNwMS92c3AxX2Rydi5jCj4gKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFf ZHJ2LmMKPiBAQCAtNzU0LDcgKzc1NCw3IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgdnNwMV9kZXZp Y2VfaW5mbyB2c3AxX2RldmljZV9pbmZvc1tdCj4gPSB7IC52ZXJzaW9uID0gVkk2X0lQX1ZFUlNJ T05fTU9ERUxfVlNQRF9HRU4zLAo+ICAJCS5tb2RlbCA9ICJWU1AyLUQiLAo+ICAJCS5nZW4gPSAz LAo+IC0JCS5mZWF0dXJlcyA9IFZTUDFfSEFTX0JSVSB8IFZTUDFfSEFTX1dQRl9WRkxJUCwKPiAr CQkuZmVhdHVyZXMgPSBWU1AxX0hBU19CUlUgfCBWU1AxX0hBU19XUEZfVkZMSVAgfCBWU1AxX0hB U19FWFRfREwsCj4gIAkJLmxpZl9jb3VudCA9IDEsCj4gIAkJLnJwZl9jb3VudCA9IDUsCj4gIAkJ LnVpZl9jb3VudCA9IDEsCj4gQEAgLTc3NCw3ICs3NzQsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0 IHZzcDFfZGV2aWNlX2luZm8gdnNwMV9kZXZpY2VfaW5mb3NbXQo+ID0geyAudmVyc2lvbiA9IFZJ Nl9JUF9WRVJTSU9OX01PREVMX1ZTUERMX0dFTjMsCj4gIAkJLm1vZGVsID0gIlZTUDItREwiLAo+ ICAJCS5nZW4gPSAzLAo+IC0JCS5mZWF0dXJlcyA9IFZTUDFfSEFTX0JSUyB8IFZTUDFfSEFTX0JS VSwKPiArCQkuZmVhdHVyZXMgPSBWU1AxX0hBU19CUlMgfCBWU1AxX0hBU19CUlUgfCBWU1AxX0hB U19FWFRfREwsCj4gIAkJLmxpZl9jb3VudCA9IDIsCj4gIAkJLnJwZl9jb3VudCA9IDUsCj4gIAkJ LnVpZl9jb3VudCA9IDIsCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNw MS92c3AxX3JlZ3MuaAo+IGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfcmVncy5o IGluZGV4IDBkMjQ5ZmY5ZjU2NC4uNWVhOWY5MDcwY2YzCj4gMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfcmVncy5oCj4gKysrIGIvZHJpdmVycy9tZWRpYS9w bGF0Zm9ybS92c3AxL3ZzcDFfcmVncy5oCj4gQEAgLTcyLDcgKzcyLDcgQEAKPiAgI2RlZmluZSBW STZfRExfU1dBUF9XRFMJCQkoMSA8PCAxKQo+ICAjZGVmaW5lIFZJNl9ETF9TV0FQX0JUUwkJCSgx IDw8IDApCj4gCj4gLSNkZWZpbmUgVkk2X0RMX0VYVF9DVFJMCQkJMHgwMTFjCj4gKyNkZWZpbmUg Vkk2X0RMX0VYVF9DVFJMKG4pCQkoMHgwMTFjICsgKG4pICogMzYpCj4gICNkZWZpbmUgVkk2X0RM X0VYVF9DVFJMX05XRQkJKDEgPDwgMTYpCj4gICNkZWZpbmUgVkk2X0RMX0VYVF9DVFJMX1BPTElO VF9NQVNLCSgweDNmIDw8IDgpCj4gICNkZWZpbmUgVkk2X0RMX0VYVF9DVFJMX1BPTElOVF9TSElG VAk4CgoKLS0gClJlZ2FyZHMsCgpMYXVyZW50IFBpbmNoYXJ0CgoKCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJp LWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9y Zy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=