From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: From: Laurent Pinchart To: Kieran Bingham Cc: linux-renesas-soc@vger.kernel.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org Subject: Re: [PATCH v4 08/11] media: vsp1: Add support for extended display list headers Date: Thu, 24 May 2018 14:44:48 +0300 Message-ID: <4341947.2iR8IN8nZS@avalon> In-Reply-To: <32c7ac51c290efd12b16172839547ba204921143.1525354194.git-series.kieran.bingham+renesas@ideasonboard.com> References: <32c7ac51c290efd12b16172839547ba204921143.1525354194.git-series.kieran.bingham+renesas@ideasonboard.com> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" Sender: linux-media-owner@vger.kernel.org List-ID: Hi Kieran, Thank you for the patch. On Thursday, 3 May 2018 16:36:19 EEST Kieran Bingham wrote: > 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 > --- > drivers/media/platform/vsp1/vsp1.h | 1 +- > drivers/media/platform/vsp1/vsp1_dl.c | 83 +++++++++++++++++++++++++- > drivers/media/platform/vsp1/vsp1_dl.h | 29 ++++++++- > drivers/media/platform/vsp1/vsp1_drv.c | 7 +- > drivers/media/platform/vsp1/vsp1_regs.h | 5 +- > 5 files changed, 116 insertions(+), 9 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 56514cd51c51..b64d32535edc > 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,11 +37,34 @@ struct vsp1_dl_header { > u32 flags; > }; > > +struct vsp1_dl_ext_header { > + u32 reserved0; /* alignment padding */ > + > + u16 pre_ext_cmd_qty; Should this be called pre_ext_dl_num_cmd to match the datasheet ? > + u16 flags; Aren't the flags supposed to come before the pre_ext_dl_num_cmd field ? > + u32 pre_ext_cmd_plist; And pre_ext_dl_plist ? > + > + u32 post_ext_cmd_qty; > + u32 post_ext_cmd_plist; Similar comments for these variables. > +}; > + > +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_dl_ext_cmd_header { Isn't this referred to in the datasheet as a body entry, not a header ? How about naming it vsp1_dl_ext_cmd_entry ? Or just vsp1_dl_ext_cmd (in which case the other structure that goes by the same name would need to be renamed) ? > + u32 cmd; > + u32 flags; > + u32 data; > + u32 reserved; The datasheet documents this as two 64-bit fields, shouldn't we handle the structure the same way ? > +}; > + > /** > * struct vsp1_dl_body - Display list body > * @list: entry in the display list list of bodies > @@ -95,9 +121,12 @@ struct vsp1_dl_body_pool { > * @list: entry in the display list manager lists > * @dlm: the display list manager > * @header: display list header > + * @extended: extended display list header. NULL for normal lists Should we name this extension instead of extended ? > * @dma: DMA address for the header > * @body0: first display list body > * @bodies: list of extra display list bodies > + * @pre_cmd: pre cmd to be issued through extended dl header > + * @post_cmd: post cmd to be issued through extended dl header I think you can spell command in full. > * @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 +136,15 @@ struct vsp1_dl_list { > struct vsp1_dl_manager *dlm; > > struct vsp1_dl_header *header; > + struct vsp1_dl_ext_header *extended; > 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; > > @@ -496,6 +529,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].cmd = cmd->cmd_opcode; > + cmd->cmds[0].flags = cmd->flags; > + cmd->cmds[0].data = 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; > @@ -548,6 +589,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->extended) > + return; > + > + dl->extended->flags = 0; > + > + if (dl->pre_cmd) { > + dl->extended->pre_ext_cmd_plist = dl->pre_cmd->cmd_dma; > + dl->extended->pre_ext_cmd_qty = dl->pre_cmd->num_cmds; > + dl->extended->flags |= VSP1_DLH_EXT_PRE_CMD_EXEC; > + > + vsp1_dl_ext_cmd_fill_header(dl->pre_cmd); > + } > + > + if (dl->post_cmd) { > + dl->extended->pre_ext_cmd_plist = dl->post_cmd->cmd_dma; > + dl->extended->pre_ext_cmd_qty = dl->post_cmd->num_cmds; > + dl->extended->flags |= VSP1_DLH_EXT_POST_CMD_EXEC; > + > + vsp1_dl_ext_cmd_fill_header(dl->pre_cmd); > + } > } > > static bool vsp1_dl_list_hw_update_pending(struct vsp1_dl_manager *dlm) > @@ -735,14 +797,20 @@ unsigned int vsp1_dlm_irq_frame_end(struct > vsp1_dl_manager *dlm) } > > /* Hardware Setup */ > -void vsp1_dlm_setup(struct vsp1_device *vsp1) > +void vsp1_dlm_setup(struct vsp1_device *vsp1, unsigned int index) > { > 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; > > + if (vsp1_feature(vsp1, VSP1_HAS_EXT_DL)) > + vsp1_write(vsp1, VI6_DL_EXT_CTRL(index), > + (0x02 << VI6_DL_EXT_CTRL_POLINT_SHIFT) | > + VI6_DL_EXT_CTRL_DLPRI | VI6_DL_EXT_CTRL_EXT); > + > vsp1_write(vsp1, VI6_DL_CTRL, ctrl); > - vsp1_write(vsp1, VI6_DL_SWAP, VI6_DL_SWAP_LWS); > + vsp1_write(vsp1, VI6_DL_SWAP(index), VI6_DL_SWAP_LWS | > + ((index == 1) ? VI6_DL_SWAP_IND : 0)); Is this change needed ? If VI6_DL_SWAP_IND is not set in VI6_DL_SWAP(1), display list swap for WPF1 is supposed to be controlled by VI6_DL_SWAP(0) according to the datasheet. If that's not the case and this change is needed, I would split support for VI6_DL_SWAP(n) to a separate patch, and moved it before 07/11. > } > > void vsp1_dlm_reset(struct vsp1_dl_manager *dlm) > @@ -787,7 +855,11 @@ struct vsp1_dl_manager *vsp1_dlm_create(struct > vsp1_device *vsp1, > * fragmentation, with the header located right after the body in > * memory. > */ > - 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); We will have to improve header handling at some point. Not all headers require extensions. > dlm->pool = vsp1_dl_body_pool_create(vsp1, prealloc, > VSP1_DL_NUM_ENTRIES, header_size); > @@ -803,6 +875,11 @@ struct vsp1_dl_manager *vsp1_dlm_create(struct > vsp1_device *vsp1, return NULL; > } > > + /* The extended header immediately follows the header */ s/ \*/. */ > + if (vsp1_feature(vsp1, VSP1_HAS_EXT_DL)) > + dl->extended = (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 216bd23029dd..aa5f4adc6617 > 100644 > --- a/drivers/media/platform/vsp1/vsp1_dl.h > +++ b/drivers/media/platform/vsp1/vsp1_dl.h > @@ -20,7 +20,34 @@ struct vsp1_dl_manager; > #define VSP1_DL_FRAME_END_COMPLETED BIT(0) > #define VSP1_DL_FRAME_END_INTERNAL BIT(1) > > -void vsp1_dlm_setup(struct vsp1_device *vsp1); > +/** > + * struct vsp1_dl_ext_cmd - Extended Display command > + * @free: entry in the pool of free commands list > + * @cmd_opcode: command type opcode Maybe just 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 bodies s/command bodies/commands body/ ? > + * @data: memory allocation for command specific data > + * @data_dma: DMA address for command specific data s/command specific/command-specific/ > + * @data_size: size of the @data_dma memory in bytes data_size is set but otherwise never used. Should we drop the field, or make use of it ? > + */ > +struct vsp1_dl_ext_cmd { > + struct list_head free; > + > + u8 cmd_opcode; > + u32 flags; > + > + struct vsp1_dl_ext_cmd_header *cmds; > + unsigned int num_cmds; > + dma_addr_t cmd_dma; > + > + void *data; > + dma_addr_t data_dma; > + size_t data_size; > +}; > + > +void vsp1_dlm_setup(struct vsp1_device *vsp1, unsigned int index); > > struct vsp1_dl_manager *vsp1_dlm_create(struct vsp1_device *vsp1, > unsigned int index, > diff --git a/drivers/media/platform/vsp1/vsp1_drv.c > b/drivers/media/platform/vsp1/vsp1_drv.c index 0fc388bf5a33..26a7b4d32e6c > 100644 > --- a/drivers/media/platform/vsp1/vsp1_drv.c > +++ b/drivers/media/platform/vsp1/vsp1_drv.c > @@ -545,7 +545,8 @@ static int vsp1_device_init(struct vsp1_device *vsp1) > vsp1_write(vsp1, VI6_DPR_HGT_SMPPT, (7 << VI6_DPR_SMPPT_TGW_SHIFT) | > (VI6_DPR_NODE_UNUSED << VI6_DPR_SMPPT_PT_SHIFT)); > > - vsp1_dlm_setup(vsp1); > + for (i = 0; i < vsp1->info->wpf_count; ++i) > + vsp1_dlm_setup(vsp1, i); > > return 0; > } > @@ -754,7 +755,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 +775,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..d054767570c1 > 100644 > --- a/drivers/media/platform/vsp1/vsp1_regs.h > +++ b/drivers/media/platform/vsp1/vsp1_regs.h > @@ -67,12 +67,13 @@ > > #define VI6_DL_HDR_ADDR(n) (0x0104 + (n) * 4) > > -#define VI6_DL_SWAP 0x0114 > +#define VI6_DL_SWAP(n) (0x0114 + (n) * 56) > +#define VI6_DL_SWAP_IND (1 << 31) > #define VI6_DL_SWAP_LWS (1 << 2) > #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 v4 08/11] media: vsp1: Add support for extended display list headers Date: Thu, 24 May 2018 14:44:48 +0300 Message-ID: <4341947.2iR8IN8nZS@avalon> References: <32c7ac51c290efd12b16172839547ba204921143.1525354194.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 C5C706E010 for ; Thu, 24 May 2018 11:44:52 +0000 (UTC) In-Reply-To: <32c7ac51c290efd12b16172839547ba204921143.1525354194.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, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org SGkgS2llcmFuLAoKVGhhbmsgeW91IGZvciB0aGUgcGF0Y2guCgpPbiBUaHVyc2RheSwgMyBNYXkg MjAxOCAxNjozNjoxOSBFRVNUIEtpZXJhbiBCaW5naGFtIHdyb3RlOgo+IEV4dGVuZGVkIGRpc3Bs YXkgbGlzdCBoZWFkZXJzIGFsbG93IHByZSBhbmQgcG9zdCBjb21tYW5kIGxpc3RzIHRvIGJlCj4g ZXhlY3V0ZWQgYnkgdGhlIFZTUCBwaXBlbGluZS4gVGhpcyBwcm92aWRlcyB0aGUgYmFzZSBzdXBw b3J0IGZvcgo+IGZlYXR1cmVzIHN1Y2ggYXMgQVVUT19GTEQgKGZvciBpbnRlcmxhY2VkIHN1cHBv cnQpIGFuZCBBVVRPX0RJU1AgKGZvcgo+IHN1cHBvcnRpbmcgY29udGludW91cyBjYW1lcmEgcHJl dmlldyBwaXBlbGluZXMuCj4gCj4gU2lnbmVkLW9mZi1ieTogS2llcmFuIEJpbmdoYW0gPGtpZXJh bi5iaW5naGFtK3JlbmVzYXNAaWRlYXNvbmJvYXJkLmNvbT4KPiAKPiAtLS0KPiAKPiB2MjoKPiAg LSByZW1vdmUgX19wYWNrZWQgYXR0cmlidXRlcwo+IC0tLQo+ICBkcml2ZXJzL21lZGlhL3BsYXRm b3JtL3ZzcDEvdnNwMS5oICAgICAgfCAgMSArLQo+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3Zz cDEvdnNwMV9kbC5jICAgfCA4MyArKysrKysrKysrKysrKysrKysrKysrKysrLQo+ICBkcml2ZXJz L21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kbC5oICAgfCAyOSArKysrKysrKy0KPiAgZHJpdmVy cy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZHJ2LmMgIHwgIDcgKy0KPiAgZHJpdmVycy9tZWRp YS9wbGF0Zm9ybS92c3AxL3ZzcDFfcmVncy5oIHwgIDUgKy0KPiAgNSBmaWxlcyBjaGFuZ2VkLCAx MTYgaW5zZXJ0aW9ucygrKSwgOSBkZWxldGlvbnMoLSkKPiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVy cy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDEuaAo+IGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92 c3AxL3ZzcDEuaCBpbmRleCBmMGQyMWNjOGU5YWIuLjU2YzYyMTIyYTgxYQo+IDEwMDY0NAo+IC0t LSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxLmgKPiArKysgYi9kcml2ZXJzL21l ZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMS5oCj4gQEAgLTUzLDYgKzUzLDcgQEAgc3RydWN0IHZzcDFf dWlmOwo+ICAjZGVmaW5lIFZTUDFfSEFTX0hHTwkJKDEgPDwgNykKPiAgI2RlZmluZSBWU1AxX0hB U19IR1QJCSgxIDw8IDgpCj4gICNkZWZpbmUgVlNQMV9IQVNfQlJTCQkoMSA8PCA5KQo+ICsjZGVm aW5lIFZTUDFfSEFTX0VYVF9ETAkJKDEgPDwgMTApCj4gCj4gIHN0cnVjdCB2c3AxX2RldmljZV9p bmZvIHsKPiAgCXUzMiB2ZXJzaW9uOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRm b3JtL3ZzcDEvdnNwMV9kbC5jCj4gYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9k bC5jIGluZGV4IDU2NTE0Y2Q1MWM1MS4uYjY0ZDMyNTM1ZWRjCj4gMTAwNjQ0Cj4gLS0tIGEvZHJp dmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwuYwo+ICsrKyBiL2RyaXZlcnMvbWVkaWEv cGxhdGZvcm0vdnNwMS92c3AxX2RsLmMKPiBAQCAtMjIsNiArMjIsOSBAQAo+ICAjZGVmaW5lIFZT UDFfRExIX0lOVF9FTkFCTEUJCSgxIDw8IDEpCj4gICNkZWZpbmUgVlNQMV9ETEhfQVVUT19TVEFS VAkJKDEgPDwgMCkKPiAKPiArI2RlZmluZSBWU1AxX0RMSF9FWFRfUFJFX0NNRF9FWEVDCSgxIDw8 IDkpCj4gKyNkZWZpbmUgVlNQMV9ETEhfRVhUX1BPU1RfQ01EX0VYRUMJKDEgPDwgOCkKPiArCj4g IHN0cnVjdCB2c3AxX2RsX2hlYWRlcl9saXN0IHsKPiAgCXUzMiBudW1fYnl0ZXM7Cj4gIAl1MzIg YWRkcjsKPiBAQCAtMzQsMTEgKzM3LDM0IEBAIHN0cnVjdCB2c3AxX2RsX2hlYWRlciB7Cj4gIAl1 MzIgZmxhZ3M7Cj4gIH07Cj4gCj4gK3N0cnVjdCB2c3AxX2RsX2V4dF9oZWFkZXIgewo+ICsJdTMy IHJlc2VydmVkMDsJCS8qIGFsaWdubWVudCBwYWRkaW5nICovCj4gKwo+ICsJdTE2IHByZV9leHRf Y21kX3F0eTsKClNob3VsZCB0aGlzIGJlIGNhbGxlZCBwcmVfZXh0X2RsX251bV9jbWQgdG8gbWF0 Y2ggdGhlIGRhdGFzaGVldCA/Cgo+ICsJdTE2IGZsYWdzOwoKQXJlbid0IHRoZSBmbGFncyBzdXBw b3NlZCB0byBjb21lIGJlZm9yZSB0aGUgcHJlX2V4dF9kbF9udW1fY21kIGZpZWxkID8KCj4gKwl1 MzIgcHJlX2V4dF9jbWRfcGxpc3Q7CgpBbmQgcHJlX2V4dF9kbF9wbGlzdCA/Cgo+ICsKPiArCXUz MiBwb3N0X2V4dF9jbWRfcXR5Owo+ICsJdTMyIHBvc3RfZXh0X2NtZF9wbGlzdDsKClNpbWlsYXIg Y29tbWVudHMgZm9yIHRoZXNlIHZhcmlhYmxlcy4KCj4gK307Cj4gKwo+ICtzdHJ1Y3QgdnNwMV9k bF9oZWFkZXJfZXh0ZW5kZWQgewo+ICsJc3RydWN0IHZzcDFfZGxfaGVhZGVyIGhlYWRlcjsKPiAr CXN0cnVjdCB2c3AxX2RsX2V4dF9oZWFkZXIgZXh0Owo+ICt9Owo+ICsKPiAgc3RydWN0IHZzcDFf ZGxfZW50cnkgewo+ICAJdTMyIGFkZHI7Cj4gIAl1MzIgZGF0YTsKPiAgfTsKPiAKPiArc3RydWN0 IHZzcDFfZGxfZXh0X2NtZF9oZWFkZXIgewoKSXNuJ3QgdGhpcyByZWZlcnJlZCB0byBpbiB0aGUg ZGF0YXNoZWV0IGFzIGEgYm9keSBlbnRyeSwgbm90IGEgaGVhZGVyID8gSG93IAphYm91dCBuYW1p bmcgaXQgdnNwMV9kbF9leHRfY21kX2VudHJ5ID8gT3IganVzdCB2c3AxX2RsX2V4dF9jbWQgKGlu IHdoaWNoIGNhc2UgCnRoZSBvdGhlciBzdHJ1Y3R1cmUgdGhhdCBnb2VzIGJ5IHRoZSBzYW1lIG5h bWUgd291bGQgbmVlZCB0byBiZSByZW5hbWVkKSA/Cgo+ICsJdTMyIGNtZDsKPiArCXUzMiBmbGFn czsKPiArCXUzMiBkYXRhOwo+ICsJdTMyIHJlc2VydmVkOwoKVGhlIGRhdGFzaGVldCBkb2N1bWVu dHMgdGhpcyBhcyB0d28gNjQtYml0IGZpZWxkcywgc2hvdWxkbid0IHdlIGhhbmRsZSB0aGUgCnN0 cnVjdHVyZSB0aGUgc2FtZSB3YXkgPwoKPiArfTsKPiArCj4gIC8qKgo+ICAgKiBzdHJ1Y3QgdnNw MV9kbF9ib2R5IC0gRGlzcGxheSBsaXN0IGJvZHkKPiAgICogQGxpc3Q6IGVudHJ5IGluIHRoZSBk aXNwbGF5IGxpc3QgbGlzdCBvZiBib2RpZXMKPiBAQCAtOTUsOSArMTIxLDEyIEBAIHN0cnVjdCB2 c3AxX2RsX2JvZHlfcG9vbCB7Cj4gICAqIEBsaXN0OiBlbnRyeSBpbiB0aGUgZGlzcGxheSBsaXN0 IG1hbmFnZXIgbGlzdHMKPiAgICogQGRsbTogdGhlIGRpc3BsYXkgbGlzdCBtYW5hZ2VyCj4gICAq IEBoZWFkZXI6IGRpc3BsYXkgbGlzdCBoZWFkZXIKPiArICogQGV4dGVuZGVkOiBleHRlbmRlZCBk aXNwbGF5IGxpc3QgaGVhZGVyLiBOVUxMIGZvciBub3JtYWwgbGlzdHMKClNob3VsZCB3ZSBuYW1l IHRoaXMgZXh0ZW5zaW9uIGluc3RlYWQgb2YgZXh0ZW5kZWQgPwoKPiAgICogQGRtYTogRE1BIGFk ZHJlc3MgZm9yIHRoZSBoZWFkZXIKPiAgICogQGJvZHkwOiBmaXJzdCBkaXNwbGF5IGxpc3QgYm9k eQo+ICAgKiBAYm9kaWVzOiBsaXN0IG9mIGV4dHJhIGRpc3BsYXkgbGlzdCBib2RpZXMKPiArICog QHByZV9jbWQ6IHByZSBjbWQgdG8gYmUgaXNzdWVkIHRocm91Z2ggZXh0ZW5kZWQgZGwgaGVhZGVy Cj4gKyAqIEBwb3N0X2NtZDogcG9zdCBjbWQgdG8gYmUgaXNzdWVkIHRocm91Z2ggZXh0ZW5kZWQg ZGwgaGVhZGVyCgpJIHRoaW5rIHlvdSBjYW4gc3BlbGwgY29tbWFuZCBpbiBmdWxsLgoKPiAgICog QGhhc19jaGFpbjogaWYgdHJ1ZSwgaW5kaWNhdGVzIHRoYXQgdGhlcmUncyBhIHBhcnRpdGlvbiBj aGFpbgo+ICAgKiBAY2hhaW46IGVudHJ5IGluIHRoZSBkaXNwbGF5IGxpc3QgcGFydGl0aW9uIGNo YWluCj4gICAqIEBpbnRlcm5hbDogd2hldGhlciB0aGUgZGlzcGxheSBsaXN0IGlzIHVzZWQgZm9y IGludGVybmFsIHB1cnBvc2UKPiBAQCAtMTA3LDExICsxMzYsMTUgQEAgc3RydWN0IHZzcDFfZGxf bGlzdCB7Cj4gIAlzdHJ1Y3QgdnNwMV9kbF9tYW5hZ2VyICpkbG07Cj4gCj4gIAlzdHJ1Y3QgdnNw MV9kbF9oZWFkZXIgKmhlYWRlcjsKPiArCXN0cnVjdCB2c3AxX2RsX2V4dF9oZWFkZXIgKmV4dGVu ZGVkOwo+ICAJZG1hX2FkZHJfdCBkbWE7Cj4gCj4gIAlzdHJ1Y3QgdnNwMV9kbF9ib2R5ICpib2R5 MDsKPiAgCXN0cnVjdCBsaXN0X2hlYWQgYm9kaWVzOwo+IAo+ICsJc3RydWN0IHZzcDFfZGxfZXh0 X2NtZCAqcHJlX2NtZDsKPiArCXN0cnVjdCB2c3AxX2RsX2V4dF9jbWQgKnBvc3RfY21kOwo+ICsK PiAgCWJvb2wgaGFzX2NoYWluOwo+ICAJc3RydWN0IGxpc3RfaGVhZCBjaGFpbjsKPiAKPiBAQCAt NDk2LDYgKzUyOSwxNCBAQCBpbnQgdnNwMV9kbF9saXN0X2FkZF9jaGFpbihzdHJ1Y3QgdnNwMV9k bF9saXN0ICpoZWFkLAo+ICAJcmV0dXJuIDA7Cj4gIH0KPiAKPiArc3RhdGljIHZvaWQgdnNwMV9k bF9leHRfY21kX2ZpbGxfaGVhZGVyKHN0cnVjdCB2c3AxX2RsX2V4dF9jbWQgKmNtZCkKCj4gK3sK PiArCWNtZC0+Y21kc1swXS5jbWQgPSBjbWQtPmNtZF9vcGNvZGU7Cj4gKwljbWQtPmNtZHNbMF0u ZmxhZ3MgPSBjbWQtPmZsYWdzOwo+ICsJY21kLT5jbWRzWzBdLmRhdGEgPSBjbWQtPmRhdGFfZG1h Owo+ICsJY21kLT5jbWRzWzBdLnJlc2VydmVkID0gMDsKPiArfQo+ICsKPiAgc3RhdGljIHZvaWQg dnNwMV9kbF9saXN0X2ZpbGxfaGVhZGVyKHN0cnVjdCB2c3AxX2RsX2xpc3QgKmRsLCBib29sIGlz X2xhc3QpCj4gewo+ICAJc3RydWN0IHZzcDFfZGxfbWFuYWdlciAqZGxtID0gZGwtPmRsbTsKPiBA QCAtNTQ4LDYgKzU4OSwyNyBAQCBzdGF0aWMgdm9pZCB2c3AxX2RsX2xpc3RfZmlsbF9oZWFkZXIo c3RydWN0Cj4gdnNwMV9kbF9saXN0ICpkbCwgYm9vbCBpc19sYXN0KSAqLwo+ICAJCWRsLT5oZWFk ZXItPmZsYWdzID0gVlNQMV9ETEhfSU5UX0VOQUJMRTsKPiAgCX0KPiArCj4gKwlpZiAoIWRsLT5l eHRlbmRlZCkKPiArCQlyZXR1cm47Cj4gKwo+ICsJZGwtPmV4dGVuZGVkLT5mbGFncyA9IDA7Cj4g Kwo+ICsJaWYgKGRsLT5wcmVfY21kKSB7Cj4gKwkJZGwtPmV4dGVuZGVkLT5wcmVfZXh0X2NtZF9w bGlzdCA9IGRsLT5wcmVfY21kLT5jbWRfZG1hOwo+ICsJCWRsLT5leHRlbmRlZC0+cHJlX2V4dF9j bWRfcXR5ID0gZGwtPnByZV9jbWQtPm51bV9jbWRzOwo+ICsJCWRsLT5leHRlbmRlZC0+ZmxhZ3Mg fD0gVlNQMV9ETEhfRVhUX1BSRV9DTURfRVhFQzsKPiArCj4gKwkJdnNwMV9kbF9leHRfY21kX2Zp bGxfaGVhZGVyKGRsLT5wcmVfY21kKTsKPiArCX0KPiArCj4gKwlpZiAoZGwtPnBvc3RfY21kKSB7 Cj4gKwkJZGwtPmV4dGVuZGVkLT5wcmVfZXh0X2NtZF9wbGlzdCA9IGRsLT5wb3N0X2NtZC0+Y21k X2RtYTsKPiArCQlkbC0+ZXh0ZW5kZWQtPnByZV9leHRfY21kX3F0eSA9IGRsLT5wb3N0X2NtZC0+ bnVtX2NtZHM7Cj4gKwkJZGwtPmV4dGVuZGVkLT5mbGFncyB8PSBWU1AxX0RMSF9FWFRfUE9TVF9D TURfRVhFQzsKPiArCj4gKwkJdnNwMV9kbF9leHRfY21kX2ZpbGxfaGVhZGVyKGRsLT5wcmVfY21k KTsKPiArCX0KPiAgfQo+IAo+ICBzdGF0aWMgYm9vbCB2c3AxX2RsX2xpc3RfaHdfdXBkYXRlX3Bl bmRpbmcoc3RydWN0IHZzcDFfZGxfbWFuYWdlciAqZGxtKQo+IEBAIC03MzUsMTQgKzc5NywyMCBA QCB1bnNpZ25lZCBpbnQgdnNwMV9kbG1faXJxX2ZyYW1lX2VuZChzdHJ1Y3QKPiB2c3AxX2RsX21h bmFnZXIgKmRsbSkgfQo+IAo+ICAvKiBIYXJkd2FyZSBTZXR1cCAqLwo+IC12b2lkIHZzcDFfZGxt X3NldHVwKHN0cnVjdCB2c3AxX2RldmljZSAqdnNwMSkKPiArdm9pZCB2c3AxX2RsbV9zZXR1cChz dHJ1Y3QgdnNwMV9kZXZpY2UgKnZzcDEsIHVuc2lnbmVkIGludCBpbmRleCkKPiAgewo+ICAJdTMy IGN0cmwgPSAoMjU2IDw8IFZJNl9ETF9DVFJMX0FSX1dBSVRfU0hJRlQpCj4gCj4gIAkJIHwgVkk2 X0RMX0NUUkxfREMyIHwgVkk2X0RMX0NUUkxfREMxIHwgVkk2X0RMX0NUUkxfREMwCj4gIAkJIHwg Vkk2X0RMX0NUUkxfRExFOwo+IAo+ICsJaWYgKHZzcDFfZmVhdHVyZSh2c3AxLCBWU1AxX0hBU19F WFRfREwpKQo+ICsJCXZzcDFfd3JpdGUodnNwMSwgVkk2X0RMX0VYVF9DVFJMKGluZGV4KSwKPiAr CQkJICAgKDB4MDIgPDwgVkk2X0RMX0VYVF9DVFJMX1BPTElOVF9TSElGVCkgfAo+ICsJCQkgICBW STZfRExfRVhUX0NUUkxfRExQUkkgfCBWSTZfRExfRVhUX0NUUkxfRVhUKTsKPiArCj4gIAl2c3Ax X3dyaXRlKHZzcDEsIFZJNl9ETF9DVFJMLCBjdHJsKTsKPiAtCXZzcDFfd3JpdGUodnNwMSwgVkk2 X0RMX1NXQVAsIFZJNl9ETF9TV0FQX0xXUyk7Cj4gKwl2c3AxX3dyaXRlKHZzcDEsIFZJNl9ETF9T V0FQKGluZGV4KSwgVkk2X0RMX1NXQVBfTFdTIHwKPiArCQkJICgoaW5kZXggPT0gMSkgPyBWSTZf RExfU1dBUF9JTkQgOiAwKSk7CgpJcyB0aGlzIGNoYW5nZSBuZWVkZWQgPyBJZiBWSTZfRExfU1dB UF9JTkQgaXMgbm90IHNldCBpbiBWSTZfRExfU1dBUCgxKSwgCmRpc3BsYXkgbGlzdCBzd2FwIGZv ciBXUEYxIGlzIHN1cHBvc2VkIHRvIGJlIGNvbnRyb2xsZWQgYnkgVkk2X0RMX1NXQVAoMCkgCmFj Y29yZGluZyB0byB0aGUgZGF0YXNoZWV0LgoKSWYgdGhhdCdzIG5vdCB0aGUgY2FzZSBhbmQgdGhp cyBjaGFuZ2UgaXMgbmVlZGVkLCBJIHdvdWxkIHNwbGl0IHN1cHBvcnQgZm9yIApWSTZfRExfU1dB UChuKSB0byBhIHNlcGFyYXRlIHBhdGNoLCBhbmQgbW92ZWQgaXQgYmVmb3JlIDA3LzExLgoKPiAg fQo+IAo+ICB2b2lkIHZzcDFfZGxtX3Jlc2V0KHN0cnVjdCB2c3AxX2RsX21hbmFnZXIgKmRsbSkK PiBAQCAtNzg3LDcgKzg1NSwxMSBAQCBzdHJ1Y3QgdnNwMV9kbF9tYW5hZ2VyICp2c3AxX2RsbV9j cmVhdGUoc3RydWN0Cj4gdnNwMV9kZXZpY2UgKnZzcDEsCj4gIAkgKiBmcmFnbWVudGF0aW9uLCB3 aXRoIHRoZSBoZWFkZXIgbG9jYXRlZCByaWdodCBhZnRlciB0aGUgYm9keSBpbgo+ICAJICogbWVt b3J5Lgo+ICAJICovCj4gLQloZWFkZXJfc2l6ZSA9IEFMSUdOKHNpemVvZihzdHJ1Y3QgdnNwMV9k bF9oZWFkZXIpLCA4KTsKPiArCWhlYWRlcl9zaXplID0gdnNwMV9mZWF0dXJlKHZzcDEsIFZTUDFf SEFTX0VYVF9ETCkgPwo+ICsJCQlzaXplb2Yoc3RydWN0IHZzcDFfZGxfaGVhZGVyX2V4dGVuZGVk KSA6Cj4gKwkJCXNpemVvZihzdHJ1Y3QgdnNwMV9kbF9oZWFkZXIpOwo+ICsKPiArCWhlYWRlcl9z aXplID0gQUxJR04oaGVhZGVyX3NpemUsIDgpOwoKV2Ugd2lsbCBoYXZlIHRvIGltcHJvdmUgaGVh ZGVyIGhhbmRsaW5nIGF0IHNvbWUgcG9pbnQuIE5vdCBhbGwgaGVhZGVycyByZXF1aXJlIApleHRl bnNpb25zLgoKPiAgCWRsbS0+cG9vbCA9IHZzcDFfZGxfYm9keV9wb29sX2NyZWF0ZSh2c3AxLCBw cmVhbGxvYywKPiAgCQkJCQkgICAgIFZTUDFfRExfTlVNX0VOVFJJRVMsIGhlYWRlcl9zaXplKTsK PiBAQCAtODAzLDYgKzg3NSwxMSBAQCBzdHJ1Y3QgdnNwMV9kbF9tYW5hZ2VyICp2c3AxX2RsbV9j cmVhdGUoc3RydWN0Cj4gdnNwMV9kZXZpY2UgKnZzcDEsIHJldHVybiBOVUxMOwo+ICAJCX0KPiAK PiArCQkvKiBUaGUgZXh0ZW5kZWQgaGVhZGVyIGltbWVkaWF0ZWx5IGZvbGxvd3MgdGhlIGhlYWRl ciAqLwoKcy8gXCovLiAqLwoKPiArCQlpZiAodnNwMV9mZWF0dXJlKHZzcDEsIFZTUDFfSEFTX0VY VF9ETCkpCj4gKwkJCWRsLT5leHRlbmRlZCA9ICh2b2lkICopZGwtPmhlYWRlcgo+ICsJCQkJICAg ICArIHNpemVvZigqZGwtPmhlYWRlcik7Cj4gKwo+ICAJCWxpc3RfYWRkX3RhaWwoJmRsLT5saXN0 LCAmZGxtLT5mcmVlKTsKPiAgCX0KPiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9wbGF0 Zm9ybS92c3AxL3ZzcDFfZGwuaAo+IGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFf ZGwuaCBpbmRleCAyMTZiZDIzMDI5ZGQuLmFhNWY0YWRjNjYxNwo+IDEwMDY0NAo+IC0tLSBhL2Ry aXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmgKPiArKysgYi9kcml2ZXJzL21lZGlh L3BsYXRmb3JtL3ZzcDEvdnNwMV9kbC5oCj4gQEAgLTIwLDcgKzIwLDM0IEBAIHN0cnVjdCB2c3Ax X2RsX21hbmFnZXI7Cj4gICNkZWZpbmUgVlNQMV9ETF9GUkFNRV9FTkRfQ09NUExFVEVECQlCSVQo MCkKPiAgI2RlZmluZSBWU1AxX0RMX0ZSQU1FX0VORF9JTlRFUk5BTAkJQklUKDEpCj4gCj4gLXZv aWQgdnNwMV9kbG1fc2V0dXAoc3RydWN0IHZzcDFfZGV2aWNlICp2c3AxKTsKPiArLyoqCj4gKyAq IHN0cnVjdCB2c3AxX2RsX2V4dF9jbWQgLSBFeHRlbmRlZCBEaXNwbGF5IGNvbW1hbmQKPiArICog QGZyZWU6IGVudHJ5IGluIHRoZSBwb29sIG9mIGZyZWUgY29tbWFuZHMgbGlzdAo+ICsgKiBAY21k X29wY29kZTogY29tbWFuZCB0eXBlIG9wY29kZQoKTWF5YmUganVzdCBvcGNvZGUgPwoKPiArICog QGZsYWdzOiBmbGFncyB1c2VkIGJ5IHRoZSBjb21tYW5kCj4gKyAqIEBjbWRzOiBhcnJheSBvZiBj b21tYW5kIGJvZGllcyBmb3IgdGhpcyBleHRlbmRlZCBjbWQKPiArICogQG51bV9jbWRzOiBxdWFu dGl0eSBvZiBjb21tYW5kcyBpbiBAY21kcyBhcnJheQo+ICsgKiBAY21kX2RtYTogRE1BIGFkZHJl c3Mgb2YgdGhlIGNvbW1hbmQgYm9kaWVzCgpzL2NvbW1hbmQgYm9kaWVzL2NvbW1hbmRzIGJvZHkv ID8KCj4gKyAqIEBkYXRhOiBtZW1vcnkgYWxsb2NhdGlvbiBmb3IgY29tbWFuZCBzcGVjaWZpYyBk YXRhCj4gKyAqIEBkYXRhX2RtYTogRE1BIGFkZHJlc3MgZm9yIGNvbW1hbmQgc3BlY2lmaWMgZGF0 YQoKcy9jb21tYW5kIHNwZWNpZmljL2NvbW1hbmQtc3BlY2lmaWMvCgo+ICsgKiBAZGF0YV9zaXpl OiBzaXplIG9mIHRoZSBAZGF0YV9kbWEgbWVtb3J5IGluIGJ5dGVzCgpkYXRhX3NpemUgaXMgc2V0 IGJ1dCBvdGhlcndpc2UgbmV2ZXIgdXNlZC4gU2hvdWxkIHdlIGRyb3AgdGhlIGZpZWxkLCBvciBt YWtlIAp1c2Ugb2YgaXQgPwoKPiArICovCj4gK3N0cnVjdCB2c3AxX2RsX2V4dF9jbWQgewo+ICsJ c3RydWN0IGxpc3RfaGVhZCBmcmVlOwo+ICsKPiArCXU4IGNtZF9vcGNvZGU7Cj4gKwl1MzIgZmxh Z3M7Cj4gKwo+ICsJc3RydWN0IHZzcDFfZGxfZXh0X2NtZF9oZWFkZXIgKmNtZHM7Cj4gKwl1bnNp Z25lZCBpbnQgbnVtX2NtZHM7Cj4gKwlkbWFfYWRkcl90IGNtZF9kbWE7Cj4gKwo+ICsJdm9pZCAq ZGF0YTsKPiArCWRtYV9hZGRyX3QgZGF0YV9kbWE7Cj4gKwlzaXplX3QgZGF0YV9zaXplOwo+ICt9 Owo+ICsKPiArdm9pZCB2c3AxX2RsbV9zZXR1cChzdHJ1Y3QgdnNwMV9kZXZpY2UgKnZzcDEsIHVu c2lnbmVkIGludCBpbmRleCk7Cj4gCj4gIHN0cnVjdCB2c3AxX2RsX21hbmFnZXIgKnZzcDFfZGxt X2NyZWF0ZShzdHJ1Y3QgdnNwMV9kZXZpY2UgKnZzcDEsCj4gIAkJCQkJdW5zaWduZWQgaW50IGlu ZGV4LAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kcnYu Ywo+IGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZHJ2LmMgaW5kZXggMGZjMzg4 YmY1YTMzLi4yNmE3YjRkMzJlNmMKPiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRm b3JtL3ZzcDEvdnNwMV9kcnYuYwo+ICsrKyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92 c3AxX2Rydi5jCj4gQEAgLTU0NSw3ICs1NDUsOCBAQCBzdGF0aWMgaW50IHZzcDFfZGV2aWNlX2lu aXQoc3RydWN0IHZzcDFfZGV2aWNlICp2c3AxKQo+ICAJdnNwMV93cml0ZSh2c3AxLCBWSTZfRFBS X0hHVF9TTVBQVCwgKDcgPDwgVkk2X0RQUl9TTVBQVF9UR1dfU0hJRlQpIHwKPiAgCQkgICAoVkk2 X0RQUl9OT0RFX1VOVVNFRCA8PCBWSTZfRFBSX1NNUFBUX1BUX1NISUZUKSk7Cj4gCj4gLQl2c3Ax X2RsbV9zZXR1cCh2c3AxKTsKPiArCWZvciAoaSA9IDA7IGkgPCB2c3AxLT5pbmZvLT53cGZfY291 bnQ7ICsraSkKPiArCQl2c3AxX2RsbV9zZXR1cCh2c3AxLCBpKTsKPiAKPiAgCXJldHVybiAwOwo+ ICB9Cj4gQEAgLTc1NCw3ICs3NTUsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IHZzcDFfZGV2aWNl X2luZm8gdnNwMV9kZXZpY2VfaW5mb3NbXQo+ID0geyAudmVyc2lvbiA9IFZJNl9JUF9WRVJTSU9O X01PREVMX1ZTUERfR0VOMywKPiAgCQkubW9kZWwgPSAiVlNQMi1EIiwKPiAgCQkuZ2VuID0gMywK PiAtCQkuZmVhdHVyZXMgPSBWU1AxX0hBU19CUlUgfCBWU1AxX0hBU19XUEZfVkZMSVAsCj4gKwkJ LmZlYXR1cmVzID0gVlNQMV9IQVNfQlJVIHwgVlNQMV9IQVNfV1BGX1ZGTElQIHwgVlNQMV9IQVNf RVhUX0RMLAo+ICAJCS5saWZfY291bnQgPSAxLAo+ICAJCS5ycGZfY291bnQgPSA1LAo+ICAJCS51 aWZfY291bnQgPSAxLAo+IEBAIC03NzQsNyArNzc1LDcgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCB2 c3AxX2RldmljZV9pbmZvIHZzcDFfZGV2aWNlX2luZm9zW10KPiA9IHsgLnZlcnNpb24gPSBWSTZf SVBfVkVSU0lPTl9NT0RFTF9WU1BETF9HRU4zLAo+ICAJCS5tb2RlbCA9ICJWU1AyLURMIiwKPiAg CQkuZ2VuID0gMywKPiAtCQkuZmVhdHVyZXMgPSBWU1AxX0hBU19CUlMgfCBWU1AxX0hBU19CUlUs Cj4gKwkJLmZlYXR1cmVzID0gVlNQMV9IQVNfQlJTIHwgVlNQMV9IQVNfQlJVIHwgVlNQMV9IQVNf RVhUX0RMLAo+ICAJCS5saWZfY291bnQgPSAyLAo+ICAJCS5ycGZfY291bnQgPSA1LAo+ICAJCS51 aWZfY291bnQgPSAyLAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEv dnNwMV9yZWdzLmgKPiBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3JlZ3MuaCBp bmRleCAwZDI0OWZmOWY1NjQuLmQwNTQ3Njc1NzBjMQo+IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMv bWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3JlZ3MuaAo+ICsrKyBiL2RyaXZlcnMvbWVkaWEvcGxh dGZvcm0vdnNwMS92c3AxX3JlZ3MuaAo+IEBAIC02NywxMiArNjcsMTMgQEAKPiAKPiAgI2RlZmlu ZSBWSTZfRExfSERSX0FERFIobikJCSgweDAxMDQgKyAobikgKiA0KQo+IAo+IC0jZGVmaW5lIFZJ Nl9ETF9TV0FQCQkJMHgwMTE0Cj4gKyNkZWZpbmUgVkk2X0RMX1NXQVAobikJCQkoMHgwMTE0ICsg KG4pICogNTYpCj4gKyNkZWZpbmUgVkk2X0RMX1NXQVBfSU5ECQkJKDEgPDwgMzEpCj4gICNkZWZp bmUgVkk2X0RMX1NXQVBfTFdTCQkJKDEgPDwgMikKPiAgI2RlZmluZSBWSTZfRExfU1dBUF9XRFMJ CQkoMSA8PCAxKQo+ICAjZGVmaW5lIFZJNl9ETF9TV0FQX0JUUwkJCSgxIDw8IDApCj4gCj4gLSNk ZWZpbmUgVkk2X0RMX0VYVF9DVFJMCQkJMHgwMTFjCj4gKyNkZWZpbmUgVkk2X0RMX0VYVF9DVFJM KG4pCQkoMHgwMTFjICsgKG4pICogMzYpCj4gICNkZWZpbmUgVkk2X0RMX0VYVF9DVFJMX05XRQkJ KDEgPDwgMTYpCj4gICNkZWZpbmUgVkk2X0RMX0VYVF9DVFJMX1BPTElOVF9NQVNLCSgweDNmIDw8 IDgpCj4gICNkZWZpbmUgVkk2X0RMX0VYVF9DVFJMX1BPTElOVF9TSElGVAk4CgotLSAKUmVnYXJk cywKCkxhdXJlbnQgUGluY2hhcnQKCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJl ZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGlu Zm8vZHJpLWRldmVsCg==