From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.6 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_PASS,USER_AGENT_MUTT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0AB49C10F03 for ; Thu, 25 Apr 2019 13:01:29 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 2310220678 for ; Thu, 25 Apr 2019 13:01:28 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1556197288; bh=Z5o13u5SEfOqQI+GfkO/KziMTykmSD5QTd6/HiylPqo=; h=Date:From:To:Cc:Subject:References:In-Reply-To:List-ID:From; b=t87qxf7q4KdhSOVE0Hv1WU2v2GxQQ6OWyBp0EyLdd0LrUy9bparRiSTIsd8131/xe 2aCcYsIu6q3x7TtCaNf6VM2i6RqXtdoKSs6+lHGoROYTEk3rZYnyVdHrkmEZV5LaGt ZXfPGkbpzQrtqj1aUyo2lZ/Sq+TpLUlUNZOlPzso= Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728045AbfDYNB2 (ORCPT ); Thu, 25 Apr 2019 09:01:28 -0400 Received: from mail.kernel.org ([198.145.29.99]:59928 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726571AbfDYNB1 (ORCPT ); Thu, 25 Apr 2019 09:01:27 -0400 Received: from localhost (173-25-63-173.client.mchsi.com [173.25.63.173]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPSA id 905F620678; Thu, 25 Apr 2019 13:01:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1556197285; bh=Z5o13u5SEfOqQI+GfkO/KziMTykmSD5QTd6/HiylPqo=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=j4WQyPfQWLosEaE+QW+8v1JRCsa3nDXl4G42rs61dn+meBuulauy67PxnFVQC2FWi WHScWmscUqdM3tJWue4LDA+sOociIPABQPfo3rJtyXh+cuG7KVNqsUM47du1ql0o9t c5NmdmVcxkz3uj+4ujed8aex8R/FS2cHVBGNDBUU= Date: Thu, 25 Apr 2019 08:01:24 -0500 From: Bjorn Helgaas To: Lyude Paul Cc: linux-pci@vger.kernel.org, nouveau@lists.freedesktop.org, dri-devel@lists.freedesktop.org, Karol Herbst , Ben Skeggs , stable@vger.kernel.org, linux-kernel@vger.kernel.org Subject: Re: [PATCH] pci/quirks: Add quirk to reset nvgpu at boot for the Lenovo ThinkPad P50 Message-ID: <20190425130124.GD11428@google.com> References: <20190212220230.1568-1-lyude@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20190212220230.1568-1-lyude@redhat.com> User-Agent: Mutt/1.10.1 (2018-07-13) Sender: linux-pci-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-pci@vger.kernel.org On Tue, Feb 12, 2019 at 05:02:30PM -0500, Lyude Paul wrote: > On a very specific subset of ThinkPad P50 SKUs, particularly ones that > come with a Quadro M1000M chip instead of the M2000M variant, the BIOS > seems to have a very nasty habit of not always resetting the secondary > Nvidia GPU between full reboots if the laptop is configured in Hybrid > Graphics mode. The reason for this happening is unknown, but the > following steps and possibly a good bit of patience will reproduce the > issue: > > 1. Boot up the laptop normally in Hybrid graphics mode > 2. Make sure nouveau is loaded and that the GPU is awake > 2. Allow the nvidia GPU to runtime suspend itself after being idle > 3. Reboot the machine, the more sudden the better (e.g sysrq-b may help) > 4. If nouveau loads up properly, reboot the machine again and go back to > step 2 until you reproduce the issue > > This results in some very strange behavior: the GPU will > quite literally be left in exactly the same state it was in when the > previously booted kernel started the reboot. This has all sorts of bad > sideaffects: for starters, this completely breaks nouveau starting with a > mysterious EVO channel failure that happens well before we've actually > used the EVO channel for anything: > > nouveau 0000:01:00.0: disp: chid 0 mthd 0000 data 00000400 00001000 > 00000002 > ... > So to do this, we add a new pci quirk using > DECLARE_PCI_FIXUP_CLASS_FINAL that will be invoked before the PCI probe > at boot finishes. From there, we check to make sure that this is indeed > the specific P50 variant of this GPU. We also make sure that the GPU PCI > device is advertising NoReset- in order to prevent us from trying to > reset the GPU when the machine is in Dedicated graphics mode (where the > GPU being initialized by the BIOS is normal and expected). Finally, we > try mapping the MMIO space for the GPU which should only work if the GPU > is actually active in D0 mode. We can then read the magic 0x2240c > register on the GPU, which will have bit 1 set if the GPU's firmware has > already been posted during a previous boot. Once we've confirmed all of > this, we reset the PCI device and re-disable it - bringing the GPU back > into a healthy state. > > Signed-off-by: Lyude Paul > Cc: nouveau@lists.freedesktop.org > Cc: dri-devel@lists.freedesktop.org > Cc: Karol Herbst > Cc: Ben Skeggs > Cc: stable@vger.kernel.org Applied to pci/misc for v5.2, thanks! > --- > drivers/pci/quirks.c | 65 ++++++++++++++++++++++++++++++++++++++++++++ > 1 file changed, 65 insertions(+) > > diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c > index b0a413f3f7ca..948492fda8bf 100644 > --- a/drivers/pci/quirks.c > +++ b/drivers/pci/quirks.c > @@ -5117,3 +5117,68 @@ SWITCHTEC_QUIRK(0x8573); /* PFXI 48XG3 */ > SWITCHTEC_QUIRK(0x8574); /* PFXI 64XG3 */ > SWITCHTEC_QUIRK(0x8575); /* PFXI 80XG3 */ > SWITCHTEC_QUIRK(0x8576); /* PFXI 96XG3 */ > + > +/* > + * On certain Lenovo Thinkpad P50 SKUs, specifically those with a Nvidia > + * Quadro M1000M, the BIOS will occasionally make the mistake of not resetting > + * the nvidia GPU between reboots if the system is configured to use hybrid > + * graphics mode. This results in the GPU being left in whatever state it was > + * in during the previous boot which causes spurious interrupts from the GPU, > + * which in turn cause us to disable the wrong IRQs and end up breaking the > + * touchpad. Unsurprisingly, this also completely breaks nouveau. > + * > + * Luckily, it seems a simple reset of the PCI device for the nvidia GPU > + * manages to bring the GPU back into a clean state and fix all of these > + * issues. Additionally since the GPU will report NoReset+ when the machine is > + * configured in Dedicated display mode, we don't need to worry about > + * accidentally resetting the GPU when it's supposed to already be > + * initialized. > + */ > +static void > +quirk_lenovo_thinkpad_p50_nvgpu_survives_reboot(struct pci_dev *pdev) > +{ > + void __iomem *map; > + int ret; > + > + if (pdev->subsystem_vendor != PCI_VENDOR_ID_LENOVO || > + pdev->subsystem_device != 0x222e || > + !pdev->reset_fn) > + return; > + > + /* > + * If we can't enable the device's mmio space, it's probably not even > + * initialized. This is fine, and means we can just skip the quirk > + * entirely. > + */ > + if (pci_enable_device_mem(pdev)) { > + pci_dbg(pdev, "Can't enable device mem, no reset needed\n"); > + return; > + } > + > + /* Taken from drivers/gpu/drm/nouveau/engine/device/base.c */ > + map = ioremap(pci_resource_start(pdev, 0), 0x102000); > + if (!map) { > + pci_err(pdev, "Can't map MMIO space, this is probably very bad\n"); > + goto out_disable; > + } > + > + /* > + * Be extra careful, and make sure that the GPU firmware is posted > + * before trying a reset > + */ > + if (ioread32(map + 0x2240c) & 0x2) { > + pci_info(pdev, > + FW_BUG "GPU left initialized by EFI, resetting\n"); > + ret = pci_reset_function(pdev); > + if (ret < 0) > + pci_err(pdev, "Failed to reset GPU: %d\n", ret); > + } > + > + iounmap(map); > +out_disable: > + pci_disable_device(pdev); > +} > + > +DECLARE_PCI_FIXUP_CLASS_FINAL(PCI_VENDOR_ID_NVIDIA, 0x13b1, > + PCI_CLASS_DISPLAY_VGA, 8, > + quirk_lenovo_thinkpad_p50_nvgpu_survives_reboot); > -- > 2.20.1 > From mboxrd@z Thu Jan 1 00:00:00 1970 From: Bjorn Helgaas Subject: Re: [PATCH] pci/quirks: Add quirk to reset nvgpu at boot for the Lenovo ThinkPad P50 Date: Thu, 25 Apr 2019 08:01:24 -0500 Message-ID: <20190425130124.GD11428@google.com> References: <20190212220230.1568-1-lyude@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <20190212220230.1568-1-lyude@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Lyude Paul Cc: Karol Herbst , linux-pci@vger.kernel.org, linux-kernel@vger.kernel.org, stable@vger.kernel.org, dri-devel@lists.freedesktop.org, nouveau@lists.freedesktop.org List-Id: nouveau.vger.kernel.org T24gVHVlLCBGZWIgMTIsIDIwMTkgYXQgMDU6MDI6MzBQTSAtMDUwMCwgTHl1ZGUgUGF1bCB3cm90 ZToKPiBPbiBhIHZlcnkgc3BlY2lmaWMgc3Vic2V0IG9mIFRoaW5rUGFkIFA1MCBTS1VzLCBwYXJ0 aWN1bGFybHkgb25lcyB0aGF0Cj4gY29tZSB3aXRoIGEgUXVhZHJvIE0xMDAwTSBjaGlwIGluc3Rl YWQgb2YgdGhlIE0yMDAwTSB2YXJpYW50LCB0aGUgQklPUwo+IHNlZW1zIHRvIGhhdmUgYSB2ZXJ5 IG5hc3R5IGhhYml0IG9mIG5vdCBhbHdheXMgcmVzZXR0aW5nIHRoZSBzZWNvbmRhcnkKPiBOdmlk aWEgR1BVIGJldHdlZW4gZnVsbCByZWJvb3RzIGlmIHRoZSBsYXB0b3AgaXMgY29uZmlndXJlZCBp biBIeWJyaWQKPiBHcmFwaGljcyBtb2RlLiBUaGUgcmVhc29uIGZvciB0aGlzIGhhcHBlbmluZyBp cyB1bmtub3duLCBidXQgdGhlCj4gZm9sbG93aW5nIHN0ZXBzIGFuZCBwb3NzaWJseSBhIGdvb2Qg Yml0IG9mIHBhdGllbmNlIHdpbGwgcmVwcm9kdWNlIHRoZQo+IGlzc3VlOgo+IAo+IDEuIEJvb3Qg dXAgdGhlIGxhcHRvcCBub3JtYWxseSBpbiBIeWJyaWQgZ3JhcGhpY3MgbW9kZQo+IDIuIE1ha2Ug c3VyZSBub3V2ZWF1IGlzIGxvYWRlZCBhbmQgdGhhdCB0aGUgR1BVIGlzIGF3YWtlCj4gMi4gQWxs b3cgdGhlIG52aWRpYSBHUFUgdG8gcnVudGltZSBzdXNwZW5kIGl0c2VsZiBhZnRlciBiZWluZyBp ZGxlCj4gMy4gUmVib290IHRoZSBtYWNoaW5lLCB0aGUgbW9yZSBzdWRkZW4gdGhlIGJldHRlciAo ZS5nIHN5c3JxLWIgbWF5IGhlbHApCj4gNC4gSWYgbm91dmVhdSBsb2FkcyB1cCBwcm9wZXJseSwg cmVib290IHRoZSBtYWNoaW5lIGFnYWluIGFuZCBnbyBiYWNrIHRvCj4gc3RlcCAyIHVudGlsIHlv dSByZXByb2R1Y2UgdGhlIGlzc3VlCj4gCj4gVGhpcyByZXN1bHRzIGluIHNvbWUgdmVyeSBzdHJh bmdlIGJlaGF2aW9yOiB0aGUgR1BVIHdpbGwKPiBxdWl0ZSBsaXRlcmFsbHkgYmUgbGVmdCBpbiBl eGFjdGx5IHRoZSBzYW1lIHN0YXRlIGl0IHdhcyBpbiB3aGVuIHRoZQo+IHByZXZpb3VzbHkgYm9v dGVkIGtlcm5lbCBzdGFydGVkIHRoZSByZWJvb3QuIFRoaXMgaGFzIGFsbCBzb3J0cyBvZiBiYWQK PiBzaWRlYWZmZWN0czogZm9yIHN0YXJ0ZXJzLCB0aGlzIGNvbXBsZXRlbHkgYnJlYWtzIG5vdXZl YXUgc3RhcnRpbmcgd2l0aCBhCj4gbXlzdGVyaW91cyBFVk8gY2hhbm5lbCBmYWlsdXJlIHRoYXQg aGFwcGVucyB3ZWxsIGJlZm9yZSB3ZSd2ZSBhY3R1YWxseQo+IHVzZWQgdGhlIEVWTyBjaGFubmVs IGZvciBhbnl0aGluZzoKPiAKPiBub3V2ZWF1IDAwMDA6MDE6MDAuMDogZGlzcDogY2hpZCAwIG10 aGQgMDAwMCBkYXRhIDAwMDAwNDAwIDAwMDAxMDAwCj4gMDAwMDAwMDIKPiAuLi4KCj4gU28gdG8g ZG8gdGhpcywgd2UgYWRkIGEgbmV3IHBjaSBxdWlyayB1c2luZwo+IERFQ0xBUkVfUENJX0ZJWFVQ X0NMQVNTX0ZJTkFMIHRoYXQgd2lsbCBiZSBpbnZva2VkIGJlZm9yZSB0aGUgUENJIHByb2JlCj4g YXQgYm9vdCBmaW5pc2hlcy4gRnJvbSB0aGVyZSwgd2UgY2hlY2sgdG8gbWFrZSBzdXJlIHRoYXQg dGhpcyBpcyBpbmRlZWQKPiB0aGUgc3BlY2lmaWMgUDUwIHZhcmlhbnQgb2YgdGhpcyBHUFUuIFdl IGFsc28gbWFrZSBzdXJlIHRoYXQgdGhlIEdQVSBQQ0kKPiBkZXZpY2UgaXMgYWR2ZXJ0aXNpbmcg Tm9SZXNldC0gaW4gb3JkZXIgdG8gcHJldmVudCB1cyBmcm9tIHRyeWluZyB0bwo+IHJlc2V0IHRo ZSBHUFUgd2hlbiB0aGUgbWFjaGluZSBpcyBpbiBEZWRpY2F0ZWQgZ3JhcGhpY3MgbW9kZSAod2hl cmUgdGhlCj4gR1BVIGJlaW5nIGluaXRpYWxpemVkIGJ5IHRoZSBCSU9TIGlzIG5vcm1hbCBhbmQg ZXhwZWN0ZWQpLiBGaW5hbGx5LCB3ZQo+IHRyeSBtYXBwaW5nIHRoZSBNTUlPIHNwYWNlIGZvciB0 aGUgR1BVIHdoaWNoIHNob3VsZCBvbmx5IHdvcmsgaWYgdGhlIEdQVQo+IGlzIGFjdHVhbGx5IGFj dGl2ZSBpbiBEMCBtb2RlLiBXZSBjYW4gdGhlbiByZWFkIHRoZSBtYWdpYyAweDIyNDBjCj4gcmVn aXN0ZXIgb24gdGhlIEdQVSwgd2hpY2ggd2lsbCBoYXZlIGJpdCAxIHNldCBpZiB0aGUgR1BVJ3Mg ZmlybXdhcmUgaGFzCj4gYWxyZWFkeSBiZWVuIHBvc3RlZCBkdXJpbmcgYSBwcmV2aW91cyBib290 LiBPbmNlIHdlJ3ZlIGNvbmZpcm1lZCBhbGwgb2YKPiB0aGlzLCB3ZSByZXNldCB0aGUgUENJIGRl dmljZSBhbmQgcmUtZGlzYWJsZSBpdCAtIGJyaW5naW5nIHRoZSBHUFUgYmFjawo+IGludG8gYSBo ZWFsdGh5IHN0YXRlLgo+IAo+IFNpZ25lZC1vZmYtYnk6IEx5dWRlIFBhdWwgPGx5dWRlQHJlZGhh dC5jb20+Cj4gQ2M6IG5vdXZlYXVAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCj4gQ2M6IGRyaS1kZXZl bEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKPiBDYzogS2Fyb2wgSGVyYnN0IDxraGVyYnN0QHJlZGhh dC5jb20+Cj4gQ2M6IEJlbiBTa2VnZ3MgPHNrZWdnc2JAZ21haWwuY29tPgo+IENjOiBzdGFibGVA dmdlci5rZXJuZWwub3JnCgpBcHBsaWVkIHRvIHBjaS9taXNjIGZvciB2NS4yLCB0aGFua3MhCgo+ IC0tLQo+ICBkcml2ZXJzL3BjaS9xdWlya3MuYyB8IDY1ICsrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrCj4gIDEgZmlsZSBjaGFuZ2VkLCA2NSBpbnNlcnRpb25zKCsp Cj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNpL3F1aXJrcy5jIGIvZHJpdmVycy9wY2kvcXVp cmtzLmMKPiBpbmRleCBiMGE0MTNmM2Y3Y2EuLjk0ODQ5MmZkYThiZiAxMDA2NDQKPiAtLS0gYS9k cml2ZXJzL3BjaS9xdWlya3MuYwo+ICsrKyBiL2RyaXZlcnMvcGNpL3F1aXJrcy5jCj4gQEAgLTUx MTcsMyArNTExNyw2OCBAQCBTV0lUQ0hURUNfUVVJUksoMHg4NTczKTsgIC8qIFBGWEkgNDhYRzMg Ki8KPiAgU1dJVENIVEVDX1FVSVJLKDB4ODU3NCk7ICAvKiBQRlhJIDY0WEczICovCj4gIFNXSVRD SFRFQ19RVUlSSygweDg1NzUpOyAgLyogUEZYSSA4MFhHMyAqLwo+ICBTV0lUQ0hURUNfUVVJUkso MHg4NTc2KTsgIC8qIFBGWEkgOTZYRzMgKi8KPiArCj4gKy8qCj4gKyAqIE9uIGNlcnRhaW4gTGVu b3ZvIFRoaW5rcGFkIFA1MCBTS1VzLCBzcGVjaWZpY2FsbHkgdGhvc2Ugd2l0aCBhIE52aWRpYQo+ ICsgKiBRdWFkcm8gTTEwMDBNLCB0aGUgQklPUyB3aWxsIG9jY2FzaW9uYWxseSBtYWtlIHRoZSBt aXN0YWtlIG9mIG5vdCByZXNldHRpbmcKPiArICogdGhlIG52aWRpYSBHUFUgYmV0d2VlbiByZWJv b3RzIGlmIHRoZSBzeXN0ZW0gaXMgY29uZmlndXJlZCB0byB1c2UgaHlicmlkCj4gKyAqIGdyYXBo aWNzIG1vZGUuIFRoaXMgcmVzdWx0cyBpbiB0aGUgR1BVIGJlaW5nIGxlZnQgaW4gd2hhdGV2ZXIg c3RhdGUgaXQgd2FzCj4gKyAqIGluIGR1cmluZyB0aGUgcHJldmlvdXMgYm9vdCB3aGljaCBjYXVz ZXMgc3B1cmlvdXMgaW50ZXJydXB0cyBmcm9tIHRoZSBHUFUsCj4gKyAqIHdoaWNoIGluIHR1cm4g Y2F1c2UgdXMgdG8gZGlzYWJsZSB0aGUgd3JvbmcgSVJRcyBhbmQgZW5kIHVwIGJyZWFraW5nIHRo ZQo+ICsgKiB0b3VjaHBhZC4gVW5zdXJwcmlzaW5nbHksIHRoaXMgYWxzbyBjb21wbGV0ZWx5IGJy ZWFrcyBub3V2ZWF1Lgo+ICsgKgo+ICsgKiBMdWNraWx5LCBpdCBzZWVtcyBhIHNpbXBsZSByZXNl dCBvZiB0aGUgUENJIGRldmljZSBmb3IgdGhlIG52aWRpYSBHUFUKPiArICogbWFuYWdlcyB0byBi cmluZyB0aGUgR1BVIGJhY2sgaW50byBhIGNsZWFuIHN0YXRlIGFuZCBmaXggYWxsIG9mIHRoZXNl Cj4gKyAqIGlzc3Vlcy4gQWRkaXRpb25hbGx5IHNpbmNlIHRoZSBHUFUgd2lsbCByZXBvcnQgTm9S ZXNldCsgd2hlbiB0aGUgbWFjaGluZSBpcwo+ICsgKiBjb25maWd1cmVkIGluIERlZGljYXRlZCBk aXNwbGF5IG1vZGUsIHdlIGRvbid0IG5lZWQgdG8gd29ycnkgYWJvdXQKPiArICogYWNjaWRlbnRh bGx5IHJlc2V0dGluZyB0aGUgR1BVIHdoZW4gaXQncyBzdXBwb3NlZCB0byBhbHJlYWR5IGJlCj4g KyAqIGluaXRpYWxpemVkLgo+ICsgKi8KPiArc3RhdGljIHZvaWQKPiArcXVpcmtfbGVub3ZvX3Ro aW5rcGFkX3A1MF9udmdwdV9zdXJ2aXZlc19yZWJvb3Qoc3RydWN0IHBjaV9kZXYgKnBkZXYpCj4g K3sKPiArCXZvaWQgX19pb21lbSAqbWFwOwo+ICsJaW50IHJldDsKPiArCj4gKwlpZiAocGRldi0+ c3Vic3lzdGVtX3ZlbmRvciAhPSBQQ0lfVkVORE9SX0lEX0xFTk9WTyB8fAo+ICsJICAgIHBkZXYt PnN1YnN5c3RlbV9kZXZpY2UgIT0gMHgyMjJlIHx8Cj4gKwkgICAgIXBkZXYtPnJlc2V0X2ZuKQo+ ICsJCXJldHVybjsKPiArCj4gKwkvKgo+ICsJICogSWYgd2UgY2FuJ3QgZW5hYmxlIHRoZSBkZXZp Y2UncyBtbWlvIHNwYWNlLCBpdCdzIHByb2JhYmx5IG5vdCBldmVuCj4gKwkgKiBpbml0aWFsaXpl ZC4gVGhpcyBpcyBmaW5lLCBhbmQgbWVhbnMgd2UgY2FuIGp1c3Qgc2tpcCB0aGUgcXVpcmsKPiAr CSAqIGVudGlyZWx5Lgo+ICsJICovCj4gKwlpZiAocGNpX2VuYWJsZV9kZXZpY2VfbWVtKHBkZXYp KSB7Cj4gKwkJcGNpX2RiZyhwZGV2LCAiQ2FuJ3QgZW5hYmxlIGRldmljZSBtZW0sIG5vIHJlc2V0 IG5lZWRlZFxuIik7Cj4gKwkJcmV0dXJuOwo+ICsJfQo+ICsKPiArCS8qIFRha2VuIGZyb20gZHJp dmVycy9ncHUvZHJtL25vdXZlYXUvZW5naW5lL2RldmljZS9iYXNlLmMgKi8KPiArCW1hcCA9IGlv cmVtYXAocGNpX3Jlc291cmNlX3N0YXJ0KHBkZXYsIDApLCAweDEwMjAwMCk7Cj4gKwlpZiAoIW1h cCkgewo+ICsJCXBjaV9lcnIocGRldiwgIkNhbid0IG1hcCBNTUlPIHNwYWNlLCB0aGlzIGlzIHBy b2JhYmx5IHZlcnkgYmFkXG4iKTsKPiArCQlnb3RvIG91dF9kaXNhYmxlOwo+ICsJfQo+ICsKPiAr CS8qCj4gKwkgKiBCZSBleHRyYSBjYXJlZnVsLCBhbmQgbWFrZSBzdXJlIHRoYXQgdGhlIEdQVSBm aXJtd2FyZSBpcyBwb3N0ZWQKPiArCSAqIGJlZm9yZSB0cnlpbmcgYSByZXNldAo+ICsJICovCj4g KwlpZiAoaW9yZWFkMzIobWFwICsgMHgyMjQwYykgJiAweDIpIHsKPiArCQlwY2lfaW5mbyhwZGV2 LAo+ICsJCQkgRldfQlVHICJHUFUgbGVmdCBpbml0aWFsaXplZCBieSBFRkksIHJlc2V0dGluZ1xu Iik7Cj4gKwkJcmV0ID0gcGNpX3Jlc2V0X2Z1bmN0aW9uKHBkZXYpOwo+ICsJCWlmIChyZXQgPCAw KQo+ICsJCQlwY2lfZXJyKHBkZXYsICJGYWlsZWQgdG8gcmVzZXQgR1BVOiAlZFxuIiwgcmV0KTsK PiArCX0KPiArCj4gKwlpb3VubWFwKG1hcCk7Cj4gK291dF9kaXNhYmxlOgo+ICsJcGNpX2Rpc2Fi bGVfZGV2aWNlKHBkZXYpOwo+ICt9Cj4gKwo+ICtERUNMQVJFX1BDSV9GSVhVUF9DTEFTU19GSU5B TChQQ0lfVkVORE9SX0lEX05WSURJQSwgMHgxM2IxLAo+ICsJCQkgICAgICBQQ0lfQ0xBU1NfRElT UExBWV9WR0EsIDgsCj4gKwkJCSAgICAgIHF1aXJrX2xlbm92b190aGlua3BhZF9wNTBfbnZncHVf c3Vydml2ZXNfcmVib290KTsKPiAtLSAKPiAyLjIwLjEKPiAKX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2 ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21h aWxtYW4vbGlzdGluZm8vZHJpLWRldmVs