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=-10.1 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT 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 DB2ACC3A5A2 for ; Tue, 3 Sep 2019 16:28:17 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id AAA43238CF for ; Tue, 3 Sep 2019 16:28:17 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1567528097; bh=1b2pBWdsuCL4bQpDtgYR8JYPmnX0yzH8g3x5zMn5w3E=; h=From:To:Cc:Subject:Date:In-Reply-To:References:List-ID:From; b=upAyeTMfjxC2tisbSEpQ6W4dnEWsmqs3ptCk0J7gD1z1BRNG2cKI9LD2Y70NWcmWl 97154R56cAJllYY5wU7TOTYosNc9TffJ18+woSIk2bTmzo2B0ZRqlzVIUtDfhJ4xbR 4PMiinyWsAt8iXsIgYCZxmbPHbSo2lgOrYWHl8zo= Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731077AbfICQ2Q (ORCPT ); Tue, 3 Sep 2019 12:28:16 -0400 Received: from mail.kernel.org ([198.145.29.99]:50060 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730610AbfICQ2Q (ORCPT ); Tue, 3 Sep 2019 12:28:16 -0400 Received: from sasha-vm.mshome.net (c-73-47-72-35.hsd1.nh.comcast.net [73.47.72.35]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPSA id A108323431; Tue, 3 Sep 2019 16:28:14 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1567528095; bh=1b2pBWdsuCL4bQpDtgYR8JYPmnX0yzH8g3x5zMn5w3E=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=pUtbeoBdZYU9OTs3+t+ABi8QDl2X3yDtoWe+UPNd9fRPHOJ/1fEzkOQl7kLXXUTHs IRvyc8ErzygYpNfAuqnjuOfMYPsvDhQISMtJ0SWWtpSSf1O/gOYR6Z6EMz+dS76RK5 mjh5UjjJfSymiPxQ/8y5fknclzH/qd/2aFWA/oM4= From: Sasha Levin To: linux-kernel@vger.kernel.org, stable@vger.kernel.org Cc: Lyude Paul , Bjorn Helgaas , nouveau@lists.freedesktop.org, dri-devel@lists.freedesktop.org, Karol Herbst , Ben Skeggs , Sasha Levin , linux-pci@vger.kernel.org Subject: [PATCH AUTOSEL 4.19 104/167] PCI: Reset Lenovo ThinkPad P50 nvgpu at boot if necessary Date: Tue, 3 Sep 2019 12:24:16 -0400 Message-Id: <20190903162519.7136-104-sashal@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20190903162519.7136-1-sashal@kernel.org> References: <20190903162519.7136-1-sashal@kernel.org> MIME-Version: 1.0 X-stable: review X-Patchwork-Hint: Ignore Content-Transfer-Encoding: 8bit Sender: linux-pci-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-pci@vger.kernel.org From: Lyude Paul [ Upstream commit e0547c81bfcfad01cbbfa93a5e66bb98ab932f80 ] On ThinkPad P50 SKUs with an Nvidia Quadro M1000M instead of the M2000M variant, the BIOS does not always reset the secondary Nvidia GPU during reboot if the laptop is configured in Hybrid Graphics mode. The reason 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 3. Allow the Nvidia GPU to runtime suspend itself after being idle 4. Reboot the machine, the more sudden the better (e.g. sysrq-b may help) 5. 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 be left in exactly the same state it was in when the previously booted kernel started the reboot. This has all sorts of bad side effects: 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 This causes a timeout trying to bring up the GR ctx: nouveau 0000:01:00.0: timeout WARNING: CPU: 0 PID: 12 at drivers/gpu/drm/nouveau/nvkm/engine/gr/ctxgf100.c:1547 gf100_grctx_generate+0x7b2/0x850 [nouveau] Hardware name: LENOVO 20EQS64N0B/20EQS64N0B, BIOS N1EET82W (1.55 ) 12/18/2018 Workqueue: events_long drm_dp_mst_link_probe_work [drm_kms_helper] ... nouveau 0000:01:00.0: gr: wait for idle timeout (en: 1, ctxsw: 0, busy: 1) nouveau 0000:01:00.0: gr: wait for idle timeout (en: 1, ctxsw: 0, busy: 1) nouveau 0000:01:00.0: fifo: fault 01 [WRITE] at 0000000000008000 engine 00 [GR] client 15 [HUB/SCC_NB] reason c4 [] on channel -1 [0000000000 unknown] The GPU never manages to recover. Booting without loading nouveau causes issues as well, since the GPU starts sending spurious interrupts that cause other device's IRQs to get disabled by the kernel: irq 16: nobody cared (try booting with the "irqpoll" option) ... handlers: [<000000007faa9e99>] i801_isr [i2c_i801] Disabling IRQ #16 ... serio: RMI4 PS/2 pass-through port at rmi4-00.fn03 i801_smbus 0000:00:1f.4: Timeout waiting for interrupt! i801_smbus 0000:00:1f.4: Transaction timeout rmi4_f03 rmi4-00.fn03: rmi_f03_pt_write: Failed to write to F03 TX register (-110). i801_smbus 0000:00:1f.4: Timeout waiting for interrupt! i801_smbus 0000:00:1f.4: Transaction timeout rmi4_physical rmi4-00: rmi_driver_set_irq_bits: Failed to change enabled interrupts! This causes the touchpad and sometimes other things to get disabled. Since this happens without nouveau, we can't fix this problem from nouveau itself. Add a PCI quirk for the specific P50 variant of this GPU. Make sure the GPU is advertising NoReset- so we don't reset the GPU when the machine is in Dedicated graphics mode (where the GPU being initialized by the BIOS is normal and expected). Map the GPU MMIO space and read the magic 0x2240c register, which will have bit 1 set if the device was POSTed during a previous boot. Once we've confirmed all of this, reset the GPU and re-disable it - bringing it back to a healthy state. Link: https://bugzilla.kernel.org/show_bug.cgi?id=203003 Link: https://lore.kernel.org/lkml/20190212220230.1568-1-lyude@redhat.com Signed-off-by: Lyude Paul Signed-off-by: Bjorn Helgaas Cc: nouveau@lists.freedesktop.org Cc: dri-devel@lists.freedesktop.org Cc: Karol Herbst Cc: Ben Skeggs Cc: stable@vger.kernel.org Signed-off-by: Sasha Levin --- drivers/pci/quirks.c | 58 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+) diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c index 6cda8b7ecc821..311f8a33e62ff 100644 --- a/drivers/pci/quirks.c +++ b/drivers/pci/quirks.c @@ -5116,3 +5116,61 @@ SWITCHTEC_QUIRK(0x8573); /* PFXI 48XG3 */ SWITCHTEC_QUIRK(0x8574); /* PFXI 64XG3 */ SWITCHTEC_QUIRK(0x8575); /* PFXI 80XG3 */ SWITCHTEC_QUIRK(0x8576); /* PFXI 96XG3 */ + +/* + * On Lenovo Thinkpad P50 SKUs with a Nvidia Quadro M1000M, the BIOS does + * not always reset the secondary 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 causes us to + * disable the wrong IRQ and end up breaking the touchpad. Unsurprisingly, + * this also completely breaks nouveau. + * + * Luckily, it seems a simple reset of the Nvidia GPU brings it back to a + * clean state and fixes all these issues. + * + * When the machine is configured in Dedicated display mode, the issue + * doesn't occur. Fortunately the GPU advertises NoReset+ when in this + * mode, so we can detect that and avoid resetting it. + */ +static void quirk_reset_lenovo_thinkpad_p50_nvgpu(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 (pci_enable_device_mem(pdev)) + return; + + /* + * Based on nvkm_device_ctor() in + * drivers/gpu/drm/nouveau/nvkm/engine/device/base.c + */ + map = pci_iomap(pdev, 0, 0x23000); + if (!map) { + pci_err(pdev, "Can't map MMIO space\n"); + goto out_disable; + } + + /* + * Make sure the GPU looks like it's been POSTed before resetting + * it. + */ + 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_reset_lenovo_thinkpad_p50_nvgpu); -- 2.20.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Sasha Levin Subject: [PATCH AUTOSEL 4.19 104/167] PCI: Reset Lenovo ThinkPad P50 nvgpu at boot if necessary Date: Tue, 3 Sep 2019 12:24:16 -0400 Message-ID: <20190903162519.7136-104-sashal@kernel.org> References: <20190903162519.7136-1-sashal@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190903162519.7136-1-sashal-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: nouveau-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "Nouveau" To: linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, stable-u79uwXL29TY76Z2rM5mHXA@public.gmane.org Cc: Sasha Levin , nouveau-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, linux-pci-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Bjorn Helgaas List-Id: nouveau.vger.kernel.org RnJvbTogTHl1ZGUgUGF1bCA8bHl1ZGVAcmVkaGF0LmNvbT4KClsgVXBzdHJlYW0gY29tbWl0IGUw NTQ3YzgxYmZjZmFkMDFjYmJmYTkzYTVlNjZiYjk4YWI5MzJmODAgXQoKT24gVGhpbmtQYWQgUDUw IFNLVXMgd2l0aCBhbiBOdmlkaWEgUXVhZHJvIE0xMDAwTSBpbnN0ZWFkIG9mIHRoZSBNMjAwME0K dmFyaWFudCwgdGhlIEJJT1MgZG9lcyBub3QgYWx3YXlzIHJlc2V0IHRoZSBzZWNvbmRhcnkgTnZp ZGlhIEdQVSBkdXJpbmcKcmVib290IGlmIHRoZSBsYXB0b3AgaXMgY29uZmlndXJlZCBpbiBIeWJy aWQgR3JhcGhpY3MgbW9kZS4gIFRoZSByZWFzb24gaXMKdW5rbm93biwgYnV0IHRoZSBmb2xsb3dp bmcgc3RlcHMgYW5kIHBvc3NpYmx5IGEgZ29vZCBiaXQgb2YgcGF0aWVuY2Ugd2lsbApyZXByb2R1 Y2UgdGhlIGlzc3VlOgoKICAxLiBCb290IHVwIHRoZSBsYXB0b3Agbm9ybWFsbHkgaW4gSHlicmlk IEdyYXBoaWNzIG1vZGUKICAyLiBNYWtlIHN1cmUgbm91dmVhdSBpcyBsb2FkZWQgYW5kIHRoYXQg dGhlIEdQVSBpcyBhd2FrZQogIDMuIEFsbG93IHRoZSBOdmlkaWEgR1BVIHRvIHJ1bnRpbWUgc3Vz cGVuZCBpdHNlbGYgYWZ0ZXIgYmVpbmcgaWRsZQogIDQuIFJlYm9vdCB0aGUgbWFjaGluZSwgdGhl IG1vcmUgc3VkZGVuIHRoZSBiZXR0ZXIgKGUuZy4gc3lzcnEtYiBtYXkgaGVscCkKICA1LiBJZiBu b3V2ZWF1IGxvYWRzIHVwIHByb3Blcmx5LCByZWJvb3QgdGhlIG1hY2hpbmUgYWdhaW4gYW5kIGdv IGJhY2sgdG8KICAgICBzdGVwIDIgdW50aWwgeW91IHJlcHJvZHVjZSB0aGUgaXNzdWUKClRoaXMg cmVzdWx0cyBpbiBzb21lIHZlcnkgc3RyYW5nZSBiZWhhdmlvcjogdGhlIEdQVSB3aWxsIGJlIGxl ZnQgaW4gZXhhY3RseQp0aGUgc2FtZSBzdGF0ZSBpdCB3YXMgaW4gd2hlbiB0aGUgcHJldmlvdXNs eSBib290ZWQga2VybmVsIHN0YXJ0ZWQgdGhlCnJlYm9vdC4gIFRoaXMgaGFzIGFsbCBzb3J0cyBv ZiBiYWQgc2lkZSBlZmZlY3RzOiBmb3Igc3RhcnRlcnMsIHRoaXMKY29tcGxldGVseSBicmVha3Mg bm91dmVhdSBzdGFydGluZyB3aXRoIGEgbXlzdGVyaW91cyBFVk8gY2hhbm5lbCBmYWlsdXJlCnRo YXQgaGFwcGVucyB3ZWxsIGJlZm9yZSB3ZSd2ZSBhY3R1YWxseSB1c2VkIHRoZSBFVk8gY2hhbm5l bCBmb3IgYW55dGhpbmc6CgogIG5vdXZlYXUgMDAwMDowMTowMC4wOiBkaXNwOiBjaGlkIDAgbXRo ZCAwMDAwIGRhdGEgMDAwMDA0MDAgMDAwMDEwMDAgMDAwMDAwMDIKClRoaXMgY2F1c2VzIGEgdGlt ZW91dCB0cnlpbmcgdG8gYnJpbmcgdXAgdGhlIEdSIGN0eDoKCiAgbm91dmVhdSAwMDAwOjAxOjAw LjA6IHRpbWVvdXQKICBXQVJOSU5HOiBDUFU6IDAgUElEOiAxMiBhdCBkcml2ZXJzL2dwdS9kcm0v bm91dmVhdS9udmttL2VuZ2luZS9nci9jdHhnZjEwMC5jOjE1NDcgZ2YxMDBfZ3JjdHhfZ2VuZXJh dGUrMHg3YjIvMHg4NTAgW25vdXZlYXVdCiAgSGFyZHdhcmUgbmFtZTogTEVOT1ZPIDIwRVFTNjRO MEIvMjBFUVM2NE4wQiwgQklPUyBOMUVFVDgyVyAoMS41NSApIDEyLzE4LzIwMTgKICBXb3JrcXVl dWU6IGV2ZW50c19sb25nIGRybV9kcF9tc3RfbGlua19wcm9iZV93b3JrIFtkcm1fa21zX2hlbHBl cl0KICAuLi4KICBub3V2ZWF1IDAwMDA6MDE6MDAuMDogZ3I6IHdhaXQgZm9yIGlkbGUgdGltZW91 dCAoZW46IDEsIGN0eHN3OiAwLCBidXN5OiAxKQogIG5vdXZlYXUgMDAwMDowMTowMC4wOiBncjog d2FpdCBmb3IgaWRsZSB0aW1lb3V0IChlbjogMSwgY3R4c3c6IDAsIGJ1c3k6IDEpCiAgbm91dmVh dSAwMDAwOjAxOjAwLjA6IGZpZm86IGZhdWx0IDAxIFtXUklURV0gYXQgMDAwMDAwMDAwMDAwODAw MCBlbmdpbmUgMDAgW0dSXSBjbGllbnQgMTUgW0hVQi9TQ0NfTkJdIHJlYXNvbiBjNCBbXSBvbiBj aGFubmVsIC0xIFswMDAwMDAwMDAwIHVua25vd25dCgpUaGUgR1BVIG5ldmVyIG1hbmFnZXMgdG8g cmVjb3Zlci4gIEJvb3Rpbmcgd2l0aG91dCBsb2FkaW5nIG5vdXZlYXUgY2F1c2VzCmlzc3VlcyBh cyB3ZWxsLCBzaW5jZSB0aGUgR1BVIHN0YXJ0cyBzZW5kaW5nIHNwdXJpb3VzIGludGVycnVwdHMg dGhhdCBjYXVzZQpvdGhlciBkZXZpY2UncyBJUlFzIHRvIGdldCBkaXNhYmxlZCBieSB0aGUga2Vy bmVsOgoKICBpcnEgMTY6IG5vYm9keSBjYXJlZCAodHJ5IGJvb3Rpbmcgd2l0aCB0aGUgImlycXBv bGwiIG9wdGlvbikKICAuLi4KICBoYW5kbGVyczoKICBbPDAwMDAwMDAwN2ZhYTllOTk+XSBpODAx X2lzciBbaTJjX2k4MDFdCiAgRGlzYWJsaW5nIElSUSAjMTYKICAuLi4KICBzZXJpbzogUk1JNCBQ Uy8yIHBhc3MtdGhyb3VnaCBwb3J0IGF0IHJtaTQtMDAuZm4wMwogIGk4MDFfc21idXMgMDAwMDow MDoxZi40OiBUaW1lb3V0IHdhaXRpbmcgZm9yIGludGVycnVwdCEKICBpODAxX3NtYnVzIDAwMDA6 MDA6MWYuNDogVHJhbnNhY3Rpb24gdGltZW91dAogIHJtaTRfZjAzIHJtaTQtMDAuZm4wMzogcm1p X2YwM19wdF93cml0ZTogRmFpbGVkIHRvIHdyaXRlIHRvIEYwMyBUWCByZWdpc3RlciAoLTExMCku CiAgaTgwMV9zbWJ1cyAwMDAwOjAwOjFmLjQ6IFRpbWVvdXQgd2FpdGluZyBmb3IgaW50ZXJydXB0 IQogIGk4MDFfc21idXMgMDAwMDowMDoxZi40OiBUcmFuc2FjdGlvbiB0aW1lb3V0CiAgcm1pNF9w aHlzaWNhbCBybWk0LTAwOiBybWlfZHJpdmVyX3NldF9pcnFfYml0czogRmFpbGVkIHRvIGNoYW5n ZSBlbmFibGVkIGludGVycnVwdHMhCgpUaGlzIGNhdXNlcyB0aGUgdG91Y2hwYWQgYW5kIHNvbWV0 aW1lcyBvdGhlciB0aGluZ3MgdG8gZ2V0IGRpc2FibGVkLgoKU2luY2UgdGhpcyBoYXBwZW5zIHdp dGhvdXQgbm91dmVhdSwgd2UgY2FuJ3QgZml4IHRoaXMgcHJvYmxlbSBmcm9tIG5vdXZlYXUKaXRz ZWxmLgoKQWRkIGEgUENJIHF1aXJrIGZvciB0aGUgc3BlY2lmaWMgUDUwIHZhcmlhbnQgb2YgdGhp cyBHUFUuICBNYWtlIHN1cmUgdGhlCkdQVSBpcyBhZHZlcnRpc2luZyBOb1Jlc2V0LSBzbyB3ZSBk b24ndCByZXNldCB0aGUgR1BVIHdoZW4gdGhlIG1hY2hpbmUgaXMKaW4gRGVkaWNhdGVkIGdyYXBo aWNzIG1vZGUgKHdoZXJlIHRoZSBHUFUgYmVpbmcgaW5pdGlhbGl6ZWQgYnkgdGhlIEJJT1MgaXMK bm9ybWFsIGFuZCBleHBlY3RlZCkuICBNYXAgdGhlIEdQVSBNTUlPIHNwYWNlIGFuZCByZWFkIHRo ZSBtYWdpYyAweDIyNDBjCnJlZ2lzdGVyLCB3aGljaCB3aWxsIGhhdmUgYml0IDEgc2V0IGlmIHRo ZSBkZXZpY2Ugd2FzIFBPU1RlZCBkdXJpbmcgYQpwcmV2aW91cyBib290LiAgT25jZSB3ZSd2ZSBj b25maXJtZWQgYWxsIG9mIHRoaXMsIHJlc2V0IHRoZSBHUFUgYW5kCnJlLWRpc2FibGUgaXQgLSBi cmluZ2luZyBpdCBiYWNrIHRvIGEgaGVhbHRoeSBzdGF0ZS4KCkxpbms6IGh0dHBzOi8vYnVnemls bGEua2VybmVsLm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAzMDAzCkxpbms6IGh0dHBzOi8vbG9yZS5r ZXJuZWwub3JnL2xrbWwvMjAxOTAyMTIyMjAyMzAuMTU2OC0xLWx5dWRlQHJlZGhhdC5jb20KU2ln bmVkLW9mZi1ieTogTHl1ZGUgUGF1bCA8bHl1ZGVAcmVkaGF0LmNvbT4KU2lnbmVkLW9mZi1ieTog Qmpvcm4gSGVsZ2FhcyA8YmhlbGdhYXNAZ29vZ2xlLmNvbT4KQ2M6IG5vdXZlYXVAbGlzdHMuZnJl ZWRlc2t0b3Aub3JnCkNjOiBkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCkNjOiBLYXJv bCBIZXJic3QgPGtoZXJic3RAcmVkaGF0LmNvbT4KQ2M6IEJlbiBTa2VnZ3MgPHNrZWdnc2JAZ21h aWwuY29tPgpDYzogc3RhYmxlQHZnZXIua2VybmVsLm9yZwpTaWduZWQtb2ZmLWJ5OiBTYXNoYSBM ZXZpbiA8c2FzaGFsQGtlcm5lbC5vcmc+Ci0tLQogZHJpdmVycy9wY2kvcXVpcmtzLmMgfCA1OCAr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogMSBmaWxlIGNoYW5n ZWQsIDU4IGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9xdWlya3MuYyBi L2RyaXZlcnMvcGNpL3F1aXJrcy5jCmluZGV4IDZjZGE4YjdlY2M4MjEuLjMxMWY4YTMzZTYyZmYg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL3F1aXJrcy5jCisrKyBiL2RyaXZlcnMvcGNpL3F1aXJr cy5jCkBAIC01MTE2LDMgKzUxMTYsNjEgQEAgU1dJVENIVEVDX1FVSVJLKDB4ODU3Myk7ICAvKiBQ RlhJIDQ4WEczICovCiBTV0lUQ0hURUNfUVVJUksoMHg4NTc0KTsgIC8qIFBGWEkgNjRYRzMgKi8K IFNXSVRDSFRFQ19RVUlSSygweDg1NzUpOyAgLyogUEZYSSA4MFhHMyAqLwogU1dJVENIVEVDX1FV SVJLKDB4ODU3Nik7ICAvKiBQRlhJIDk2WEczICovCisKKy8qCisgKiBPbiBMZW5vdm8gVGhpbmtw YWQgUDUwIFNLVXMgd2l0aCBhIE52aWRpYSBRdWFkcm8gTTEwMDBNLCB0aGUgQklPUyBkb2VzCisg KiBub3QgYWx3YXlzIHJlc2V0IHRoZSBzZWNvbmRhcnkgTnZpZGlhIEdQVSBiZXR3ZWVuIHJlYm9v dHMgaWYgdGhlIHN5c3RlbQorICogaXMgY29uZmlndXJlZCB0byB1c2UgSHlicmlkIEdyYXBoaWNz IG1vZGUuICBUaGlzIHJlc3VsdHMgaW4gdGhlIEdQVQorICogYmVpbmcgbGVmdCBpbiB3aGF0ZXZl ciBzdGF0ZSBpdCB3YXMgaW4gZHVyaW5nIHRoZSAqcHJldmlvdXMqIGJvb3QsIHdoaWNoCisgKiBj YXVzZXMgc3B1cmlvdXMgaW50ZXJydXB0cyBmcm9tIHRoZSBHUFUsIHdoaWNoIGluIHR1cm4gY2F1 c2VzIHVzIHRvCisgKiBkaXNhYmxlIHRoZSB3cm9uZyBJUlEgYW5kIGVuZCB1cCBicmVha2luZyB0 aGUgdG91Y2hwYWQuICBVbnN1cnByaXNpbmdseSwKKyAqIHRoaXMgYWxzbyBjb21wbGV0ZWx5IGJy ZWFrcyBub3V2ZWF1LgorICoKKyAqIEx1Y2tpbHksIGl0IHNlZW1zIGEgc2ltcGxlIHJlc2V0IG9m IHRoZSBOdmlkaWEgR1BVIGJyaW5ncyBpdCBiYWNrIHRvIGEKKyAqIGNsZWFuIHN0YXRlIGFuZCBm aXhlcyBhbGwgdGhlc2UgaXNzdWVzLgorICoKKyAqIFdoZW4gdGhlIG1hY2hpbmUgaXMgY29uZmln dXJlZCBpbiBEZWRpY2F0ZWQgZGlzcGxheSBtb2RlLCB0aGUgaXNzdWUKKyAqIGRvZXNuJ3Qgb2Nj dXIuICBGb3J0dW5hdGVseSB0aGUgR1BVIGFkdmVydGlzZXMgTm9SZXNldCsgd2hlbiBpbiB0aGlz CisgKiBtb2RlLCBzbyB3ZSBjYW4gZGV0ZWN0IHRoYXQgYW5kIGF2b2lkIHJlc2V0dGluZyBpdC4K KyAqLworc3RhdGljIHZvaWQgcXVpcmtfcmVzZXRfbGVub3ZvX3RoaW5rcGFkX3A1MF9udmdwdShz dHJ1Y3QgcGNpX2RldiAqcGRldikKK3sKKwl2b2lkIF9faW9tZW0gKm1hcDsKKwlpbnQgcmV0Owor CisJaWYgKHBkZXYtPnN1YnN5c3RlbV92ZW5kb3IgIT0gUENJX1ZFTkRPUl9JRF9MRU5PVk8gfHwK KwkgICAgcGRldi0+c3Vic3lzdGVtX2RldmljZSAhPSAweDIyMmUgfHwKKwkgICAgIXBkZXYtPnJl c2V0X2ZuKQorCQlyZXR1cm47CisKKwlpZiAocGNpX2VuYWJsZV9kZXZpY2VfbWVtKHBkZXYpKQor CQlyZXR1cm47CisKKwkvKgorCSAqIEJhc2VkIG9uIG52a21fZGV2aWNlX2N0b3IoKSBpbgorCSAq IGRyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vZW5naW5lL2RldmljZS9iYXNlLmMKKwkgKi8K KwltYXAgPSBwY2lfaW9tYXAocGRldiwgMCwgMHgyMzAwMCk7CisJaWYgKCFtYXApIHsKKwkJcGNp X2VycihwZGV2LCAiQ2FuJ3QgbWFwIE1NSU8gc3BhY2VcbiIpOworCQlnb3RvIG91dF9kaXNhYmxl OworCX0KKworCS8qCisJICogTWFrZSBzdXJlIHRoZSBHUFUgbG9va3MgbGlrZSBpdCdzIGJlZW4g UE9TVGVkIGJlZm9yZSByZXNldHRpbmcKKwkgKiBpdC4KKwkgKi8KKwlpZiAoaW9yZWFkMzIobWFw ICsgMHgyMjQwYykgJiAweDIpIHsKKwkJcGNpX2luZm8ocGRldiwgRldfQlVHICJHUFUgbGVmdCBp bml0aWFsaXplZCBieSBFRkksIHJlc2V0dGluZ1xuIik7CisJCXJldCA9IHBjaV9yZXNldF9mdW5j dGlvbihwZGV2KTsKKwkJaWYgKHJldCA8IDApCisJCQlwY2lfZXJyKHBkZXYsICJGYWlsZWQgdG8g cmVzZXQgR1BVOiAlZFxuIiwgcmV0KTsKKwl9CisKKwlpb3VubWFwKG1hcCk7CitvdXRfZGlzYWJs ZToKKwlwY2lfZGlzYWJsZV9kZXZpY2UocGRldik7Cit9CitERUNMQVJFX1BDSV9GSVhVUF9DTEFT U19GSU5BTChQQ0lfVkVORE9SX0lEX05WSURJQSwgMHgxM2IxLAorCQkJICAgICAgUENJX0NMQVNT X0RJU1BMQVlfVkdBLCA4LAorCQkJICAgICAgcXVpcmtfcmVzZXRfbGVub3ZvX3RoaW5rcGFkX3A1 MF9udmdwdSk7Ci0tIAoyLjIwLjEKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fCk5vdXZlYXUgbWFpbGluZyBsaXN0Ck5vdXZlYXVAbGlzdHMuZnJlZWRlc2t0 b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vbm91 dmVhdQ==