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.2 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, 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 BB530C43215 for ; Wed, 20 Nov 2019 10:18:26 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 9D83E2245B for ; Wed, 20 Nov 2019 10:18:26 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728504AbfKTKSZ (ORCPT ); Wed, 20 Nov 2019 05:18:25 -0500 Received: from mga12.intel.com ([192.55.52.136]:42704 "EHLO mga12.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727856AbfKTKSZ (ORCPT ); Wed, 20 Nov 2019 05:18:25 -0500 X-Amp-Result: UNKNOWN X-Amp-Original-Verdict: FILE UNKNOWN X-Amp-File-Uploaded: False Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by fmsmga106.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 20 Nov 2019 02:18:20 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.69,221,1571727600"; d="scan'208";a="215747198" Received: from lahna.fi.intel.com (HELO lahna) ([10.237.72.163]) by fmsmga001.fm.intel.com with SMTP; 20 Nov 2019 02:18:17 -0800 Received: by lahna (sSMTP sendmail emulation); Wed, 20 Nov 2019 12:18:16 +0200 Date: Wed, 20 Nov 2019 12:18:16 +0200 From: Mika Westerberg To: Karol Herbst Cc: Bjorn Helgaas , LKML , Lyude Paul , "Rafael J . Wysocki" , Linux PCI , Linux PM , dri-devel , nouveau , Dave Airlie , Mario.Limonciello@dell.com Subject: Re: [PATCH v4] pci: prevent putting nvidia GPUs into lower device states on certain intel bridges Message-ID: <20191120101816.GX11621@lahna.fi.intel.com> References: <20191017121901.13699-1-kherbst@redhat.com> <20191119214955.GA223696@google.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: Organization: Intel Finland Oy - BIC 0357606-4 - Westendinkatu 7, 02160 Espoo User-Agent: Mutt/1.12.1 (2019-06-15) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi Karol, On Tue, Nov 19, 2019 at 11:26:45PM +0100, Karol Herbst wrote: > On Tue, Nov 19, 2019 at 10:50 PM Bjorn Helgaas wrote: > > > > [+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. > > > > Thanks, and I agree with your statement, but at this point I think > only Intel can help out digging deeper as I see no way to debug this > further. I don't have anything against this patch, as long as the quirk stays limited to the particular root port leading to the NVIDIA GPU. The reason why I think it should to be limited is that I'm pretty certain the problem is not in the root port itself. I have here a KBL based Thinkpad X1 Carbon 6th gen that can put the TBT controller into D3cold (it is connected to PCH root port) and it wakes up there just fine, so don't want to break that. Now, PCIe devices cannot go into D3cold all by themselves. They always need help from the platform side which is ACPI in this case. This is done by having the device to have _PR3 method that returns one or more power resources that the OS is supposed to turn off when the device is put into D3cold. All of that is implemented as form of ACPI methods that pretty much do the hardware specific things that are outside of PCIe spec to get the device into D3cold. At high level the _OFF() method causes the root port to broadcast PME_Turn_Off message that results the link to enter L2/3 ready, it then asserts PERST, configures WAKE (both can be GPIOs) and finally removes power (if the link goes into L3, otherwise it goes into L2). I think this is where the problem actually lies - the ASL methods that are used to put the device into D3cold and back. We know that in Windows this all works fine so unless Windows quirks the root port the same way there is another reason behind this. In case of Dell XPS 9560 (IIRC that's the machine you have) the corresponding power resource is called \_SB.PCI0.PEG0.PG00 and its _ON/_OFF methods end up calling PGON()/PGOF() accordingly. The methods itself do lots of things and it is hard to follow the dissassembled ASL which does not have any comments but there are couple of things that stand out where we may go into a different path. One of them is this in the PGOF() method: If (((OSYS <= 0x07D9) || ((OSYS == 0x07DF) && (_REV == 0x05)))) The ((OSYS == 0x07DF) && (_REV == 0x05)) checks specifically for Linux (see [1] and 18d78b64fddc ("ACPI / init: Make it possible to override _REV")) so it might be that Dell people tested this at some point in Linux as well. Added Mario in case he has any ideas. Previously I suggested you to try the ACPI method tracing to see what happens inside PGOF(). Did you have time to try it? It may provide more information about that is happening inside those methods and hopefully point us to the root cause. Also if you haven't tried already passing acpi_rev_override in the command line makes the _REV to return 5 so it should go into the "Linux" path in PGOF(). [1] https://www.kernel.org/doc/html/latest/firmware-guide/acpi/osi.html#do-not-use-rev > > > 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? > > > > correct. It By the way, it doesn't matter if I put the device into D1 > instead, as long as the device is not in D0 state before putting it > into D3cold, it fails. > > > > + * 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. > > > > makes sense, I could ,orthogonal to this, make the code more robust if > we hit issues like this in the future. What I am mostly wondering > about is, why pci core doesn't give up if the device doesn't come back > from D3cold? It sounds like, that the most sane thing to do here is to > just give up and fail runtime_resume and report errors back to > userspace trying to make use of the devices. > > > > + * - 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. > > > > yeah.. I try to get more infos on that. But at least for me (and it > might be a distribution thing) if I execute lspci, the system shuts > down, or at least tries to and might fail. > > > > + * 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. > > > > those are registers on the bridge controller and are using inside ACPI > to power down the link. Depending on the OS detected other methods are > used afaik. > > > 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. > > > > one big one is https://bugzilla.kernel.org/show_bug.cgi?id=156341 but > it's filled with a lot of different reports, but I am sure most of > them point to this very issue. > > Sadly nobody thought of checking lspci with runpm disabled.. but I > could check for other bugs. > > > > + * 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? > > > > yes, I found this bridge controllers on skylake and kaby lake SoCs, > but I could verify there are systems with a different architecture > (using the "PCI Express Root Port" devices instead of "Processor PCIe > Controller") do not show this issue, so I think it might indeed be > just this one bridge controller. I couldn't verify this issue on any > other so far. > > But I could verify this issue with this one bridge controller in > combination with Maxwell, Pascal and Turing Nvidia GPUs. > > > > + 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 > > > > > > > Will send out a v5 later addressing you review. Thanks! 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.2 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, 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 DFC3AC432C0 for ; Wed, 20 Nov 2019 10:18:23 +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 B6C3422311 for ; Wed, 20 Nov 2019 10:18:23 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org B6C3422311 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com 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 2C50C6E1C4; Wed, 20 Nov 2019 10:18:23 +0000 (UTC) Received: from mga03.intel.com (mga03.intel.com [134.134.136.65]) by gabe.freedesktop.org (Postfix) with ESMTPS id 8DDF96E1C4; Wed, 20 Nov 2019 10:18:21 +0000 (UTC) X-Amp-Result: UNKNOWN X-Amp-Original-Verdict: FILE UNKNOWN X-Amp-File-Uploaded: False Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by orsmga103.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 20 Nov 2019 02:18:20 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.69,221,1571727600"; d="scan'208";a="215747198" Received: from lahna.fi.intel.com (HELO lahna) ([10.237.72.163]) by fmsmga001.fm.intel.com with SMTP; 20 Nov 2019 02:18:17 -0800 Received: by lahna (sSMTP sendmail emulation); Wed, 20 Nov 2019 12:18:16 +0200 Date: Wed, 20 Nov 2019 12:18:16 +0200 From: Mika Westerberg To: Karol Herbst Subject: Re: [PATCH v4] pci: prevent putting nvidia GPUs into lower device states on certain intel bridges Message-ID: <20191120101816.GX11621@lahna.fi.intel.com> References: <20191017121901.13699-1-kherbst@redhat.com> <20191119214955.GA223696@google.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: Organization: Intel Finland Oy - BIC 0357606-4 - Westendinkatu 7, 02160 Espoo User-Agent: Mutt/1.12.1 (2019-06-15) 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 , Linux PCI , Mario.Limonciello@dell.com, "Rafael J . Wysocki" , LKML , dri-devel , Bjorn Helgaas , nouveau Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Message-ID: <20191120101816.MyuvmY-yUjyGOoOy4Jugp6a5RDCJAfM9iQdByPIAtlI@z> SGkgS2Fyb2wsCgpPbiBUdWUsIE5vdiAxOSwgMjAxOSBhdCAxMToyNjo0NVBNICswMTAwLCBLYXJv bCBIZXJic3Qgd3JvdGU6Cj4gT24gVHVlLCBOb3YgMTksIDIwMTkgYXQgMTA6NTAgUE0gQmpvcm4g SGVsZ2FhcyA8aGVsZ2Fhc0BrZXJuZWwub3JnPiB3cm90ZToKPiA+Cj4gPiBbK2NjIERhdmVdCj4g Pgo+ID4gT24gVGh1LCBPY3QgMTcsIDIwMTkgYXQgMDI6MTk6MDFQTSArMDIwMCwgS2Fyb2wgSGVy YnN0IHdyb3RlOgo+ID4gPiBGaXhlcyBzdGF0ZSB0cmFuc2l0aW9ucyBvZiBOdmlkaWEgUGFzY2Fs IEdQVXMgZnJvbSBEM2NvbGQgaW50byBoaWdoZXIgZGV2aWNlCj4gPiA+IHN0YXRlcy4KPiA+ID4K PiA+ID4gdjI6IGNvbnZlcnQgdG8gcGNpX2RldiBxdWlyawo+ID4gPiAgICAgcHV0IGEgcHJvcGVy IHRlY2huaWNhbCBleHBsYW5hdGlvbiBvZiB0aGUgaXNzdWUgYXMgYSBpbi1jb2RlIGNvbW1lbnQK PiA+ID4gdjM6IGRpc2FibGUgaXQgb25seSBmb3IgY2VydGFpbiBjb21iaW5hdGlvbnMgb2YgaW50 ZWwgYW5kIG52aWRpYSBoYXJkd2FyZQo+ID4gPiB2NDogc2ltcGxpZnkgcXVpcmsgYnkgc2V0dGlu ZyBmbGFnIG9uIHRoZSBHUFUgaXRzZWxmCj4gPgo+ID4gSSBoYXZlIHplcm8gY29uZmlkZW5jZSB0 aGF0IHdlIHVuZGVyc3RhbmQgdGhlIHJlYWwgcHJvYmxlbSwgYnV0IHdlIGRvCj4gPiBuZWVkIHRv IGRvIHNvbWV0aGluZyB3aXRoIHRoaXMuICBJJ2xsIG1lcmdlIGl0IGZvciB2NS41IGlmIHdlIGdl dCB0aGUKPiA+IG1pbm9yIHByb2NlZHVyYWwgc3R1ZmYgYmVsb3cgc3RyYWlnaHRlbmVkIG91dC4K PiA+Cj4gCj4gVGhhbmtzLCBhbmQgSSBhZ3JlZSB3aXRoIHlvdXIgc3RhdGVtZW50LCBidXQgYXQg dGhpcyBwb2ludCBJIHRoaW5rCj4gb25seSBJbnRlbCBjYW4gaGVscCBvdXQgZGlnZ2luZyBkZWVw ZXIgYXMgSSBzZWUgbm8gd2F5IHRvIGRlYnVnIHRoaXMKPiBmdXJ0aGVyLgoKSSBkb24ndCBoYXZl IGFueXRoaW5nIGFnYWluc3QgdGhpcyBwYXRjaCwgYXMgbG9uZyBhcyB0aGUgcXVpcmsgc3RheXMK bGltaXRlZCB0byB0aGUgcGFydGljdWxhciByb290IHBvcnQgbGVhZGluZyB0byB0aGUgTlZJRElB IEdQVS4gVGhlCnJlYXNvbiB3aHkgSSB0aGluayBpdCBzaG91bGQgdG8gYmUgbGltaXRlZCBpcyB0 aGF0IEknbSBwcmV0dHkgY2VydGFpbgp0aGUgcHJvYmxlbSBpcyBub3QgaW4gdGhlIHJvb3QgcG9y dCBpdHNlbGYuIEkgaGF2ZSBoZXJlIGEgS0JMIGJhc2VkClRoaW5rcGFkIFgxIENhcmJvbiA2dGgg Z2VuIHRoYXQgY2FuIHB1dCB0aGUgVEJUIGNvbnRyb2xsZXIgaW50byBEM2NvbGQKKGl0IGlzIGNv bm5lY3RlZCB0byBQQ0ggcm9vdCBwb3J0KSBhbmQgaXQgd2FrZXMgdXAgdGhlcmUganVzdCBmaW5l LCBzbwpkb24ndCB3YW50IHRvIGJyZWFrIHRoYXQuCgpOb3csIFBDSWUgZGV2aWNlcyBjYW5ub3Qg Z28gaW50byBEM2NvbGQgYWxsIGJ5IHRoZW1zZWx2ZXMuIFRoZXkgYWx3YXlzCm5lZWQgaGVscCBm cm9tIHRoZSBwbGF0Zm9ybSBzaWRlIHdoaWNoIGlzIEFDUEkgaW4gdGhpcyBjYXNlLiBUaGlzIGlz CmRvbmUgYnkgaGF2aW5nIHRoZSBkZXZpY2UgdG8gaGF2ZSBfUFIzIG1ldGhvZCB0aGF0IHJldHVy bnMgb25lIG9yIG1vcmUKcG93ZXIgcmVzb3VyY2VzIHRoYXQgdGhlIE9TIGlzIHN1cHBvc2VkIHRv IHR1cm4gb2ZmIHdoZW4gdGhlIGRldmljZSBpcwpwdXQgaW50byBEM2NvbGQuIEFsbCBvZiB0aGF0 IGlzIGltcGxlbWVudGVkIGFzIGZvcm0gb2YgQUNQSSBtZXRob2RzIHRoYXQKcHJldHR5IG11Y2gg ZG8gdGhlIGhhcmR3YXJlIHNwZWNpZmljIHRoaW5ncyB0aGF0IGFyZSBvdXRzaWRlIG9mIFBDSWUK c3BlYyB0byBnZXQgdGhlIGRldmljZSBpbnRvIEQzY29sZC4gQXQgaGlnaCBsZXZlbCB0aGUgX09G RigpIG1ldGhvZApjYXVzZXMgdGhlIHJvb3QgcG9ydCB0byBicm9hZGNhc3QgUE1FX1R1cm5fT2Zm IG1lc3NhZ2UgdGhhdCByZXN1bHRzIHRoZQpsaW5rIHRvIGVudGVyIEwyLzMgcmVhZHksIGl0IHRo ZW4gYXNzZXJ0cyBQRVJTVCwgY29uZmlndXJlcyBXQUtFIChib3RoCmNhbiBiZSBHUElPcykgYW5k IGZpbmFsbHkgcmVtb3ZlcyBwb3dlciAoaWYgdGhlIGxpbmsgZ29lcyBpbnRvIEwzLApvdGhlcndp c2UgaXQgZ29lcyBpbnRvIEwyKS4KCkkgdGhpbmsgdGhpcyBpcyB3aGVyZSB0aGUgcHJvYmxlbSBh Y3R1YWxseSBsaWVzIC0gdGhlIEFTTCBtZXRob2RzIHRoYXQKYXJlIHVzZWQgdG8gcHV0IHRoZSBk ZXZpY2UgaW50byBEM2NvbGQgYW5kIGJhY2suIFdlIGtub3cgdGhhdCBpbiBXaW5kb3dzCnRoaXMg YWxsIHdvcmtzIGZpbmUgc28gdW5sZXNzIFdpbmRvd3MgcXVpcmtzIHRoZSByb290IHBvcnQgdGhl IHNhbWUgd2F5CnRoZXJlIGlzIGFub3RoZXIgcmVhc29uIGJlaGluZCB0aGlzLgoKSW4gY2FzZSBv ZiBEZWxsIFhQUyA5NTYwIChJSVJDIHRoYXQncyB0aGUgbWFjaGluZSB5b3UgaGF2ZSkgdGhlCmNv cnJlc3BvbmRpbmcgcG93ZXIgcmVzb3VyY2UgaXMgY2FsbGVkIFxfU0IuUENJMC5QRUcwLlBHMDAg YW5kIGl0cwpfT04vX09GRiBtZXRob2RzIGVuZCB1cCBjYWxsaW5nIFBHT04oKS9QR09GKCkgYWNj b3JkaW5nbHkuIFRoZSBtZXRob2RzCml0c2VsZiBkbyBsb3RzIG9mIHRoaW5ncyBhbmQgaXQgaXMg aGFyZCB0byBmb2xsb3cgdGhlIGRpc3Nhc3NlbWJsZWQKQVNMIHdoaWNoIGRvZXMgbm90IGhhdmUg YW55IGNvbW1lbnRzIGJ1dCB0aGVyZSBhcmUgY291cGxlIG9mIHRoaW5ncyB0aGF0CnN0YW5kIG91 dCB3aGVyZSB3ZSBtYXkgZ28gaW50byBhIGRpZmZlcmVudCBwYXRoLiBPbmUgb2YgdGhlbSBpcyB0 aGlzIGluCnRoZSBQR09GKCkgbWV0aG9kOgoKICAgSWYgKCgoT1NZUyA8PSAweDA3RDkpIHx8ICgo T1NZUyA9PSAweDA3REYpICYmIChfUkVWID09IDB4MDUpKSkpCgpUaGUgKChPU1lTID09IDB4MDdE RikgJiYgKF9SRVYgPT0gMHgwNSkpIGNoZWNrcyBzcGVjaWZpY2FsbHkgZm9yIExpbnV4CihzZWUg WzFdIGFuZCAxOGQ3OGI2NGZkZGMgKCJBQ1BJIC8gaW5pdDogTWFrZSBpdCBwb3NzaWJsZSB0byBv dmVycmlkZQpfUkVWIikpIHNvIGl0IG1pZ2h0IGJlIHRoYXQgRGVsbCBwZW9wbGUgdGVzdGVkIHRo aXMgYXQgc29tZSBwb2ludCBpbgpMaW51eCBhcyB3ZWxsLiBBZGRlZCBNYXJpbyBpbiBjYXNlIGhl IGhhcyBhbnkgaWRlYXMuCgpQcmV2aW91c2x5IEkgc3VnZ2VzdGVkIHlvdSB0byB0cnkgdGhlIEFD UEkgbWV0aG9kIHRyYWNpbmcgdG8gc2VlIHdoYXQKaGFwcGVucyBpbnNpZGUgUEdPRigpLiBEaWQg eW91IGhhdmUgdGltZSB0byB0cnkgaXQ/IEl0IG1heSBwcm92aWRlIG1vcmUKaW5mb3JtYXRpb24g YWJvdXQgdGhhdCBpcyBoYXBwZW5pbmcgaW5zaWRlIHRob3NlIG1ldGhvZHMgYW5kIGhvcGVmdWxs eQpwb2ludCB1cyB0byB0aGUgcm9vdCBjYXVzZS4KCkFsc28gaWYgeW91IGhhdmVuJ3QgdHJpZWQg YWxyZWFkeSBwYXNzaW5nIGFjcGlfcmV2X292ZXJyaWRlIGluIHRoZQpjb21tYW5kIGxpbmUgbWFr ZXMgdGhlIF9SRVYgdG8gcmV0dXJuIDUgc28gaXQgc2hvdWxkIGdvIGludG8gdGhlICJMaW51eCIK cGF0aCBpbiBQR09GKCkuCgpbMV0gaHR0cHM6Ly93d3cua2VybmVsLm9yZy9kb2MvaHRtbC9sYXRl c3QvZmlybXdhcmUtZ3VpZGUvYWNwaS9vc2kuaHRtbCNkby1ub3QtdXNlLXJldgoKPiA+ID4gU2ln bmVkLW9mZi1ieTogS2Fyb2wgSGVyYnN0IDxraGVyYnN0QHJlZGhhdC5jb20+Cj4gPiA+IENjOiBC am9ybiBIZWxnYWFzIDxiaGVsZ2Fhc0Bnb29nbGUuY29tPgo+ID4gPiBDYzogTHl1ZGUgUGF1bCA8 bHl1ZGVAcmVkaGF0LmNvbT4KPiA+ID4gQ2M6IFJhZmFlbCBKLiBXeXNvY2tpIDxyandAcmp3eXNv Y2tpLm5ldD4KPiA+ID4gQ2M6IE1pa2EgV2VzdGVyYmVyZyA8bWlrYS53ZXN0ZXJiZXJnQGludGVs LmNvbT4KPiA+ID4gQ2M6IGxpbnV4LXBjaUB2Z2VyLmtlcm5lbC5vcmcKPiA+ID4gQ2M6IGxpbnV4 LXBtQHZnZXIua2VybmVsLm9yZwo+ID4gPiBDYzogZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9w Lm9yZwo+ID4gPiBDYzogbm91dmVhdUBsaXN0cy5mcmVlZGVza3RvcC5vcmcKPiA+ID4gLS0tCj4g PiA+ICBkcml2ZXJzL3BjaS9wY2kuYyAgICB8ICA3ICsrKysrKwo+ID4gPiAgZHJpdmVycy9wY2kv cXVpcmtzLmMgfCA1MyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr Kwo+ID4gPiAgaW5jbHVkZS9saW51eC9wY2kuaCAgfCAgMSArCj4gPiA+ICAzIGZpbGVzIGNoYW5n ZWQsIDYxIGluc2VydGlvbnMoKykKPiA+ID4KPiA+ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNp L3BjaS5jIGIvZHJpdmVycy9wY2kvcGNpLmMKPiA+ID4gaW5kZXggYjk3ZDllMTBjOWNjLi4wMmU3 MWUwYmNkZDcgMTAwNjQ0Cj4gPiA+IC0tLSBhL2RyaXZlcnMvcGNpL3BjaS5jCj4gPiA+ICsrKyBi L2RyaXZlcnMvcGNpL3BjaS5jCj4gPiA+IEBAIC04NTAsNiArODUwLDEzIEBAIHN0YXRpYyBpbnQg cGNpX3Jhd19zZXRfcG93ZXJfc3RhdGUoc3RydWN0IHBjaV9kZXYgKmRldiwgcGNpX3Bvd2VyX3Qg c3RhdGUpCj4gPiA+ICAgICAgICAgIHx8IChzdGF0ZSA9PSBQQ0lfRDIgJiYgIWRldi0+ZDJfc3Vw cG9ydCkpCj4gPiA+ICAgICAgICAgICAgICAgcmV0dXJuIC1FSU87Cj4gPiA+Cj4gPiA+ICsgICAg IC8qCj4gPiA+ICsgICAgICAqIGNoZWNrIGlmIHdlIGhhdmUgYSBiYWQgY29tYmluYXRpb24gb2Yg YnJpZGdlIGNvbnRyb2xsZXIgYW5kIG52aWRpYQo+ID4gPiArICAgICAgICAgKiBHUFUsIHNlZSBx dWlya19icm9rZW5fbnZfcnVucG0gZm9yIG1vcmUgaW5mbwo+ID4KPiA+IFdoaXRlc3BhY2UgZGFt YWdlLiAgQ2FwaXRhbGl6ZWQgaW5jb3JyZWN0bHkgKHNlZSBvdGhlciBjb21tZW50cwo+ID4gbmVh cmJ5KS4KPiA+Cj4gPiA+ICsgICAgICAqLwo+ID4gPiArICAgICBpZiAoc3RhdGUgIT0gUENJX0Qw ICYmIGRldi0+YnJva2VuX252X3J1bnBtKQo+ID4gPiArICAgICAgICAgICAgIHJldHVybiAwOwo+ ID4gPiArCj4gPiA+ICAgICAgIHBjaV9yZWFkX2NvbmZpZ193b3JkKGRldiwgZGV2LT5wbV9jYXAg KyBQQ0lfUE1fQ1RSTCwgJnBtY3NyKTsKPiA+ID4KPiA+ID4gICAgICAgLyoKPiA+ID4gZGlmZiAt LWdpdCBhL2RyaXZlcnMvcGNpL3F1aXJrcy5jIGIvZHJpdmVycy9wY2kvcXVpcmtzLmMKPiA+ID4g aW5kZXggNDRjNGFlMWFiZDAwLi4wMDA2YzllMzdiNmYgMTAwNjQ0Cj4gPiA+IC0tLSBhL2RyaXZl cnMvcGNpL3F1aXJrcy5jCj4gPiA+ICsrKyBiL2RyaXZlcnMvcGNpL3F1aXJrcy5jCj4gPiA+IEBA IC01MjY4LDMgKzUyNjgsNTYgQEAgc3RhdGljIHZvaWQgcXVpcmtfcmVzZXRfbGVub3ZvX3RoaW5r cGFkX3A1MF9udmdwdShzdHJ1Y3QgcGNpX2RldiAqcGRldikKPiA+ID4gIERFQ0xBUkVfUENJX0ZJ WFVQX0NMQVNTX0ZJTkFMKFBDSV9WRU5ET1JfSURfTlZJRElBLCAweDEzYjEsCj4gPiA+ICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBQQ0lfQ0xBU1NfRElTUExBWV9WR0EsIDgsCj4gPiA+ICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBxdWlya19yZXNldF9sZW5vdm9fdGhpbmtwYWRfcDUw X252Z3B1KTsKPiA+ID4gKwo+ID4gPiArLyoKPiA+ID4gKyAqIFNvbWUgSW50ZWwgUENJZSBicmlk Z2VzIGNhdXNlIGRldmljZXMgdG8gZGlzYXBwZWFyIGZyb20gdGhlIFBDSWUgYnVzIGFmdGVyCj4g PiA+ICsgKiB0aG9zZSB3ZXJlIHB1dCBpbnRvIEQzY29sZCBzdGF0ZSBpZiB0aGV5IHdlcmUgcHV0 IGludG8gYSBub24gRDAgUENJIFBNCj4gPiA+ICsgKiBkZXZpY2Ugc3RhdGUgYmVmb3JlIGRvaW5n IHNvLgo+ID4KPiA+IEEgZGV2aWNlIGluIEQzY29sZCBpcyBvZmYgdGhlIGJ1cyBieSBkZWZpbml0 aW9uLgo+ID4KPiA+IElJVUMgdGhlIHByb2JsZW0gaXMgdGhhdCB0aGUgc2VxdWVuY2UgRDAgLT4g RDNob3QgLT4gRDNjb2xkIC0+IEQwIGZvcgo+ID4gdGhlIEdQVSBmYWlscyBpbiB0aGUgdHJhbnNp dGlvbiBiYWNrIHRvIEQwLCB3aGlsZSBEMCAtPiBEM2NvbGQgLT4gRDAKPiA+IHdvcmtzIGZpbmUu Cj4gPgo+ID4gU28gSSBndWVzcyB0aGUgcHJvYmxlbSBpcyB0aGF0IHdlIGNhbiBwdXQgdGhlIGRl dmljZSBpbiBEM2NvbGQgd2l0aCBubwo+ID4gcHJvYmxlbSwgYnV0IGlmIHdlIHB1dCBpbiBEM2hv dCBiZWZvcmUgZ29pbmcgdG8gRDNjb2xkLCB0aGUgZGV2aWNlCj4gPiBuZXZlciBjb21lcyBiYWNr IHRvIEQwLiAgUmlnaHQ/Cj4gPgo+IAo+IGNvcnJlY3QuIEl0IEJ5IHRoZSB3YXksIGl0IGRvZXNu J3QgbWF0dGVyIGlmIEkgcHV0IHRoZSBkZXZpY2UgaW50byBEMQo+IGluc3RlYWQsIGFzIGxvbmcg YXMgdGhlIGRldmljZSBpcyBub3QgaW4gRDAgc3RhdGUgYmVmb3JlIHB1dHRpbmcgaXQKPiBpbnRv IEQzY29sZCwgaXQgZmFpbHMuCj4gCj4gPiA+ICsgKiBUaGlzIGxlYWRzIHRvIHZhcmlvdXMgaXNz dWUgZGlmZmVyZW50IGlzc3VlcyB3aGljaCBhbGwgbWFuaWZlc3QgZGlmZmVyZW50bHksCj4gPgo+ ID4gcy9pc3N1ZSBkaWZmZXJlbnQvLwo+ID4KPiA+IEFjdHVhbGx5LCBJIHRoaW5rIHRoZXJlJ3Mg b25seSBvbmUgdW5kZXJseWluZyBpc3N1ZSB3aXRoIHNldmVyYWwKPiA+IG1hbmlmZXN0YXRpb25z Lgo+ID4KPiA+ID4gKyAqIGJ1dCBoYXZlIHRoZSBzYW1lIHJvb3QgY2F1c2U6Cj4gPiA+ICsgKiAg LSBBSU1MIGNvZGUgZXhlY3V0aW9uIGhpdHMgYW4gaW5maW5pdGUgbG9vcCAoYXMgdGhlIGNvZSB3 YWl0cyBvbiBkZXZpY2UKPiA+ID4gKyAqICAgIG1lbW9yeSB0byBjaGFuZ2UpLgo+ID4KPiA+IHMv QUlNTC9BTUwvCj4gPiBzL2NvZS9jb2RlLwo+ID4KPiA+ID4gKyAqICAtIGtlcm5lbCBjcmFzaGVz LCBhcyBhbGwgcGNpIHJlYWRzIHJldHVybiAtMSwgd2hpY2ggbW9zdCBjb2RlIGlzbid0IGFibGUK PiA+ID4gKyAqICAgIHRvIGhhbmRsZSB3ZWxsIGVub3VnaC4KPiA+Cj4gPiBzL3BjaS9QQ0kvCj4g Pgo+ID4gTW9yZSBkZXRhaWxzIGFib3V0IHRoZXNlIGNyYXNoZXMgd291bGQgYmUgdXNlZnVsIGFz IHdlIGxvb2sgYXQgcGxhY2VzCj4gPiB0aGF0ICpzaG91bGQqIGJlIGFibGUgdG8gaGFuZGxlIGVy cm9ycyBsaWtlIHRoaXMuCj4gPgo+IAo+IG1ha2VzIHNlbnNlLCBJIGNvdWxkICxvcnRob2dvbmFs IHRvIHRoaXMsIG1ha2UgdGhlIGNvZGUgbW9yZSByb2J1c3QgaWYKPiB3ZSBoaXQgaXNzdWVzIGxp a2UgdGhpcyBpbiB0aGUgZnV0dXJlLiBXaGF0IEkgYW0gbW9zdGx5IHdvbmRlcmluZwo+IGFib3V0 IGlzLCB3aHkgcGNpIGNvcmUgZG9lc24ndCBnaXZlIHVwIGlmIHRoZSBkZXZpY2UgZG9lc24ndCBj b21lIGJhY2sKPiBmcm9tIEQzY29sZD8gSXQgc291bmRzIGxpa2UsIHRoYXQgdGhlIG1vc3Qgc2Fu ZSB0aGluZyB0byBkbyBoZXJlIGlzIHRvCj4ganVzdCBnaXZlIHVwIGFuZCBmYWlsIHJ1bnRpbWVf cmVzdW1lIGFuZCByZXBvcnQgZXJyb3JzIGJhY2sgdG8KPiB1c2Vyc3BhY2UgdHJ5aW5nIHRvIG1h a2UgdXNlIG9mIHRoZSBkZXZpY2VzLgo+IAo+ID4gPiArICogIC0gc3VkZGVuIHNodXRkb3ducywg YXMgdGhlIGtlcm5lbCBpZGVudGlmaWVkIGFuIHVucmVjb3ZlcmFibGUgZXJyb3IgYWZ0ZXIKPiA+ ID4gKyAqICAgIHVzZXJzcGFjZSB0cmllcyB0byBhY2Nlc3MgdGhlIEdQVS4KPiA+Cj4gPiBUaGlz IGRvZXNuJ3QgZml0IHdpdGggdGhlIG90aGVycyBhbmQgbW9yZSBkZXRhaWxzIG1pZ2h0IGJlCj4g PiBpbmZvcm1hdGl2ZSBoZXJlIGFzIHdlbGwuCj4gPgo+IAo+IHllYWguLiBJIHRyeSB0byBnZXQg bW9yZSBpbmZvcyBvbiB0aGF0LiBCdXQgYXQgbGVhc3QgZm9yIG1lIChhbmQgaXQKPiBtaWdodCBi ZSBhIGRpc3RyaWJ1dGlvbiB0aGluZykgaWYgSSBleGVjdXRlIGxzcGNpLCB0aGUgc3lzdGVtIHNo dXRzCj4gZG93biwgb3IgYXQgbGVhc3QgdHJpZXMgdG8gYW5kIG1pZ2h0IGZhaWwuCj4gCj4gPiA+ ICsgKiBJbiBhbGwgY2FzZXMgZG1lc2cgd2lsbCBjb250YWluIGF0IGxlYXN0IG9uZSBsaW5lIGxp a2UgdGhpczoKPiA+ID4gKyAqICdub3V2ZWF1IDAwMDA6MDE6MDAuMDogUmVmdXNlZCB0byBjaGFu Z2UgcG93ZXIgc3RhdGUsIGN1cnJlbnRseSBpbiBEMycKPiA+ID4gKyAqIGZvbGxvd2VkIGJ5IGEg bG90IG9mIG5vdXZlYXUgdGltZW91dHMuCj4gPiA+ICsgKgo+ID4gPiArICogQUNQSSBjb2RlIHdy aXRlcyBiaXQgMHg4MCB0byB0aGUgbm90IGRvY3VtZW50ZWQgUENJIHJlZ2lzdGVyIDB4MjQ4IG9m IHRoZQo+ID4gPiArICogUENJZSBicmlkZ2UgY29udHJvbGxlciBpbiBvcmRlciB0byBwb3dlciBk b3duIHRoZSBHUFUuCj4gPiA+ICsgKiBOb25ldGhlbGVzcywgdGhlcmUgYXJlIG90aGVyIGNvZGUg cGF0aHMgaW5zaWRlIHRoZSBBQ1BJIGZpcm13YXJlIHdoaWNoIHVzZQo+ID4gPiArICogb3RoZXIg cmVnaXN0ZXJzLCB3aGljaCBzZWVtIHRvIHdvcmsgZmluZToKPiA+ID4gKyAqICAtIDB4YmMgYml0 IDB4MjAgKHB1YmxpY2x5IGF2YWlsYWJsZSBkb2N1bWVudGF0aW9uIGNsYWltcyAncmVzZXJ2ZWQn KQo+ID4gPiArICogIC0gMHhiMCBiaXQgMHgxMCAobGluayBkaXNhYmxlKQo+ID4KPiA+IEFsbCB0 aGVzZSByZWdpc3RlciBhZGRyZXNzZXMgYXJlIGRldmljZS1zcGVjaWZpYywgc28gdGhleSdyZSB1 c2VsZXNzCj4gPiB3aXRob3V0IGlkZW50aWZ5aW5nIHRoZSBkZXZpY2UuICAibHNwY2kgLXZ2bm4i IG91dHB1dCB3b3VsZCBsZXQgdXMgYXQKPiA+IGxlYXN0IGNvbm5lY3QgdGhpcyB3aXRoIHNvbWV0 aGluZy4gIEl0IHdvdWxkIGJlIG5pY2UgdG8gaGF2ZSB0aGF0IGluZm8KPiA+IGFyY2hpdmVkIGFs b25nIHdpdGggeW91ciBhY3BpZHVtcCBhbmQgcHl0aG9uIHJlcHJvIHNjcmlwdHMgaW4gYQo+ID4g YnVnemlsbGEgd2l0aCB0aGUgVVJMIGluIHRoZSBjb21taXQgbG9nLgo+ID4KPiA+IFRoZXNlIGFy ZSBsaWtlbHkgaW4gUENJIGNhcGFiaWxpdGllcy4gIElmIEkgbWFrZSB0aGUgbGVhcCBvZiBhc3N1 bWluZwo+ID4gdGhlICJsaW5rIGRpc2FibGUiIGJpdCBpcyBQQ0lfRVhQX0xOS0NUTF9MRCwgdGhh dCB3b3VsZCBtZWFuIHRoZSBMaW5rCj4gPiBDb250cm9sIHJlZ2lzdGVyIGlzIGF0IDB4YjAgYW5k IHRoZSByZWdpc3RlciBhdCAweGJjIHdvdWxkIGJlIHRoZSBSb290Cj4gPiBDb250cm9sIHJlZ2lz dGVyLCBhbmQgaW5kZWVkIDB4MjAgaW4gUm9vdCBDb250cm9sIGlzIHJlc2VydmVkLgo+ID4KPiA+ IEkgZG9uJ3Qga25vdyB3aGF0IHRoZSByZWxldmFuY2Ugb2YgYWxsIHRoaXMgaXMsIHRob3VnaC4g IEl0J3Mgbm90Cj4gPiByZW1hcmthYmxlIHRoYXQgYWNjZXNzZXMgdG8gdGhlc2UgcmVnaXN0ZXJz IHdvcmsuCj4gPgo+IAo+IHRob3NlIGFyZSByZWdpc3RlcnMgb24gdGhlIGJyaWRnZSBjb250cm9s bGVyIGFuZCBhcmUgdXNpbmcgaW5zaWRlIEFDUEkKPiB0byBwb3dlciBkb3duIHRoZSBsaW5rLiBE ZXBlbmRpbmcgb24gdGhlIE9TIGRldGVjdGVkIG90aGVyIG1ldGhvZHMgYXJlCj4gdXNlZCBhZmFp ay4KPiAKPiA+IFVubGVzcyB5b3UgbWVhbiB5b3UgY2FuIGFjY2VzcyB0aGVzZSByZWdpc3RlcnMg KmFmdGVyKiB0cnlpbmcgdG8gcHV0Cj4gPiB0aGUgZGV2aWNlIGJhY2sgaW4gRDAsIGJ1dCBvdGhl ciBhY2Nlc3NlcyB0byB0aGUgZGV2aWNlIGZhaWwuICBUaGF0Cj4gPiB3b3VsZCBpbmRlZWQgYmUg dmVyeSBpbnRlcmVzdGluZy4KPiA+Cj4gPiA+ICsgKiBDaGFuZ2luZyB0aGUgY29uZGl0aW9ucyBp bnNpZGUgdGhlIGZpcm13YXJlIGJ5IHBva2luZyBpbnRvIHRoZSByZWxldmFudAo+ID4gPiArICog YWRkcmVzc2VzIGRvZXMgcmVzb2x2ZSB0aGUgaXNzdWUsIGJ1dCBpdCBzZWVtZWQgdG8gYmUgQUNQ SSBwcml2YXRlIG1lbW9yeQo+ID4gPiArICogYW5kIG5vdCBhbnkgZGV2aWNlIGFjY2Vzc2libGUg bWVtb3J5IGF0IGFsbCwgc28gdGhlcmUgaXMgbm8gcG9ydGFibGUgd2F5IG9mCj4gPiA+ICsgKiBj aGFuZ2luZyB0aGUgY29uZGl0aW9ucy4KPiA+ID4gKyAqCj4gPiA+ICsgKiBUaGUgb25seSBzeXN0 ZW1zIHdoZXJlIHRoaXMgYmVoYXZpb3IgY2FuIGJlIHNlZW4gYXJlIGh5YnJpZCBncmFwaGljcyBs YXB0b3BzCj4gPiA+ICsgKiB3aXRoIGEgc2Vjb25kYXJ5IE52aWRpYSBQYXNjYWwgR1BVLiBJdCBj YW5ub3QgYmUgcnVsZWQgb3V0IHRoYXQgdGhpcyBpc3N1ZQo+ID4gPiArICogb25seSBvY2N1cnMg aW4gY29tYmluYXRpb24gd2l0aCBsaXN0ZWQgSW50ZWwgUENJZSBicmlkZ2UgY29udHJvbGxlcnMg YW5kCj4gPiA+ICsgKiB0aGUgbWVudGlvbmVkIEdQVXMgb3IgaWYgaXQncyBvbmx5IGEgaHcgYnVn IGluIHRoZSBicmlkZ2UgY29udHJvbGxlci4KPiA+ID4gKyAqCj4gPiA+ICsgKiBCdXQgYmVjYXVz ZSB0aGlzIGlzc3VlIHdhcyBOT1Qgc2VlbiBvbiBsYXB0b3BzIHdpdGggYW4gTnZpZGlhIFBhc2Nh bCBHUFUKPiA+ID4gKyAqIGFuZCBhbiBJbnRlbCBDb2ZmZWUgTGFrZSBTb0MsIHRoZXJlIGlzIGEg aGlnaGVyIGNoYW5jZSBvZiB0aGVyZSBiZWluZyBhIGJ1Zwo+ID4gPiArICogaW4gdGhlIGJyaWRn ZSBjb250cm9sbGVyIHJhdGhlciB0aGFuIGluIHRoZSBHUFUuCj4gPgo+ID4gSSBkb24ndCB0aGlu ayB3ZSBjYW4gY29uY2x1ZGUgYW55dGhpbmcgYWJvdXQgd2hlcmUgdGhlIGRlZmVjdCBpcyBhbmQg SQo+ID4gZG9uJ3QgdGhpbmsgc3BlY3VsYXRpbmcgaGVyZSB3aWxsIGhlbHAgZnV0dXJlIHJlYWRl cnMgb2YgdGhpcyBjb2RlLgo+ID4KPiA+IEkgKndvdWxkKiBzdGlsbCBsaWtlIHRvIHNlZSBhIGJ1 Z3ppbGxhIGxpc3RpbmcgdGhlIHN5c3RlbXMgd2hlcmUgdGhpcwo+ID4gcHJvYmxlbSBoYXMgYmVl biBzZWVuIHdpdGggdGhlICJsc3BjaSAtdnZubiIsIGRtZXNnIGxvZ3MsIGFuZCBhdCBsZWFzdAo+ ID4gb25lIGFjcGlkdW1wLiAgSSB0aGluayB0aGVyZSdzIG1vcmUgdG8gdGhpcyBzdG9yeSwgYW5k IEkgc3VzcGVjdCB3ZQo+ID4gbWF5IGJlIHJldmlzaXRpbmcgdGhpcyBpbiB0aGUgZnV0dXJlLgo+ ID4KPiAKPiBvbmUgYmlnIG9uZSBpcyBodHRwczovL2J1Z3ppbGxhLmtlcm5lbC5vcmcvc2hvd19i dWcuY2dpP2lkPTE1NjM0MSBidXQKPiBpdCdzIGZpbGxlZCB3aXRoIGEgbG90IG9mIGRpZmZlcmVu dCByZXBvcnRzLCBidXQgSSBhbSBzdXJlIG1vc3Qgb2YKPiB0aGVtIHBvaW50IHRvIHRoaXMgdmVy eSBpc3N1ZS4KPiAKPiBTYWRseSBub2JvZHkgdGhvdWdodCBvZiBjaGVja2luZyBsc3BjaSB3aXRo IHJ1bnBtIGRpc2FibGVkLi4gYnV0IEkKPiBjb3VsZCBjaGVjayBmb3Igb3RoZXIgYnVncy4KPiAK PiA+ID4gKyAqIFRoaXMgaXNzdWUgd2FzIG5vdCBhYmxlIHRvIGJlIHJlcHJvZHVjZWQgb24gbm9u IGxhcHRvcCBzeXN0ZW1zLgo+ID4gPiArICovCj4gPiA+ICsKPiA+ID4gK3N0YXRpYyB2b2lkIHF1 aXJrX2Jyb2tlbl9udl9ydW5wbShzdHJ1Y3QgcGNpX2RldiAqZGV2KQo+ID4gPiArewo+ID4gPiAr ICAgICBzdHJ1Y3QgcGNpX2RldiAqYnJpZGdlID0gcGNpX3Vwc3RyZWFtX2JyaWRnZShkZXYpOwo+ ID4gPiArCj4gPiA+ICsgICAgIGlmIChicmlkZ2UtPnZlbmRvciA9PSBQQ0lfVkVORE9SX0lEX0lO VEVMICYmCj4gPiA+ICsgICAgICAgICBicmlkZ2UtPmRldmljZSA9PSAweDE5MDEpCj4gPgo+ID4g cGNpX3Vwc3RyZWFtX2JyaWRnZSgpIG1heSByZXR1cm4gTlVMTCwgc28geW91IG5lZWQKPiA+Cj4g PiAgIGlmIChicmlkZ2UgJiYgYnJpZGdlLT52ZW5kb3IgPT0gUENJX1ZFTkRPUl9JRF9JTlRFTCAu Li4KPiA+Cj4gPiBodHRwczovL2xvcmUua2VybmVsLm9yZy9yLzIwMTkwOTI3MTQ0NDIxLjIyNjA4 LTEta2hlcmJzdEByZWRoYXQuY29tCj4gPiBzYXlzIFNreWxha2UgYW5kIEthYnkgTGFrZSBTb0Nz IGFyZSBhZmZlY3RlZC4gIEJ1dCBoZXJlIHlvdSBvbmx5IGNoZWNrCj4gPiBmb3Igb25lIERldmlj ZSBJRD8KPiA+Cj4gCj4geWVzLCBJIGZvdW5kIHRoaXMgYnJpZGdlIGNvbnRyb2xsZXJzIG9uIHNr eWxha2UgYW5kIGthYnkgbGFrZSBTb0NzLAo+IGJ1dCBJIGNvdWxkIHZlcmlmeSB0aGVyZSBhcmUg c3lzdGVtcyB3aXRoIGEgZGlmZmVyZW50IGFyY2hpdGVjdHVyZQo+ICh1c2luZyB0aGUgIlBDSSBF eHByZXNzIFJvb3QgUG9ydCIgZGV2aWNlcyBpbnN0ZWFkIG9mICJQcm9jZXNzb3IgUENJZQo+IENv bnRyb2xsZXIiKSBkbyBub3Qgc2hvdyB0aGlzIGlzc3VlLCBzbyBJIHRoaW5rIGl0IG1pZ2h0IGlu ZGVlZCBiZQo+IGp1c3QgdGhpcyBvbmUgYnJpZGdlIGNvbnRyb2xsZXIuIEkgY291bGRuJ3QgdmVy aWZ5IHRoaXMgaXNzdWUgb24gYW55Cj4gb3RoZXIgc28gZmFyLgo+IAo+IEJ1dCBJIGNvdWxkIHZl cmlmeSB0aGlzIGlzc3VlIHdpdGggdGhpcyBvbmUgYnJpZGdlIGNvbnRyb2xsZXIgaW4KPiBjb21i aW5hdGlvbiB3aXRoIE1heHdlbGwsIFBhc2NhbCBhbmQgVHVyaW5nIE52aWRpYSBHUFVzLgo+IAo+ ID4gPiArICAgICAgICAgICAgIGRldi0+YnJva2VuX252X3J1bnBtID0gMTsKPiA+ID4gK30KPiA+ ID4gK0RFQ0xBUkVfUENJX0ZJWFVQX0NMQVNTX0ZJTkFMKFBDSV9WRU5ET1JfSURfTlZJRElBLCBQ Q0lfQU5ZX0lELAo+ID4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgUENJX0JBU0VfQ0xB U1NfRElTUExBWSwgMTYsCj4gPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICBxdWlya19i cm9rZW5fbnZfcnVucG0pOwo+ID4gPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9wY2kuaCBi L2luY2x1ZGUvbGludXgvcGNpLmgKPiA+ID4gaW5kZXggYWM4YTZjNGUxNzkyLi45MDNhMGIzYTM5 ZWMgMTAwNjQ0Cj4gPiA+IC0tLSBhL2luY2x1ZGUvbGludXgvcGNpLmgKPiA+ID4gKysrIGIvaW5j bHVkZS9saW51eC9wY2kuaAo+ID4gPiBAQCAtNDE2LDYgKzQxNiw3IEBAIHN0cnVjdCBwY2lfZGV2 IHsKPiA+ID4gICAgICAgdW5zaWduZWQgaW50ICAgIF9fYWVyX2Zpcm13YXJlX2ZpcnN0X3ZhbGlk OjE7Cj4gPiA+ICAgICAgIHVuc2lnbmVkIGludCAgICBfX2Flcl9maXJtd2FyZV9maXJzdDoxOwo+ ID4gPiAgICAgICB1bnNpZ25lZCBpbnQgICAgYnJva2VuX2ludHhfbWFza2luZzoxOyAgLyogSU5U eCBtYXNraW5nIGNhbid0IGJlIHVzZWQgKi8KPiA+ID4gKyAgICAgdW5zaWduZWQgaW50ICAgIGJy b2tlbl9udl9ydW5wbToxOyAgICAgIC8qIHNvbWUgY29tYmluYXRpb25zIG9mIGludGVsIGJyaWRn ZSBjb250cm9sbGVyIGFuZCBudmlkaWEgR1BVcyBicmVhayBydGQzICovCj4gPiA+ICAgICAgIHVu c2lnbmVkIGludCAgICBpb193aW5kb3dfMWs6MTsgICAgICAgICAvKiBJbnRlbCBicmlkZ2UgMUsg SS9PIHdpbmRvd3MgKi8KPiA+ID4gICAgICAgdW5zaWduZWQgaW50ICAgIGlycV9tYW5hZ2VkOjE7 Cj4gPiA+ICAgICAgIHVuc2lnbmVkIGludCAgICBoYXNfc2Vjb25kYXJ5X2xpbms6MTsKPiA+ID4g LS0KPiA+ID4gMi4yMS4wCj4gPiA+Cj4gPgo+IAo+IFdpbGwgc2VuZCBvdXQgYSB2NSBsYXRlciBh ZGRyZXNzaW5nIHlvdSByZXZpZXcuIFRoYW5rcyEKX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlz dHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4v bGlzdGluZm8vZHJpLWRldmVs