From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from hygieia.santi-shop.eu ([78.46.175.2]:60105 "EHLO hygieia.santi-shop.eu" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751407AbaENUxS convert rfc822-to-8bit (ORCPT ); Wed, 14 May 2014 16:53:18 -0400 Date: Wed, 14 May 2014 22:43:39 +0200 From: Bruno =?UTF-8?B?UHLDqW1vbnQ=?= To: Bjorn Helgaas Cc: DRI mailing list , Linux PCI , Dave Airlie Subject: [Patch] x86, ia64, efifb: Move boot_vga fixup from pci to vgaarb Message-ID: <20140514224339.7f8be3a9@neptune.home> Mime-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Sender: linux-pci-owner@vger.kernel.org List-ID: With commit b4aa0163056b6c70029b6e8619ce07c274351f42 Matthew Garret introduced a efifb vga_default_device() so that EFI systems that do not load shadow VBIOS or setup VGA get proper value for boot_vga PCI sysfs attribute on the corresponding PCI device. Xorg is refusing to autodetect devices when boot_vga=0 which is the case on some EFI system (e.g. MacBookAir2,1). Xorg detects the GPU and finds the dri device but then bails out with "no devices detected". With introduction of sysfb/simplefb/simpledrm efifb is getting obsolete while having native drivers for the GPU also makes selecting sysfb/efifb optional. Remove the efifb implementation of vga_default_device() and initialize vgaarb's vga_default_device() with the PCI GPU that matches boot screen_info in pci_fixup_video() [x86 and ia64 pci_fixup_video merged into common function in vgaarb.c]. Other architectures with PCI GPU might need a similar fixup. Note: If CONFIG_VGA_ARB is unset vga_default_device() is only available as a stub that returns NULL, making this adjustment insufficient. In addition, with the merge of x86/ia64 fixup code, this would also result in disabled fixup. Unsetting CONFIG_VGA_ARB requires CONFIG_EXPERT=y though. Signed-off-by: Bruno Prémont --- This is ported to changes in pci/fixup.c that landed in 3.15-rcs. Is this fine to go in, if so who will take it? I got no feedback on my last respin (on top of 3.14 a couple of weeks ago, which added moving the ia64 pci boot_vga fixup). I've been running this revision for a week or so on 3.15-rc kernels here (mostly EFI-enabled system, the mentioned MBA as wells as non-Apple systems where the patch was not required). arch/ia64/pci/fixup.c | 56 ++------------------------------- arch/x86/include/asm/vga.h | 6 ---- arch/x86/pci/fixup.c | 55 +-------------------------------- drivers/gpu/vga/vgaarb.c | 75 +++++++++++++++++++++++++++++++++++++++++++++ drivers/video/fbdev/efifb.c | 38 ----------------------- include/linux/vgaarb.h | 37 ++++++++++++++++++++++ 6 files changed, 116 insertions(+), 151 deletions(-) diff --git a/arch/ia64/pci/fixup.c b/arch/ia64/pci/fixup.c index eee069a..5df22f9 100644 --- a/arch/ia64/pci/fixup.c +++ b/arch/ia64/pci/fixup.c @@ -9,64 +9,14 @@ #include -/* - * Fixup to mark boot BIOS video selected by BIOS before it changes - * - * From information provided by "Jon Smirl" - * - * The standard boot ROM sequence for an x86 machine uses the BIOS - * to select an initial video card for boot display. This boot video - * card will have it's BIOS copied to C0000 in system RAM. - * IORESOURCE_ROM_SHADOW is used to associate the boot video - * card with this copy. On laptops this copy has to be used since - * the main ROM may be compressed or combined with another image. - * See pci_map_rom() for use of this flag. Before marking the device - * with IORESOURCE_ROM_SHADOW check if a vga_default_device is already set - * by either arch cde or vga-arbitration, if so only apply the fixup to this - * already determined primary video card. - */ - -static void pci_fixup_video(struct pci_dev *pdev) +static void pci_ia64_fixup_video(struct pci_dev *pdev) { - struct pci_dev *bridge; - struct pci_bus *bus; - u16 config; - if ((strcmp(ia64_platform_name, "dig") != 0) && (strcmp(ia64_platform_name, "hpzx1") != 0)) return; /* Maybe, this machine supports legacy memory map. */ - /* Is VGA routed to us? */ - bus = pdev->bus; - while (bus) { - bridge = bus->self; - - /* - * From information provided by - * "David Miller" - * The bridge control register is valid for PCI header - * type BRIDGE, or CARDBUS. Host to PCI controllers use - * PCI header type NORMAL. - */ - if (bridge - &&((bridge->hdr_type == PCI_HEADER_TYPE_BRIDGE) - ||(bridge->hdr_type == PCI_HEADER_TYPE_CARDBUS))) { - pci_read_config_word(bridge, PCI_BRIDGE_CONTROL, - &config); - if (!(config & PCI_BRIDGE_CTL_VGA)) - return; - } - bus = bus->parent; - } - if (!vga_default_device() || pdev == vga_default_device()) { - pci_read_config_word(pdev, PCI_COMMAND, &config); - if (config & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY)) { - pdev->resource[PCI_ROM_RESOURCE].flags |= IORESOURCE_ROM_SHADOW; - dev_printk(KERN_DEBUG, &pdev->dev, "Boot video device\n"); - vga_set_default_device(pdev); - } - } + pci_fixup_video(pdev); } DECLARE_PCI_FIXUP_CLASS_FINAL(PCI_ANY_ID, PCI_ANY_ID, - PCI_CLASS_DISPLAY_VGA, 8, pci_fixup_video); + PCI_CLASS_DISPLAY_VGA, 8, pci_ia64_fixup_video); diff --git a/arch/x86/include/asm/vga.h b/arch/x86/include/asm/vga.h index 44282fb..c4b9dc2 100644 --- a/arch/x86/include/asm/vga.h +++ b/arch/x86/include/asm/vga.h @@ -17,10 +17,4 @@ #define vga_readb(x) (*(x)) #define vga_writeb(x, y) (*(y) = (x)) -#ifdef CONFIG_FB_EFI -#define __ARCH_HAS_VGA_DEFAULT_DEVICE -extern struct pci_dev *vga_default_device(void); -extern void vga_set_default_device(struct pci_dev *pdev); -#endif - #endif /* _ASM_X86_VGA_H */ diff --git a/arch/x86/pci/fixup.c b/arch/x86/pci/fixup.c index 94ae9ae..b599847 100644 --- a/arch/x86/pci/fixup.c +++ b/arch/x86/pci/fixup.c @@ -302,60 +302,7 @@ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_MCH_PB1, pcie_r DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_MCH_PC, pcie_rootport_aspm_quirk); DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_MCH_PC1, pcie_rootport_aspm_quirk); -/* - * Fixup to mark boot BIOS video selected by BIOS before it changes - * - * From information provided by "Jon Smirl" - * - * The standard boot ROM sequence for an x86 machine uses the BIOS - * to select an initial video card for boot display. This boot video - * card will have it's BIOS copied to C0000 in system RAM. - * IORESOURCE_ROM_SHADOW is used to associate the boot video - * card with this copy. On laptops this copy has to be used since - * the main ROM may be compressed or combined with another image. - * See pci_map_rom() for use of this flag. Before marking the device - * with IORESOURCE_ROM_SHADOW check if a vga_default_device is already set - * by either arch cde or vga-arbitration, if so only apply the fixup to this - * already determined primary video card. - */ - -static void pci_fixup_video(struct pci_dev *pdev) -{ - struct pci_dev *bridge; - struct pci_bus *bus; - u16 config; - - /* Is VGA routed to us? */ - bus = pdev->bus; - while (bus) { - bridge = bus->self; - - /* - * From information provided by - * "David Miller" - * The bridge control register is valid for PCI header - * type BRIDGE, or CARDBUS. Host to PCI controllers use - * PCI header type NORMAL. - */ - if (bridge - && ((bridge->hdr_type == PCI_HEADER_TYPE_BRIDGE) - || (bridge->hdr_type == PCI_HEADER_TYPE_CARDBUS))) { - pci_read_config_word(bridge, PCI_BRIDGE_CONTROL, - &config); - if (!(config & PCI_BRIDGE_CTL_VGA)) - return; - } - bus = bus->parent; - } - if (!vga_default_device() || pdev == vga_default_device()) { - pci_read_config_word(pdev, PCI_COMMAND, &config); - if (config & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY)) { - pdev->resource[PCI_ROM_RESOURCE].flags |= IORESOURCE_ROM_SHADOW; - dev_printk(KERN_DEBUG, &pdev->dev, "Boot video device\n"); - vga_set_default_device(pdev); - } - } -} +/* pci_fixup_video shared in vgaarb.c */ DECLARE_PCI_FIXUP_CLASS_FINAL(PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA, 8, pci_fixup_video); diff --git a/drivers/gpu/vga/vgaarb.c b/drivers/gpu/vga/vgaarb.c index af02597..f0fbdf6 100644 --- a/drivers/gpu/vga/vgaarb.c +++ b/drivers/gpu/vga/vgaarb.c @@ -149,6 +149,81 @@ void vga_set_default_device(struct pci_dev *pdev) } #endif +/* + * Fixup to mark boot BIOS video selected by BIOS before it changes + * + * From information provided by "Jon Smirl" + * + * The standard boot ROM sequence for an x86 machine uses the BIOS + * to select an initial video card for boot display. This boot video + * card will have it's BIOS copied to C0000 in system RAM. + * IORESOURCE_ROM_SHADOW is used to associate the boot video + * card with this copy. On laptops this copy has to be used since + * the main ROM may be compressed or combined with another image. + * See pci_map_rom() for use of this flag. Before marking the device + * with IORESOURCE_ROM_SHADOW check if a vga_default_device is already set + * by either arch cde or vga-arbitration, if so only apply the fixup to this + * already determined primary video card. + */ + +void pci_fixup_video(struct pci_dev *pdev) +{ + struct pci_dev *bridge; + struct pci_bus *bus; + u16 config; + + if (!vga_default_device()) { + resource_size_t start, end; + int i; + + for (i=0; i < DEVICE_COUNT_RESOURCE; i++) { + if (!(pci_resource_flags(pdev, i) & IORESOURCE_MEM)) + continue; + + start = pci_resource_start(pdev, i); + end = pci_resource_end(pdev, i); + + if (!start || !end) + continue; + + if (screen_info.lfb_base >= start && + (screen_info.lfb_base + screen_info.lfb_size) < end) + vga_set_default_device(pdev); + } + } + + /* Is VGA routed to us? */ + bus = pdev->bus; + while (bus) { + bridge = bus->self; + + /* + * From information provided by + * "David Miller" + * The bridge control register is valid for PCI header + * type BRIDGE, or CARDBUS. Host to PCI controllers use + * PCI header type NORMAL. + */ + if (bridge + && ((bridge->hdr_type == PCI_HEADER_TYPE_BRIDGE) + || (bridge->hdr_type == PCI_HEADER_TYPE_CARDBUS))) { + pci_read_config_word(bridge, PCI_BRIDGE_CONTROL, + &config); + if (!(config & PCI_BRIDGE_CTL_VGA)) + return; + } + bus = bus->parent; + } + if (!vga_default_device() || pdev == vga_default_device()) { + pci_read_config_word(pdev, PCI_COMMAND, &config); + if (config & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY)) { + pdev->resource[PCI_ROM_RESOURCE].flags |= IORESOURCE_ROM_SHADOW; + dev_printk(KERN_DEBUG, &pdev->dev, "Boot video device\n"); + vga_set_default_device(pdev); + } + } +} + static inline void vga_irq_set_state(struct vga_device *vgadev, bool state) { if (vgadev->irq_set_state) diff --git a/drivers/video/fbdev/efifb.c b/drivers/video/fbdev/efifb.c index ae9618f..a033180 100644 --- a/drivers/video/fbdev/efifb.c +++ b/drivers/video/fbdev/efifb.c @@ -19,8 +19,6 @@ static bool request_mem_succeeded = false; -static struct pci_dev *default_vga; - static struct fb_var_screeninfo efifb_defined = { .activate = FB_ACTIVATE_NOW, .height = -1, @@ -84,18 +82,6 @@ static struct fb_ops efifb_ops = { .fb_imageblit = cfb_imageblit, }; -struct pci_dev *vga_default_device(void) -{ - return default_vga; -} - -EXPORT_SYMBOL_GPL(vga_default_device); - -void vga_set_default_device(struct pci_dev *pdev) -{ - default_vga = pdev; -} - static int efifb_setup(char *options) { char *this_opt; @@ -126,30 +112,6 @@ static int efifb_setup(char *options) } } - for_each_pci_dev(dev) { - int i; - - if ((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA) - continue; - - for (i=0; i < DEVICE_COUNT_RESOURCE; i++) { - resource_size_t start, end; - - if (!(pci_resource_flags(dev, i) & IORESOURCE_MEM)) - continue; - - start = pci_resource_start(dev, i); - end = pci_resource_end(dev, i); - - if (!start || !end) - continue; - - if (screen_info.lfb_base >= start && - (screen_info.lfb_base + screen_info.lfb_size) < end) - default_vga = dev; - } - } - return 0; } diff --git a/include/linux/vgaarb.h b/include/linux/vgaarb.h index 2c02f3a..6518460 100644 --- a/include/linux/vgaarb.h +++ b/include/linux/vgaarb.h @@ -162,6 +162,43 @@ extern void vga_put(struct pci_dev *pdev, unsigned int rsrc); #define vga_put(pdev, rsrc) #endif +/** + * pci_fixup_video + * + * This can be called by arch PCI to fixup boot VGA tagging + * of VGA PCI devices (e.g. for X86, IA64) + * + * This code was initially spread/duplicated across: + * - X86 PCI-fixup + * - IA64 PCI-fixup + * - EFI_FB + * + * * PCI-fixup part: + * Fixup to mark boot BIOS video selected by BIOS before it changes + * + * From information provided by "Jon Smirl" + * + * The standard boot ROM sequence for an x86 machine uses the BIOS + * to select an initial video card for boot display. This boot video + * card will have it's BIOS copied to C0000 in system RAM. + * IORESOURCE_ROM_SHADOW is used to associate the boot video + * card with this copy. On laptops this copy has to be used since + * the main ROM may be compressed or combined with another image. + * See pci_map_rom() for use of this flag. IORESOURCE_ROM_SHADOW + * is marked here since the boot video device will be the only enabled + * video device at this point. + * + * * EFI_FB part: + * Some EFI-based system (e.g. Intel-Macs from Apple) do not setup + * shadow Video-BIOS and thus can only be detected by framebuffer + * IO memory range. Flag the corresponding GPU as boot_vga. + */ + +#if defined(CONFIG_VGA_ARB) +void pci_fixup_video(struct pci_dev *pdev); +#else +static inline void pci_fixup_video(struct pci_dev *pdev) { } +#endif /** * vga_default_device From mboxrd@z Thu Jan 1 00:00:00 1970 From: Bruno =?UTF-8?B?UHLDqW1vbnQ=?= Subject: [Patch] x86, ia64, efifb: Move boot_vga fixup from pci to vgaarb Date: Wed, 14 May 2014 22:43:39 +0200 Message-ID: <20140514224339.7f8be3a9@neptune.home> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from hygieia.santi-shop.eu (hygieia.santi-shop.eu [78.46.175.2]) by gabe.freedesktop.org (Postfix) with ESMTP id 1636B6E696 for ; Wed, 14 May 2014 13:53:17 -0700 (PDT) List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Bjorn Helgaas Cc: Linux PCI , DRI mailing list List-Id: dri-devel@lists.freedesktop.org V2l0aCBjb21taXQgYjRhYTAxNjMwNTZiNmM3MDAyOWI2ZTg2MTljZTA3YzI3NDM1MWY0MiBNYXR0 aGV3IEdhcnJldAppbnRyb2R1Y2VkIGEgZWZpZmIgdmdhX2RlZmF1bHRfZGV2aWNlKCkgc28gdGhh dCBFRkkgc3lzdGVtcyB0aGF0IGRvIG5vdApsb2FkIHNoYWRvdyBWQklPUyBvciBzZXR1cCBWR0Eg Z2V0IHByb3BlciB2YWx1ZSBmb3IgYm9vdF92Z2EgUENJIHN5c2ZzCmF0dHJpYnV0ZSBvbiB0aGUg Y29ycmVzcG9uZGluZyBQQ0kgZGV2aWNlLgoKWG9yZyBpcyByZWZ1c2luZyB0byBhdXRvZGV0ZWN0 IGRldmljZXMgd2hlbiBib290X3ZnYT0wIHdoaWNoIGlzIHRoZSBjYXNlCm9uIHNvbWUgRUZJIHN5 c3RlbSAoZS5nLiBNYWNCb29rQWlyMiwxKS4gWG9yZyBkZXRlY3RzIHRoZSBHUFUgYW5kIGZpbmRz CnRoZSBkcmkgZGV2aWNlIGJ1dCB0aGVuIGJhaWxzIG91dCB3aXRoICJubyBkZXZpY2VzIGRldGVj dGVkIi4KCldpdGggaW50cm9kdWN0aW9uIG9mIHN5c2ZiL3NpbXBsZWZiL3NpbXBsZWRybSBlZmlm YiBpcyBnZXR0aW5nIG9ic29sZXRlCndoaWxlIGhhdmluZyBuYXRpdmUgZHJpdmVycyBmb3IgdGhl IEdQVSBhbHNvIG1ha2VzIHNlbGVjdGluZwpzeXNmYi9lZmlmYiBvcHRpb25hbC4KClJlbW92ZSB0 aGUgZWZpZmIgaW1wbGVtZW50YXRpb24gb2YgdmdhX2RlZmF1bHRfZGV2aWNlKCkgYW5kIGluaXRp YWxpemUKdmdhYXJiJ3MgdmdhX2RlZmF1bHRfZGV2aWNlKCkgd2l0aCB0aGUgUENJIEdQVSB0aGF0 IG1hdGNoZXMgYm9vdApzY3JlZW5faW5mbyBpbiBwY2lfZml4dXBfdmlkZW8oKSBbeDg2IGFuZCBp YTY0IHBjaV9maXh1cF92aWRlbyBtZXJnZWQKaW50byBjb21tb24gZnVuY3Rpb24gaW4gdmdhYXJi LmNdLgoKT3RoZXIgYXJjaGl0ZWN0dXJlcyB3aXRoIFBDSSBHUFUgbWlnaHQgbmVlZCBhIHNpbWls YXIgZml4dXAuCgpOb3RlOiBJZiBDT05GSUdfVkdBX0FSQiBpcyB1bnNldCB2Z2FfZGVmYXVsdF9k ZXZpY2UoKSBpcyBvbmx5IGF2YWlsYWJsZQogICAgICBhcyBhIHN0dWIgdGhhdCByZXR1cm5zIE5V TEwsIG1ha2luZyB0aGlzIGFkanVzdG1lbnQgaW5zdWZmaWNpZW50LgogICAgICBJbiBhZGRpdGlv biwgd2l0aCB0aGUgbWVyZ2Ugb2YgeDg2L2lhNjQgZml4dXAgY29kZSwgdGhpcyB3b3VsZAogICAg ICBhbHNvIHJlc3VsdCBpbiBkaXNhYmxlZCBmaXh1cC4KICAgICAgVW5zZXR0aW5nIENPTkZJR19W R0FfQVJCIHJlcXVpcmVzIENPTkZJR19FWFBFUlQ9eSB0aG91Z2guCgpTaWduZWQtb2ZmLWJ5OiBC cnVubyBQcsOpbW9udCA8Ym9uYm9uc0BsaW51eC12c2VydmVyLm9yZz4KLS0tClRoaXMgaXMgcG9y dGVkIHRvIGNoYW5nZXMgaW4gcGNpL2ZpeHVwLmMgdGhhdCBsYW5kZWQgaW4gMy4xNS1yY3MuCgpJ cyB0aGlzIGZpbmUgdG8gZ28gaW4sIGlmIHNvIHdobyB3aWxsIHRha2UgaXQ/CgpJIGdvdCBubyBm ZWVkYmFjayBvbiBteSBsYXN0IHJlc3BpbiAob24gdG9wIG9mIDMuMTQgYSBjb3VwbGUgb2Ygd2Vl a3MgYWdvLAp3aGljaCBhZGRlZCBtb3ZpbmcgdGhlIGlhNjQgcGNpIGJvb3RfdmdhIGZpeHVwKS4K SSd2ZSBiZWVuIHJ1bm5pbmcgdGhpcyByZXZpc2lvbiBmb3IgYSB3ZWVrIG9yIHNvIG9uIDMuMTUt cmMga2VybmVscyBoZXJlCihtb3N0bHkgRUZJLWVuYWJsZWQgc3lzdGVtLCB0aGUgbWVudGlvbmVk IE1CQSBhcyB3ZWxscyBhcyBub24tQXBwbGUgc3lzdGVtcwp3aGVyZSB0aGUgcGF0Y2ggd2FzIG5v dCByZXF1aXJlZCkuCgoKIGFyY2gvaWE2NC9wY2kvZml4dXAuYyAgICAgICB8IDU2ICsrLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogYXJjaC94ODYvaW5jbHVkZS9hc20vdmdhLmggIHwg IDYgLS0tLQogYXJjaC94ODYvcGNpL2ZpeHVwLmMgICAgICAgIHwgNTUgKy0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL2dwdS92Z2EvdmdhYXJiLmMgICAgfCA3NSArKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIGRyaXZlcnMvdmlkZW8v ZmJkZXYvZWZpZmIuYyB8IDM4IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiBpbmNsdWRlL2xpbnV4 L3ZnYWFyYi5oICAgICAgfCAzNyArKysrKysrKysrKysrKysrKysrKysrCiA2IGZpbGVzIGNoYW5n ZWQsIDExNiBpbnNlcnRpb25zKCspLCAxNTEgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvYXJj aC9pYTY0L3BjaS9maXh1cC5jIGIvYXJjaC9pYTY0L3BjaS9maXh1cC5jCmluZGV4IGVlZTA2OWEu LjVkZjIyZjkgMTAwNjQ0Ci0tLSBhL2FyY2gvaWE2NC9wY2kvZml4dXAuYworKysgYi9hcmNoL2lh NjQvcGNpL2ZpeHVwLmMKQEAgLTksNjQgKzksMTQgQEAKIAogI2luY2x1ZGUgPGFzbS9tYWNodmVj Lmg+CiAKLS8qCi0gKiBGaXh1cCB0byBtYXJrIGJvb3QgQklPUyB2aWRlbyBzZWxlY3RlZCBieSBC SU9TIGJlZm9yZSBpdCBjaGFuZ2VzCi0gKgotICogRnJvbSBpbmZvcm1hdGlvbiBwcm92aWRlZCBi eSAiSm9uIFNtaXJsIiA8am9uc21pcmxAZ21haWwuY29tPgotICoKLSAqIFRoZSBzdGFuZGFyZCBi b290IFJPTSBzZXF1ZW5jZSBmb3IgYW4geDg2IG1hY2hpbmUgdXNlcyB0aGUgQklPUwotICogdG8g c2VsZWN0IGFuIGluaXRpYWwgdmlkZW8gY2FyZCBmb3IgYm9vdCBkaXNwbGF5LiBUaGlzIGJvb3Qg dmlkZW8KLSAqIGNhcmQgd2lsbCBoYXZlIGl0J3MgQklPUyBjb3BpZWQgdG8gQzAwMDAgaW4gc3lz dGVtIFJBTS4KLSAqIElPUkVTT1VSQ0VfUk9NX1NIQURPVyBpcyB1c2VkIHRvIGFzc29jaWF0ZSB0 aGUgYm9vdCB2aWRlbwotICogY2FyZCB3aXRoIHRoaXMgY29weS4gT24gbGFwdG9wcyB0aGlzIGNv cHkgaGFzIHRvIGJlIHVzZWQgc2luY2UKLSAqIHRoZSBtYWluIFJPTSBtYXkgYmUgY29tcHJlc3Nl ZCBvciBjb21iaW5lZCB3aXRoIGFub3RoZXIgaW1hZ2UuCi0gKiBTZWUgcGNpX21hcF9yb20oKSBm b3IgdXNlIG9mIHRoaXMgZmxhZy4gQmVmb3JlIG1hcmtpbmcgdGhlIGRldmljZQotICogd2l0aCBJ T1JFU09VUkNFX1JPTV9TSEFET1cgY2hlY2sgaWYgYSB2Z2FfZGVmYXVsdF9kZXZpY2UgaXMgYWxy ZWFkeSBzZXQKLSAqIGJ5IGVpdGhlciBhcmNoIGNkZSBvciB2Z2EtYXJiaXRyYXRpb24sIGlmIHNv IG9ubHkgYXBwbHkgdGhlIGZpeHVwIHRvIHRoaXMKLSAqIGFscmVhZHkgZGV0ZXJtaW5lZCBwcmlt YXJ5IHZpZGVvIGNhcmQuCi0gKi8KLQotc3RhdGljIHZvaWQgcGNpX2ZpeHVwX3ZpZGVvKHN0cnVj dCBwY2lfZGV2ICpwZGV2KQorc3RhdGljIHZvaWQgcGNpX2lhNjRfZml4dXBfdmlkZW8oc3RydWN0 IHBjaV9kZXYgKnBkZXYpCiB7Ci0Jc3RydWN0IHBjaV9kZXYgKmJyaWRnZTsKLQlzdHJ1Y3QgcGNp X2J1cyAqYnVzOwotCXUxNiBjb25maWc7Ci0KIAlpZiAoKHN0cmNtcChpYTY0X3BsYXRmb3JtX25h bWUsICJkaWciKSAhPSAwKQogCSAgICAmJiAoc3RyY21wKGlhNjRfcGxhdGZvcm1fbmFtZSwgImhw engxIikgICE9IDApKQogCQlyZXR1cm47CiAJLyogTWF5YmUsIHRoaXMgbWFjaGluZSBzdXBwb3J0 cyBsZWdhY3kgbWVtb3J5IG1hcC4gKi8KIAotCS8qIElzIFZHQSByb3V0ZWQgdG8gdXM/ICovCi0J YnVzID0gcGRldi0+YnVzOwotCXdoaWxlIChidXMpIHsKLQkJYnJpZGdlID0gYnVzLT5zZWxmOwot Ci0JCS8qCi0JCSAqIEZyb20gaW5mb3JtYXRpb24gcHJvdmlkZWQgYnkKLQkJICogIkRhdmlkIE1p bGxlciIgPGRhdmVtQGRhdmVtbG9mdC5uZXQ+Ci0JCSAqIFRoZSBicmlkZ2UgY29udHJvbCByZWdp c3RlciBpcyB2YWxpZCBmb3IgUENJIGhlYWRlcgotCQkgKiB0eXBlIEJSSURHRSwgb3IgQ0FSREJV Uy4gSG9zdCB0byBQQ0kgY29udHJvbGxlcnMgdXNlCi0JCSAqIFBDSSBoZWFkZXIgdHlwZSBOT1JN QUwuCi0JCSAqLwotCQlpZiAoYnJpZGdlCi0JCSAgICAmJigoYnJpZGdlLT5oZHJfdHlwZSA9PSBQ Q0lfSEVBREVSX1RZUEVfQlJJREdFKQotCQkgICAgICAgfHwoYnJpZGdlLT5oZHJfdHlwZSA9PSBQ Q0lfSEVBREVSX1RZUEVfQ0FSREJVUykpKSB7Ci0JCQlwY2lfcmVhZF9jb25maWdfd29yZChicmlk Z2UsIFBDSV9CUklER0VfQ09OVFJPTCwKLQkJCQkJCSZjb25maWcpOwotCQkJaWYgKCEoY29uZmln ICYgUENJX0JSSURHRV9DVExfVkdBKSkKLQkJCQlyZXR1cm47Ci0JCX0KLQkJYnVzID0gYnVzLT5w YXJlbnQ7Ci0JfQotCWlmICghdmdhX2RlZmF1bHRfZGV2aWNlKCkgfHwgcGRldiA9PSB2Z2FfZGVm YXVsdF9kZXZpY2UoKSkgewotCQlwY2lfcmVhZF9jb25maWdfd29yZChwZGV2LCBQQ0lfQ09NTUFO RCwgJmNvbmZpZyk7Ci0JCWlmIChjb25maWcgJiAoUENJX0NPTU1BTkRfSU8gfCBQQ0lfQ09NTUFO RF9NRU1PUlkpKSB7Ci0JCQlwZGV2LT5yZXNvdXJjZVtQQ0lfUk9NX1JFU09VUkNFXS5mbGFncyB8 PSBJT1JFU09VUkNFX1JPTV9TSEFET1c7Ci0JCQlkZXZfcHJpbnRrKEtFUk5fREVCVUcsICZwZGV2 LT5kZXYsICJCb290IHZpZGVvIGRldmljZVxuIik7Ci0JCQl2Z2Ffc2V0X2RlZmF1bHRfZGV2aWNl KHBkZXYpOwotCQl9Ci0JfQorCXBjaV9maXh1cF92aWRlbyhwZGV2KTsKIH0KIERFQ0xBUkVfUENJ X0ZJWFVQX0NMQVNTX0ZJTkFMKFBDSV9BTllfSUQsIFBDSV9BTllfSUQsCi0JCQkJUENJX0NMQVNT X0RJU1BMQVlfVkdBLCA4LCBwY2lfZml4dXBfdmlkZW8pOworCQkJCVBDSV9DTEFTU19ESVNQTEFZ X1ZHQSwgOCwgcGNpX2lhNjRfZml4dXBfdmlkZW8pOwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvaW5j bHVkZS9hc20vdmdhLmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS92Z2EuaAppbmRleCA0NDI4MmZi Li5jNGI5ZGMyIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS92Z2EuaAorKysgYi9h cmNoL3g4Ni9pbmNsdWRlL2FzbS92Z2EuaApAQCAtMTcsMTAgKzE3LDQgQEAKICNkZWZpbmUgdmdh X3JlYWRiKHgpICgqKHgpKQogI2RlZmluZSB2Z2Ffd3JpdGViKHgsIHkpICgqKHkpID0gKHgpKQog Ci0jaWZkZWYgQ09ORklHX0ZCX0VGSQotI2RlZmluZSBfX0FSQ0hfSEFTX1ZHQV9ERUZBVUxUX0RF VklDRQotZXh0ZXJuIHN0cnVjdCBwY2lfZGV2ICp2Z2FfZGVmYXVsdF9kZXZpY2Uodm9pZCk7Ci1l eHRlcm4gdm9pZCB2Z2Ffc2V0X2RlZmF1bHRfZGV2aWNlKHN0cnVjdCBwY2lfZGV2ICpwZGV2KTsK LSNlbmRpZgotCiAjZW5kaWYgLyogX0FTTV9YODZfVkdBX0ggKi8KZGlmZiAtLWdpdCBhL2FyY2gv eDg2L3BjaS9maXh1cC5jIGIvYXJjaC94ODYvcGNpL2ZpeHVwLmMKaW5kZXggOTRhZTlhZS4uYjU5 OTg0NyAxMDA2NDQKLS0tIGEvYXJjaC94ODYvcGNpL2ZpeHVwLmMKKysrIGIvYXJjaC94ODYvcGNp L2ZpeHVwLmMKQEAgLTMwMiw2MCArMzAyLDcgQEAgREVDTEFSRV9QQ0lfRklYVVBfRklOQUwoUENJ X1ZFTkRPUl9JRF9JTlRFTCwJUENJX0RFVklDRV9JRF9JTlRFTF9NQ0hfUEIxLAlwY2llX3IKIERF Q0xBUkVfUENJX0ZJWFVQX0ZJTkFMKFBDSV9WRU5ET1JfSURfSU5URUwsCVBDSV9ERVZJQ0VfSURf SU5URUxfTUNIX1BDLAlwY2llX3Jvb3Rwb3J0X2FzcG1fcXVpcmspOwogREVDTEFSRV9QQ0lfRklY VVBfRklOQUwoUENJX1ZFTkRPUl9JRF9JTlRFTCwJUENJX0RFVklDRV9JRF9JTlRFTF9NQ0hfUEMx LAlwY2llX3Jvb3Rwb3J0X2FzcG1fcXVpcmspOwogCi0vKgotICogRml4dXAgdG8gbWFyayBib290 IEJJT1MgdmlkZW8gc2VsZWN0ZWQgYnkgQklPUyBiZWZvcmUgaXQgY2hhbmdlcwotICoKLSAqIEZy b20gaW5mb3JtYXRpb24gcHJvdmlkZWQgYnkgIkpvbiBTbWlybCIgPGpvbnNtaXJsQGdtYWlsLmNv bT4KLSAqCi0gKiBUaGUgc3RhbmRhcmQgYm9vdCBST00gc2VxdWVuY2UgZm9yIGFuIHg4NiBtYWNo aW5lIHVzZXMgdGhlIEJJT1MKLSAqIHRvIHNlbGVjdCBhbiBpbml0aWFsIHZpZGVvIGNhcmQgZm9y IGJvb3QgZGlzcGxheS4gVGhpcyBib290IHZpZGVvCi0gKiBjYXJkIHdpbGwgaGF2ZSBpdCdzIEJJ T1MgY29waWVkIHRvIEMwMDAwIGluIHN5c3RlbSBSQU0uCi0gKiBJT1JFU09VUkNFX1JPTV9TSEFE T1cgaXMgdXNlZCB0byBhc3NvY2lhdGUgdGhlIGJvb3QgdmlkZW8KLSAqIGNhcmQgd2l0aCB0aGlz IGNvcHkuIE9uIGxhcHRvcHMgdGhpcyBjb3B5IGhhcyB0byBiZSB1c2VkIHNpbmNlCi0gKiB0aGUg bWFpbiBST00gbWF5IGJlIGNvbXByZXNzZWQgb3IgY29tYmluZWQgd2l0aCBhbm90aGVyIGltYWdl LgotICogU2VlIHBjaV9tYXBfcm9tKCkgZm9yIHVzZSBvZiB0aGlzIGZsYWcuIEJlZm9yZSBtYXJr aW5nIHRoZSBkZXZpY2UKLSAqIHdpdGggSU9SRVNPVVJDRV9ST01fU0hBRE9XIGNoZWNrIGlmIGEg dmdhX2RlZmF1bHRfZGV2aWNlIGlzIGFscmVhZHkgc2V0Ci0gKiBieSBlaXRoZXIgYXJjaCBjZGUg b3IgdmdhLWFyYml0cmF0aW9uLCBpZiBzbyBvbmx5IGFwcGx5IHRoZSBmaXh1cCB0byB0aGlzCi0g KiBhbHJlYWR5IGRldGVybWluZWQgcHJpbWFyeSB2aWRlbyBjYXJkLgotICovCi0KLXN0YXRpYyB2 b2lkIHBjaV9maXh1cF92aWRlbyhzdHJ1Y3QgcGNpX2RldiAqcGRldikKLXsKLQlzdHJ1Y3QgcGNp X2RldiAqYnJpZGdlOwotCXN0cnVjdCBwY2lfYnVzICpidXM7Ci0JdTE2IGNvbmZpZzsKLQotCS8q IElzIFZHQSByb3V0ZWQgdG8gdXM/ICovCi0JYnVzID0gcGRldi0+YnVzOwotCXdoaWxlIChidXMp IHsKLQkJYnJpZGdlID0gYnVzLT5zZWxmOwotCi0JCS8qCi0JCSAqIEZyb20gaW5mb3JtYXRpb24g cHJvdmlkZWQgYnkKLQkJICogIkRhdmlkIE1pbGxlciIgPGRhdmVtQGRhdmVtbG9mdC5uZXQ+Ci0J CSAqIFRoZSBicmlkZ2UgY29udHJvbCByZWdpc3RlciBpcyB2YWxpZCBmb3IgUENJIGhlYWRlcgot CQkgKiB0eXBlIEJSSURHRSwgb3IgQ0FSREJVUy4gSG9zdCB0byBQQ0kgY29udHJvbGxlcnMgdXNl Ci0JCSAqIFBDSSBoZWFkZXIgdHlwZSBOT1JNQUwuCi0JCSAqLwotCQlpZiAoYnJpZGdlCi0JCSAg ICAmJiAoKGJyaWRnZS0+aGRyX3R5cGUgPT0gUENJX0hFQURFUl9UWVBFX0JSSURHRSkKLQkJICAg ICAgIHx8IChicmlkZ2UtPmhkcl90eXBlID09IFBDSV9IRUFERVJfVFlQRV9DQVJEQlVTKSkpIHsK LQkJCXBjaV9yZWFkX2NvbmZpZ193b3JkKGJyaWRnZSwgUENJX0JSSURHRV9DT05UUk9MLAotCQkJ CQkJJmNvbmZpZyk7Ci0JCQlpZiAoIShjb25maWcgJiBQQ0lfQlJJREdFX0NUTF9WR0EpKQotCQkJ CXJldHVybjsKLQkJfQotCQlidXMgPSBidXMtPnBhcmVudDsKLQl9Ci0JaWYgKCF2Z2FfZGVmYXVs dF9kZXZpY2UoKSB8fCBwZGV2ID09IHZnYV9kZWZhdWx0X2RldmljZSgpKSB7Ci0JCXBjaV9yZWFk X2NvbmZpZ193b3JkKHBkZXYsIFBDSV9DT01NQU5ELCAmY29uZmlnKTsKLQkJaWYgKGNvbmZpZyAm IChQQ0lfQ09NTUFORF9JTyB8IFBDSV9DT01NQU5EX01FTU9SWSkpIHsKLQkJCXBkZXYtPnJlc291 cmNlW1BDSV9ST01fUkVTT1VSQ0VdLmZsYWdzIHw9IElPUkVTT1VSQ0VfUk9NX1NIQURPVzsKLQkJ CWRldl9wcmludGsoS0VSTl9ERUJVRywgJnBkZXYtPmRldiwgIkJvb3QgdmlkZW8gZGV2aWNlXG4i KTsKLQkJCXZnYV9zZXRfZGVmYXVsdF9kZXZpY2UocGRldik7Ci0JCX0KLQl9Ci19CisvKiBwY2lf Zml4dXBfdmlkZW8gc2hhcmVkIGluIHZnYWFyYi5jICovCiBERUNMQVJFX1BDSV9GSVhVUF9DTEFT U19GSU5BTChQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELAogCQkJCVBDSV9DTEFTU19ESVNQTEFZX1ZH QSwgOCwgcGNpX2ZpeHVwX3ZpZGVvKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvdmdhL3Zn YWFyYi5jIGIvZHJpdmVycy9ncHUvdmdhL3ZnYWFyYi5jCmluZGV4IGFmMDI1OTcuLmYwZmJkZjYg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L3ZnYS92Z2FhcmIuYworKysgYi9kcml2ZXJzL2dwdS92 Z2EvdmdhYXJiLmMKQEAgLTE0OSw2ICsxNDksODEgQEAgdm9pZCB2Z2Ffc2V0X2RlZmF1bHRfZGV2 aWNlKHN0cnVjdCBwY2lfZGV2ICpwZGV2KQogfQogI2VuZGlmCiAKKy8qCisgKiBGaXh1cCB0byBt YXJrIGJvb3QgQklPUyB2aWRlbyBzZWxlY3RlZCBieSBCSU9TIGJlZm9yZSBpdCBjaGFuZ2VzCisg KgorICogRnJvbSBpbmZvcm1hdGlvbiBwcm92aWRlZCBieSAiSm9uIFNtaXJsIiA8am9uc21pcmxA Z21haWwuY29tPgorICoKKyAqIFRoZSBzdGFuZGFyZCBib290IFJPTSBzZXF1ZW5jZSBmb3IgYW4g eDg2IG1hY2hpbmUgdXNlcyB0aGUgQklPUworICogdG8gc2VsZWN0IGFuIGluaXRpYWwgdmlkZW8g Y2FyZCBmb3IgYm9vdCBkaXNwbGF5LiBUaGlzIGJvb3QgdmlkZW8KKyAqIGNhcmQgd2lsbCBoYXZl IGl0J3MgQklPUyBjb3BpZWQgdG8gQzAwMDAgaW4gc3lzdGVtIFJBTS4KKyAqIElPUkVTT1VSQ0Vf Uk9NX1NIQURPVyBpcyB1c2VkIHRvIGFzc29jaWF0ZSB0aGUgYm9vdCB2aWRlbworICogY2FyZCB3 aXRoIHRoaXMgY29weS4gT24gbGFwdG9wcyB0aGlzIGNvcHkgaGFzIHRvIGJlIHVzZWQgc2luY2UK KyAqIHRoZSBtYWluIFJPTSBtYXkgYmUgY29tcHJlc3NlZCBvciBjb21iaW5lZCB3aXRoIGFub3Ro ZXIgaW1hZ2UuCisgKiBTZWUgcGNpX21hcF9yb20oKSBmb3IgdXNlIG9mIHRoaXMgZmxhZy4gQmVm b3JlIG1hcmtpbmcgdGhlIGRldmljZQorICogd2l0aCBJT1JFU09VUkNFX1JPTV9TSEFET1cgY2hl Y2sgaWYgYSB2Z2FfZGVmYXVsdF9kZXZpY2UgaXMgYWxyZWFkeSBzZXQKKyAqIGJ5IGVpdGhlciBh cmNoIGNkZSBvciB2Z2EtYXJiaXRyYXRpb24sIGlmIHNvIG9ubHkgYXBwbHkgdGhlIGZpeHVwIHRv IHRoaXMKKyAqIGFscmVhZHkgZGV0ZXJtaW5lZCBwcmltYXJ5IHZpZGVvIGNhcmQuCisgKi8KKwor dm9pZCBwY2lfZml4dXBfdmlkZW8oc3RydWN0IHBjaV9kZXYgKnBkZXYpCit7CisJc3RydWN0IHBj aV9kZXYgKmJyaWRnZTsKKwlzdHJ1Y3QgcGNpX2J1cyAqYnVzOworCXUxNiBjb25maWc7CisKKwlp ZiAoIXZnYV9kZWZhdWx0X2RldmljZSgpKSB7CisJCXJlc291cmNlX3NpemVfdCBzdGFydCwgZW5k OworCQlpbnQgaTsKKworCQlmb3IgKGk9MDsgaSA8IERFVklDRV9DT1VOVF9SRVNPVVJDRTsgaSsr KSB7CisJCQlpZiAoIShwY2lfcmVzb3VyY2VfZmxhZ3MocGRldiwgaSkgJiBJT1JFU09VUkNFX01F TSkpCisJCQkJY29udGludWU7CisKKwkJCXN0YXJ0ID0gcGNpX3Jlc291cmNlX3N0YXJ0KHBkZXYs IGkpOworCQkJZW5kICA9IHBjaV9yZXNvdXJjZV9lbmQocGRldiwgaSk7CisKKwkJCWlmICghc3Rh cnQgfHwgIWVuZCkKKwkJCQljb250aW51ZTsKKworCQkJaWYgKHNjcmVlbl9pbmZvLmxmYl9iYXNl ID49IHN0YXJ0ICYmCisJCQkJKHNjcmVlbl9pbmZvLmxmYl9iYXNlICsgc2NyZWVuX2luZm8ubGZi X3NpemUpIDwgZW5kKQorCQkJCXZnYV9zZXRfZGVmYXVsdF9kZXZpY2UocGRldik7CisJCX0KKwl9 CisKKwkvKiBJcyBWR0Egcm91dGVkIHRvIHVzPyAqLworCWJ1cyA9IHBkZXYtPmJ1czsKKwl3aGls ZSAoYnVzKSB7CisJCWJyaWRnZSA9IGJ1cy0+c2VsZjsKKworCQkvKgorCQkgKiBGcm9tIGluZm9y bWF0aW9uIHByb3ZpZGVkIGJ5CisJCSAqICJEYXZpZCBNaWxsZXIiIDxkYXZlbUBkYXZlbWxvZnQu bmV0PgorCQkgKiBUaGUgYnJpZGdlIGNvbnRyb2wgcmVnaXN0ZXIgaXMgdmFsaWQgZm9yIFBDSSBo ZWFkZXIKKwkJICogdHlwZSBCUklER0UsIG9yIENBUkRCVVMuIEhvc3QgdG8gUENJIGNvbnRyb2xs ZXJzIHVzZQorCQkgKiBQQ0kgaGVhZGVyIHR5cGUgTk9STUFMLgorCQkgKi8KKwkJaWYgKGJyaWRn ZQorCQkgICAgJiYgKChicmlkZ2UtPmhkcl90eXBlID09IFBDSV9IRUFERVJfVFlQRV9CUklER0Up CisJCSAgICAgICB8fCAoYnJpZGdlLT5oZHJfdHlwZSA9PSBQQ0lfSEVBREVSX1RZUEVfQ0FSREJV UykpKSB7CisJCQlwY2lfcmVhZF9jb25maWdfd29yZChicmlkZ2UsIFBDSV9CUklER0VfQ09OVFJP TCwKKwkJCQkJCSZjb25maWcpOworCQkJaWYgKCEoY29uZmlnICYgUENJX0JSSURHRV9DVExfVkdB KSkKKwkJCQlyZXR1cm47CisJCX0KKwkJYnVzID0gYnVzLT5wYXJlbnQ7CisJfQorCWlmICghdmdh X2RlZmF1bHRfZGV2aWNlKCkgfHwgcGRldiA9PSB2Z2FfZGVmYXVsdF9kZXZpY2UoKSkgeworCQlw Y2lfcmVhZF9jb25maWdfd29yZChwZGV2LCBQQ0lfQ09NTUFORCwgJmNvbmZpZyk7CisJCWlmIChj b25maWcgJiAoUENJX0NPTU1BTkRfSU8gfCBQQ0lfQ09NTUFORF9NRU1PUlkpKSB7CisJCQlwZGV2 LT5yZXNvdXJjZVtQQ0lfUk9NX1JFU09VUkNFXS5mbGFncyB8PSBJT1JFU09VUkNFX1JPTV9TSEFE T1c7CisJCQlkZXZfcHJpbnRrKEtFUk5fREVCVUcsICZwZGV2LT5kZXYsICJCb290IHZpZGVvIGRl dmljZVxuIik7CisJCQl2Z2Ffc2V0X2RlZmF1bHRfZGV2aWNlKHBkZXYpOworCQl9CisJfQorfQor CiBzdGF0aWMgaW5saW5lIHZvaWQgdmdhX2lycV9zZXRfc3RhdGUoc3RydWN0IHZnYV9kZXZpY2Ug KnZnYWRldiwgYm9vbCBzdGF0ZSkKIHsKIAlpZiAodmdhZGV2LT5pcnFfc2V0X3N0YXRlKQpkaWZm IC0tZ2l0IGEvZHJpdmVycy92aWRlby9mYmRldi9lZmlmYi5jIGIvZHJpdmVycy92aWRlby9mYmRl di9lZmlmYi5jCmluZGV4IGFlOTYxOGYuLmEwMzMxODAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlk ZW8vZmJkZXYvZWZpZmIuYworKysgYi9kcml2ZXJzL3ZpZGVvL2ZiZGV2L2VmaWZiLmMKQEAgLTE5 LDggKzE5LDYgQEAKIAogc3RhdGljIGJvb2wgcmVxdWVzdF9tZW1fc3VjY2VlZGVkID0gZmFsc2U7 CiAKLXN0YXRpYyBzdHJ1Y3QgcGNpX2RldiAqZGVmYXVsdF92Z2E7Ci0KIHN0YXRpYyBzdHJ1Y3Qg ZmJfdmFyX3NjcmVlbmluZm8gZWZpZmJfZGVmaW5lZCA9IHsKIAkuYWN0aXZhdGUJCT0gRkJfQUNU SVZBVEVfTk9XLAogCS5oZWlnaHQJCQk9IC0xLApAQCAtODQsMTggKzgyLDYgQEAgc3RhdGljIHN0 cnVjdCBmYl9vcHMgZWZpZmJfb3BzID0gewogCS5mYl9pbWFnZWJsaXQJPSBjZmJfaW1hZ2VibGl0 LAogfTsKIAotc3RydWN0IHBjaV9kZXYgKnZnYV9kZWZhdWx0X2RldmljZSh2b2lkKQotewotCXJl dHVybiBkZWZhdWx0X3ZnYTsKLX0KLQotRVhQT1JUX1NZTUJPTF9HUEwodmdhX2RlZmF1bHRfZGV2 aWNlKTsKLQotdm9pZCB2Z2Ffc2V0X2RlZmF1bHRfZGV2aWNlKHN0cnVjdCBwY2lfZGV2ICpwZGV2 KQotewotCWRlZmF1bHRfdmdhID0gcGRldjsKLX0KLQogc3RhdGljIGludCBlZmlmYl9zZXR1cChj aGFyICpvcHRpb25zKQogewogCWNoYXIgKnRoaXNfb3B0OwpAQCAtMTI2LDMwICsxMTIsNiBAQCBz dGF0aWMgaW50IGVmaWZiX3NldHVwKGNoYXIgKm9wdGlvbnMpCiAJCX0KIAl9CiAKLQlmb3JfZWFj aF9wY2lfZGV2KGRldikgewotCQlpbnQgaTsKLQotCQlpZiAoKGRldi0+Y2xhc3MgPj4gOCkgIT0g UENJX0NMQVNTX0RJU1BMQVlfVkdBKQotCQkJY29udGludWU7Ci0KLQkJZm9yIChpPTA7IGkgPCBE RVZJQ0VfQ09VTlRfUkVTT1VSQ0U7IGkrKykgewotCQkJcmVzb3VyY2Vfc2l6ZV90IHN0YXJ0LCBl bmQ7Ci0KLQkJCWlmICghKHBjaV9yZXNvdXJjZV9mbGFncyhkZXYsIGkpICYgSU9SRVNPVVJDRV9N RU0pKQotCQkJCWNvbnRpbnVlOwotCi0JCQlzdGFydCA9IHBjaV9yZXNvdXJjZV9zdGFydChkZXYs IGkpOwotCQkJZW5kICA9IHBjaV9yZXNvdXJjZV9lbmQoZGV2LCBpKTsKLQotCQkJaWYgKCFzdGFy dCB8fCAhZW5kKQotCQkJCWNvbnRpbnVlOwotCi0JCQlpZiAoc2NyZWVuX2luZm8ubGZiX2Jhc2Ug Pj0gc3RhcnQgJiYKLQkJCSAgICAoc2NyZWVuX2luZm8ubGZiX2Jhc2UgKyBzY3JlZW5faW5mby5s ZmJfc2l6ZSkgPCBlbmQpCi0JCQkJZGVmYXVsdF92Z2EgPSBkZXY7Ci0JCX0KLQl9Ci0KIAlyZXR1 cm4gMDsKIH0KIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC92Z2FhcmIuaCBiL2luY2x1ZGUv bGludXgvdmdhYXJiLmgKaW5kZXggMmMwMmYzYS4uNjUxODQ2MCAxMDA2NDQKLS0tIGEvaW5jbHVk ZS9saW51eC92Z2FhcmIuaAorKysgYi9pbmNsdWRlL2xpbnV4L3ZnYWFyYi5oCkBAIC0xNjIsNiAr MTYyLDQzIEBAIGV4dGVybiB2b2lkIHZnYV9wdXQoc3RydWN0IHBjaV9kZXYgKnBkZXYsIHVuc2ln bmVkIGludCByc3JjKTsKICNkZWZpbmUgdmdhX3B1dChwZGV2LCByc3JjKQogI2VuZGlmCiAKKy8q KgorICogICAgIHBjaV9maXh1cF92aWRlbworICoKKyAqICAgICBUaGlzIGNhbiBiZSBjYWxsZWQg YnkgYXJjaCBQQ0kgdG8gZml4dXAgYm9vdCBWR0EgdGFnZ2luZworICogICAgIG9mIFZHQSBQQ0kg ZGV2aWNlcyAoZS5nLiBmb3IgWDg2LCBJQTY0KQorICoKKyAqICAgICBUaGlzIGNvZGUgd2FzIGlu aXRpYWxseSBzcHJlYWQvZHVwbGljYXRlZCBhY3Jvc3M6CisgKiAgICAgLSBYODYgUENJLWZpeHVw CisgKiAgICAgLSBJQTY0IFBDSS1maXh1cAorICogICAgIC0gRUZJX0ZCCisgKgorICogICAgICog UENJLWZpeHVwIHBhcnQ6CisgKiAgICAgRml4dXAgdG8gbWFyayBib290IEJJT1MgdmlkZW8gc2Vs ZWN0ZWQgYnkgQklPUyBiZWZvcmUgaXQgY2hhbmdlcworICoKKyAqICAgICBGcm9tIGluZm9ybWF0 aW9uIHByb3ZpZGVkIGJ5ICJKb24gU21pcmwiIDxqb25zbWlybEBnbWFpbC5jb20+CisgKgorICog ICAgIFRoZSBzdGFuZGFyZCBib290IFJPTSBzZXF1ZW5jZSBmb3IgYW4geDg2IG1hY2hpbmUgdXNl cyB0aGUgQklPUworICogICAgIHRvIHNlbGVjdCBhbiBpbml0aWFsIHZpZGVvIGNhcmQgZm9yIGJv b3QgZGlzcGxheS4gVGhpcyBib290IHZpZGVvCisgKiAgICAgY2FyZCB3aWxsIGhhdmUgaXQncyBC SU9TIGNvcGllZCB0byBDMDAwMCBpbiBzeXN0ZW0gUkFNLgorICogICAgIElPUkVTT1VSQ0VfUk9N X1NIQURPVyBpcyB1c2VkIHRvIGFzc29jaWF0ZSB0aGUgYm9vdCB2aWRlbworICogICAgIGNhcmQg d2l0aCB0aGlzIGNvcHkuIE9uIGxhcHRvcHMgdGhpcyBjb3B5IGhhcyB0byBiZSB1c2VkIHNpbmNl CisgKiAgICAgdGhlIG1haW4gUk9NIG1heSBiZSBjb21wcmVzc2VkIG9yIGNvbWJpbmVkIHdpdGgg YW5vdGhlciBpbWFnZS4KKyAqICAgICBTZWUgcGNpX21hcF9yb20oKSBmb3IgdXNlIG9mIHRoaXMg ZmxhZy4gSU9SRVNPVVJDRV9ST01fU0hBRE9XCisgKiAgICAgaXMgbWFya2VkIGhlcmUgc2luY2Ug dGhlIGJvb3QgdmlkZW8gZGV2aWNlIHdpbGwgYmUgdGhlIG9ubHkgZW5hYmxlZAorICogICAgIHZp ZGVvIGRldmljZSBhdCB0aGlzIHBvaW50LgorICoKKyAqICAgICAqIEVGSV9GQiBwYXJ0OgorICog ICAgIFNvbWUgRUZJLWJhc2VkIHN5c3RlbSAoZS5nLiBJbnRlbC1NYWNzIGZyb20gQXBwbGUpIGRv IG5vdCBzZXR1cAorICogICAgIHNoYWRvdyBWaWRlby1CSU9TIGFuZCB0aHVzIGNhbiBvbmx5IGJl IGRldGVjdGVkIGJ5IGZyYW1lYnVmZmVyCisgKiAgICAgSU8gbWVtb3J5IHJhbmdlLiBGbGFnIHRo ZSBjb3JyZXNwb25kaW5nIEdQVSBhcyBib290X3ZnYS4KKyAqLworCisjaWYgZGVmaW5lZChDT05G SUdfVkdBX0FSQikKK3ZvaWQgcGNpX2ZpeHVwX3ZpZGVvKHN0cnVjdCBwY2lfZGV2ICpwZGV2KTsK KyNlbHNlCitzdGF0aWMgaW5saW5lIHZvaWQgcGNpX2ZpeHVwX3ZpZGVvKHN0cnVjdCBwY2lfZGV2 ICpwZGV2KSB7IH0KKyNlbmRpZgogCiAvKioKICAqICAgICB2Z2FfZGVmYXVsdF9kZXZpY2UKX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1h aWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHA6Ly9saXN0cy5m cmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK