From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754457AbdERFgj (ORCPT ); Thu, 18 May 2017 01:36:39 -0400 Received: from ozlabs.org ([103.22.144.67]:51663 "EHLO ozlabs.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753810AbdERFgg (ORCPT ); Thu, 18 May 2017 01:36:36 -0400 From: Michael Ellerman To: Borislav Petkov , Chris Packham , linuxppc-dev@lists.ozlabs.org Cc: mchehab@kernel.org, linux-kernel@vger.kernel.org, linux-edac@vger.kernel.org Subject: Re: [PATCH 3/3] EDAC: mv64x60: replace in_le32/out_le32 with ioread32/iowrite32 In-Reply-To: <20170517181021.yfctrok7f25d5bu5@pd.tnic> References: <20170512042002.18524-1-chris.packham@alliedtelesis.co.nz> <20170512042002.18524-4-chris.packham@alliedtelesis.co.nz> <20170517181021.yfctrok7f25d5bu5@pd.tnic> User-Agent: Notmuch/0.21 (https://notmuchmail.org) Date: Thu, 18 May 2017 15:36:33 +1000 Message-ID: <87a86alo9q.fsf@concordia.ellerman.id.au> MIME-Version: 1.0 Content-Type: text/plain Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Borislav Petkov writes: > Top-posting so that the PPC list can see the whole patch below. > > Since I don't know PPC, let me add PPC ML to CC for a confirmation this > change is correct. > > Which brings me to the tangential: this driver is from 2006-ish and > is for some "Marvell MV64x60 Memory Controller kernel module for PPC > platforms". If you're going to touch it, then you should test on the PPC > hardware too, so that you don't break the driver there. > > Unless that hardware is obsolete now and we don't care and, and ..? > > Maybe someone has some insights... Not really sorry. I don't have one of those boards, so I can't test. Maybe someone else on the list does? I'd err on the side of the PPC hardware being obsolete and no one really caring. If the driver is helpful on ARM then we may as well use it there, if we can also avoid breaking it on PPC then great. cheers > On Fri, May 12, 2017 at 04:20:02PM +1200, Chris Packham wrote: >> To allow this driver to be used on non-powerpc platforms it needs to use >> io accessors suitable for all platforms. >> >> Signed-off-by: Chris Packham >> --- >> drivers/edac/mv64x60_edac.c | 84 ++++++++++++++++++++++----------------------- >> 1 file changed, 42 insertions(+), 42 deletions(-) >> >> diff --git a/drivers/edac/mv64x60_edac.c b/drivers/edac/mv64x60_edac.c >> index ddc5082f7577..102ec29f864b 100644 >> --- a/drivers/edac/mv64x60_edac.c >> +++ b/drivers/edac/mv64x60_edac.c >> @@ -32,21 +32,21 @@ static void mv64x60_pci_check(struct edac_pci_ctl_info *pci) >> struct mv64x60_pci_pdata *pdata = pci->pvt_info; >> u32 cause; >> >> - cause = in_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_CAUSE); >> + cause = ioread32(pdata->pci_vbase + MV64X60_PCI_ERROR_CAUSE); >> if (!cause) >> return; >> >> printk(KERN_ERR "Error in PCI %d Interface\n", pdata->pci_hose); >> printk(KERN_ERR "Cause register: 0x%08x\n", cause); >> printk(KERN_ERR "Address Low: 0x%08x\n", >> - in_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_ADDR_LO)); >> + ioread32(pdata->pci_vbase + MV64X60_PCI_ERROR_ADDR_LO)); >> printk(KERN_ERR "Address High: 0x%08x\n", >> - in_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_ADDR_HI)); >> + ioread32(pdata->pci_vbase + MV64X60_PCI_ERROR_ADDR_HI)); >> printk(KERN_ERR "Attribute: 0x%08x\n", >> - in_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_ATTR)); >> + ioread32(pdata->pci_vbase + MV64X60_PCI_ERROR_ATTR)); >> printk(KERN_ERR "Command: 0x%08x\n", >> - in_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_CMD)); >> - out_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_CAUSE, ~cause); >> + ioread32(pdata->pci_vbase + MV64X60_PCI_ERROR_CMD)); >> + iowrite32(~cause, pdata->pci_vbase + MV64X60_PCI_ERROR_CAUSE); >> >> if (cause & MV64X60_PCI_PE_MASK) >> edac_pci_handle_pe(pci, pci->ctl_name); >> @@ -61,7 +61,7 @@ static irqreturn_t mv64x60_pci_isr(int irq, void *dev_id) >> struct mv64x60_pci_pdata *pdata = pci->pvt_info; >> u32 val; >> >> - val = in_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_CAUSE); >> + val = ioread32(pdata->pci_vbase + MV64X60_PCI_ERROR_CAUSE); >> if (!val) >> return IRQ_NONE; >> >> @@ -93,7 +93,7 @@ static int __init mv64x60_pci_fixup(struct platform_device *pdev) >> if (!pci_serr) >> return -ENOMEM; >> >> - out_le32(pci_serr, in_le32(pci_serr) & ~0x1); >> + iowrite32(ioread32(pci_serr) & ~0x1, pci_serr); >> iounmap(pci_serr); >> >> return 0; >> @@ -161,10 +161,10 @@ static int mv64x60_pci_err_probe(struct platform_device *pdev) >> goto err; >> } >> >> - out_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_CAUSE, 0); >> - out_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_MASK, 0); >> - out_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_MASK, >> - MV64X60_PCIx_ERR_MASK_VAL); >> + iowrite32(0, pdata->pci_vbase + MV64X60_PCI_ERROR_CAUSE); >> + iowrite32(0, pdata->pci_vbase + MV64X60_PCI_ERROR_MASK); >> + iowrite32(MV64X60_PCIx_ERR_MASK_VAL, >> + pdata->pci_vbase + MV64X60_PCI_ERROR_MASK); >> >> if (edac_pci_add_device(pci, pdata->edac_idx) > 0) { >> edac_dbg(3, "failed edac_pci_add_device()\n"); >> @@ -233,23 +233,23 @@ static void mv64x60_sram_check(struct edac_device_ctl_info *edac_dev) >> struct mv64x60_sram_pdata *pdata = edac_dev->pvt_info; >> u32 cause; >> >> - cause = in_le32(pdata->sram_vbase + MV64X60_SRAM_ERR_CAUSE); >> + cause = ioread32(pdata->sram_vbase + MV64X60_SRAM_ERR_CAUSE); >> if (!cause) >> return; >> >> printk(KERN_ERR "Error in internal SRAM\n"); >> printk(KERN_ERR "Cause register: 0x%08x\n", cause); >> printk(KERN_ERR "Address Low: 0x%08x\n", >> - in_le32(pdata->sram_vbase + MV64X60_SRAM_ERR_ADDR_LO)); >> + ioread32(pdata->sram_vbase + MV64X60_SRAM_ERR_ADDR_LO)); >> printk(KERN_ERR "Address High: 0x%08x\n", >> - in_le32(pdata->sram_vbase + MV64X60_SRAM_ERR_ADDR_HI)); >> + ioread32(pdata->sram_vbase + MV64X60_SRAM_ERR_ADDR_HI)); >> printk(KERN_ERR "Data Low: 0x%08x\n", >> - in_le32(pdata->sram_vbase + MV64X60_SRAM_ERR_DATA_LO)); >> + ioread32(pdata->sram_vbase + MV64X60_SRAM_ERR_DATA_LO)); >> printk(KERN_ERR "Data High: 0x%08x\n", >> - in_le32(pdata->sram_vbase + MV64X60_SRAM_ERR_DATA_HI)); >> + ioread32(pdata->sram_vbase + MV64X60_SRAM_ERR_DATA_HI)); >> printk(KERN_ERR "Parity: 0x%08x\n", >> - in_le32(pdata->sram_vbase + MV64X60_SRAM_ERR_PARITY)); >> - out_le32(pdata->sram_vbase + MV64X60_SRAM_ERR_CAUSE, 0); >> + ioread32(pdata->sram_vbase + MV64X60_SRAM_ERR_PARITY)); >> + iowrite32(0, pdata->sram_vbase + MV64X60_SRAM_ERR_CAUSE); >> >> edac_device_handle_ue(edac_dev, 0, 0, edac_dev->ctl_name); >> } >> @@ -260,7 +260,7 @@ static irqreturn_t mv64x60_sram_isr(int irq, void *dev_id) >> struct mv64x60_sram_pdata *pdata = edac_dev->pvt_info; >> u32 cause; >> >> - cause = in_le32(pdata->sram_vbase + MV64X60_SRAM_ERR_CAUSE); >> + cause = ioread32(pdata->sram_vbase + MV64X60_SRAM_ERR_CAUSE); >> if (!cause) >> return IRQ_NONE; >> >> @@ -322,7 +322,7 @@ static int mv64x60_sram_err_probe(struct platform_device *pdev) >> } >> >> /* setup SRAM err registers */ >> - out_le32(pdata->sram_vbase + MV64X60_SRAM_ERR_CAUSE, 0); >> + iowrite32(0, pdata->sram_vbase + MV64X60_SRAM_ERR_CAUSE); >> >> edac_dev->mod_name = EDAC_MOD_STR; >> edac_dev->ctl_name = pdata->name; >> @@ -398,7 +398,7 @@ static void mv64x60_cpu_check(struct edac_device_ctl_info *edac_dev) >> struct mv64x60_cpu_pdata *pdata = edac_dev->pvt_info; >> u32 cause; >> >> - cause = in_le32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_CAUSE) & >> + cause = ioread32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_CAUSE) & >> MV64x60_CPU_CAUSE_MASK; >> if (!cause) >> return; >> @@ -406,16 +406,16 @@ static void mv64x60_cpu_check(struct edac_device_ctl_info *edac_dev) >> printk(KERN_ERR "Error on CPU interface\n"); >> printk(KERN_ERR "Cause register: 0x%08x\n", cause); >> printk(KERN_ERR "Address Low: 0x%08x\n", >> - in_le32(pdata->cpu_vbase[0] + MV64x60_CPU_ERR_ADDR_LO)); >> + ioread32(pdata->cpu_vbase[0] + MV64x60_CPU_ERR_ADDR_LO)); >> printk(KERN_ERR "Address High: 0x%08x\n", >> - in_le32(pdata->cpu_vbase[0] + MV64x60_CPU_ERR_ADDR_HI)); >> + ioread32(pdata->cpu_vbase[0] + MV64x60_CPU_ERR_ADDR_HI)); >> printk(KERN_ERR "Data Low: 0x%08x\n", >> - in_le32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_DATA_LO)); >> + ioread32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_DATA_LO)); >> printk(KERN_ERR "Data High: 0x%08x\n", >> - in_le32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_DATA_HI)); >> + ioread32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_DATA_HI)); >> printk(KERN_ERR "Parity: 0x%08x\n", >> - in_le32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_PARITY)); >> - out_le32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_CAUSE, 0); >> + ioread32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_PARITY)); >> + iowrite32(0, pdata->cpu_vbase[1] + MV64x60_CPU_ERR_CAUSE); >> >> edac_device_handle_ue(edac_dev, 0, 0, edac_dev->ctl_name); >> } >> @@ -426,7 +426,7 @@ static irqreturn_t mv64x60_cpu_isr(int irq, void *dev_id) >> struct mv64x60_cpu_pdata *pdata = edac_dev->pvt_info; >> u32 cause; >> >> - cause = in_le32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_CAUSE) & >> + cause = ioread32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_CAUSE) & >> MV64x60_CPU_CAUSE_MASK; >> if (!cause) >> return IRQ_NONE; >> @@ -515,9 +515,9 @@ static int mv64x60_cpu_err_probe(struct platform_device *pdev) >> } >> >> /* setup CPU err registers */ >> - out_le32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_CAUSE, 0); >> - out_le32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_MASK, 0); >> - out_le32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_MASK, 0x000000ff); >> + iowrite32(0, pdata->cpu_vbase[1] + MV64x60_CPU_ERR_CAUSE); >> + iowrite32(0, pdata->cpu_vbase[1] + MV64x60_CPU_ERR_MASK); >> + iowrite32(0x000000ff, pdata->cpu_vbase[1] + MV64x60_CPU_ERR_MASK); >> >> edac_dev->mod_name = EDAC_MOD_STR; >> edac_dev->ctl_name = pdata->name; >> @@ -596,13 +596,13 @@ static void mv64x60_mc_check(struct mem_ctl_info *mci) >> u32 comp_ecc; >> u32 syndrome; >> >> - reg = in_le32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ADDR); >> + reg = ioread32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ADDR); >> if (!reg) >> return; >> >> err_addr = reg & ~0x3; >> - sdram_ecc = in_le32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ECC_RCVD); >> - comp_ecc = in_le32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ECC_CALC); >> + sdram_ecc = ioread32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ECC_RCVD); >> + comp_ecc = ioread32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ECC_CALC); >> syndrome = sdram_ecc ^ comp_ecc; >> >> /* first bit clear in ECC Err Reg, 1 bit error, correctable by HW */ >> @@ -620,7 +620,7 @@ static void mv64x60_mc_check(struct mem_ctl_info *mci) >> mci->ctl_name, ""); >> >> /* clear the error */ >> - out_le32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ADDR, 0); >> + iowrite32(0, pdata->mc_vbase + MV64X60_SDRAM_ERR_ADDR); >> } >> >> static irqreturn_t mv64x60_mc_isr(int irq, void *dev_id) >> @@ -629,7 +629,7 @@ static irqreturn_t mv64x60_mc_isr(int irq, void *dev_id) >> struct mv64x60_mc_pdata *pdata = mci->pvt_info; >> u32 reg; >> >> - reg = in_le32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ADDR); >> + reg = ioread32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ADDR); >> if (!reg) >> return IRQ_NONE; >> >> @@ -664,7 +664,7 @@ static void mv64x60_init_csrows(struct mem_ctl_info *mci, >> >> get_total_mem(pdata); >> >> - ctl = in_le32(pdata->mc_vbase + MV64X60_SDRAM_CONFIG); >> + ctl = ioread32(pdata->mc_vbase + MV64X60_SDRAM_CONFIG); >> >> csrow = mci->csrows[0]; >> dimm = csrow->channels[0]->dimm; >> @@ -753,7 +753,7 @@ static int mv64x60_mc_err_probe(struct platform_device *pdev) >> goto err; >> } >> >> - ctl = in_le32(pdata->mc_vbase + MV64X60_SDRAM_CONFIG); >> + ctl = ioread32(pdata->mc_vbase + MV64X60_SDRAM_CONFIG); >> if (!(ctl & MV64X60_SDRAM_ECC)) { >> /* Non-ECC RAM? */ >> printk(KERN_WARNING "%s: No ECC DIMMs discovered\n", __func__); >> @@ -779,10 +779,10 @@ static int mv64x60_mc_err_probe(struct platform_device *pdev) >> mv64x60_init_csrows(mci, pdata); >> >> /* setup MC registers */ >> - out_le32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ADDR, 0); >> - ctl = in_le32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ECC_CNTL); >> + iowrite32(0, pdata->mc_vbase + MV64X60_SDRAM_ERR_ADDR); >> + ctl = ioread32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ECC_CNTL); >> ctl = (ctl & 0xff00ffff) | 0x10000; >> - out_le32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ECC_CNTL, ctl); >> + iowrite32(ctl, pdata->mc_vbase + MV64X60_SDRAM_ERR_ECC_CNTL); >> >> res = edac_mc_add_mc(mci); >> if (res) { >> -- >> 2.11.0.24.ge6920cf >> > > -- > Regards/Gruss, > Boris. > > Good mailing practices for 400: try to avoid top-posting and trim the reply. From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [3/3] EDAC: mv64x60: replace in_le32/out_le32 with ioread32/iowrite32 From: Michael Ellerman Message-Id: <87a86alo9q.fsf@concordia.ellerman.id.au> Date: Thu, 18 May 2017 15:36:33 +1000 To: Borislav Petkov , Chris Packham , linuxppc-dev@lists.ozlabs.org Cc: mchehab@kernel.org, linux-kernel@vger.kernel.org, linux-edac@vger.kernel.org List-ID: Qm9yaXNsYXYgUGV0a292IDxicEBhbGllbjguZGU+IHdyaXRlczoKCj4gVG9wLXBvc3Rpbmcgc28g dGhhdCB0aGUgUFBDIGxpc3QgY2FuIHNlZSB0aGUgd2hvbGUgcGF0Y2ggYmVsb3cuCj4KPiBTaW5j ZSBJIGRvbid0IGtub3cgUFBDLCBsZXQgbWUgYWRkIFBQQyBNTCB0byBDQyBmb3IgYSBjb25maXJt YXRpb24gdGhpcwo+IGNoYW5nZSBpcyBjb3JyZWN0Lgo+Cj4gV2hpY2ggYnJpbmdzIG1lIHRvIHRo ZSB0YW5nZW50aWFsOiB0aGlzIGRyaXZlciBpcyBmcm9tIDIwMDYtaXNoIGFuZAo+IGlzIGZvciBz b21lICJNYXJ2ZWxsIE1WNjR4NjAgTWVtb3J5IENvbnRyb2xsZXIga2VybmVsIG1vZHVsZSBmb3Ig UFBDCj4gcGxhdGZvcm1zIi4gSWYgeW91J3JlIGdvaW5nIHRvIHRvdWNoIGl0LCB0aGVuIHlvdSBz aG91bGQgdGVzdCBvbiB0aGUgUFBDCj4gaGFyZHdhcmUgdG9vLCBzbyB0aGF0IHlvdSBkb24ndCBi cmVhayB0aGUgZHJpdmVyIHRoZXJlLgo+Cj4gVW5sZXNzIHRoYXQgaGFyZHdhcmUgaXMgb2Jzb2xl dGUgbm93IGFuZCB3ZSBkb24ndCBjYXJlIGFuZCwgYW5kIC4uPwo+Cj4gTWF5YmUgc29tZW9uZSBo YXMgc29tZSBpbnNpZ2h0cy4uLgoKTm90IHJlYWxseSBzb3JyeS4KCkkgZG9uJ3QgaGF2ZSBvbmUg b2YgdGhvc2UgYm9hcmRzLCBzbyBJIGNhbid0IHRlc3QuIE1heWJlIHNvbWVvbmUgZWxzZSBvbgp0 aGUgbGlzdCBkb2VzPwoKSSdkIGVyciBvbiB0aGUgc2lkZSBvZiB0aGUgUFBDIGhhcmR3YXJlIGJl aW5nIG9ic29sZXRlIGFuZCBubyBvbmUgcmVhbGx5CmNhcmluZy4gSWYgdGhlIGRyaXZlciBpcyBo ZWxwZnVsIG9uIEFSTSB0aGVuIHdlIG1heSBhcyB3ZWxsIHVzZSBpdAp0aGVyZSwgaWYgd2UgY2Fu IGFsc28gYXZvaWQgYnJlYWtpbmcgaXQgb24gUFBDIHRoZW4gZ3JlYXQuCgpjaGVlcnMKCgo+IE9u IEZyaSwgTWF5IDEyLCAyMDE3IGF0IDA0OjIwOjAyUE0gKzEyMDAsIENocmlzIFBhY2toYW0gd3Jv dGU6Cj4+IFRvIGFsbG93IHRoaXMgZHJpdmVyIHRvIGJlIHVzZWQgb24gbm9uLXBvd2VycGMgcGxh dGZvcm1zIGl0IG5lZWRzIHRvIHVzZQo+PiBpbyBhY2Nlc3NvcnMgc3VpdGFibGUgZm9yIGFsbCBw bGF0Zm9ybXMuCj4+IAo+PiBTaWduZWQtb2ZmLWJ5OiBDaHJpcyBQYWNraGFtIDxjaHJpcy5wYWNr aGFtQGFsbGllZHRlbGVzaXMuY28ubno+Cj4+IC0tLQo+PiAgZHJpdmVycy9lZGFjL212NjR4NjBf ZWRhYy5jIHwgODQgKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t Cj4+ICAxIGZpbGUgY2hhbmdlZCwgNDIgaW5zZXJ0aW9ucygrKSwgNDIgZGVsZXRpb25zKC0pCj4+ IAo+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9lZGFjL212NjR4NjBfZWRhYy5jIGIvZHJpdmVycy9l ZGFjL212NjR4NjBfZWRhYy5jCj4+IGluZGV4IGRkYzUwODJmNzU3Ny4uMTAyZWMyOWY4NjRiIDEw MDY0NAo+PiAtLS0gYS9kcml2ZXJzL2VkYWMvbXY2NHg2MF9lZGFjLmMKPj4gKysrIGIvZHJpdmVy cy9lZGFjL212NjR4NjBfZWRhYy5jCj4+IEBAIC0zMiwyMSArMzIsMjEgQEAgc3RhdGljIHZvaWQg bXY2NHg2MF9wY2lfY2hlY2soc3RydWN0IGVkYWNfcGNpX2N0bF9pbmZvICpwY2kpCj4+ICAJc3Ry dWN0IG12NjR4NjBfcGNpX3BkYXRhICpwZGF0YSA9IHBjaS0+cHZ0X2luZm87Cj4+ICAJdTMyIGNh dXNlOwo+PiAgCj4+IC0JY2F1c2UgPSBpbl9sZTMyKHBkYXRhLT5wY2lfdmJhc2UgKyBNVjY0WDYw X1BDSV9FUlJPUl9DQVVTRSk7Cj4+ICsJY2F1c2UgPSBpb3JlYWQzMihwZGF0YS0+cGNpX3ZiYXNl ICsgTVY2NFg2MF9QQ0lfRVJST1JfQ0FVU0UpOwo+PiAgCWlmICghY2F1c2UpCj4+ICAJCXJldHVy bjsKPj4gIAo+PiAgCXByaW50ayhLRVJOX0VSUiAiRXJyb3IgaW4gUENJICVkIEludGVyZmFjZVxu IiwgcGRhdGEtPnBjaV9ob3NlKTsKPj4gIAlwcmludGsoS0VSTl9FUlIgIkNhdXNlIHJlZ2lzdGVy OiAweCUwOHhcbiIsIGNhdXNlKTsKPj4gIAlwcmludGsoS0VSTl9FUlIgIkFkZHJlc3MgTG93OiAw eCUwOHhcbiIsCj4+IC0JICAgICAgIGluX2xlMzIocGRhdGEtPnBjaV92YmFzZSArIE1WNjRYNjBf UENJX0VSUk9SX0FERFJfTE8pKTsKPj4gKwkgICAgICAgaW9yZWFkMzIocGRhdGEtPnBjaV92YmFz ZSArIE1WNjRYNjBfUENJX0VSUk9SX0FERFJfTE8pKTsKPj4gIAlwcmludGsoS0VSTl9FUlIgIkFk ZHJlc3MgSGlnaDogMHglMDh4XG4iLAo+PiAtCSAgICAgICBpbl9sZTMyKHBkYXRhLT5wY2lfdmJh c2UgKyBNVjY0WDYwX1BDSV9FUlJPUl9BRERSX0hJKSk7Cj4+ICsJICAgICAgIGlvcmVhZDMyKHBk YXRhLT5wY2lfdmJhc2UgKyBNVjY0WDYwX1BDSV9FUlJPUl9BRERSX0hJKSk7Cj4+ICAJcHJpbnRr KEtFUk5fRVJSICJBdHRyaWJ1dGU6IDB4JTA4eFxuIiwKPj4gLQkgICAgICAgaW5fbGUzMihwZGF0 YS0+cGNpX3ZiYXNlICsgTVY2NFg2MF9QQ0lfRVJST1JfQVRUUikpOwo+PiArCSAgICAgICBpb3Jl YWQzMihwZGF0YS0+cGNpX3ZiYXNlICsgTVY2NFg2MF9QQ0lfRVJST1JfQVRUUikpOwo+PiAgCXBy aW50ayhLRVJOX0VSUiAiQ29tbWFuZDogMHglMDh4XG4iLAo+PiAtCSAgICAgICBpbl9sZTMyKHBk YXRhLT5wY2lfdmJhc2UgKyBNVjY0WDYwX1BDSV9FUlJPUl9DTUQpKTsKPj4gLQlvdXRfbGUzMihw ZGF0YS0+cGNpX3ZiYXNlICsgTVY2NFg2MF9QQ0lfRVJST1JfQ0FVU0UsIH5jYXVzZSk7Cj4+ICsJ ICAgICAgIGlvcmVhZDMyKHBkYXRhLT5wY2lfdmJhc2UgKyBNVjY0WDYwX1BDSV9FUlJPUl9DTUQp KTsKPj4gKwlpb3dyaXRlMzIofmNhdXNlLCBwZGF0YS0+cGNpX3ZiYXNlICsgTVY2NFg2MF9QQ0lf RVJST1JfQ0FVU0UpOwo+PiAgCj4+ICAJaWYgKGNhdXNlICYgTVY2NFg2MF9QQ0lfUEVfTUFTSykK Pj4gIAkJZWRhY19wY2lfaGFuZGxlX3BlKHBjaSwgcGNpLT5jdGxfbmFtZSk7Cj4+IEBAIC02MSw3 ICs2MSw3IEBAIHN0YXRpYyBpcnFyZXR1cm5fdCBtdjY0eDYwX3BjaV9pc3IoaW50IGlycSwgdm9p ZCAqZGV2X2lkKQo+PiAgCXN0cnVjdCBtdjY0eDYwX3BjaV9wZGF0YSAqcGRhdGEgPSBwY2ktPnB2 dF9pbmZvOwo+PiAgCXUzMiB2YWw7Cj4+ICAKPj4gLQl2YWwgPSBpbl9sZTMyKHBkYXRhLT5wY2lf dmJhc2UgKyBNVjY0WDYwX1BDSV9FUlJPUl9DQVVTRSk7Cj4+ICsJdmFsID0gaW9yZWFkMzIocGRh dGEtPnBjaV92YmFzZSArIE1WNjRYNjBfUENJX0VSUk9SX0NBVVNFKTsKPj4gIAlpZiAoIXZhbCkK Pj4gIAkJcmV0dXJuIElSUV9OT05FOwo+PiAgCj4+IEBAIC05Myw3ICs5Myw3IEBAIHN0YXRpYyBp bnQgX19pbml0IG12NjR4NjBfcGNpX2ZpeHVwKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYp Cj4+ICAJaWYgKCFwY2lfc2VycikKPj4gIAkJcmV0dXJuIC1FTk9NRU07Cj4+ICAKPj4gLQlvdXRf bGUzMihwY2lfc2VyciwgaW5fbGUzMihwY2lfc2VycikgJiB+MHgxKTsKPj4gKwlpb3dyaXRlMzIo aW9yZWFkMzIocGNpX3NlcnIpICYgfjB4MSwgcGNpX3NlcnIpOwo+PiAgCWlvdW5tYXAocGNpX3Nl cnIpOwo+PiAgCj4+ICAJcmV0dXJuIDA7Cj4+IEBAIC0xNjEsMTAgKzE2MSwxMCBAQCBzdGF0aWMg aW50IG12NjR4NjBfcGNpX2Vycl9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+ PiAgCQlnb3RvIGVycjsKPj4gIAl9Cj4+ICAKPj4gLQlvdXRfbGUzMihwZGF0YS0+cGNpX3ZiYXNl ICsgTVY2NFg2MF9QQ0lfRVJST1JfQ0FVU0UsIDApOwo+PiAtCW91dF9sZTMyKHBkYXRhLT5wY2lf dmJhc2UgKyBNVjY0WDYwX1BDSV9FUlJPUl9NQVNLLCAwKTsKPj4gLQlvdXRfbGUzMihwZGF0YS0+ cGNpX3ZiYXNlICsgTVY2NFg2MF9QQ0lfRVJST1JfTUFTSywKPj4gLQkJIE1WNjRYNjBfUENJeF9F UlJfTUFTS19WQUwpOwo+PiArCWlvd3JpdGUzMigwLCBwZGF0YS0+cGNpX3ZiYXNlICsgTVY2NFg2 MF9QQ0lfRVJST1JfQ0FVU0UpOwo+PiArCWlvd3JpdGUzMigwLCBwZGF0YS0+cGNpX3ZiYXNlICsg TVY2NFg2MF9QQ0lfRVJST1JfTUFTSyk7Cj4+ICsJaW93cml0ZTMyKE1WNjRYNjBfUENJeF9FUlJf TUFTS19WQUwsCj4+ICsJCSAgcGRhdGEtPnBjaV92YmFzZSArIE1WNjRYNjBfUENJX0VSUk9SX01B U0spOwo+PiAgCj4+ICAJaWYgKGVkYWNfcGNpX2FkZF9kZXZpY2UocGNpLCBwZGF0YS0+ZWRhY19p ZHgpID4gMCkgewo+PiAgCQllZGFjX2RiZygzLCAiZmFpbGVkIGVkYWNfcGNpX2FkZF9kZXZpY2Uo KVxuIik7Cj4+IEBAIC0yMzMsMjMgKzIzMywyMyBAQCBzdGF0aWMgdm9pZCBtdjY0eDYwX3NyYW1f Y2hlY2soc3RydWN0IGVkYWNfZGV2aWNlX2N0bF9pbmZvICplZGFjX2RldikKPj4gIAlzdHJ1Y3Qg bXY2NHg2MF9zcmFtX3BkYXRhICpwZGF0YSA9IGVkYWNfZGV2LT5wdnRfaW5mbzsKPj4gIAl1MzIg Y2F1c2U7Cj4+ICAKPj4gLQljYXVzZSA9IGluX2xlMzIocGRhdGEtPnNyYW1fdmJhc2UgKyBNVjY0 WDYwX1NSQU1fRVJSX0NBVVNFKTsKPj4gKwljYXVzZSA9IGlvcmVhZDMyKHBkYXRhLT5zcmFtX3Zi YXNlICsgTVY2NFg2MF9TUkFNX0VSUl9DQVVTRSk7Cj4+ICAJaWYgKCFjYXVzZSkKPj4gIAkJcmV0 dXJuOwo+PiAgCj4+ICAJcHJpbnRrKEtFUk5fRVJSICJFcnJvciBpbiBpbnRlcm5hbCBTUkFNXG4i KTsKPj4gIAlwcmludGsoS0VSTl9FUlIgIkNhdXNlIHJlZ2lzdGVyOiAweCUwOHhcbiIsIGNhdXNl KTsKPj4gIAlwcmludGsoS0VSTl9FUlIgIkFkZHJlc3MgTG93OiAweCUwOHhcbiIsCj4+IC0JICAg ICAgIGluX2xlMzIocGRhdGEtPnNyYW1fdmJhc2UgKyBNVjY0WDYwX1NSQU1fRVJSX0FERFJfTE8p KTsKPj4gKwkgICAgICAgaW9yZWFkMzIocGRhdGEtPnNyYW1fdmJhc2UgKyBNVjY0WDYwX1NSQU1f RVJSX0FERFJfTE8pKTsKPj4gIAlwcmludGsoS0VSTl9FUlIgIkFkZHJlc3MgSGlnaDogMHglMDh4 XG4iLAo+PiAtCSAgICAgICBpbl9sZTMyKHBkYXRhLT5zcmFtX3ZiYXNlICsgTVY2NFg2MF9TUkFN X0VSUl9BRERSX0hJKSk7Cj4+ICsJICAgICAgIGlvcmVhZDMyKHBkYXRhLT5zcmFtX3ZiYXNlICsg TVY2NFg2MF9TUkFNX0VSUl9BRERSX0hJKSk7Cj4+ICAJcHJpbnRrKEtFUk5fRVJSICJEYXRhIExv dzogMHglMDh4XG4iLAo+PiAtCSAgICAgICBpbl9sZTMyKHBkYXRhLT5zcmFtX3ZiYXNlICsgTVY2 NFg2MF9TUkFNX0VSUl9EQVRBX0xPKSk7Cj4+ICsJICAgICAgIGlvcmVhZDMyKHBkYXRhLT5zcmFt X3ZiYXNlICsgTVY2NFg2MF9TUkFNX0VSUl9EQVRBX0xPKSk7Cj4+ICAJcHJpbnRrKEtFUk5fRVJS ICJEYXRhIEhpZ2g6IDB4JTA4eFxuIiwKPj4gLQkgICAgICAgaW5fbGUzMihwZGF0YS0+c3JhbV92 YmFzZSArIE1WNjRYNjBfU1JBTV9FUlJfREFUQV9ISSkpOwo+PiArCSAgICAgICBpb3JlYWQzMihw ZGF0YS0+c3JhbV92YmFzZSArIE1WNjRYNjBfU1JBTV9FUlJfREFUQV9ISSkpOwo+PiAgCXByaW50 ayhLRVJOX0VSUiAiUGFyaXR5OiAweCUwOHhcbiIsCj4+IC0JICAgICAgIGluX2xlMzIocGRhdGEt PnNyYW1fdmJhc2UgKyBNVjY0WDYwX1NSQU1fRVJSX1BBUklUWSkpOwo+PiAtCW91dF9sZTMyKHBk YXRhLT5zcmFtX3ZiYXNlICsgTVY2NFg2MF9TUkFNX0VSUl9DQVVTRSwgMCk7Cj4+ICsJICAgICAg IGlvcmVhZDMyKHBkYXRhLT5zcmFtX3ZiYXNlICsgTVY2NFg2MF9TUkFNX0VSUl9QQVJJVFkpKTsK Pj4gKwlpb3dyaXRlMzIoMCwgcGRhdGEtPnNyYW1fdmJhc2UgKyBNVjY0WDYwX1NSQU1fRVJSX0NB VVNFKTsKPj4gIAo+PiAgCWVkYWNfZGV2aWNlX2hhbmRsZV91ZShlZGFjX2RldiwgMCwgMCwgZWRh Y19kZXYtPmN0bF9uYW1lKTsKPj4gIH0KPj4gQEAgLTI2MCw3ICsyNjAsNyBAQCBzdGF0aWMgaXJx cmV0dXJuX3QgbXY2NHg2MF9zcmFtX2lzcihpbnQgaXJxLCB2b2lkICpkZXZfaWQpCj4+ICAJc3Ry dWN0IG12NjR4NjBfc3JhbV9wZGF0YSAqcGRhdGEgPSBlZGFjX2Rldi0+cHZ0X2luZm87Cj4+ICAJ dTMyIGNhdXNlOwo+PiAgCj4+IC0JY2F1c2UgPSBpbl9sZTMyKHBkYXRhLT5zcmFtX3ZiYXNlICsg TVY2NFg2MF9TUkFNX0VSUl9DQVVTRSk7Cj4+ICsJY2F1c2UgPSBpb3JlYWQzMihwZGF0YS0+c3Jh bV92YmFzZSArIE1WNjRYNjBfU1JBTV9FUlJfQ0FVU0UpOwo+PiAgCWlmICghY2F1c2UpCj4+ICAJ CXJldHVybiBJUlFfTk9ORTsKPj4gIAo+PiBAQCAtMzIyLDcgKzMyMiw3IEBAIHN0YXRpYyBpbnQg bXY2NHg2MF9zcmFtX2Vycl9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+PiAg CX0KPj4gIAo+PiAgCS8qIHNldHVwIFNSQU0gZXJyIHJlZ2lzdGVycyAqLwo+PiAtCW91dF9sZTMy KHBkYXRhLT5zcmFtX3ZiYXNlICsgTVY2NFg2MF9TUkFNX0VSUl9DQVVTRSwgMCk7Cj4+ICsJaW93 cml0ZTMyKDAsIHBkYXRhLT5zcmFtX3ZiYXNlICsgTVY2NFg2MF9TUkFNX0VSUl9DQVVTRSk7Cj4+ ICAKPj4gIAllZGFjX2Rldi0+bW9kX25hbWUgPSBFREFDX01PRF9TVFI7Cj4+ICAJZWRhY19kZXYt PmN0bF9uYW1lID0gcGRhdGEtPm5hbWU7Cj4+IEBAIC0zOTgsNyArMzk4LDcgQEAgc3RhdGljIHZv aWQgbXY2NHg2MF9jcHVfY2hlY2soc3RydWN0IGVkYWNfZGV2aWNlX2N0bF9pbmZvICplZGFjX2Rl dikKPj4gIAlzdHJ1Y3QgbXY2NHg2MF9jcHVfcGRhdGEgKnBkYXRhID0gZWRhY19kZXYtPnB2dF9p bmZvOwo+PiAgCXUzMiBjYXVzZTsKPj4gIAo+PiAtCWNhdXNlID0gaW5fbGUzMihwZGF0YS0+Y3B1 X3ZiYXNlWzFdICsgTVY2NHg2MF9DUFVfRVJSX0NBVVNFKSAmCj4+ICsJY2F1c2UgPSBpb3JlYWQz MihwZGF0YS0+Y3B1X3ZiYXNlWzFdICsgTVY2NHg2MF9DUFVfRVJSX0NBVVNFKSAmCj4+ICAJICAg IE1WNjR4NjBfQ1BVX0NBVVNFX01BU0s7Cj4+ICAJaWYgKCFjYXVzZSkKPj4gIAkJcmV0dXJuOwo+ PiBAQCAtNDA2LDE2ICs0MDYsMTYgQEAgc3RhdGljIHZvaWQgbXY2NHg2MF9jcHVfY2hlY2soc3Ry dWN0IGVkYWNfZGV2aWNlX2N0bF9pbmZvICplZGFjX2RldikKPj4gIAlwcmludGsoS0VSTl9FUlIg IkVycm9yIG9uIENQVSBpbnRlcmZhY2VcbiIpOwo+PiAgCXByaW50ayhLRVJOX0VSUiAiQ2F1c2Ug cmVnaXN0ZXI6IDB4JTA4eFxuIiwgY2F1c2UpOwo+PiAgCXByaW50ayhLRVJOX0VSUiAiQWRkcmVz cyBMb3c6IDB4JTA4eFxuIiwKPj4gLQkgICAgICAgaW5fbGUzMihwZGF0YS0+Y3B1X3ZiYXNlWzBd ICsgTVY2NHg2MF9DUFVfRVJSX0FERFJfTE8pKTsKPj4gKwkgICAgICAgaW9yZWFkMzIocGRhdGEt PmNwdV92YmFzZVswXSArIE1WNjR4NjBfQ1BVX0VSUl9BRERSX0xPKSk7Cj4+ICAJcHJpbnRrKEtF Uk5fRVJSICJBZGRyZXNzIEhpZ2g6IDB4JTA4eFxuIiwKPj4gLQkgICAgICAgaW5fbGUzMihwZGF0 YS0+Y3B1X3ZiYXNlWzBdICsgTVY2NHg2MF9DUFVfRVJSX0FERFJfSEkpKTsKPj4gKwkgICAgICAg aW9yZWFkMzIocGRhdGEtPmNwdV92YmFzZVswXSArIE1WNjR4NjBfQ1BVX0VSUl9BRERSX0hJKSk7 Cj4+ICAJcHJpbnRrKEtFUk5fRVJSICJEYXRhIExvdzogMHglMDh4XG4iLAo+PiAtCSAgICAgICBp bl9sZTMyKHBkYXRhLT5jcHVfdmJhc2VbMV0gKyBNVjY0eDYwX0NQVV9FUlJfREFUQV9MTykpOwo+ PiArCSAgICAgICBpb3JlYWQzMihwZGF0YS0+Y3B1X3ZiYXNlWzFdICsgTVY2NHg2MF9DUFVfRVJS X0RBVEFfTE8pKTsKPj4gIAlwcmludGsoS0VSTl9FUlIgIkRhdGEgSGlnaDogMHglMDh4XG4iLAo+ PiAtCSAgICAgICBpbl9sZTMyKHBkYXRhLT5jcHVfdmJhc2VbMV0gKyBNVjY0eDYwX0NQVV9FUlJf REFUQV9ISSkpOwo+PiArCSAgICAgICBpb3JlYWQzMihwZGF0YS0+Y3B1X3ZiYXNlWzFdICsgTVY2 NHg2MF9DUFVfRVJSX0RBVEFfSEkpKTsKPj4gIAlwcmludGsoS0VSTl9FUlIgIlBhcml0eTogMHgl MDh4XG4iLAo+PiAtCSAgICAgICBpbl9sZTMyKHBkYXRhLT5jcHVfdmJhc2VbMV0gKyBNVjY0eDYw X0NQVV9FUlJfUEFSSVRZKSk7Cj4+IC0Jb3V0X2xlMzIocGRhdGEtPmNwdV92YmFzZVsxXSArIE1W NjR4NjBfQ1BVX0VSUl9DQVVTRSwgMCk7Cj4+ICsJICAgICAgIGlvcmVhZDMyKHBkYXRhLT5jcHVf dmJhc2VbMV0gKyBNVjY0eDYwX0NQVV9FUlJfUEFSSVRZKSk7Cj4+ICsJaW93cml0ZTMyKDAsIHBk YXRhLT5jcHVfdmJhc2VbMV0gKyBNVjY0eDYwX0NQVV9FUlJfQ0FVU0UpOwo+PiAgCj4+ICAJZWRh Y19kZXZpY2VfaGFuZGxlX3VlKGVkYWNfZGV2LCAwLCAwLCBlZGFjX2Rldi0+Y3RsX25hbWUpOwo+ PiAgfQo+PiBAQCAtNDI2LDcgKzQyNiw3IEBAIHN0YXRpYyBpcnFyZXR1cm5fdCBtdjY0eDYwX2Nw dV9pc3IoaW50IGlycSwgdm9pZCAqZGV2X2lkKQo+PiAgCXN0cnVjdCBtdjY0eDYwX2NwdV9wZGF0 YSAqcGRhdGEgPSBlZGFjX2Rldi0+cHZ0X2luZm87Cj4+ICAJdTMyIGNhdXNlOwo+PiAgCj4+IC0J Y2F1c2UgPSBpbl9sZTMyKHBkYXRhLT5jcHVfdmJhc2VbMV0gKyBNVjY0eDYwX0NQVV9FUlJfQ0FV U0UpICYKPj4gKwljYXVzZSA9IGlvcmVhZDMyKHBkYXRhLT5jcHVfdmJhc2VbMV0gKyBNVjY0eDYw X0NQVV9FUlJfQ0FVU0UpICYKPj4gIAkgICAgTVY2NHg2MF9DUFVfQ0FVU0VfTUFTSzsKPj4gIAlp ZiAoIWNhdXNlKQo+PiAgCQlyZXR1cm4gSVJRX05PTkU7Cj4+IEBAIC01MTUsOSArNTE1LDkgQEAg c3RhdGljIGludCBtdjY0eDYwX2NwdV9lcnJfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAq cGRldikKPj4gIAl9Cj4+ICAKPj4gIAkvKiBzZXR1cCBDUFUgZXJyIHJlZ2lzdGVycyAqLwo+PiAt CW91dF9sZTMyKHBkYXRhLT5jcHVfdmJhc2VbMV0gKyBNVjY0eDYwX0NQVV9FUlJfQ0FVU0UsIDAp Owo+PiAtCW91dF9sZTMyKHBkYXRhLT5jcHVfdmJhc2VbMV0gKyBNVjY0eDYwX0NQVV9FUlJfTUFT SywgMCk7Cj4+IC0Jb3V0X2xlMzIocGRhdGEtPmNwdV92YmFzZVsxXSArIE1WNjR4NjBfQ1BVX0VS Ul9NQVNLLCAweDAwMDAwMGZmKTsKPj4gKwlpb3dyaXRlMzIoMCwgcGRhdGEtPmNwdV92YmFzZVsx XSArIE1WNjR4NjBfQ1BVX0VSUl9DQVVTRSk7Cj4+ICsJaW93cml0ZTMyKDAsIHBkYXRhLT5jcHVf dmJhc2VbMV0gKyBNVjY0eDYwX0NQVV9FUlJfTUFTSyk7Cj4+ICsJaW93cml0ZTMyKDB4MDAwMDAw ZmYsIHBkYXRhLT5jcHVfdmJhc2VbMV0gKyBNVjY0eDYwX0NQVV9FUlJfTUFTSyk7Cj4+ICAKPj4g IAllZGFjX2Rldi0+bW9kX25hbWUgPSBFREFDX01PRF9TVFI7Cj4+ICAJZWRhY19kZXYtPmN0bF9u YW1lID0gcGRhdGEtPm5hbWU7Cj4+IEBAIC01OTYsMTMgKzU5NiwxMyBAQCBzdGF0aWMgdm9pZCBt djY0eDYwX21jX2NoZWNrKHN0cnVjdCBtZW1fY3RsX2luZm8gKm1jaSkKPj4gIAl1MzIgY29tcF9l Y2M7Cj4+ICAJdTMyIHN5bmRyb21lOwo+PiAgCj4+IC0JcmVnID0gaW5fbGUzMihwZGF0YS0+bWNf dmJhc2UgKyBNVjY0WDYwX1NEUkFNX0VSUl9BRERSKTsKPj4gKwlyZWcgPSBpb3JlYWQzMihwZGF0 YS0+bWNfdmJhc2UgKyBNVjY0WDYwX1NEUkFNX0VSUl9BRERSKTsKPj4gIAlpZiAoIXJlZykKPj4g IAkJcmV0dXJuOwo+PiAgCj4+ICAJZXJyX2FkZHIgPSByZWcgJiB+MHgzOwo+PiAtCXNkcmFtX2Vj YyA9IGluX2xlMzIocGRhdGEtPm1jX3ZiYXNlICsgTVY2NFg2MF9TRFJBTV9FUlJfRUNDX1JDVkQp Owo+PiAtCWNvbXBfZWNjID0gaW5fbGUzMihwZGF0YS0+bWNfdmJhc2UgKyBNVjY0WDYwX1NEUkFN X0VSUl9FQ0NfQ0FMQyk7Cj4+ICsJc2RyYW1fZWNjID0gaW9yZWFkMzIocGRhdGEtPm1jX3ZiYXNl ICsgTVY2NFg2MF9TRFJBTV9FUlJfRUNDX1JDVkQpOwo+PiArCWNvbXBfZWNjID0gaW9yZWFkMzIo cGRhdGEtPm1jX3ZiYXNlICsgTVY2NFg2MF9TRFJBTV9FUlJfRUNDX0NBTEMpOwo+PiAgCXN5bmRy b21lID0gc2RyYW1fZWNjIF4gY29tcF9lY2M7Cj4+ICAKPj4gIAkvKiBmaXJzdCBiaXQgY2xlYXIg aW4gRUNDIEVyciBSZWcsIDEgYml0IGVycm9yLCBjb3JyZWN0YWJsZSBieSBIVyAqLwo+PiBAQCAt NjIwLDcgKzYyMCw3IEBAIHN0YXRpYyB2b2lkIG12NjR4NjBfbWNfY2hlY2soc3RydWN0IG1lbV9j dGxfaW5mbyAqbWNpKQo+PiAgCQkJCSAgICAgbWNpLT5jdGxfbmFtZSwgIiIpOwo+PiAgCj4+ICAJ LyogY2xlYXIgdGhlIGVycm9yICovCj4+IC0Jb3V0X2xlMzIocGRhdGEtPm1jX3ZiYXNlICsgTVY2 NFg2MF9TRFJBTV9FUlJfQUREUiwgMCk7Cj4+ICsJaW93cml0ZTMyKDAsIHBkYXRhLT5tY192YmFz ZSArIE1WNjRYNjBfU0RSQU1fRVJSX0FERFIpOwo+PiAgfQo+PiAgCj4+ICBzdGF0aWMgaXJxcmV0 dXJuX3QgbXY2NHg2MF9tY19pc3IoaW50IGlycSwgdm9pZCAqZGV2X2lkKQo+PiBAQCAtNjI5LDcg KzYyOSw3IEBAIHN0YXRpYyBpcnFyZXR1cm5fdCBtdjY0eDYwX21jX2lzcihpbnQgaXJxLCB2b2lk ICpkZXZfaWQpCj4+ICAJc3RydWN0IG12NjR4NjBfbWNfcGRhdGEgKnBkYXRhID0gbWNpLT5wdnRf aW5mbzsKPj4gIAl1MzIgcmVnOwo+PiAgCj4+IC0JcmVnID0gaW5fbGUzMihwZGF0YS0+bWNfdmJh c2UgKyBNVjY0WDYwX1NEUkFNX0VSUl9BRERSKTsKPj4gKwlyZWcgPSBpb3JlYWQzMihwZGF0YS0+ bWNfdmJhc2UgKyBNVjY0WDYwX1NEUkFNX0VSUl9BRERSKTsKPj4gIAlpZiAoIXJlZykKPj4gIAkJ cmV0dXJuIElSUV9OT05FOwo+PiAgCj4+IEBAIC02NjQsNyArNjY0LDcgQEAgc3RhdGljIHZvaWQg bXY2NHg2MF9pbml0X2Nzcm93cyhzdHJ1Y3QgbWVtX2N0bF9pbmZvICptY2ksCj4+ICAKPj4gIAln ZXRfdG90YWxfbWVtKHBkYXRhKTsKPj4gIAo+PiAtCWN0bCA9IGluX2xlMzIocGRhdGEtPm1jX3Zi YXNlICsgTVY2NFg2MF9TRFJBTV9DT05GSUcpOwo+PiArCWN0bCA9IGlvcmVhZDMyKHBkYXRhLT5t Y192YmFzZSArIE1WNjRYNjBfU0RSQU1fQ09ORklHKTsKPj4gIAo+PiAgCWNzcm93ID0gbWNpLT5j c3Jvd3NbMF07Cj4+ICAJZGltbSA9IGNzcm93LT5jaGFubmVsc1swXS0+ZGltbTsKPj4gQEAgLTc1 Myw3ICs3NTMsNyBAQCBzdGF0aWMgaW50IG12NjR4NjBfbWNfZXJyX3Byb2JlKHN0cnVjdCBwbGF0 Zm9ybV9kZXZpY2UgKnBkZXYpCj4+ICAJCWdvdG8gZXJyOwo+PiAgCX0KPj4gIAo+PiAtCWN0bCA9 IGluX2xlMzIocGRhdGEtPm1jX3ZiYXNlICsgTVY2NFg2MF9TRFJBTV9DT05GSUcpOwo+PiArCWN0 bCA9IGlvcmVhZDMyKHBkYXRhLT5tY192YmFzZSArIE1WNjRYNjBfU0RSQU1fQ09ORklHKTsKPj4g IAlpZiAoIShjdGwgJiBNVjY0WDYwX1NEUkFNX0VDQykpIHsKPj4gIAkJLyogTm9uLUVDQyBSQU0/ ICovCj4+ICAJCXByaW50ayhLRVJOX1dBUk5JTkcgIiVzOiBObyBFQ0MgRElNTXMgZGlzY292ZXJl ZFxuIiwgX19mdW5jX18pOwo+PiBAQCAtNzc5LDEwICs3NzksMTAgQEAgc3RhdGljIGludCBtdjY0 eDYwX21jX2Vycl9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+PiAgCW12NjR4 NjBfaW5pdF9jc3Jvd3MobWNpLCBwZGF0YSk7Cj4+ICAKPj4gIAkvKiBzZXR1cCBNQyByZWdpc3Rl cnMgKi8KPj4gLQlvdXRfbGUzMihwZGF0YS0+bWNfdmJhc2UgKyBNVjY0WDYwX1NEUkFNX0VSUl9B RERSLCAwKTsKPj4gLQljdGwgPSBpbl9sZTMyKHBkYXRhLT5tY192YmFzZSArIE1WNjRYNjBfU0RS QU1fRVJSX0VDQ19DTlRMKTsKPj4gKwlpb3dyaXRlMzIoMCwgcGRhdGEtPm1jX3ZiYXNlICsgTVY2 NFg2MF9TRFJBTV9FUlJfQUREUik7Cj4+ICsJY3RsID0gaW9yZWFkMzIocGRhdGEtPm1jX3ZiYXNl ICsgTVY2NFg2MF9TRFJBTV9FUlJfRUNDX0NOVEwpOwo+PiAgCWN0bCA9IChjdGwgJiAweGZmMDBm ZmZmKSB8IDB4MTAwMDA7Cj4+IC0Jb3V0X2xlMzIocGRhdGEtPm1jX3ZiYXNlICsgTVY2NFg2MF9T RFJBTV9FUlJfRUNDX0NOVEwsIGN0bCk7Cj4+ICsJaW93cml0ZTMyKGN0bCwgcGRhdGEtPm1jX3Zi YXNlICsgTVY2NFg2MF9TRFJBTV9FUlJfRUNDX0NOVEwpOwo+PiAgCj4+ICAJcmVzID0gZWRhY19t Y19hZGRfbWMobWNpKTsKPj4gIAlpZiAocmVzKSB7Cj4+IC0tIAo+PiAyLjExLjAuMjQuZ2U2OTIw Y2YKPj4gCj4KPiAtLSAKPiBSZWdhcmRzL0dydXNzLAo+ICAgICBCb3Jpcy4KPgo+IEdvb2QgbWFp bGluZyBwcmFjdGljZXMgZm9yIDQwMDogdHJ5IHRvIGF2b2lkIHRvcC1wb3N0aW5nIGFuZCB0cmlt IHRoZSByZXBseS4KLS0tClRvIHVuc3Vic2NyaWJlIGZyb20gdGhpcyBsaXN0OiBzZW5kIHRoZSBs aW5lICJ1bnN1YnNjcmliZSBsaW51eC1lZGFjIiBpbgp0aGUgYm9keSBvZiBhIG1lc3NhZ2UgdG8g bWFqb3Jkb21vQHZnZXIua2VybmVsLm9yZwpNb3JlIG1ham9yZG9tbyBpbmZvIGF0ICBodHRwOi8v dmdlci5rZXJuZWwub3JnL21ham9yZG9tby1pbmZvLmh0bWwK