From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1035408AbdDUFGm (ORCPT ); Fri, 21 Apr 2017 01:06:42 -0400 Received: from userp1040.oracle.com ([156.151.31.81]:37813 "EHLO userp1040.oracle.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1035322AbdDUFFu (ORCPT ); Fri, 21 Apr 2017 01:05:50 -0400 From: Yinghai Lu To: Bjorn Helgaas , David Miller , Benjamin Herrenschmidt Cc: Wei Yang , Khalid Aziz , linux-pci@vger.kernel.org, linux-kernel@vger.kernel.org, Yinghai Lu , sparclinux@vger.kernel.org Subject: [PATCH 09/13] PCI: Check pref compatible bit for mem64 resource of PCIe device Date: Thu, 20 Apr 2017 22:04:56 -0700 Message-Id: <20170421050500.13957-10-yinghai@kernel.org> X-Mailer: git-send-email 2.9.3 In-Reply-To: <20170421050500.13957-1-yinghai@kernel.org> References: <20170421050500.13957-1-yinghai@kernel.org> X-Source-IP: aserv0021.oracle.com [141.146.126.233] Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org We still get "no compatible bridge window" warning on sparc T5-8 after we add support for 64bit resource parsing for root bus. PCI: scan_bus[/pci@300/pci@1/pci@0/pci@6] bus no 8 PCI: Claiming 0000:00:01.0: Resource 15: 0000800100000000..00008004afffffff [220c] PCI: Claiming 0000:01:00.0: Resource 15: 0000800100000000..00008004afffffff [220c] PCI: Claiming 0000:02:04.0: Resource 15: 0000800100000000..000080012fffffff [220c] PCI: Claiming 0000:03:00.0: Resource 15: 0000800100000000..000080012fffffff [220c] PCI: Claiming 0000:04:06.0: Resource 14: 0000800100000000..000080010fffffff [220c] PCI: Claiming 0000:05:00.0: Resource 0: 0000800100000000..0000800100001fff [204] pci 0000:05:00.0: can't claim BAR 0 [mem 0x800100000000-0x800100001fff]: no compatible bridge window All the bridges 64-bit resource have pref bit, but the device resource does not have pref set, then we can not find parent for the device resource, as we can not put non-pref mmio under pref mmio. According to pcie spec errta https://www.pcisig.com/specifications/pciexpress/base2/PCIe_Base_r2.1_Errata_08Jun10.pdf page 13, in some case it is ok to mark some as pref. Mark if the entire path from the host to the adapter is over PCI Express. Set pref compatible bit for claim/sizing/assign for 64bit mem resource on that pcie device. -v2: set pref for mmio 64 when whole path is PCI Express, according to David Miller. -v3: don't set pref directly, change to UNDER_PREF, and set PREF before sizing and assign resource, and cleart PREF afterwards. requested by BenH. -v4: use on_all_pcie_path device flag instead. -v6: update after pci_find_bus_resource() change Link: http://lkml.kernel.org/r/CAE9FiQU1gJY1LYrxs+ma5LCTEEe4xmtjRG0aXJ9K_Tsu+m9Wuw@mail.gmail.com Reported-by: David Ahern Tested-by: David Ahern Link: https://bugzilla.kernel.org/show_bug.cgi?id=81431 Tested-by: TJ Signed-off-by: Yinghai Lu Tested-by: Khalid Aziz Cc: sparclinux@vger.kernel.org --- arch/sparc/kernel/pci_common.c | 2 +- drivers/pci/pci.c | 8 +++++--- drivers/pci/pci.h | 2 ++ drivers/pci/probe.c | 33 +++++++++++++++++++++++++++++++++ drivers/pci/setup-bus.c | 23 +++++++++++++++++++---- drivers/pci/setup-res.c | 4 ++++ include/linux/pci.h | 3 ++- 7 files changed, 66 insertions(+), 9 deletions(-) diff --git a/arch/sparc/kernel/pci_common.c b/arch/sparc/kernel/pci_common.c index 1ebc7ff..6f206a1 100644 --- a/arch/sparc/kernel/pci_common.c +++ b/arch/sparc/kernel/pci_common.c @@ -343,7 +343,7 @@ static void pci_register_region(struct pci_bus *bus, const char *name, region.start = rstart; region.end = rstart + size - 1UL; pcibios_bus_to_resource(bus, res, ®ion); - bus_res = pci_find_bus_resource(bus, res); + bus_res = pci_find_bus_resource(bus, res, res->flags); if (!bus_res) { kfree(res); return; diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c index deb828f..bdb70b7 100644 --- a/drivers/pci/pci.c +++ b/drivers/pci/pci.c @@ -438,7 +438,7 @@ int pci_find_ht_capability(struct pci_dev *dev, int ht_cap) EXPORT_SYMBOL_GPL(pci_find_ht_capability); struct resource *pci_find_bus_resource(const struct pci_bus *bus, - struct resource *res) + struct resource *res, int flags) { struct resource *r; int i; @@ -453,7 +453,7 @@ struct resource *pci_find_bus_resource(const struct pci_bus *bus, * not, the allocator made a mistake. */ if (r->flags & IORESOURCE_PREFETCH && - !(res->flags & IORESOURCE_PREFETCH)) + !(flags & IORESOURCE_PREFETCH)) return NULL; /* @@ -481,7 +481,9 @@ struct resource *pci_find_bus_resource(const struct pci_bus *bus, struct resource *pci_find_parent_resource(const struct pci_dev *dev, struct resource *res) { - return pci_find_bus_resource(dev->bus, res); + int flags = pci_resource_pref_compatible(dev, res); + + return pci_find_bus_resource(dev->bus, res, flags); } EXPORT_SYMBOL(pci_find_parent_resource); diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h index 586e63f..eb57780 100644 --- a/drivers/pci/pci.h +++ b/drivers/pci/pci.h @@ -368,4 +368,6 @@ int acpi_get_rc_resources(struct device *dev, const char *hid, u16 segment, struct resource *res); #endif +int pci_resource_pref_compatible(const struct pci_dev *dev, + struct resource *res); #endif /* DRIVERS_PCI_H */ diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c index 5548044..676b55f 100644 --- a/drivers/pci/probe.c +++ b/drivers/pci/probe.c @@ -1920,6 +1920,36 @@ static void pci_dma_configure(struct pci_dev *dev) pci_put_host_bridge_device(bridge); } +static bool pci_up_path_over_pcie(struct pci_bus *bus) +{ + if (pci_is_root_bus(bus)) + return true; + + if (bus->self && !pci_is_pcie(bus->self)) + return false; + + return pci_up_path_over_pcie(bus->parent); +} + +/* + * According to + * https://www.pcisig.com/specifications/pciexpress/base2/PCIe_Base_r2.1_Errata_08Jun10.pdf + * page 13, system firmware could put some 64bit non-pref under 64bit pref, + * on some cases. + * Let's mark if entire path from the host to the adapter is over PCI + * Express. later will use that compute pref compaitable bit. + */ +static void pci_set_on_all_pcie_path(struct pci_dev *dev) +{ + if (!pci_is_pcie(dev)) + return; + + if (!pci_up_path_over_pcie(dev->bus)) + return; + + dev->on_all_pcie_path = 1; +} + void pci_device_add(struct pci_dev *dev, struct pci_bus *bus) { int ret; @@ -1950,6 +1980,9 @@ void pci_device_add(struct pci_dev *dev, struct pci_bus *bus) /* Initialize various capabilities */ pci_init_capabilities(dev); + /* After pcie_cap is assigned */ + pci_set_on_all_pcie_path(dev); + /* * Add the device to our list of discovered devices * and the bus list for fixup functions, etc. diff --git a/drivers/pci/setup-bus.c b/drivers/pci/setup-bus.c index 958da7d..3de66e6 100644 --- a/drivers/pci/setup-bus.c +++ b/drivers/pci/setup-bus.c @@ -735,6 +735,20 @@ int pci_claim_bridge_resource(struct pci_dev *bridge, int i) return -EINVAL; } +int pci_resource_pref_compatible(const struct pci_dev *dev, + struct resource *res) +{ + if (res->flags & IORESOURCE_PREFETCH) + return res->flags; + + if ((res->flags & IORESOURCE_MEM) && + (res->flags & IORESOURCE_MEM_64) && + dev->on_all_pcie_path) + return res->flags | IORESOURCE_PREFETCH; + + return res->flags; +} + /* Check whether the bridge supports optional I/O and prefetchable memory ranges. If not, the respective base/limit registers must be read-only and read as 0. */ @@ -1032,11 +1046,12 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask, for (i = 0; i < PCI_NUM_RESOURCES; i++) { struct resource *r = &dev->resource[i]; resource_size_t r_size; + int flags = pci_resource_pref_compatible(dev, r); - if (r->parent || (r->flags & IORESOURCE_PCI_FIXED) || - ((r->flags & mask) != type && - (r->flags & mask) != type2 && - (r->flags & mask) != type3)) + if (r->parent || (flags & IORESOURCE_PCI_FIXED) || + ((flags & mask) != type && + (flags & mask) != type2 && + (flags & mask) != type3)) continue; r_size = resource_size(r); #ifdef CONFIG_PCI_IOV diff --git a/drivers/pci/setup-res.c b/drivers/pci/setup-res.c index 85774b7..2aeb4bc 100644 --- a/drivers/pci/setup-res.c +++ b/drivers/pci/setup-res.c @@ -285,15 +285,19 @@ static int __pci_assign_resource(struct pci_bus *bus, struct pci_dev *dev, static int _pci_assign_resource(struct pci_dev *dev, int resno, resource_size_t size, resource_size_t min_align) { + struct resource *res = dev->resource + resno; + int old_flags = res->flags; struct pci_bus *bus; int ret; + res->flags = pci_resource_pref_compatible(dev, res); bus = dev->bus; while ((ret = __pci_assign_resource(bus, dev, resno, size, min_align))) { if (!bus->parent || !bus->self->transparent) break; bus = bus->parent; } + res->flags = old_flags; return ret; } diff --git a/include/linux/pci.h b/include/linux/pci.h index 817786b..b14dd94 100644 --- a/include/linux/pci.h +++ b/include/linux/pci.h @@ -321,6 +321,7 @@ struct pci_dev { unsigned int hotplug_user_indicators:1; /* SlotCtl indicators controlled exclusively by user sysfs */ + unsigned int on_all_pcie_path:1; /* up to host-bridge all pcie */ unsigned int d3_delay; /* D3->D0 transition time in ms */ unsigned int d3cold_delay; /* D3cold->D0 transition time in ms */ @@ -837,7 +838,7 @@ void pcibios_resource_to_bus(struct pci_bus *bus, struct pci_bus_region *region, void pcibios_bus_to_resource(struct pci_bus *bus, struct resource *res, struct pci_bus_region *region); struct resource *pci_find_bus_resource(const struct pci_bus *bus, - struct resource *res); + struct resource *res, int flags); void pcibios_scan_specific_bus(int busn); struct pci_bus *pci_find_bus(int domain, int busnr); void pci_bus_add_devices(const struct pci_bus *bus); -- 2.9.3 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Yinghai Lu Date: Fri, 21 Apr 2017 05:04:56 +0000 Subject: [PATCH 09/13] PCI: Check pref compatible bit for mem64 resource of PCIe device Message-Id: <20170421050500.13957-10-yinghai@kernel.org> List-Id: References: <20170421050500.13957-1-yinghai@kernel.org> In-Reply-To: <20170421050500.13957-1-yinghai@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset="windows-1254" Content-Transfer-Encoding: base64 To: Bjorn Helgaas , David Miller , Benjamin Herrenschmidt Cc: Wei Yang , Khalid Aziz , linux-pci@vger.kernel.org, linux-kernel@vger.kernel.org, Yinghai Lu , sparclinux@vger.kernel.org V2Ugc3RpbGwgZ2V0ICJubyBjb21wYXRpYmxlIGJyaWRnZSB3aW5kb3ciIHdhcm5pbmcgb24gc3Bh cmMgVDUtOAphZnRlciB3ZSBhZGQgc3VwcG9ydCBmb3IgNjRiaXQgcmVzb3VyY2UgcGFyc2luZyBm b3Igcm9vdCBidXMuCgogUENJOiBzY2FuX2J1c1svcGNpQDMwMC9wY2lAMS9wY2lAMC9wY2lANl0g YnVzIG5vIDgKIFBDSTogQ2xhaW1pbmcgMDAwMDowMDowMS4wOiBSZXNvdXJjZSAxNTogMDAwMDgw MDEwMDAwMDAwMC4uMDAwMDgwMDRhZmZmZmZmZiBbMjIwY10KIFBDSTogQ2xhaW1pbmcgMDAwMDow MTowMC4wOiBSZXNvdXJjZSAxNTogMDAwMDgwMDEwMDAwMDAwMC4uMDAwMDgwMDRhZmZmZmZmZiBb MjIwY10KIFBDSTogQ2xhaW1pbmcgMDAwMDowMjowNC4wOiBSZXNvdXJjZSAxNTogMDAwMDgwMDEw MDAwMDAwMC4uMDAwMDgwMDEyZmZmZmZmZiBbMjIwY10KIFBDSTogQ2xhaW1pbmcgMDAwMDowMzow MC4wOiBSZXNvdXJjZSAxNTogMDAwMDgwMDEwMDAwMDAwMC4uMDAwMDgwMDEyZmZmZmZmZiBbMjIw Y10KIFBDSTogQ2xhaW1pbmcgMDAwMDowNDowNi4wOiBSZXNvdXJjZSAxNDogMDAwMDgwMDEwMDAw MDAwMC4uMDAwMDgwMDEwZmZmZmZmZiBbMjIwY10KIFBDSTogQ2xhaW1pbmcgMDAwMDowNTowMC4w OiBSZXNvdXJjZSAwOiAwMDAwODAwMTAwMDAwMDAwLi4wMDAwODAwMTAwMDAxZmZmIFsyMDRdCiBw Y2kgMDAwMDowNTowMC4wOiBjYW4ndCBjbGFpbSBCQVIgMCBbbWVtIDB4ODAwMTAwMDAwMDAwLTB4 ODAwMTAwMDAxZmZmXTogbm8gY29tcGF0aWJsZSBicmlkZ2Ugd2luZG93CgpBbGwgdGhlIGJyaWRn ZXMgNjQtYml0IHJlc291cmNlIGhhdmUgcHJlZiBiaXQsIGJ1dCB0aGUgZGV2aWNlIHJlc291cmNl IGRvZXMgbm90CmhhdmUgcHJlZiBzZXQsIHRoZW4gd2UgY2FuIG5vdCBmaW5kIHBhcmVudCBmb3Ig dGhlIGRldmljZSByZXNvdXJjZSwKYXMgd2UgY2FuIG5vdCBwdXQgbm9uLXByZWYgbW1pbyB1bmRl ciBwcmVmIG1taW8uCgpBY2NvcmRpbmcgdG8gcGNpZSBzcGVjIGVycnRhCmh0dHBzOi8vd3d3LnBj aXNpZy5jb20vc3BlY2lmaWNhdGlvbnMvcGNpZXhwcmVzcy9iYXNlMi9QQ0llX0Jhc2VfcjIuMV9F cnJhdGFfMDhKdW4xMC5wZGYKcGFnZSAxMywgaW4gc29tZSBjYXNlIGl0IGlzIG9rIHRvIG1hcmsg c29tZSBhcyBwcmVmLgoKTWFyayBpZiB0aGUgZW50aXJlIHBhdGggZnJvbSB0aGUgaG9zdCB0byB0 aGUgYWRhcHRlciBpcyBvdmVyIFBDSSBFeHByZXNzLgpTZXQgcHJlZiBjb21wYXRpYmxlIGJpdCBm b3IgY2xhaW0vc2l6aW5nL2Fzc2lnbiBmb3IgNjRiaXQgbWVtIHJlc291cmNlCm9uIHRoYXQgcGNp ZSBkZXZpY2UuCgotdjI6IHNldCBwcmVmIGZvciBtbWlvIDY0IHdoZW4gd2hvbGUgcGF0aCBpcyBQ Q0kgRXhwcmVzcywgYWNjb3JkaW5nIHRvIERhdmlkIE1pbGxlci4KLXYzOiBkb24ndCBzZXQgcHJl ZiBkaXJlY3RseSwgY2hhbmdlIHRvIFVOREVSX1BSRUYsIGFuZCBzZXQgUFJFRiBiZWZvcmUKICAg ICBzaXppbmcgYW5kIGFzc2lnbiByZXNvdXJjZSwgYW5kIGNsZWFydCBQUkVGIGFmdGVyd2FyZHMu IHJlcXVlc3RlZCBieSBCZW5ILgotdjQ6IHVzZSBvbl9hbGxfcGNpZV9wYXRoIGRldmljZSBmbGFn IGluc3RlYWQuCi12NjogdXBkYXRlIGFmdGVyIHBjaV9maW5kX2J1c19yZXNvdXJjZSgpIGNoYW5n ZQoKTGluazogaHR0cDovL2xrbWwua2VybmVsLm9yZy9yL0NBRTlGaVFVMWdKWTFMWXJ4cyttYTVM Q1RFRWU0eG10alJHMGFYSjlLX1RzdSttOVd1d0BtYWlsLmdtYWlsLmNvbQpSZXBvcnRlZC1ieTog RGF2aWQgQWhlcm4gPGRhdmlkLmFoZXJuQG9yYWNsZS5jb20+ClRlc3RlZC1ieTogRGF2aWQgQWhl cm4gPGRhdmlkLmFoZXJuQG9yYWNsZS5jb20+Ckxpbms6IGh0dHBzOi8vYnVnemlsbGEua2VybmVs Lm9yZy9zaG93X2J1Zy5jZ2k/aWSBNDMxClRlc3RlZC1ieTogVEogPGxpbnV4QGlhbS50aj4KU2ln bmVkLW9mZi1ieTogWWluZ2hhaSBMdSA8eWluZ2hhaUBrZXJuZWwub3JnPgpUZXN0ZWQtYnk6IEto YWxpZCBBeml6IDxraGFsaWQuYXppekBvcmFjbGUuY29tPgpDYzogc3BhcmNsaW51eEB2Z2VyLmtl cm5lbC5vcmcKLS0tCiBhcmNoL3NwYXJjL2tlcm5lbC9wY2lfY29tbW9uLmMgfCAgMiArLQogZHJp dmVycy9wY2kvcGNpLmMgICAgICAgICAgICAgIHwgIDggKysrKystLS0KIGRyaXZlcnMvcGNpL3Bj aS5oICAgICAgICAgICAgICB8ICAyICsrCiBkcml2ZXJzL3BjaS9wcm9iZS5jICAgICAgICAgICAg fCAzMyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIGRyaXZlcnMvcGNpL3NldHVw LWJ1cy5jICAgICAgICB8IDIzICsrKysrKysrKysrKysrKysrKystLS0tCiBkcml2ZXJzL3BjaS9z ZXR1cC1yZXMuYyAgICAgICAgfCAgNCArKysrCiBpbmNsdWRlL2xpbnV4L3BjaS5oICAgICAgICAg ICAgfCAgMyArKy0KIDcgZmlsZXMgY2hhbmdlZCwgNjYgaW5zZXJ0aW9ucygrKSwgOSBkZWxldGlv bnMoLSkKCmRpZmYgLS1naXQgYS9hcmNoL3NwYXJjL2tlcm5lbC9wY2lfY29tbW9uLmMgYi9hcmNo L3NwYXJjL2tlcm5lbC9wY2lfY29tbW9uLmMKaW5kZXggMWViYzdmZi4uNmYyMDZhMSAxMDA2NDQK LS0tIGEvYXJjaC9zcGFyYy9rZXJuZWwvcGNpX2NvbW1vbi5jCisrKyBiL2FyY2gvc3BhcmMva2Vy bmVsL3BjaV9jb21tb24uYwpAQCAtMzQzLDcgKzM0Myw3IEBAIHN0YXRpYyB2b2lkIHBjaV9yZWdp c3Rlcl9yZWdpb24oc3RydWN0IHBjaV9idXMgKmJ1cywgY29uc3QgY2hhciAqbmFtZSwKIAlyZWdp b24uc3RhcnQgPSByc3RhcnQ7CiAJcmVnaW9uLmVuZCA9IHJzdGFydCArIHNpemUgLSAxVUw7CiAJ cGNpYmlvc19idXNfdG9fcmVzb3VyY2UoYnVzLCByZXMsICZyZWdpb24pOwotCWJ1c19yZXMgPSBw Y2lfZmluZF9idXNfcmVzb3VyY2UoYnVzLCByZXMpOworCWJ1c19yZXMgPSBwY2lfZmluZF9idXNf cmVzb3VyY2UoYnVzLCByZXMsIHJlcy0+ZmxhZ3MpOwogCWlmICghYnVzX3JlcykgewogCQlrZnJl ZShyZXMpOwogCQlyZXR1cm47CmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9wY2kuYyBiL2RyaXZl cnMvcGNpL3BjaS5jCmluZGV4IGRlYjgyOGYuLmJkYjcwYjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv cGNpL3BjaS5jCisrKyBiL2RyaXZlcnMvcGNpL3BjaS5jCkBAIC00MzgsNyArNDM4LDcgQEAgaW50 IHBjaV9maW5kX2h0X2NhcGFiaWxpdHkoc3RydWN0IHBjaV9kZXYgKmRldiwgaW50IGh0X2NhcCkK IEVYUE9SVF9TWU1CT0xfR1BMKHBjaV9maW5kX2h0X2NhcGFiaWxpdHkpOwogCiBzdHJ1Y3QgcmVz b3VyY2UgKnBjaV9maW5kX2J1c19yZXNvdXJjZShjb25zdCBzdHJ1Y3QgcGNpX2J1cyAqYnVzLAot CQkJCQlzdHJ1Y3QgcmVzb3VyY2UgKnJlcykKKwkJCQkJc3RydWN0IHJlc291cmNlICpyZXMsIGlu dCBmbGFncykKIHsKIAlzdHJ1Y3QgcmVzb3VyY2UgKnI7CiAJaW50IGk7CkBAIC00NTMsNyArNDUz LDcgQEAgc3RydWN0IHJlc291cmNlICpwY2lfZmluZF9idXNfcmVzb3VyY2UoY29uc3Qgc3RydWN0 IHBjaV9idXMgKmJ1cywKIAkJCSAqIG5vdCwgdGhlIGFsbG9jYXRvciBtYWRlIGEgbWlzdGFrZS4K IAkJCSAqLwogCQkJaWYgKHItPmZsYWdzICYgSU9SRVNPVVJDRV9QUkVGRVRDSCAmJgotCQkJICAg ICEocmVzLT5mbGFncyAmIElPUkVTT1VSQ0VfUFJFRkVUQ0gpKQorCQkJICAgICEoZmxhZ3MgJiBJ T1JFU09VUkNFX1BSRUZFVENIKSkKIAkJCQlyZXR1cm4gTlVMTDsKIAogCQkJLyoKQEAgLTQ4MSw3 ICs0ODEsOSBAQCBzdHJ1Y3QgcmVzb3VyY2UgKnBjaV9maW5kX2J1c19yZXNvdXJjZShjb25zdCBz dHJ1Y3QgcGNpX2J1cyAqYnVzLAogc3RydWN0IHJlc291cmNlICpwY2lfZmluZF9wYXJlbnRfcmVz b3VyY2UoY29uc3Qgc3RydWN0IHBjaV9kZXYgKmRldiwKIAkJCQkJICBzdHJ1Y3QgcmVzb3VyY2Ug KnJlcykKIHsKLQlyZXR1cm4gcGNpX2ZpbmRfYnVzX3Jlc291cmNlKGRldi0+YnVzLCByZXMpOwor CWludCBmbGFncyA9IHBjaV9yZXNvdXJjZV9wcmVmX2NvbXBhdGlibGUoZGV2LCByZXMpOworCisJ cmV0dXJuIHBjaV9maW5kX2J1c19yZXNvdXJjZShkZXYtPmJ1cywgcmVzLCBmbGFncyk7CiB9CiBF WFBPUlRfU1lNQk9MKHBjaV9maW5kX3BhcmVudF9yZXNvdXJjZSk7CiAKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvcGNpL3BjaS5oIGIvZHJpdmVycy9wY2kvcGNpLmgKaW5kZXggNTg2ZTYzZi4uZWI1Nzc4 MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9wY2kvcGNpLmgKKysrIGIvZHJpdmVycy9wY2kvcGNpLmgK QEAgLTM2OCw0ICszNjgsNiBAQCBpbnQgYWNwaV9nZXRfcmNfcmVzb3VyY2VzKHN0cnVjdCBkZXZp Y2UgKmRldiwgY29uc3QgY2hhciAqaGlkLCB1MTYgc2VnbWVudCwKIAkJCSAgc3RydWN0IHJlc291 cmNlICpyZXMpOwogI2VuZGlmCiAKK2ludCBwY2lfcmVzb3VyY2VfcHJlZl9jb21wYXRpYmxlKGNv bnN0IHN0cnVjdCBwY2lfZGV2ICpkZXYsCisJCQkJIHN0cnVjdCByZXNvdXJjZSAqcmVzKTsKICNl bmRpZiAvKiBEUklWRVJTX1BDSV9IICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9wcm9iZS5j IGIvZHJpdmVycy9wY2kvcHJvYmUuYwppbmRleCA1NTQ4MDQ0Li42NzZiNTVmIDEwMDY0NAotLS0g YS9kcml2ZXJzL3BjaS9wcm9iZS5jCisrKyBiL2RyaXZlcnMvcGNpL3Byb2JlLmMKQEAgLTE5MjAs NiArMTkyMCwzNiBAQCBzdGF0aWMgdm9pZCBwY2lfZG1hX2NvbmZpZ3VyZShzdHJ1Y3QgcGNpX2Rl diAqZGV2KQogCXBjaV9wdXRfaG9zdF9icmlkZ2VfZGV2aWNlKGJyaWRnZSk7CiB9CiAKK3N0YXRp YyBib29sIHBjaV91cF9wYXRoX292ZXJfcGNpZShzdHJ1Y3QgcGNpX2J1cyAqYnVzKQoreworCWlm IChwY2lfaXNfcm9vdF9idXMoYnVzKSkKKwkJcmV0dXJuIHRydWU7CisKKwlpZiAoYnVzLT5zZWxm ICYmICFwY2lfaXNfcGNpZShidXMtPnNlbGYpKQorCQlyZXR1cm4gZmFsc2U7CisKKwlyZXR1cm4g cGNpX3VwX3BhdGhfb3Zlcl9wY2llKGJ1cy0+cGFyZW50KTsKK30KKworLyoKKyAqIEFjY29yZGlu ZyB0bworICogaHR0cHM6Ly93d3cucGNpc2lnLmNvbS9zcGVjaWZpY2F0aW9ucy9wY2lleHByZXNz L2Jhc2UyL1BDSWVfQmFzZV9yMi4xX0VycmF0YV8wOEp1bjEwLnBkZgorICogcGFnZSAxMywgc3lz dGVtIGZpcm13YXJlIGNvdWxkIHB1dCBzb21lIDY0Yml0IG5vbi1wcmVmIHVuZGVyIDY0Yml0IHBy ZWYsCisgKiBvbiBzb21lIGNhc2VzLgorICogTGV0J3MgbWFyayBpZiBlbnRpcmUgcGF0aCBmcm9t IHRoZSBob3N0IHRvIHRoZSBhZGFwdGVyIGlzIG92ZXIgUENJCisgKiBFeHByZXNzLiBsYXRlciB3 aWxsIHVzZSB0aGF0IGNvbXB1dGUgcHJlZiBjb21wYWl0YWJsZSBiaXQuCisgKi8KK3N0YXRpYyB2 b2lkIHBjaV9zZXRfb25fYWxsX3BjaWVfcGF0aChzdHJ1Y3QgcGNpX2RldiAqZGV2KQoreworCWlm ICghcGNpX2lzX3BjaWUoZGV2KSkKKwkJcmV0dXJuOworCisJaWYgKCFwY2lfdXBfcGF0aF9vdmVy X3BjaWUoZGV2LT5idXMpKQorCQlyZXR1cm47CisKKwlkZXYtPm9uX2FsbF9wY2llX3BhdGggPSAx OworfQorCiB2b2lkIHBjaV9kZXZpY2VfYWRkKHN0cnVjdCBwY2lfZGV2ICpkZXYsIHN0cnVjdCBw Y2lfYnVzICpidXMpCiB7CiAJaW50IHJldDsKQEAgLTE5NTAsNiArMTk4MCw5IEBAIHZvaWQgcGNp X2RldmljZV9hZGQoc3RydWN0IHBjaV9kZXYgKmRldiwgc3RydWN0IHBjaV9idXMgKmJ1cykKIAkv KiBJbml0aWFsaXplIHZhcmlvdXMgY2FwYWJpbGl0aWVzICovCiAJcGNpX2luaXRfY2FwYWJpbGl0 aWVzKGRldik7CiAKKwkvKiBBZnRlciBwY2llX2NhcCBpcyBhc3NpZ25lZCAqLworCXBjaV9zZXRf b25fYWxsX3BjaWVfcGF0aChkZXYpOworCiAJLyoKIAkgKiBBZGQgdGhlIGRldmljZSB0byBvdXIg bGlzdCBvZiBkaXNjb3ZlcmVkIGRldmljZXMKIAkgKiBhbmQgdGhlIGJ1cyBsaXN0IGZvciBmaXh1 cCBmdW5jdGlvbnMsIGV0Yy4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNpL3NldHVwLWJ1cy5jIGIv ZHJpdmVycy9wY2kvc2V0dXAtYnVzLmMKaW5kZXggOTU4ZGE3ZC4uM2RlNjZlNiAxMDA2NDQKLS0t IGEvZHJpdmVycy9wY2kvc2V0dXAtYnVzLmMKKysrIGIvZHJpdmVycy9wY2kvc2V0dXAtYnVzLmMK QEAgLTczNSw2ICs3MzUsMjAgQEAgaW50IHBjaV9jbGFpbV9icmlkZ2VfcmVzb3VyY2Uoc3RydWN0 IHBjaV9kZXYgKmJyaWRnZSwgaW50IGkpCiAJcmV0dXJuIC1FSU5WQUw7CiB9CiAKK2ludCBwY2lf cmVzb3VyY2VfcHJlZl9jb21wYXRpYmxlKGNvbnN0IHN0cnVjdCBwY2lfZGV2ICpkZXYsCisJCQkJ IHN0cnVjdCByZXNvdXJjZSAqcmVzKQoreworCWlmIChyZXMtPmZsYWdzICYgSU9SRVNPVVJDRV9Q UkVGRVRDSCkKKwkJcmV0dXJuIHJlcy0+ZmxhZ3M7CisKKwlpZiAoKHJlcy0+ZmxhZ3MgJiBJT1JF U09VUkNFX01FTSkgJiYKKwkgICAgKHJlcy0+ZmxhZ3MgJiBJT1JFU09VUkNFX01FTV82NCkgJiYK KwkgICAgZGV2LT5vbl9hbGxfcGNpZV9wYXRoKQorCQlyZXR1cm4gcmVzLT5mbGFncyB8IElPUkVT T1VSQ0VfUFJFRkVUQ0g7CisKKwlyZXR1cm4gcmVzLT5mbGFnczsKK30KKwogLyogQ2hlY2sgd2hl dGhlciB0aGUgYnJpZGdlIHN1cHBvcnRzIG9wdGlvbmFsIEkvTyBhbmQKICAgIHByZWZldGNoYWJs ZSBtZW1vcnkgcmFuZ2VzLiBJZiBub3QsIHRoZSByZXNwZWN0aXZlCiAgICBiYXNlL2xpbWl0IHJl Z2lzdGVycyBtdXN0IGJlIHJlYWQtb25seSBhbmQgcmVhZCBhcyAwLiAqLwpAQCAtMTAzMiwxMSAr MTA0NiwxMiBAQCBzdGF0aWMgaW50IHBidXNfc2l6ZV9tZW0oc3RydWN0IHBjaV9idXMgKmJ1cywg dW5zaWduZWQgbG9uZyBtYXNrLAogCQlmb3IgKGkgPSAwOyBpIDwgUENJX05VTV9SRVNPVVJDRVM7 IGkrKykgewogCQkJc3RydWN0IHJlc291cmNlICpyID0gJmRldi0+cmVzb3VyY2VbaV07CiAJCQly ZXNvdXJjZV9zaXplX3Qgcl9zaXplOworCQkJaW50IGZsYWdzID0gcGNpX3Jlc291cmNlX3ByZWZf Y29tcGF0aWJsZShkZXYsIHIpOwogCi0JCQlpZiAoci0+cGFyZW50IHx8IChyLT5mbGFncyAmIElP UkVTT1VSQ0VfUENJX0ZJWEVEKSB8fAotCQkJICAgICgoci0+ZmxhZ3MgJiBtYXNrKSAhPSB0eXBl ICYmCi0JCQkgICAgIChyLT5mbGFncyAmIG1hc2spICE9IHR5cGUyICYmCi0JCQkgICAgIChyLT5m bGFncyAmIG1hc2spICE9IHR5cGUzKSkKKwkJCWlmIChyLT5wYXJlbnQgfHwgKGZsYWdzICYgSU9S RVNPVVJDRV9QQ0lfRklYRUQpIHx8CisJCQkgICAgKChmbGFncyAmIG1hc2spICE9IHR5cGUgJiYK KwkJCSAgICAgKGZsYWdzICYgbWFzaykgIT0gdHlwZTIgJiYKKwkJCSAgICAgKGZsYWdzICYgbWFz aykgIT0gdHlwZTMpKQogCQkJCWNvbnRpbnVlOwogCQkJcl9zaXplID0gcmVzb3VyY2Vfc2l6ZShy KTsKICNpZmRlZiBDT05GSUdfUENJX0lPVgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvc2V0dXAt cmVzLmMgYi9kcml2ZXJzL3BjaS9zZXR1cC1yZXMuYwppbmRleCA4NTc3NGI3Li4yYWViNGJjIDEw MDY0NAotLS0gYS9kcml2ZXJzL3BjaS9zZXR1cC1yZXMuYworKysgYi9kcml2ZXJzL3BjaS9zZXR1 cC1yZXMuYwpAQCAtMjg1LDE1ICsyODUsMTkgQEAgc3RhdGljIGludCBfX3BjaV9hc3NpZ25fcmVz b3VyY2Uoc3RydWN0IHBjaV9idXMgKmJ1cywgc3RydWN0IHBjaV9kZXYgKmRldiwKIHN0YXRpYyBp bnQgX3BjaV9hc3NpZ25fcmVzb3VyY2Uoc3RydWN0IHBjaV9kZXYgKmRldiwgaW50IHJlc25vLAog CQkJCXJlc291cmNlX3NpemVfdCBzaXplLCByZXNvdXJjZV9zaXplX3QgbWluX2FsaWduKQogewor CXN0cnVjdCByZXNvdXJjZSAqcmVzID0gZGV2LT5yZXNvdXJjZSArIHJlc25vOworCWludCBvbGRf ZmxhZ3MgPSByZXMtPmZsYWdzOwogCXN0cnVjdCBwY2lfYnVzICpidXM7CiAJaW50IHJldDsKIAor CXJlcy0+ZmxhZ3MgPSBwY2lfcmVzb3VyY2VfcHJlZl9jb21wYXRpYmxlKGRldiwgcmVzKTsKIAli dXMgPSBkZXYtPmJ1czsKIAl3aGlsZSAoKHJldCA9IF9fcGNpX2Fzc2lnbl9yZXNvdXJjZShidXMs IGRldiwgcmVzbm8sIHNpemUsIG1pbl9hbGlnbikpKSB7CiAJCWlmICghYnVzLT5wYXJlbnQgfHwg IWJ1cy0+c2VsZi0+dHJhbnNwYXJlbnQpCiAJCQlicmVhazsKIAkJYnVzID0gYnVzLT5wYXJlbnQ7 CiAJfQorCXJlcy0+ZmxhZ3MgPSBvbGRfZmxhZ3M7CiAKIAlyZXR1cm4gcmV0OwogfQpkaWZmIC0t Z2l0IGEvaW5jbHVkZS9saW51eC9wY2kuaCBiL2luY2x1ZGUvbGludXgvcGNpLmgKaW5kZXggODE3 Nzg2Yi4uYjE0ZGQ5NCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9wY2kuaAorKysgYi9pbmNs dWRlL2xpbnV4L3BjaS5oCkBAIC0zMjEsNiArMzIxLDcgQEAgc3RydWN0IHBjaV9kZXYgewogCXVu c2lnbmVkIGludAlob3RwbHVnX3VzZXJfaW5kaWNhdG9yczoxOyAvKiBTbG90Q3RsIGluZGljYXRv cnMKIAkJCQkJCSAgICAgIGNvbnRyb2xsZWQgZXhjbHVzaXZlbHkgYnkKIAkJCQkJCSAgICAgIHVz ZXIgc3lzZnMgKi8KKwl1bnNpZ25lZCBpbnQJb25fYWxsX3BjaWVfcGF0aDoxOwkvKiB1cCB0byBo b3N0LWJyaWRnZSBhbGwgcGNpZSAqLwogCXVuc2lnbmVkIGludAlkM19kZWxheTsJLyogRDMtPkQw IHRyYW5zaXRpb24gdGltZSBpbiBtcyAqLwogCXVuc2lnbmVkIGludAlkM2NvbGRfZGVsYXk7CS8q IEQzY29sZC0+RDAgdHJhbnNpdGlvbiB0aW1lIGluIG1zICovCiAKQEAgLTgzNyw3ICs4MzgsNyBA QCB2b2lkIHBjaWJpb3NfcmVzb3VyY2VfdG9fYnVzKHN0cnVjdCBwY2lfYnVzICpidXMsIHN0cnVj dCBwY2lfYnVzX3JlZ2lvbiAqcmVnaW9uLAogdm9pZCBwY2liaW9zX2J1c190b19yZXNvdXJjZShz dHJ1Y3QgcGNpX2J1cyAqYnVzLCBzdHJ1Y3QgcmVzb3VyY2UgKnJlcywKIAkJCSAgICAgc3RydWN0 IHBjaV9idXNfcmVnaW9uICpyZWdpb24pOwogc3RydWN0IHJlc291cmNlICpwY2lfZmluZF9idXNf cmVzb3VyY2UoY29uc3Qgc3RydWN0IHBjaV9idXMgKmJ1cywKLQkJCQkJc3RydWN0IHJlc291cmNl ICpyZXMpOworCQkJCQlzdHJ1Y3QgcmVzb3VyY2UgKnJlcywgaW50IGZsYWdzKTsKIHZvaWQgcGNp Ymlvc19zY2FuX3NwZWNpZmljX2J1cyhpbnQgYnVzbik7CiBzdHJ1Y3QgcGNpX2J1cyAqcGNpX2Zp bmRfYnVzKGludCBkb21haW4sIGludCBidXNucik7CiB2b2lkIHBjaV9idXNfYWRkX2RldmljZXMo Y29uc3Qgc3RydWN0IHBjaV9idXMgKmJ1cyk7Ci0tIAoyLjkuMwoKLS0KVG8gdW5zdWJzY3JpYmUg ZnJvbSB0aGlzIGxpc3Q6IHNlbmQgdGhlIGxpbmUgInVuc3Vic2NyaWJlIHNwYXJjbGludXgiIGlu CnRoZSBib2R5IG9mIGEgbWVzc2FnZSB0byBtYWpvcmRvbW9Admdlci5rZXJuZWwub3JnCk1vcmUg bWFqb3Jkb21vIGluZm8gYXQgIGh0dHA6Ly92Z2VyLmtlcm5lbC5vcmcvbWFqb3Jkb21vLWluZm8u aHRtbA==