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_HELO_NONE,SPF_PASS,URIBL_BLOCKED,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 484A7C31E45 for ; Thu, 13 Jun 2019 20:03:48 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 16F462133D for ; Thu, 13 Jun 2019 20:03:48 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1560456228; bh=p5KoBKCSXKCER3NA/4mUu7NC8BUpmkP2g1h1duOC4iU=; h=Date:From:To:Cc:Subject:References:In-Reply-To:List-ID:From; b=WudvaX260TQUfD/JRCiU1HPJjR24hGfypZcIO0IVsvBWE2BiCgvFG26YN5LTXGx2A Iah6eAbVQ8/OQu6fD2j1G/FGSxh8S1xe8+hxiioMakOvbnEOyhZV5bo2kMnbi/r7f5 3oIctySCCGT6wfevhM5fWGx4R5GBWX8vBfXRabuc= Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726784AbfFMUDr (ORCPT ); Thu, 13 Jun 2019 16:03:47 -0400 Received: from mail.kernel.org ([198.145.29.99]:43400 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726164AbfFMUDr (ORCPT ); Thu, 13 Jun 2019 16:03:47 -0400 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 4CFA12147A; Thu, 13 Jun 2019 20:03:46 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1560456226; bh=p5KoBKCSXKCER3NA/4mUu7NC8BUpmkP2g1h1duOC4iU=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=HX6QcmPg0m8/a1afpgx+O4qLwDTCBlPrS8R5qnYM3UWrFWizgndJK35Qzz5NOf8/3 zj6Ae1FnVbocjTVOCSqxZh+QcyFrc17WK076PBXyghd3uhty8I/WoiMW4aIUagHitn 0xIVUcBtCaDvu+K2SFmue+UQJzGNS3s+0zQebiGI= Date: Thu, 13 Jun 2019 15:03:44 -0500 From: Bjorn Helgaas To: Daniel Drake Cc: linux-pci@vger.kernel.org, linux@endlessm.com, nouveau@lists.freedesktop.org, Lukas Wunner , Aaron Plattner , Peter Wu , Ilia Mirkin , Karol Herbst , Maik Freudenberg , "Rafael J. Wysocki" , Martin =?utf-8?B?TG9wYXTDocWZ?= , zigarrre@gmail.com Subject: Re: [PATCH] PCI: Expose hidden NVIDIA HDA controllers Message-ID: <20190613200344.GI13533@google.com> References: <20190613063514.15317-1-drake@endlessm.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20190613063514.15317-1-drake@endlessm.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 Rafael, Martin, zigarrre] On Thu, Jun 13, 2019 at 02:35:14PM +0800, Daniel Drake wrote: > From: Lukas Wunner > > The integrated HDA controller on Nvidia GPUs can be hidden with a bit in > the GPU's config space. Information about this scheme was provided by > NVIDIA on their forums. > > Many laptops now ship with this device hidden, meaning that Linux users > of affected platforms (where the HDMI connector comes off the NVIDIA GPU) > cannot use HDMI audio functionality. > > Avoid this issue by exposing the HDMI audio device on device enumeration > and resume. > > The GPU and HDA controller are two functions of the same PCI device > (VGA class device on function 0 and audio device on function 1). > The multifunction flag in the GPU's Header Type register is cleared when > the HDA controller is hidden and set if it's exposed, so reread the flag > after exposing the HDA. Is it possible that this works on Windows but not Linux because they handle ACPI hotplug slightly differently? Martin did some nice debug [1] and found that _DSM, _PS0, and _PS3 functions write the config bit at 0x488. The dmesg log [2] from zigarrre seems to show that _OSC failed (which I *think* means we won't use pciehp) and that there's a slot registered by acpiphp. Maybe this works on Windows via an ACPI hotplug event that runs AML to flip the 0x488 bit and rescans the bus? That would make more sense to me than the idea that the Nvidia driver does it. I could imagine the driver flipping the bit, but the bus rescan seems like it would be out of the driver's purview. The dmesg log also shows some _DSM warnings; are these correlated with cable plug/unplug? Is there some acpiphp debug we can turn on to get more visibility into hotplug events and how we handle them? [1] https://bugs.freedesktop.org/show_bug.cgi?id=75985#c32 [2] https://bugs.freedesktop.org/attachment.cgi?id=128640 > According to Ilia Mirkin, the HDA controller is only present from MCP89 > onward, so do not touch config space on older GPUs. > > This quirk is limited to NVIDIA PCI devices with the VGA Controller > device class. This is expected to correspond to product configurations > where the NVIDIA GPU has connectors attached. Other products where the > device class is 3D Controller are expected to correspond to configurations > where the NVIDIA GPU is dedicated (dGPU) and has no connectors. > > It's sensible to avoid exposing the HDA controller on dGPU setups, > especially because we've seen cases where the PCI BARs are not set > up correctly by the platform in this case, causing Linux to log > errors if the device is visible. This assumption of device class > accurately corresponding to product configuration is true for 6 of 6 > laptops recently checked at the Endless lab, and there are also signs of > agreement checking the data from 74 previously tested products, however > Ilia Mirkin comments that he's seen cases where it is not true. Anyway, it > looks like this quirk should fix audio support for the majority of > affected users. > > This commit takes inspiration from an earlier patch by Daniel Drake. > > Link: https://devtalk.nvidia.com/default/topic/1024022 > Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=75985 > Cc: Aaron Plattner > Cc: Peter Wu > Cc: Ilia Mirkin > Cc: Karol Herbst > Cc: Maik Freudenberg > Signed-off-by: Lukas Wunner > Tested-by: Daniel Drake > --- > drivers/pci/quirks.c | 28 ++++++++++++++++++++++++++++ > include/linux/pci_ids.h | 1 + > 2 files changed, 29 insertions(+) > > Submitting Lukas's patch from over a year ago. > > It got held up before on patch dependencies (which are now all merged) > and also the concern around the device class assumption not being true > in all cases. However, there hasn't been any progress towards finding a > better approach, and we don't have any logs to hand from the cases where > this isn't true, so I think we should go with this approach which will > work in the (vast?) majority of cases. > > diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c > index 0f16acc323c6..52046b517e2e 100644 > --- a/drivers/pci/quirks.c > +++ b/drivers/pci/quirks.c > @@ -4971,6 +4971,34 @@ DECLARE_PCI_FIXUP_CLASS_FINAL(PCI_VENDOR_ID_AMD, PCI_ANY_ID, > DECLARE_PCI_FIXUP_CLASS_FINAL(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID, > PCI_CLASS_MULTIMEDIA_HD_AUDIO, 8, quirk_gpu_hda); > > +/* > + * Many laptop BIOSes hide the integrated HDA controller on NVIDIA GPUs > + * via a special bit. This prevents Linux from seeing and using it. > + * Unhide it here. > + * https://devtalk.nvidia.com/default/topic/1024022 > + */ > +static void quirk_nvidia_hda(struct pci_dev *gpu) > +{ > + u8 hdr_type; > + u32 val; > + > + /* there was no integrated HDA controller before MCP89 */ > + if (gpu->device < PCI_DEVICE_ID_NVIDIA_GEFORCE_320M) > + return; > + > + /* bit 25 at offset 0x488 hides or exposes the HDA controller */ > + pci_read_config_dword(gpu, 0x488, &val); > + pci_write_config_dword(gpu, 0x488, val | BIT(25)); > + > + /* the GPU becomes a multifunction device when the HDA is exposed */ > + pci_read_config_byte(gpu, PCI_HEADER_TYPE, &hdr_type); > + gpu->multifunction = !!(hdr_type & BIT(7)); > +} > +DECLARE_PCI_FIXUP_CLASS_HEADER(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID, > + PCI_BASE_CLASS_DISPLAY, 16, quirk_nvidia_hda); > +DECLARE_PCI_FIXUP_CLASS_RESUME_EARLY(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID, > + PCI_BASE_CLASS_DISPLAY, 16, quirk_nvidia_hda); > + > /* > * Some IDT switches incorrectly flag an ACS Source Validation error on > * completions for config read requests even though PCIe r4.0, sec > diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h > index 70e86148cb1e..66898463b81f 100644 > --- a/include/linux/pci_ids.h > +++ b/include/linux/pci_ids.h > @@ -1336,6 +1336,7 @@ > #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP78S_SMBUS 0x0752 > #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP77_IDE 0x0759 > #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP73_SMBUS 0x07D8 > +#define PCI_DEVICE_ID_NVIDIA_GEFORCE_320M 0x08A0 > #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP79_SMBUS 0x0AA2 > #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP89_SATA 0x0D85 > > -- > 2.20.1 > From mboxrd@z Thu Jan 1 00:00:00 1970 From: Bjorn Helgaas Subject: Re: [PATCH] PCI: Expose hidden NVIDIA HDA controllers Date: Thu, 13 Jun 2019 15:03:44 -0500 Message-ID: <20190613200344.GI13533@google.com> References: <20190613063514.15317-1-drake@endlessm.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <20190613063514.15317-1-drake-6IF/jdPJHihWk0Htik3J/w@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: nouveau-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "Nouveau" To: Daniel Drake Cc: Aaron Plattner , linux-pci-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Maik Freudenberg , "Rafael J. Wysocki" , Martin =?utf-8?B?TG9wYXTDocWZ?= , zigarrre-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org, nouveau-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, linux-6IF/jdPJHihWk0Htik3J/w@public.gmane.org List-Id: nouveau.vger.kernel.org WytjYyBSYWZhZWwsIE1hcnRpbiwgemlnYXJycmVdCgpPbiBUaHUsIEp1biAxMywgMjAxOSBhdCAw MjozNToxNFBNICswODAwLCBEYW5pZWwgRHJha2Ugd3JvdGU6Cj4gRnJvbTogTHVrYXMgV3VubmVy IDxsdWthc0B3dW5uZXIuZGU+Cj4gCj4gVGhlIGludGVncmF0ZWQgSERBIGNvbnRyb2xsZXIgb24g TnZpZGlhIEdQVXMgY2FuIGJlIGhpZGRlbiB3aXRoIGEgYml0IGluCj4gdGhlIEdQVSdzIGNvbmZp ZyBzcGFjZS4gSW5mb3JtYXRpb24gYWJvdXQgdGhpcyBzY2hlbWUgd2FzIHByb3ZpZGVkIGJ5Cj4g TlZJRElBIG9uIHRoZWlyIGZvcnVtcy4KPiAKPiBNYW55IGxhcHRvcHMgbm93IHNoaXAgd2l0aCB0 aGlzIGRldmljZSBoaWRkZW4sIG1lYW5pbmcgdGhhdCBMaW51eCB1c2Vycwo+IG9mIGFmZmVjdGVk IHBsYXRmb3JtcyAod2hlcmUgdGhlIEhETUkgY29ubmVjdG9yIGNvbWVzIG9mZiB0aGUgTlZJRElB IEdQVSkKPiBjYW5ub3QgdXNlIEhETUkgYXVkaW8gZnVuY3Rpb25hbGl0eS4KPiAKPiBBdm9pZCB0 aGlzIGlzc3VlIGJ5IGV4cG9zaW5nIHRoZSBIRE1JIGF1ZGlvIGRldmljZSBvbiBkZXZpY2UgZW51 bWVyYXRpb24KPiBhbmQgcmVzdW1lLgo+IAo+IFRoZSBHUFUgYW5kIEhEQSBjb250cm9sbGVyIGFy ZSB0d28gZnVuY3Rpb25zIG9mIHRoZSBzYW1lIFBDSSBkZXZpY2UKPiAoVkdBIGNsYXNzIGRldmlj ZSBvbiBmdW5jdGlvbiAwIGFuZCBhdWRpbyBkZXZpY2Ugb24gZnVuY3Rpb24gMSkuCj4gVGhlIG11 bHRpZnVuY3Rpb24gZmxhZyBpbiB0aGUgR1BVJ3MgSGVhZGVyIFR5cGUgcmVnaXN0ZXIgaXMgY2xl YXJlZCB3aGVuCj4gdGhlIEhEQSBjb250cm9sbGVyIGlzIGhpZGRlbiBhbmQgc2V0IGlmIGl0J3Mg ZXhwb3NlZCwgc28gcmVyZWFkIHRoZSBmbGFnCj4gYWZ0ZXIgZXhwb3NpbmcgdGhlIEhEQS4KCklz IGl0IHBvc3NpYmxlIHRoYXQgdGhpcyB3b3JrcyBvbiBXaW5kb3dzIGJ1dCBub3QgTGludXggYmVj YXVzZSB0aGV5CmhhbmRsZSBBQ1BJIGhvdHBsdWcgc2xpZ2h0bHkgZGlmZmVyZW50bHk/CgpNYXJ0 aW4gZGlkIHNvbWUgbmljZSBkZWJ1ZyBbMV0gYW5kIGZvdW5kIHRoYXQgX0RTTSwgX1BTMCwgYW5k IF9QUzMKZnVuY3Rpb25zIHdyaXRlIHRoZSBjb25maWcgYml0IGF0IDB4NDg4LiAgVGhlIGRtZXNn IGxvZyBbMl0gZnJvbQp6aWdhcnJyZSBzZWVtcyB0byBzaG93IHRoYXQgX09TQyBmYWlsZWQgKHdo aWNoIEkgKnRoaW5rKiBtZWFucyB3ZQp3b24ndCB1c2UgcGNpZWhwKSBhbmQgdGhhdCB0aGVyZSdz IGEgc2xvdCByZWdpc3RlcmVkIGJ5IGFjcGlwaHAuCgpNYXliZSB0aGlzIHdvcmtzIG9uIFdpbmRv d3MgdmlhIGFuIEFDUEkgaG90cGx1ZyBldmVudCB0aGF0IHJ1bnMgQU1MIHRvCmZsaXAgdGhlIDB4 NDg4IGJpdCBhbmQgcmVzY2FucyB0aGUgYnVzPyAgVGhhdCB3b3VsZCBtYWtlIG1vcmUgc2Vuc2Ug dG8KbWUgdGhhbiB0aGUgaWRlYSB0aGF0IHRoZSBOdmlkaWEgZHJpdmVyIGRvZXMgaXQuICBJIGNv dWxkIGltYWdpbmUgdGhlCmRyaXZlciBmbGlwcGluZyB0aGUgYml0LCBidXQgdGhlIGJ1cyByZXNj YW4gc2VlbXMgbGlrZSBpdCB3b3VsZCBiZSBvdXQKb2YgdGhlIGRyaXZlcidzIHB1cnZpZXcuCgpU aGUgZG1lc2cgbG9nIGFsc28gc2hvd3Mgc29tZSBfRFNNIHdhcm5pbmdzOyBhcmUgdGhlc2UgY29y cmVsYXRlZCB3aXRoCmNhYmxlIHBsdWcvdW5wbHVnPyAgSXMgdGhlcmUgc29tZSBhY3BpcGhwIGRl YnVnIHdlIGNhbiB0dXJuIG9uIHRvIGdldAptb3JlIHZpc2liaWxpdHkgaW50byBob3RwbHVnIGV2 ZW50cyBhbmQgaG93IHdlIGhhbmRsZSB0aGVtPwoKWzFdIGh0dHBzOi8vYnVncy5mcmVlZGVza3Rv cC5vcmcvc2hvd19idWcuY2dpP2lkPTc1OTg1I2MzMgpbMl0gaHR0cHM6Ly9idWdzLmZyZWVkZXNr dG9wLm9yZy9hdHRhY2htZW50LmNnaT9pZD0xMjg2NDAKCj4gQWNjb3JkaW5nIHRvIElsaWEgTWly a2luLCB0aGUgSERBIGNvbnRyb2xsZXIgaXMgb25seSBwcmVzZW50IGZyb20gTUNQODkKPiBvbndh cmQsIHNvIGRvIG5vdCB0b3VjaCBjb25maWcgc3BhY2Ugb24gb2xkZXIgR1BVcy4KPiAKPiBUaGlz IHF1aXJrIGlzIGxpbWl0ZWQgdG8gTlZJRElBIFBDSSBkZXZpY2VzIHdpdGggdGhlIFZHQSBDb250 cm9sbGVyCj4gZGV2aWNlIGNsYXNzLiBUaGlzIGlzIGV4cGVjdGVkIHRvIGNvcnJlc3BvbmQgdG8g cHJvZHVjdCBjb25maWd1cmF0aW9ucwo+IHdoZXJlIHRoZSBOVklESUEgR1BVIGhhcyBjb25uZWN0 b3JzIGF0dGFjaGVkLiBPdGhlciBwcm9kdWN0cyB3aGVyZSB0aGUKPiBkZXZpY2UgY2xhc3MgaXMg M0QgQ29udHJvbGxlciBhcmUgZXhwZWN0ZWQgdG8gY29ycmVzcG9uZCB0byBjb25maWd1cmF0aW9u cwo+IHdoZXJlIHRoZSBOVklESUEgR1BVIGlzIGRlZGljYXRlZCAoZEdQVSkgYW5kIGhhcyBubyBj b25uZWN0b3JzLgo+IAo+IEl0J3Mgc2Vuc2libGUgdG8gYXZvaWQgZXhwb3NpbmcgdGhlIEhEQSBj b250cm9sbGVyIG9uIGRHUFUgc2V0dXBzLAo+IGVzcGVjaWFsbHkgYmVjYXVzZSB3ZSd2ZSBzZWVu IGNhc2VzIHdoZXJlIHRoZSBQQ0kgQkFScyBhcmUgbm90IHNldAo+IHVwIGNvcnJlY3RseSBieSB0 aGUgcGxhdGZvcm0gaW4gdGhpcyBjYXNlLCBjYXVzaW5nIExpbnV4IHRvIGxvZwo+IGVycm9ycyBp ZiB0aGUgZGV2aWNlIGlzIHZpc2libGUuIFRoaXMgYXNzdW1wdGlvbiBvZiBkZXZpY2UgY2xhc3MK PiBhY2N1cmF0ZWx5IGNvcnJlc3BvbmRpbmcgdG8gcHJvZHVjdCBjb25maWd1cmF0aW9uIGlzIHRy dWUgZm9yIDYgb2YgNgo+IGxhcHRvcHMgcmVjZW50bHkgY2hlY2tlZCBhdCB0aGUgRW5kbGVzcyBs YWIsIGFuZCB0aGVyZSBhcmUgYWxzbyBzaWducyBvZgo+IGFncmVlbWVudCBjaGVja2luZyB0aGUg ZGF0YSBmcm9tIDc0IHByZXZpb3VzbHkgdGVzdGVkIHByb2R1Y3RzLCBob3dldmVyCj4gSWxpYSBN aXJraW4gY29tbWVudHMgdGhhdCBoZSdzIHNlZW4gY2FzZXMgd2hlcmUgaXQgaXMgbm90IHRydWUu IEFueXdheSwgaXQKPiBsb29rcyBsaWtlIHRoaXMgcXVpcmsgc2hvdWxkIGZpeCBhdWRpbyBzdXBw b3J0IGZvciB0aGUgbWFqb3JpdHkgb2YKPiBhZmZlY3RlZCB1c2Vycy4KPiAKPiBUaGlzIGNvbW1p dCB0YWtlcyBpbnNwaXJhdGlvbiBmcm9tIGFuIGVhcmxpZXIgcGF0Y2ggYnkgRGFuaWVsIERyYWtl Lgo+IAo+IExpbms6IGh0dHBzOi8vZGV2dGFsay5udmlkaWEuY29tL2RlZmF1bHQvdG9waWMvMTAy NDAyMgo+IEJ1Z3ppbGxhOiBodHRwczovL2J1Z3MuZnJlZWRlc2t0b3Aub3JnL3Nob3dfYnVnLmNn aT9pZD03NTk4NQo+IENjOiBBYXJvbiBQbGF0dG5lciA8YXBsYXR0bmVyQG52aWRpYS5jb20+Cj4g Q2M6IFBldGVyIFd1IDxwZXRlckBsZWtlbnN0ZXluLm5sPgo+IENjOiBJbGlhIE1pcmtpbiA8aW1p cmtpbkBhbHVtLm1pdC5lZHU+Cj4gQ2M6IEthcm9sIEhlcmJzdCA8a2hlcmJzdEByZWRoYXQuY29t Pgo+IENjOiBNYWlrIEZyZXVkZW5iZXJnIDxoaGZldWVyQGdteC5kZT4KPiBTaWduZWQtb2ZmLWJ5 OiBMdWthcyBXdW5uZXIgPGx1a2FzQHd1bm5lci5kZT4KPiBUZXN0ZWQtYnk6IERhbmllbCBEcmFr ZSA8ZHJha2VAZW5kbGVzc20uY29tPgo+IC0tLQo+ICBkcml2ZXJzL3BjaS9xdWlya3MuYyAgICB8 IDI4ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysKPiAgaW5jbHVkZS9saW51eC9wY2lfaWRz LmggfCAgMSArCj4gIDIgZmlsZXMgY2hhbmdlZCwgMjkgaW5zZXJ0aW9ucygrKQo+IAo+IFN1Ym1p dHRpbmcgTHVrYXMncyBwYXRjaCBmcm9tIG92ZXIgYSB5ZWFyIGFnby4KPiAKPiBJdCBnb3QgaGVs ZCB1cCBiZWZvcmUgb24gcGF0Y2ggZGVwZW5kZW5jaWVzICh3aGljaCBhcmUgbm93IGFsbCBtZXJn ZWQpCj4gYW5kIGFsc28gdGhlIGNvbmNlcm4gYXJvdW5kIHRoZSBkZXZpY2UgY2xhc3MgYXNzdW1w dGlvbiBub3QgYmVpbmcgdHJ1ZQo+IGluIGFsbCBjYXNlcy4gSG93ZXZlciwgdGhlcmUgaGFzbid0 IGJlZW4gYW55IHByb2dyZXNzIHRvd2FyZHMgZmluZGluZyBhCj4gYmV0dGVyIGFwcHJvYWNoLCBh bmQgd2UgZG9uJ3QgaGF2ZSBhbnkgbG9ncyB0byBoYW5kIGZyb20gdGhlIGNhc2VzIHdoZXJlCj4g dGhpcyBpc24ndCB0cnVlLCBzbyBJIHRoaW5rIHdlIHNob3VsZCBnbyB3aXRoIHRoaXMgYXBwcm9h Y2ggd2hpY2ggd2lsbAo+IHdvcmsgaW4gdGhlICh2YXN0PykgbWFqb3JpdHkgb2YgY2FzZXMuCj4g Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNpL3F1aXJrcy5jIGIvZHJpdmVycy9wY2kvcXVpcmtz LmMKPiBpbmRleCAwZjE2YWNjMzIzYzYuLjUyMDQ2YjUxN2UyZSAxMDA2NDQKPiAtLS0gYS9kcml2 ZXJzL3BjaS9xdWlya3MuYwo+ICsrKyBiL2RyaXZlcnMvcGNpL3F1aXJrcy5jCj4gQEAgLTQ5NzEs NiArNDk3MSwzNCBAQCBERUNMQVJFX1BDSV9GSVhVUF9DTEFTU19GSU5BTChQQ0lfVkVORE9SX0lE X0FNRCwgUENJX0FOWV9JRCwKPiAgREVDTEFSRV9QQ0lfRklYVVBfQ0xBU1NfRklOQUwoUENJX1ZF TkRPUl9JRF9OVklESUEsIFBDSV9BTllfSUQsCj4gIAkJCSAgICAgIFBDSV9DTEFTU19NVUxUSU1F RElBX0hEX0FVRElPLCA4LCBxdWlya19ncHVfaGRhKTsKPiAgCj4gKy8qCj4gKyAqIE1hbnkgbGFw dG9wIEJJT1NlcyBoaWRlIHRoZSBpbnRlZ3JhdGVkIEhEQSBjb250cm9sbGVyIG9uIE5WSURJQSBH UFVzCj4gKyAqIHZpYSBhIHNwZWNpYWwgYml0LiBUaGlzIHByZXZlbnRzIExpbnV4IGZyb20gc2Vl aW5nIGFuZCB1c2luZyBpdC4KPiArICogVW5oaWRlIGl0IGhlcmUuCj4gKyAqIGh0dHBzOi8vZGV2 dGFsay5udmlkaWEuY29tL2RlZmF1bHQvdG9waWMvMTAyNDAyMgo+ICsgKi8KPiArc3RhdGljIHZv aWQgcXVpcmtfbnZpZGlhX2hkYShzdHJ1Y3QgcGNpX2RldiAqZ3B1KQo+ICt7Cj4gKwl1OCBoZHJf dHlwZTsKPiArCXUzMiB2YWw7Cj4gKwo+ICsJLyogdGhlcmUgd2FzIG5vIGludGVncmF0ZWQgSERB IGNvbnRyb2xsZXIgYmVmb3JlIE1DUDg5ICovCj4gKwlpZiAoZ3B1LT5kZXZpY2UgPCBQQ0lfREVW SUNFX0lEX05WSURJQV9HRUZPUkNFXzMyME0pCj4gKwkJcmV0dXJuOwo+ICsKPiArCS8qIGJpdCAy NSBhdCBvZmZzZXQgMHg0ODggaGlkZXMgb3IgZXhwb3NlcyB0aGUgSERBIGNvbnRyb2xsZXIgKi8K PiArCXBjaV9yZWFkX2NvbmZpZ19kd29yZChncHUsIDB4NDg4LCAmdmFsKTsKPiArCXBjaV93cml0 ZV9jb25maWdfZHdvcmQoZ3B1LCAweDQ4OCwgdmFsIHwgQklUKDI1KSk7Cj4gKwo+ICsJLyogdGhl IEdQVSBiZWNvbWVzIGEgbXVsdGlmdW5jdGlvbiBkZXZpY2Ugd2hlbiB0aGUgSERBIGlzIGV4cG9z ZWQgKi8KPiArCXBjaV9yZWFkX2NvbmZpZ19ieXRlKGdwdSwgUENJX0hFQURFUl9UWVBFLCAmaGRy X3R5cGUpOwo+ICsJZ3B1LT5tdWx0aWZ1bmN0aW9uID0gISEoaGRyX3R5cGUgJiBCSVQoNykpOwo+ ICt9Cj4gK0RFQ0xBUkVfUENJX0ZJWFVQX0NMQVNTX0hFQURFUihQQ0lfVkVORE9SX0lEX05WSURJ QSwgUENJX0FOWV9JRCwKPiArCQkJICAgICAgIFBDSV9CQVNFX0NMQVNTX0RJU1BMQVksIDE2LCBx dWlya19udmlkaWFfaGRhKTsKPiArREVDTEFSRV9QQ0lfRklYVVBfQ0xBU1NfUkVTVU1FX0VBUkxZ KFBDSV9WRU5ET1JfSURfTlZJRElBLCBQQ0lfQU5ZX0lELAo+ICsJCQkgICAgICAgUENJX0JBU0Vf Q0xBU1NfRElTUExBWSwgMTYsIHF1aXJrX252aWRpYV9oZGEpOwo+ICsKPiAgLyoKPiAgICogU29t ZSBJRFQgc3dpdGNoZXMgaW5jb3JyZWN0bHkgZmxhZyBhbiBBQ1MgU291cmNlIFZhbGlkYXRpb24g ZXJyb3Igb24KPiAgICogY29tcGxldGlvbnMgZm9yIGNvbmZpZyByZWFkIHJlcXVlc3RzIGV2ZW4g dGhvdWdoIFBDSWUgcjQuMCwgc2VjCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcGNpX2lk cy5oIGIvaW5jbHVkZS9saW51eC9wY2lfaWRzLmgKPiBpbmRleCA3MGU4NjE0OGNiMWUuLjY2ODk4 NDYzYjgxZiAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2xpbnV4L3BjaV9pZHMuaAo+ICsrKyBiL2lu Y2x1ZGUvbGludXgvcGNpX2lkcy5oCj4gQEAgLTEzMzYsNiArMTMzNiw3IEBACj4gICNkZWZpbmUg UENJX0RFVklDRV9JRF9OVklESUFfTkZPUkNFX01DUDc4U19TTUJVUyAgICAweDA3NTIKPiAgI2Rl ZmluZSBQQ0lfREVWSUNFX0lEX05WSURJQV9ORk9SQ0VfTUNQNzdfSURFICAgICAgIDB4MDc1OQo+ ICAjZGVmaW5lIFBDSV9ERVZJQ0VfSURfTlZJRElBX05GT1JDRV9NQ1A3M19TTUJVUyAgICAgMHgw N0Q4Cj4gKyNkZWZpbmUgUENJX0RFVklDRV9JRF9OVklESUFfR0VGT1JDRV8zMjBNICAgICAgICAg ICAweDA4QTAKPiAgI2RlZmluZSBQQ0lfREVWSUNFX0lEX05WSURJQV9ORk9SQ0VfTUNQNzlfU01C VVMgICAgIDB4MEFBMgo+ICAjZGVmaW5lIFBDSV9ERVZJQ0VfSURfTlZJRElBX05GT1JDRV9NQ1A4 OV9TQVRBCSAgICAweDBEODUKPiAgCj4gLS0gCj4gMi4yMC4xCj4gCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCk5vdXZlYXUgbWFpbGluZyBsaXN0Ck5vdXZl YXVAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21h aWxtYW4vbGlzdGluZm8vbm91dmVhdQ==