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,FAKE_REPLY_C,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=unavailable 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 F2F4EC432C0 for ; Tue, 19 Nov 2019 21:50:01 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id BED6C2244A for ; Tue, 19 Nov 2019 21:50:01 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1574200201; bh=3V2L09toUxptX2c4GyIIq3dB2l2q1UOY0O+e0/o+suM=; h=Date:From:To:Cc:Subject:In-Reply-To:List-ID:From; b=06e6BhmbvRbdTtvmLG3BZZk6vWZp3ZD49ius7VfZLUFoArwS1v6kZ24RFta3WY3Hj meYkn/Kz45A9tL1+SsSv2PSGQ+CMELmelQNQV+on2TnX3k1nwPdEA6Xuiw95zHj/Dr A17f216D2QKEBzpwKulNWTAvts0UZu1vEUChgHYI= Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727243AbfKSVuB (ORCPT ); Tue, 19 Nov 2019 16:50:01 -0500 Received: from mail.kernel.org ([198.145.29.99]:53496 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726874AbfKSVuA (ORCPT ); Tue, 19 Nov 2019 16:50:00 -0500 Received: from localhost (unknown [69.71.4.100]) (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 4176F22463; Tue, 19 Nov 2019 21:49:58 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1574200199; bh=3V2L09toUxptX2c4GyIIq3dB2l2q1UOY0O+e0/o+suM=; h=Date:From:To:Cc:Subject:In-Reply-To:From; b=rxwMl4PFySKcal9t5bQekScNqvYp8/V7Vg4OFziNDWOAHrkDPZP1x+FBFhN/dUhY0 IlYDw1UnAekPNEJwf2FSp8//tLhGUv3I3l7CccB4rt2bmHTcQudOSWWNWgBbAlnX6+ Lg8TIQZi3wAjKzdlyG2C8qgByeqH9JZb/zo7DQ84= Date: Tue, 19 Nov 2019 15:49:55 -0600 From: Bjorn Helgaas To: Karol Herbst Cc: linux-kernel@vger.kernel.org, Lyude Paul , "Rafael J . Wysocki" , Mika Westerberg , linux-pci@vger.kernel.org, linux-pm@vger.kernel.org, dri-devel@lists.freedesktop.org, nouveau@lists.freedesktop.org, Dave Airlie Subject: Re: [PATCH v4] pci: prevent putting nvidia GPUs into lower device states on certain intel bridges Message-ID: <20191119214955.GA223696@google.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20191017121901.13699-1-kherbst@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 [+cc Dave] On Thu, Oct 17, 2019 at 02:19:01PM +0200, Karol Herbst wrote: > Fixes state transitions of Nvidia Pascal GPUs from D3cold into higher device > states. > > v2: convert to pci_dev quirk > put a proper technical explanation of the issue as a in-code comment > v3: disable it only for certain combinations of intel and nvidia hardware > v4: simplify quirk by setting flag on the GPU itself I have zero confidence that we understand the real problem, but we do need to do something with this. I'll merge it for v5.5 if we get the minor procedural stuff below straightened out. > Signed-off-by: Karol Herbst > Cc: Bjorn Helgaas > Cc: Lyude Paul > Cc: Rafael J. Wysocki > Cc: Mika Westerberg > Cc: linux-pci@vger.kernel.org > Cc: linux-pm@vger.kernel.org > Cc: dri-devel@lists.freedesktop.org > Cc: nouveau@lists.freedesktop.org > --- > drivers/pci/pci.c | 7 ++++++ > drivers/pci/quirks.c | 53 ++++++++++++++++++++++++++++++++++++++++++++ > include/linux/pci.h | 1 + > 3 files changed, 61 insertions(+) > > diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c > index b97d9e10c9cc..02e71e0bcdd7 100644 > --- a/drivers/pci/pci.c > +++ b/drivers/pci/pci.c > @@ -850,6 +850,13 @@ static int pci_raw_set_power_state(struct pci_dev *dev, pci_power_t state) > || (state == PCI_D2 && !dev->d2_support)) > return -EIO; > > + /* > + * check if we have a bad combination of bridge controller and nvidia > + * GPU, see quirk_broken_nv_runpm for more info Whitespace damage. Capitalized incorrectly (see other comments nearby). > + */ > + if (state != PCI_D0 && dev->broken_nv_runpm) > + return 0; > + > pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr); > > /* > diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c > index 44c4ae1abd00..0006c9e37b6f 100644 > --- a/drivers/pci/quirks.c > +++ b/drivers/pci/quirks.c > @@ -5268,3 +5268,56 @@ static void quirk_reset_lenovo_thinkpad_p50_nvgpu(struct pci_dev *pdev) > DECLARE_PCI_FIXUP_CLASS_FINAL(PCI_VENDOR_ID_NVIDIA, 0x13b1, > PCI_CLASS_DISPLAY_VGA, 8, > quirk_reset_lenovo_thinkpad_p50_nvgpu); > + > +/* > + * Some Intel PCIe bridges cause devices to disappear from the PCIe bus after > + * those were put into D3cold state if they were put into a non D0 PCI PM > + * device state before doing so. A device in D3cold is off the bus by definition. IIUC the problem is that the sequence D0 -> D3hot -> D3cold -> D0 for the GPU fails in the transition back to D0, while D0 -> D3cold -> D0 works fine. So I guess the problem is that we can put the device in D3cold with no problem, but if we put in D3hot before going to D3cold, the device never comes back to D0. Right? > + * This leads to various issue different issues which all manifest differently, s/issue different// Actually, I think there's only one underlying issue with several manifestations. > + * but have the same root cause: > + * - AIML code execution hits an infinite loop (as the coe waits on device > + * memory to change). s/AIML/AML/ s/coe/code/ > + * - kernel crashes, as all pci reads return -1, which most code isn't able > + * to handle well enough. s/pci/PCI/ More details about these crashes would be useful as we look at places that *should* be able to handle errors like this. > + * - sudden shutdowns, as the kernel identified an unrecoverable error after > + * userspace tries to access the GPU. This doesn't fit with the others and more details might be informative here as well. > + * In all cases dmesg will contain at least one line like this: > + * 'nouveau 0000:01:00.0: Refused to change power state, currently in D3' > + * followed by a lot of nouveau timeouts. > + * > + * ACPI code writes bit 0x80 to the not documented PCI register 0x248 of the > + * PCIe bridge controller in order to power down the GPU. > + * Nonetheless, there are other code paths inside the ACPI firmware which use > + * other registers, which seem to work fine: > + * - 0xbc bit 0x20 (publicly available documentation claims 'reserved') > + * - 0xb0 bit 0x10 (link disable) All these register addresses are device-specific, so they're useless without identifying the device. "lspci -vvnn" output would let us at least connect this with something. It would be nice to have that info archived along with your acpidump and python repro scripts in a bugzilla with the URL in the commit log. These are likely in PCI capabilities. If I make the leap of assuming the "link disable" bit is PCI_EXP_LNKCTL_LD, that would mean the Link Control register is at 0xb0 and the register at 0xbc would be the Root Control register, and indeed 0x20 in Root Control is reserved. I don't know what the relevance of all this is, though. It's not remarkable that accesses to these registers work. Unless you mean you can access these registers *after* trying to put the device back in D0, but other accesses to the device fail. That would indeed be very interesting. > + * Changing the conditions inside the firmware by poking into the relevant > + * addresses does resolve the issue, but it seemed to be ACPI private memory > + * and not any device accessible memory at all, so there is no portable way of > + * changing the conditions. > + * > + * The only systems where this behavior can be seen are hybrid graphics laptops > + * with a secondary Nvidia Pascal GPU. It cannot be ruled out that this issue > + * only occurs in combination with listed Intel PCIe bridge controllers and > + * the mentioned GPUs or if it's only a hw bug in the bridge controller. > + * > + * But because this issue was NOT seen on laptops with an Nvidia Pascal GPU > + * and an Intel Coffee Lake SoC, there is a higher chance of there being a bug > + * in the bridge controller rather than in the GPU. I don't think we can conclude anything about where the defect is and I don't think speculating here will help future readers of this code. I *would* still like to see a bugzilla listing the systems where this problem has been seen with the "lspci -vvnn", dmesg logs, and at least one acpidump. I think there's more to this story, and I suspect we may be revisiting this in the future. > + * This issue was not able to be reproduced on non laptop systems. > + */ > + > +static void quirk_broken_nv_runpm(struct pci_dev *dev) > +{ > + struct pci_dev *bridge = pci_upstream_bridge(dev); > + > + if (bridge->vendor == PCI_VENDOR_ID_INTEL && > + bridge->device == 0x1901) pci_upstream_bridge() may return NULL, so you need if (bridge && bridge->vendor == PCI_VENDOR_ID_INTEL ... https://lore.kernel.org/r/20190927144421.22608-1-kherbst@redhat.com says Skylake and Kaby Lake SoCs are affected. But here you only check for one Device ID? > + dev->broken_nv_runpm = 1; > +} > +DECLARE_PCI_FIXUP_CLASS_FINAL(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID, > + PCI_BASE_CLASS_DISPLAY, 16, > + quirk_broken_nv_runpm); > diff --git a/include/linux/pci.h b/include/linux/pci.h > index ac8a6c4e1792..903a0b3a39ec 100644 > --- a/include/linux/pci.h > +++ b/include/linux/pci.h > @@ -416,6 +416,7 @@ struct pci_dev { > unsigned int __aer_firmware_first_valid:1; > unsigned int __aer_firmware_first:1; > unsigned int broken_intx_masking:1; /* INTx masking can't be used */ > + unsigned int broken_nv_runpm:1; /* some combinations of intel bridge controller and nvidia GPUs break rtd3 */ > unsigned int io_window_1k:1; /* Intel bridge 1K I/O windows */ > unsigned int irq_managed:1; > unsigned int has_secondary_link:1; > -- > 2.21.0 > 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.5 required=3.0 tests=FAKE_REPLY_C,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 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 582F3C33C9F for ; Tue, 19 Nov 2019 21:50:03 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 3848D2244A for ; Tue, 19 Nov 2019 21:50:03 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 3848D2244A Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=kernel.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id A8CF36E925; Tue, 19 Nov 2019 21:50:00 +0000 (UTC) Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by gabe.freedesktop.org (Postfix) with ESMTPS id 3959C6E41F; Tue, 19 Nov 2019 21:49:59 +0000 (UTC) Received: from localhost (unknown [69.71.4.100]) (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 4176F22463; Tue, 19 Nov 2019 21:49:58 +0000 (UTC) Date: Tue, 19 Nov 2019 15:49:55 -0600 From: Bjorn Helgaas To: Karol Herbst Subject: Re: [PATCH v4] pci: prevent putting nvidia GPUs into lower device states on certain intel bridges Message-ID: <20191119214955.GA223696@google.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20191017121901.13699-1-kherbst@redhat.com> User-Agent: Mutt/1.10.1 (2018-07-13) X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1574200199; bh=3V2L09toUxptX2c4GyIIq3dB2l2q1UOY0O+e0/o+suM=; h=Date:From:To:Cc:Subject:In-Reply-To:From; b=rxwMl4PFySKcal9t5bQekScNqvYp8/V7Vg4OFziNDWOAHrkDPZP1x+FBFhN/dUhY0 IlYDw1UnAekPNEJwf2FSp8//tLhGUv3I3l7CccB4rt2bmHTcQudOSWWNWgBbAlnX6+ Lg8TIQZi3wAjKzdlyG2C8qgByeqH9JZb/zo7DQ84= X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-pm@vger.kernel.org, linux-pci@vger.kernel.org, Mika Westerberg , "Rafael J . Wysocki" , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, nouveau@lists.freedesktop.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Message-ID: <20191119214955.BP8SQlqAvSFVI2EacgSksVww-YLI-4Mf0K5Ins--kig@z> WytjYyBEYXZlXQoKT24gVGh1LCBPY3QgMTcsIDIwMTkgYXQgMDI6MTk6MDFQTSArMDIwMCwgS2Fy b2wgSGVyYnN0IHdyb3RlOgo+IEZpeGVzIHN0YXRlIHRyYW5zaXRpb25zIG9mIE52aWRpYSBQYXNj YWwgR1BVcyBmcm9tIEQzY29sZCBpbnRvIGhpZ2hlciBkZXZpY2UKPiBzdGF0ZXMuCj4gCj4gdjI6 IGNvbnZlcnQgdG8gcGNpX2RldiBxdWlyawo+ICAgICBwdXQgYSBwcm9wZXIgdGVjaG5pY2FsIGV4 cGxhbmF0aW9uIG9mIHRoZSBpc3N1ZSBhcyBhIGluLWNvZGUgY29tbWVudAo+IHYzOiBkaXNhYmxl IGl0IG9ubHkgZm9yIGNlcnRhaW4gY29tYmluYXRpb25zIG9mIGludGVsIGFuZCBudmlkaWEgaGFy ZHdhcmUKPiB2NDogc2ltcGxpZnkgcXVpcmsgYnkgc2V0dGluZyBmbGFnIG9uIHRoZSBHUFUgaXRz ZWxmCgpJIGhhdmUgemVybyBjb25maWRlbmNlIHRoYXQgd2UgdW5kZXJzdGFuZCB0aGUgcmVhbCBw cm9ibGVtLCBidXQgd2UgZG8KbmVlZCB0byBkbyBzb21ldGhpbmcgd2l0aCB0aGlzLiAgSSdsbCBt ZXJnZSBpdCBmb3IgdjUuNSBpZiB3ZSBnZXQgdGhlCm1pbm9yIHByb2NlZHVyYWwgc3R1ZmYgYmVs b3cgc3RyYWlnaHRlbmVkIG91dC4KCj4gU2lnbmVkLW9mZi1ieTogS2Fyb2wgSGVyYnN0IDxraGVy YnN0QHJlZGhhdC5jb20+Cj4gQ2M6IEJqb3JuIEhlbGdhYXMgPGJoZWxnYWFzQGdvb2dsZS5jb20+ Cj4gQ2M6IEx5dWRlIFBhdWwgPGx5dWRlQHJlZGhhdC5jb20+Cj4gQ2M6IFJhZmFlbCBKLiBXeXNv Y2tpIDxyandAcmp3eXNvY2tpLm5ldD4KPiBDYzogTWlrYSBXZXN0ZXJiZXJnIDxtaWthLndlc3Rl cmJlcmdAaW50ZWwuY29tPgo+IENjOiBsaW51eC1wY2lAdmdlci5rZXJuZWwub3JnCj4gQ2M6IGxp bnV4LXBtQHZnZXIua2VybmVsLm9yZwo+IENjOiBkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Au b3JnCj4gQ2M6IG5vdXZlYXVAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCj4gLS0tCj4gIGRyaXZlcnMv cGNpL3BjaS5jICAgIHwgIDcgKysrKysrCj4gIGRyaXZlcnMvcGNpL3F1aXJrcy5jIHwgNTMgKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKPiAgaW5jbHVkZS9saW51 eC9wY2kuaCAgfCAgMSArCj4gIDMgZmlsZXMgY2hhbmdlZCwgNjEgaW5zZXJ0aW9ucygrKQo+IAo+ IGRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9wY2kuYyBiL2RyaXZlcnMvcGNpL3BjaS5jCj4gaW5k ZXggYjk3ZDllMTBjOWNjLi4wMmU3MWUwYmNkZDcgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9wY2kv cGNpLmMKPiArKysgYi9kcml2ZXJzL3BjaS9wY2kuYwo+IEBAIC04NTAsNiArODUwLDEzIEBAIHN0 YXRpYyBpbnQgcGNpX3Jhd19zZXRfcG93ZXJfc3RhdGUoc3RydWN0IHBjaV9kZXYgKmRldiwgcGNp X3Bvd2VyX3Qgc3RhdGUpCj4gIAkgICB8fCAoc3RhdGUgPT0gUENJX0QyICYmICFkZXYtPmQyX3N1 cHBvcnQpKQo+ICAJCXJldHVybiAtRUlPOwo+ICAKPiArCS8qCj4gKwkgKiBjaGVjayBpZiB3ZSBo YXZlIGEgYmFkIGNvbWJpbmF0aW9uIG9mIGJyaWRnZSBjb250cm9sbGVyIGFuZCBudmlkaWEKPiAr ICAgICAgICAgKiBHUFUsIHNlZSBxdWlya19icm9rZW5fbnZfcnVucG0gZm9yIG1vcmUgaW5mbwoK V2hpdGVzcGFjZSBkYW1hZ2UuICBDYXBpdGFsaXplZCBpbmNvcnJlY3RseSAoc2VlIG90aGVyIGNv bW1lbnRzCm5lYXJieSkuCgo+ICsJICovCj4gKwlpZiAoc3RhdGUgIT0gUENJX0QwICYmIGRldi0+ YnJva2VuX252X3J1bnBtKQo+ICsJCXJldHVybiAwOwo+ICsKPiAgCXBjaV9yZWFkX2NvbmZpZ193 b3JkKGRldiwgZGV2LT5wbV9jYXAgKyBQQ0lfUE1fQ1RSTCwgJnBtY3NyKTsKPiAgCj4gIAkvKgo+ IGRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9xdWlya3MuYyBiL2RyaXZlcnMvcGNpL3F1aXJrcy5j Cj4gaW5kZXggNDRjNGFlMWFiZDAwLi4wMDA2YzllMzdiNmYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy9wY2kvcXVpcmtzLmMKPiArKysgYi9kcml2ZXJzL3BjaS9xdWlya3MuYwo+IEBAIC01MjY4LDMg KzUyNjgsNTYgQEAgc3RhdGljIHZvaWQgcXVpcmtfcmVzZXRfbGVub3ZvX3RoaW5rcGFkX3A1MF9u dmdwdShzdHJ1Y3QgcGNpX2RldiAqcGRldikKPiAgREVDTEFSRV9QQ0lfRklYVVBfQ0xBU1NfRklO QUwoUENJX1ZFTkRPUl9JRF9OVklESUEsIDB4MTNiMSwKPiAgCQkJICAgICAgUENJX0NMQVNTX0RJ U1BMQVlfVkdBLCA4LAo+ICAJCQkgICAgICBxdWlya19yZXNldF9sZW5vdm9fdGhpbmtwYWRfcDUw X252Z3B1KTsKPiArCj4gKy8qCj4gKyAqIFNvbWUgSW50ZWwgUENJZSBicmlkZ2VzIGNhdXNlIGRl dmljZXMgdG8gZGlzYXBwZWFyIGZyb20gdGhlIFBDSWUgYnVzIGFmdGVyCj4gKyAqIHRob3NlIHdl cmUgcHV0IGludG8gRDNjb2xkIHN0YXRlIGlmIHRoZXkgd2VyZSBwdXQgaW50byBhIG5vbiBEMCBQ Q0kgUE0KPiArICogZGV2aWNlIHN0YXRlIGJlZm9yZSBkb2luZyBzby4KCkEgZGV2aWNlIGluIEQz Y29sZCBpcyBvZmYgdGhlIGJ1cyBieSBkZWZpbml0aW9uLgoKSUlVQyB0aGUgcHJvYmxlbSBpcyB0 aGF0IHRoZSBzZXF1ZW5jZSBEMCAtPiBEM2hvdCAtPiBEM2NvbGQgLT4gRDAgZm9yCnRoZSBHUFUg ZmFpbHMgaW4gdGhlIHRyYW5zaXRpb24gYmFjayB0byBEMCwgd2hpbGUgRDAgLT4gRDNjb2xkIC0+ IEQwCndvcmtzIGZpbmUuCgpTbyBJIGd1ZXNzIHRoZSBwcm9ibGVtIGlzIHRoYXQgd2UgY2FuIHB1 dCB0aGUgZGV2aWNlIGluIEQzY29sZCB3aXRoIG5vCnByb2JsZW0sIGJ1dCBpZiB3ZSBwdXQgaW4g RDNob3QgYmVmb3JlIGdvaW5nIHRvIEQzY29sZCwgdGhlIGRldmljZQpuZXZlciBjb21lcyBiYWNr IHRvIEQwLiAgUmlnaHQ/Cgo+ICsgKiBUaGlzIGxlYWRzIHRvIHZhcmlvdXMgaXNzdWUgZGlmZmVy ZW50IGlzc3VlcyB3aGljaCBhbGwgbWFuaWZlc3QgZGlmZmVyZW50bHksCgpzL2lzc3VlIGRpZmZl cmVudC8vCgpBY3R1YWxseSwgSSB0aGluayB0aGVyZSdzIG9ubHkgb25lIHVuZGVybHlpbmcgaXNz dWUgd2l0aCBzZXZlcmFsCm1hbmlmZXN0YXRpb25zLgoKPiArICogYnV0IGhhdmUgdGhlIHNhbWUg cm9vdCBjYXVzZToKPiArICogIC0gQUlNTCBjb2RlIGV4ZWN1dGlvbiBoaXRzIGFuIGluZmluaXRl IGxvb3AgKGFzIHRoZSBjb2Ugd2FpdHMgb24gZGV2aWNlCj4gKyAqICAgIG1lbW9yeSB0byBjaGFu Z2UpLgoKcy9BSU1ML0FNTC8Kcy9jb2UvY29kZS8KCj4gKyAqICAtIGtlcm5lbCBjcmFzaGVzLCBh cyBhbGwgcGNpIHJlYWRzIHJldHVybiAtMSwgd2hpY2ggbW9zdCBjb2RlIGlzbid0IGFibGUKPiAr ICogICAgdG8gaGFuZGxlIHdlbGwgZW5vdWdoLgoKcy9wY2kvUENJLwoKTW9yZSBkZXRhaWxzIGFi b3V0IHRoZXNlIGNyYXNoZXMgd291bGQgYmUgdXNlZnVsIGFzIHdlIGxvb2sgYXQgcGxhY2VzCnRo YXQgKnNob3VsZCogYmUgYWJsZSB0byBoYW5kbGUgZXJyb3JzIGxpa2UgdGhpcy4KCj4gKyAqICAt IHN1ZGRlbiBzaHV0ZG93bnMsIGFzIHRoZSBrZXJuZWwgaWRlbnRpZmllZCBhbiB1bnJlY292ZXJh YmxlIGVycm9yIGFmdGVyCj4gKyAqICAgIHVzZXJzcGFjZSB0cmllcyB0byBhY2Nlc3MgdGhlIEdQ VS4KClRoaXMgZG9lc24ndCBmaXQgd2l0aCB0aGUgb3RoZXJzIGFuZCBtb3JlIGRldGFpbHMgbWln aHQgYmUKaW5mb3JtYXRpdmUgaGVyZSBhcyB3ZWxsLgoKPiArICogSW4gYWxsIGNhc2VzIGRtZXNn IHdpbGwgY29udGFpbiBhdCBsZWFzdCBvbmUgbGluZSBsaWtlIHRoaXM6Cj4gKyAqICdub3V2ZWF1 IDAwMDA6MDE6MDAuMDogUmVmdXNlZCB0byBjaGFuZ2UgcG93ZXIgc3RhdGUsIGN1cnJlbnRseSBp biBEMycKPiArICogZm9sbG93ZWQgYnkgYSBsb3Qgb2Ygbm91dmVhdSB0aW1lb3V0cy4KPiArICoK PiArICogQUNQSSBjb2RlIHdyaXRlcyBiaXQgMHg4MCB0byB0aGUgbm90IGRvY3VtZW50ZWQgUENJ IHJlZ2lzdGVyIDB4MjQ4IG9mIHRoZQo+ICsgKiBQQ0llIGJyaWRnZSBjb250cm9sbGVyIGluIG9y ZGVyIHRvIHBvd2VyIGRvd24gdGhlIEdQVS4KPiArICogTm9uZXRoZWxlc3MsIHRoZXJlIGFyZSBv dGhlciBjb2RlIHBhdGhzIGluc2lkZSB0aGUgQUNQSSBmaXJtd2FyZSB3aGljaCB1c2UKPiArICog b3RoZXIgcmVnaXN0ZXJzLCB3aGljaCBzZWVtIHRvIHdvcmsgZmluZToKPiArICogIC0gMHhiYyBi aXQgMHgyMCAocHVibGljbHkgYXZhaWxhYmxlIGRvY3VtZW50YXRpb24gY2xhaW1zICdyZXNlcnZl ZCcpCj4gKyAqICAtIDB4YjAgYml0IDB4MTAgKGxpbmsgZGlzYWJsZSkKCkFsbCB0aGVzZSByZWdp c3RlciBhZGRyZXNzZXMgYXJlIGRldmljZS1zcGVjaWZpYywgc28gdGhleSdyZSB1c2VsZXNzCndp dGhvdXQgaWRlbnRpZnlpbmcgdGhlIGRldmljZS4gICJsc3BjaSAtdnZubiIgb3V0cHV0IHdvdWxk IGxldCB1cyBhdApsZWFzdCBjb25uZWN0IHRoaXMgd2l0aCBzb21ldGhpbmcuICBJdCB3b3VsZCBi ZSBuaWNlIHRvIGhhdmUgdGhhdCBpbmZvCmFyY2hpdmVkIGFsb25nIHdpdGggeW91ciBhY3BpZHVt cCBhbmQgcHl0aG9uIHJlcHJvIHNjcmlwdHMgaW4gYQpidWd6aWxsYSB3aXRoIHRoZSBVUkwgaW4g dGhlIGNvbW1pdCBsb2cuCgpUaGVzZSBhcmUgbGlrZWx5IGluIFBDSSBjYXBhYmlsaXRpZXMuICBJ ZiBJIG1ha2UgdGhlIGxlYXAgb2YgYXNzdW1pbmcKdGhlICJsaW5rIGRpc2FibGUiIGJpdCBpcyBQ Q0lfRVhQX0xOS0NUTF9MRCwgdGhhdCB3b3VsZCBtZWFuIHRoZSBMaW5rCkNvbnRyb2wgcmVnaXN0 ZXIgaXMgYXQgMHhiMCBhbmQgdGhlIHJlZ2lzdGVyIGF0IDB4YmMgd291bGQgYmUgdGhlIFJvb3QK Q29udHJvbCByZWdpc3RlciwgYW5kIGluZGVlZCAweDIwIGluIFJvb3QgQ29udHJvbCBpcyByZXNl cnZlZC4KCkkgZG9uJ3Qga25vdyB3aGF0IHRoZSByZWxldmFuY2Ugb2YgYWxsIHRoaXMgaXMsIHRo b3VnaC4gIEl0J3Mgbm90CnJlbWFya2FibGUgdGhhdCBhY2Nlc3NlcyB0byB0aGVzZSByZWdpc3Rl cnMgd29yay4KClVubGVzcyB5b3UgbWVhbiB5b3UgY2FuIGFjY2VzcyB0aGVzZSByZWdpc3RlcnMg KmFmdGVyKiB0cnlpbmcgdG8gcHV0CnRoZSBkZXZpY2UgYmFjayBpbiBEMCwgYnV0IG90aGVyIGFj Y2Vzc2VzIHRvIHRoZSBkZXZpY2UgZmFpbC4gIFRoYXQKd291bGQgaW5kZWVkIGJlIHZlcnkgaW50 ZXJlc3RpbmcuCgo+ICsgKiBDaGFuZ2luZyB0aGUgY29uZGl0aW9ucyBpbnNpZGUgdGhlIGZpcm13 YXJlIGJ5IHBva2luZyBpbnRvIHRoZSByZWxldmFudAo+ICsgKiBhZGRyZXNzZXMgZG9lcyByZXNv bHZlIHRoZSBpc3N1ZSwgYnV0IGl0IHNlZW1lZCB0byBiZSBBQ1BJIHByaXZhdGUgbWVtb3J5Cj4g KyAqIGFuZCBub3QgYW55IGRldmljZSBhY2Nlc3NpYmxlIG1lbW9yeSBhdCBhbGwsIHNvIHRoZXJl IGlzIG5vIHBvcnRhYmxlIHdheSBvZgo+ICsgKiBjaGFuZ2luZyB0aGUgY29uZGl0aW9ucy4KPiAr ICoKPiArICogVGhlIG9ubHkgc3lzdGVtcyB3aGVyZSB0aGlzIGJlaGF2aW9yIGNhbiBiZSBzZWVu IGFyZSBoeWJyaWQgZ3JhcGhpY3MgbGFwdG9wcwo+ICsgKiB3aXRoIGEgc2Vjb25kYXJ5IE52aWRp YSBQYXNjYWwgR1BVLiBJdCBjYW5ub3QgYmUgcnVsZWQgb3V0IHRoYXQgdGhpcyBpc3N1ZQo+ICsg KiBvbmx5IG9jY3VycyBpbiBjb21iaW5hdGlvbiB3aXRoIGxpc3RlZCBJbnRlbCBQQ0llIGJyaWRn ZSBjb250cm9sbGVycyBhbmQKPiArICogdGhlIG1lbnRpb25lZCBHUFVzIG9yIGlmIGl0J3Mgb25s eSBhIGh3IGJ1ZyBpbiB0aGUgYnJpZGdlIGNvbnRyb2xsZXIuCj4gKyAqCj4gKyAqIEJ1dCBiZWNh dXNlIHRoaXMgaXNzdWUgd2FzIE5PVCBzZWVuIG9uIGxhcHRvcHMgd2l0aCBhbiBOdmlkaWEgUGFz Y2FsIEdQVQo+ICsgKiBhbmQgYW4gSW50ZWwgQ29mZmVlIExha2UgU29DLCB0aGVyZSBpcyBhIGhp Z2hlciBjaGFuY2Ugb2YgdGhlcmUgYmVpbmcgYSBidWcKPiArICogaW4gdGhlIGJyaWRnZSBjb250 cm9sbGVyIHJhdGhlciB0aGFuIGluIHRoZSBHUFUuCgpJIGRvbid0IHRoaW5rIHdlIGNhbiBjb25j bHVkZSBhbnl0aGluZyBhYm91dCB3aGVyZSB0aGUgZGVmZWN0IGlzIGFuZCBJCmRvbid0IHRoaW5r IHNwZWN1bGF0aW5nIGhlcmUgd2lsbCBoZWxwIGZ1dHVyZSByZWFkZXJzIG9mIHRoaXMgY29kZS4K CkkgKndvdWxkKiBzdGlsbCBsaWtlIHRvIHNlZSBhIGJ1Z3ppbGxhIGxpc3RpbmcgdGhlIHN5c3Rl bXMgd2hlcmUgdGhpcwpwcm9ibGVtIGhhcyBiZWVuIHNlZW4gd2l0aCB0aGUgImxzcGNpIC12dm5u IiwgZG1lc2cgbG9ncywgYW5kIGF0IGxlYXN0Cm9uZSBhY3BpZHVtcC4gIEkgdGhpbmsgdGhlcmUn cyBtb3JlIHRvIHRoaXMgc3RvcnksIGFuZCBJIHN1c3BlY3Qgd2UKbWF5IGJlIHJldmlzaXRpbmcg dGhpcyBpbiB0aGUgZnV0dXJlLgoKPiArICogVGhpcyBpc3N1ZSB3YXMgbm90IGFibGUgdG8gYmUg cmVwcm9kdWNlZCBvbiBub24gbGFwdG9wIHN5c3RlbXMuCj4gKyAqLwo+ICsKPiArc3RhdGljIHZv aWQgcXVpcmtfYnJva2VuX252X3J1bnBtKHN0cnVjdCBwY2lfZGV2ICpkZXYpCj4gK3sKPiArCXN0 cnVjdCBwY2lfZGV2ICpicmlkZ2UgPSBwY2lfdXBzdHJlYW1fYnJpZGdlKGRldik7Cj4gKwo+ICsJ aWYgKGJyaWRnZS0+dmVuZG9yID09IFBDSV9WRU5ET1JfSURfSU5URUwgJiYKPiArCSAgICBicmlk Z2UtPmRldmljZSA9PSAweDE5MDEpCgpwY2lfdXBzdHJlYW1fYnJpZGdlKCkgbWF5IHJldHVybiBO VUxMLCBzbyB5b3UgbmVlZAoKICBpZiAoYnJpZGdlICYmIGJyaWRnZS0+dmVuZG9yID09IFBDSV9W RU5ET1JfSURfSU5URUwgLi4uCgpodHRwczovL2xvcmUua2VybmVsLm9yZy9yLzIwMTkwOTI3MTQ0 NDIxLjIyNjA4LTEta2hlcmJzdEByZWRoYXQuY29tCnNheXMgU2t5bGFrZSBhbmQgS2FieSBMYWtl IFNvQ3MgYXJlIGFmZmVjdGVkLiAgQnV0IGhlcmUgeW91IG9ubHkgY2hlY2sKZm9yIG9uZSBEZXZp Y2UgSUQ/Cgo+ICsJCWRldi0+YnJva2VuX252X3J1bnBtID0gMTsKPiArfQo+ICtERUNMQVJFX1BD SV9GSVhVUF9DTEFTU19GSU5BTChQQ0lfVkVORE9SX0lEX05WSURJQSwgUENJX0FOWV9JRCwKPiAr CQkJICAgICAgUENJX0JBU0VfQ0xBU1NfRElTUExBWSwgMTYsCj4gKwkJCSAgICAgIHF1aXJrX2Jy b2tlbl9udl9ydW5wbSk7Cj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcGNpLmggYi9pbmNs dWRlL2xpbnV4L3BjaS5oCj4gaW5kZXggYWM4YTZjNGUxNzkyLi45MDNhMGIzYTM5ZWMgMTAwNjQ0 Cj4gLS0tIGEvaW5jbHVkZS9saW51eC9wY2kuaAo+ICsrKyBiL2luY2x1ZGUvbGludXgvcGNpLmgK PiBAQCAtNDE2LDYgKzQxNiw3IEBAIHN0cnVjdCBwY2lfZGV2IHsKPiAgCXVuc2lnbmVkIGludAlf X2Flcl9maXJtd2FyZV9maXJzdF92YWxpZDoxOwo+ICAJdW5zaWduZWQgaW50CV9fYWVyX2Zpcm13 YXJlX2ZpcnN0OjE7Cj4gIAl1bnNpZ25lZCBpbnQJYnJva2VuX2ludHhfbWFza2luZzoxOwkvKiBJ TlR4IG1hc2tpbmcgY2FuJ3QgYmUgdXNlZCAqLwo+ICsJdW5zaWduZWQgaW50CWJyb2tlbl9udl9y dW5wbToxOwkvKiBzb21lIGNvbWJpbmF0aW9ucyBvZiBpbnRlbCBicmlkZ2UgY29udHJvbGxlciBh bmQgbnZpZGlhIEdQVXMgYnJlYWsgcnRkMyAqLwo+ICAJdW5zaWduZWQgaW50CWlvX3dpbmRvd18x azoxOwkJLyogSW50ZWwgYnJpZGdlIDFLIEkvTyB3aW5kb3dzICovCj4gIAl1bnNpZ25lZCBpbnQJ aXJxX21hbmFnZWQ6MTsKPiAgCXVuc2lnbmVkIGludAloYXNfc2Vjb25kYXJ5X2xpbms6MTsKPiAt LSAKPiAyLjIxLjAKPiAKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Au b3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRl dmVs