From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751871AbdFIJIV (ORCPT ); Fri, 9 Jun 2017 05:08:21 -0400 Received: from pegasos-out.vodafone.de ([80.84.1.38]:59363 "EHLO pegasos-out.vodafone.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751758AbdFIJIP (ORCPT ); Fri, 9 Jun 2017 05:08:15 -0400 X-Spam-Flag: NO X-Spam-Score: -0.055 Authentication-Results: rohrpostix1.prod.vfnet.de (amavisd-new); dkim=pass header.i=@vodafone.de X-DKIM: OpenDKIM Filter v2.6.8 pegasos-out.vodafone.de 33210261F98 From: =?UTF-8?q?Christian=20K=C3=B6nig?= To: helgaas@kernel.org, linux-pci@vger.kernel.org, dri-devel@lists.freedesktop.org, platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, amd-gfx@lists.freedesktop.org Subject: [PATCH v5 2/6] PCI: add resizeable BAR infrastructure v5 Date: Fri, 9 Jun 2017 10:59:43 +0200 Message-Id: <1496998787-6371-3-git-send-email-deathsimple@vodafone.de> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1496998787-6371-1-git-send-email-deathsimple@vodafone.de> References: <1496998787-6371-1-git-send-email-deathsimple@vodafone.de> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Christian König Just the defines and helper functions to read the possible sizes of a BAR and update it's size. See https://pcisig.com/sites/default/files/specification_documents/ECN_Resizable-BAR_24Apr2008.pdf and PCIe r3.1, sec 7.22. This is useful for hardware with large local storage (mostly GFX) which only expose 256MB BARs initially to be compatible with 32bit systems. v2: provide read helper as well v3: improve function names, use unsigned values, add better comments. v4: move definition, improve commit message, s/bar/BAR/ v5: split out helper to find ctrl reg pos, style fixes, comment fixes, add pci_rbar_size_to_bytes as well Signed-off-by: Christian König Reviewed-by: Andy Shevchenko --- drivers/pci/pci.c | 104 ++++++++++++++++++++++++++++++++++++++++++ drivers/pci/pci.h | 8 ++++ include/uapi/linux/pci_regs.h | 11 ++++- 3 files changed, 121 insertions(+), 2 deletions(-) diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c index 7904d02..d91ec39 100644 --- a/drivers/pci/pci.c +++ b/drivers/pci/pci.c @@ -2940,6 +2940,110 @@ bool pci_acs_path_enabled(struct pci_dev *start, } /** + * pci_rbar_find_pos - find position of resize ctrl reg for BAR + * @dev: PCI device + * @bar: BAR to find + * + * Helper to find the postion of the ctrl register for a BAR. + * Returns -ENOTSUPP of resizeable BARs are not supported at all. + * Returns -ENOENT if not ctrl register for the BAR could be found. + */ +static int pci_rbar_find_pos(struct pci_dev *pdev, int bar) +{ + unsigned int pos, nbars; + unsigned int i; + u32 ctrl; + + pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_REBAR); + if (!pos) + return -ENOTSUPP; + + pci_read_config_dword(pdev, pos + PCI_REBAR_CTRL, &ctrl); + nbars = (ctrl & PCI_REBAR_CTRL_NBAR_MASK) >> PCI_REBAR_CTRL_NBAR_SHIFT; + + for (i = 0; i < nbars; ++i, pos += 8) { + int bar_idx; + + pci_read_config_dword(pdev, pos + PCI_REBAR_CTRL, &ctrl); + bar_idx = (ctrl & PCI_REBAR_CTRL_BAR_IDX_MASK) >> + PCI_REBAR_CTRL_BAR_IDX_SHIFT; + if (bar_idx == bar) + return pos; + } + + return -ENOENT; +} + +/** + * pci_rbar_get_possible_sizes - get possible sizes for BAR + * @dev: PCI device + * @bar: BAR to query + * + * Get the possible sizes of a resizeable BAR as bitmask defined in the spec + * (bit 0=1MB, bit 19=512GB). Returns 0 if BAR isn't resizeable. + */ +u32 pci_rbar_get_possible_sizes(struct pci_dev *pdev, int bar) +{ + u32 cap; + int pos; + + pos = pci_rbar_find_pos(pdev, bar); + if (pos < 0) + return 0; + + pci_read_config_dword(pdev, pos + PCI_REBAR_CAP, &cap); + return (cap & PCI_REBAR_CTRL_SIZES_MASK) >> + PCI_REBAR_CTRL_SIZES_SHIFT; +} + +/** + * pci_rbar_get_current_size - get the current size of a BAR + * @dev: PCI device + * @bar: BAR to set size to + * + * Read the size of a BAR from the resizeable BAR config. + * Returns size if found or negative error code. + */ +int pci_rbar_get_current_size(struct pci_dev *pdev, int bar) +{ + u32 ctrl; + int pos; + + pos = pci_rbar_find_pos(pdev, bar); + if (pos < 0) + return pos; + + pci_read_config_dword(pdev, pos + PCI_REBAR_CTRL, &ctrl); + return (ctrl & PCI_REBAR_CTRL_BAR_SIZE_MASK) >> + PCI_REBAR_CTRL_BAR_SIZE_SHIFT; +} + +/** + * pci_rbar_set_size - set a new size for a BAR + * @dev: PCI device + * @bar: BAR to set size to + * @size: new size as defined in the spec (0=1MB, 19=512GB) + * + * Set the new size of a BAR as defined in the spec. + * Returns zero if resizing was successful, error code otherwise. + */ +int pci_rbar_set_size(struct pci_dev *pdev, int bar, int size) +{ + u32 ctrl; + int pos; + + pos = pci_rbar_find_pos(pdev, bar); + if (pos < 0) + return pos; + + pci_read_config_dword(pdev, pos + PCI_REBAR_CTRL, &ctrl); + ctrl &= ~PCI_REBAR_CTRL_BAR_SIZE_MASK; + ctrl |= size << PCI_REBAR_CTRL_BAR_SIZE_SHIFT; + pci_write_config_dword(pdev, pos + PCI_REBAR_CTRL, ctrl); + return 0; +} + +/** * pci_swizzle_interrupt_pin - swizzle INTx for device behind bridge * @dev: the PCI device * @pin: the INTx pin (1=INTA, 2=INTB, 3=INTC, 4=INTD) diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h index b3da553..23b75e8 100644 --- a/drivers/pci/pci.h +++ b/drivers/pci/pci.h @@ -357,4 +357,12 @@ int acpi_get_rc_resources(struct device *dev, const char *hid, u16 segment, struct resource *res); #endif +u32 pci_rbar_get_possible_sizes(struct pci_dev *pdev, int bar); +int pci_rbar_get_current_size(struct pci_dev *pdev, int bar); +int pci_rbar_set_size(struct pci_dev *pdev, int bar, int size); +static inline u64 pci_rbar_size_to_bytes(int size) +{ + return 1ULL << (size + 20); +} + #endif /* DRIVERS_PCI_H */ diff --git a/include/uapi/linux/pci_regs.h b/include/uapi/linux/pci_regs.h index 634c9c4..b6bd6e5 100644 --- a/include/uapi/linux/pci_regs.h +++ b/include/uapi/linux/pci_regs.h @@ -941,9 +941,16 @@ #define PCI_SATA_SIZEOF_LONG 16 /* Resizable BARs */ +#define PCI_REBAR_CAP 4 /* capability register */ +#define PCI_REBAR_CTRL_SIZES_MASK (0xFFFFF << 4) /* mask for sizes */ +#define PCI_REBAR_CTRL_SIZES_SHIFT 4 /* shift for sizes */ #define PCI_REBAR_CTRL 8 /* control register */ -#define PCI_REBAR_CTRL_NBAR_MASK (7 << 5) /* mask for # bars */ -#define PCI_REBAR_CTRL_NBAR_SHIFT 5 /* shift for # bars */ +#define PCI_REBAR_CTRL_BAR_IDX_MASK (7 << 0) /* mask for BAR index */ +#define PCI_REBAR_CTRL_BAR_IDX_SHIFT 0 /* shift for BAR index */ +#define PCI_REBAR_CTRL_NBAR_MASK (7 << 5) /* mask for # BARs */ +#define PCI_REBAR_CTRL_NBAR_SHIFT 5 /* shift for # BARs */ +#define PCI_REBAR_CTRL_BAR_SIZE_MASK (0x1F << 8) /* mask for BAR size */ +#define PCI_REBAR_CTRL_BAR_SIZE_SHIFT 8 /* shift for BAR size */ /* Dynamic Power Allocation */ #define PCI_DPA_CAP 4 /* capability register */ -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?q?Christian=20K=C3=B6nig?= Subject: [PATCH v5 2/6] PCI: add resizeable BAR infrastructure v5 Date: Fri, 9 Jun 2017 10:59:43 +0200 Message-ID: <1496998787-6371-3-git-send-email-deathsimple@vodafone.de> References: <1496998787-6371-1-git-send-email-deathsimple@vodafone.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1496998787-6371-1-git-send-email-deathsimple-ANTagKRnAhcb1SvskN2V4Q@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: amd-gfx-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "amd-gfx" To: helgaas-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org, linux-pci-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, platform-driver-x86-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, amd-gfx-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org List-Id: platform-driver-x86.vger.kernel.org RnJvbTogQ2hyaXN0aWFuIEvDtm5pZyA8Y2hyaXN0aWFuLmtvZW5pZ0BhbWQuY29tPgoKSnVzdCB0 aGUgZGVmaW5lcyBhbmQgaGVscGVyIGZ1bmN0aW9ucyB0byByZWFkIHRoZSBwb3NzaWJsZSBzaXpl cyBvZiBhIEJBUiBhbmQKdXBkYXRlIGl0J3Mgc2l6ZS4KClNlZSBodHRwczovL3BjaXNpZy5jb20v c2l0ZXMvZGVmYXVsdC9maWxlcy9zcGVjaWZpY2F0aW9uX2RvY3VtZW50cy9FQ05fUmVzaXphYmxl LUJBUl8yNEFwcjIwMDgucGRmCmFuZCBQQ0llIHIzLjEsIHNlYyA3LjIyLgoKVGhpcyBpcyB1c2Vm dWwgZm9yIGhhcmR3YXJlIHdpdGggbGFyZ2UgbG9jYWwgc3RvcmFnZSAobW9zdGx5IEdGWCkgd2hp Y2ggb25seQpleHBvc2UgMjU2TUIgQkFScyBpbml0aWFsbHkgdG8gYmUgY29tcGF0aWJsZSB3aXRo IDMyYml0IHN5c3RlbXMuCgp2MjogcHJvdmlkZSByZWFkIGhlbHBlciBhcyB3ZWxsCnYzOiBpbXBy b3ZlIGZ1bmN0aW9uIG5hbWVzLCB1c2UgdW5zaWduZWQgdmFsdWVzLCBhZGQgYmV0dGVyIGNvbW1l bnRzLgp2NDogbW92ZSBkZWZpbml0aW9uLCBpbXByb3ZlIGNvbW1pdCBtZXNzYWdlLCBzL2Jhci9C QVIvCnY1OiBzcGxpdCBvdXQgaGVscGVyIHRvIGZpbmQgY3RybCByZWcgcG9zLCBzdHlsZSBmaXhl cywgY29tbWVudCBmaXhlcywKICAgIGFkZCBwY2lfcmJhcl9zaXplX3RvX2J5dGVzIGFzIHdlbGwK ClNpZ25lZC1vZmYtYnk6IENocmlzdGlhbiBLw7ZuaWcgPGNocmlzdGlhbi5rb2VuaWdAYW1kLmNv bT4KUmV2aWV3ZWQtYnk6IEFuZHkgU2hldmNoZW5rbyA8YW5keS5zaGV2Y2hlbmtvQGdtYWlsLmNv bT4KLS0tCiBkcml2ZXJzL3BjaS9wY2kuYyAgICAgICAgICAgICB8IDEwNCArKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIGRyaXZlcnMvcGNpL3BjaS5oICAgICAgICAg ICAgIHwgICA4ICsrKysKIGluY2x1ZGUvdWFwaS9saW51eC9wY2lfcmVncy5oIHwgIDExICsrKyst CiAzIGZpbGVzIGNoYW5nZWQsIDEyMSBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQoKZGlm ZiAtLWdpdCBhL2RyaXZlcnMvcGNpL3BjaS5jIGIvZHJpdmVycy9wY2kvcGNpLmMKaW5kZXggNzkw NGQwMi4uZDkxZWMzOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9wY2kvcGNpLmMKKysrIGIvZHJpdmVy cy9wY2kvcGNpLmMKQEAgLTI5NDAsNiArMjk0MCwxMTAgQEAgYm9vbCBwY2lfYWNzX3BhdGhfZW5h YmxlZChzdHJ1Y3QgcGNpX2RldiAqc3RhcnQsCiB9CiAKIC8qKgorICogcGNpX3JiYXJfZmluZF9w b3MgLSBmaW5kIHBvc2l0aW9uIG9mIHJlc2l6ZSBjdHJsIHJlZyBmb3IgQkFSCisgKiBAZGV2OiBQ Q0kgZGV2aWNlCisgKiBAYmFyOiBCQVIgdG8gZmluZAorICoKKyAqIEhlbHBlciB0byBmaW5kIHRo ZSBwb3N0aW9uIG9mIHRoZSBjdHJsIHJlZ2lzdGVyIGZvciBhIEJBUi4KKyAqIFJldHVybnMgLUVO T1RTVVBQIG9mIHJlc2l6ZWFibGUgQkFScyBhcmUgbm90IHN1cHBvcnRlZCBhdCBhbGwuCisgKiBS ZXR1cm5zIC1FTk9FTlQgaWYgbm90IGN0cmwgcmVnaXN0ZXIgZm9yIHRoZSBCQVIgY291bGQgYmUg Zm91bmQuCisgKi8KK3N0YXRpYyBpbnQgcGNpX3JiYXJfZmluZF9wb3Moc3RydWN0IHBjaV9kZXYg KnBkZXYsIGludCBiYXIpCit7CisJdW5zaWduZWQgaW50IHBvcywgbmJhcnM7CisJdW5zaWduZWQg aW50IGk7CisJdTMyIGN0cmw7CisKKwlwb3MgPSBwY2lfZmluZF9leHRfY2FwYWJpbGl0eShwZGV2 LCBQQ0lfRVhUX0NBUF9JRF9SRUJBUik7CisJaWYgKCFwb3MpCisJCXJldHVybiAtRU5PVFNVUFA7 CisKKwlwY2lfcmVhZF9jb25maWdfZHdvcmQocGRldiwgcG9zICsgUENJX1JFQkFSX0NUUkwsICZj dHJsKTsKKwluYmFycyA9IChjdHJsICYgUENJX1JFQkFSX0NUUkxfTkJBUl9NQVNLKSA+PiBQQ0lf UkVCQVJfQ1RSTF9OQkFSX1NISUZUOworCisJZm9yIChpID0gMDsgaSA8IG5iYXJzOyArK2ksIHBv cyArPSA4KSB7CisJCWludCBiYXJfaWR4OworCisJCXBjaV9yZWFkX2NvbmZpZ19kd29yZChwZGV2 LCBwb3MgKyBQQ0lfUkVCQVJfQ1RSTCwgJmN0cmwpOworCQliYXJfaWR4ID0gKGN0cmwgJiBQQ0lf UkVCQVJfQ1RSTF9CQVJfSURYX01BU0spID4+CisJCQkJUENJX1JFQkFSX0NUUkxfQkFSX0lEWF9T SElGVDsKKwkJaWYgKGJhcl9pZHggPT0gYmFyKQorCQkJcmV0dXJuIHBvczsKKwl9CisKKwlyZXR1 cm4gLUVOT0VOVDsKK30KKworLyoqCisgKiBwY2lfcmJhcl9nZXRfcG9zc2libGVfc2l6ZXMgLSBn ZXQgcG9zc2libGUgc2l6ZXMgZm9yIEJBUgorICogQGRldjogUENJIGRldmljZQorICogQGJhcjog QkFSIHRvIHF1ZXJ5CisgKgorICogR2V0IHRoZSBwb3NzaWJsZSBzaXplcyBvZiBhIHJlc2l6ZWFi bGUgQkFSIGFzIGJpdG1hc2sgZGVmaW5lZCBpbiB0aGUgc3BlYworICogKGJpdCAwPTFNQiwgYml0 IDE5PTUxMkdCKS4gUmV0dXJucyAwIGlmIEJBUiBpc24ndCByZXNpemVhYmxlLgorICovCit1MzIg cGNpX3JiYXJfZ2V0X3Bvc3NpYmxlX3NpemVzKHN0cnVjdCBwY2lfZGV2ICpwZGV2LCBpbnQgYmFy KQoreworCXUzMiBjYXA7CisJaW50IHBvczsKKworCXBvcyA9IHBjaV9yYmFyX2ZpbmRfcG9zKHBk ZXYsIGJhcik7CisJaWYgKHBvcyA8IDApCisJCXJldHVybiAwOworCisJcGNpX3JlYWRfY29uZmln X2R3b3JkKHBkZXYsIHBvcyArIFBDSV9SRUJBUl9DQVAsICZjYXApOworCXJldHVybiAoY2FwICYg UENJX1JFQkFSX0NUUkxfU0laRVNfTUFTSykgPj4KKwkJUENJX1JFQkFSX0NUUkxfU0laRVNfU0hJ RlQ7Cit9CisKKy8qKgorICogcGNpX3JiYXJfZ2V0X2N1cnJlbnRfc2l6ZSAtIGdldCB0aGUgY3Vy cmVudCBzaXplIG9mIGEgQkFSCisgKiBAZGV2OiBQQ0kgZGV2aWNlCisgKiBAYmFyOiBCQVIgdG8g c2V0IHNpemUgdG8KKyAqCisgKiBSZWFkIHRoZSBzaXplIG9mIGEgQkFSIGZyb20gdGhlIHJlc2l6 ZWFibGUgQkFSIGNvbmZpZy4KKyAqIFJldHVybnMgc2l6ZSBpZiBmb3VuZCBvciBuZWdhdGl2ZSBl cnJvciBjb2RlLgorICovCitpbnQgcGNpX3JiYXJfZ2V0X2N1cnJlbnRfc2l6ZShzdHJ1Y3QgcGNp X2RldiAqcGRldiwgaW50IGJhcikKK3sKKwl1MzIgY3RybDsKKwlpbnQgcG9zOworCisJcG9zID0g cGNpX3JiYXJfZmluZF9wb3MocGRldiwgYmFyKTsKKwlpZiAocG9zIDwgMCkKKwkJcmV0dXJuIHBv czsKKworCXBjaV9yZWFkX2NvbmZpZ19kd29yZChwZGV2LCBwb3MgKyBQQ0lfUkVCQVJfQ1RSTCwg JmN0cmwpOworCXJldHVybiAoY3RybCAmIFBDSV9SRUJBUl9DVFJMX0JBUl9TSVpFX01BU0spID4+ CisJCVBDSV9SRUJBUl9DVFJMX0JBUl9TSVpFX1NISUZUOworfQorCisvKioKKyAqIHBjaV9yYmFy X3NldF9zaXplIC0gc2V0IGEgbmV3IHNpemUgZm9yIGEgQkFSCisgKiBAZGV2OiBQQ0kgZGV2aWNl CisgKiBAYmFyOiBCQVIgdG8gc2V0IHNpemUgdG8KKyAqIEBzaXplOiBuZXcgc2l6ZSBhcyBkZWZp bmVkIGluIHRoZSBzcGVjICgwPTFNQiwgMTk9NTEyR0IpCisgKgorICogU2V0IHRoZSBuZXcgc2l6 ZSBvZiBhIEJBUiBhcyBkZWZpbmVkIGluIHRoZSBzcGVjLgorICogUmV0dXJucyB6ZXJvIGlmIHJl c2l6aW5nIHdhcyBzdWNjZXNzZnVsLCBlcnJvciBjb2RlIG90aGVyd2lzZS4KKyAqLworaW50IHBj aV9yYmFyX3NldF9zaXplKHN0cnVjdCBwY2lfZGV2ICpwZGV2LCBpbnQgYmFyLCBpbnQgc2l6ZSkK K3sKKwl1MzIgY3RybDsKKwlpbnQgcG9zOworCisJcG9zID0gcGNpX3JiYXJfZmluZF9wb3MocGRl diwgYmFyKTsKKwlpZiAocG9zIDwgMCkKKwkJcmV0dXJuIHBvczsKKworCXBjaV9yZWFkX2NvbmZp Z19kd29yZChwZGV2LCBwb3MgKyBQQ0lfUkVCQVJfQ1RSTCwgJmN0cmwpOworCWN0cmwgJj0gflBD SV9SRUJBUl9DVFJMX0JBUl9TSVpFX01BU0s7CisJY3RybCB8PSBzaXplIDw8IFBDSV9SRUJBUl9D VFJMX0JBUl9TSVpFX1NISUZUOworCXBjaV93cml0ZV9jb25maWdfZHdvcmQocGRldiwgcG9zICsg UENJX1JFQkFSX0NUUkwsIGN0cmwpOworCXJldHVybiAwOworfQorCisvKioKICAqIHBjaV9zd2l6 emxlX2ludGVycnVwdF9waW4gLSBzd2l6emxlIElOVHggZm9yIGRldmljZSBiZWhpbmQgYnJpZGdl CiAgKiBAZGV2OiB0aGUgUENJIGRldmljZQogICogQHBpbjogdGhlIElOVHggcGluICgxPUlOVEEs IDI9SU5UQiwgMz1JTlRDLCA0PUlOVEQpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9wY2kuaCBi L2RyaXZlcnMvcGNpL3BjaS5oCmluZGV4IGIzZGE1NTMuLjIzYjc1ZTggMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvcGNpL3BjaS5oCisrKyBiL2RyaXZlcnMvcGNpL3BjaS5oCkBAIC0zNTcsNCArMzU3LDEy IEBAIGludCBhY3BpX2dldF9yY19yZXNvdXJjZXMoc3RydWN0IGRldmljZSAqZGV2LCBjb25zdCBj aGFyICpoaWQsIHUxNiBzZWdtZW50LAogCQkJICBzdHJ1Y3QgcmVzb3VyY2UgKnJlcyk7CiAjZW5k aWYKIAordTMyIHBjaV9yYmFyX2dldF9wb3NzaWJsZV9zaXplcyhzdHJ1Y3QgcGNpX2RldiAqcGRl diwgaW50IGJhcik7CitpbnQgcGNpX3JiYXJfZ2V0X2N1cnJlbnRfc2l6ZShzdHJ1Y3QgcGNpX2Rl diAqcGRldiwgaW50IGJhcik7CitpbnQgcGNpX3JiYXJfc2V0X3NpemUoc3RydWN0IHBjaV9kZXYg KnBkZXYsIGludCBiYXIsIGludCBzaXplKTsKK3N0YXRpYyBpbmxpbmUgdTY0IHBjaV9yYmFyX3Np emVfdG9fYnl0ZXMoaW50IHNpemUpCit7CisJcmV0dXJuIDFVTEwgPDwgKHNpemUgKyAyMCk7Cit9 CisKICNlbmRpZiAvKiBEUklWRVJTX1BDSV9IICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL3VhcGkv bGludXgvcGNpX3JlZ3MuaCBiL2luY2x1ZGUvdWFwaS9saW51eC9wY2lfcmVncy5oCmluZGV4IDYz NGM5YzQuLmI2YmQ2ZTUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvdWFwaS9saW51eC9wY2lfcmVncy5o CisrKyBiL2luY2x1ZGUvdWFwaS9saW51eC9wY2lfcmVncy5oCkBAIC05NDEsOSArOTQxLDE2IEBA CiAjZGVmaW5lIFBDSV9TQVRBX1NJWkVPRl9MT05HCTE2CiAKIC8qIFJlc2l6YWJsZSBCQVJzICov CisjZGVmaW5lIFBDSV9SRUJBUl9DQVAJCTQJLyogY2FwYWJpbGl0eSByZWdpc3RlciAqLworI2Rl ZmluZSAgUENJX1JFQkFSX0NUUkxfU0laRVNfTUFTSwkoMHhGRkZGRiA8PCA0KQkvKiBtYXNrIGZv ciBzaXplcyAqLworI2RlZmluZSAgUENJX1JFQkFSX0NUUkxfU0laRVNfU0hJRlQJNAkvKiBzaGlm dCBmb3Igc2l6ZXMgKi8KICNkZWZpbmUgUENJX1JFQkFSX0NUUkwJCTgJLyogY29udHJvbCByZWdp c3RlciAqLwotI2RlZmluZSAgUENJX1JFQkFSX0NUUkxfTkJBUl9NQVNLCSg3IDw8IDUpCS8qIG1h c2sgZm9yICMgYmFycyAqLwotI2RlZmluZSAgUENJX1JFQkFSX0NUUkxfTkJBUl9TSElGVAk1CS8q IHNoaWZ0IGZvciAjIGJhcnMgKi8KKyNkZWZpbmUgIFBDSV9SRUJBUl9DVFJMX0JBUl9JRFhfTUFT SwkoNyA8PCAwKQkvKiBtYXNrIGZvciBCQVIgaW5kZXggKi8KKyNkZWZpbmUgIFBDSV9SRUJBUl9D VFJMX0JBUl9JRFhfU0hJRlQJMAkvKiBzaGlmdCBmb3IgQkFSIGluZGV4ICovCisjZGVmaW5lICBQ Q0lfUkVCQVJfQ1RSTF9OQkFSX01BU0sJKDcgPDwgNSkJLyogbWFzayBmb3IgIyBCQVJzICovCisj ZGVmaW5lICBQQ0lfUkVCQVJfQ1RSTF9OQkFSX1NISUZUCTUJLyogc2hpZnQgZm9yICMgQkFScyAq LworI2RlZmluZSAgUENJX1JFQkFSX0NUUkxfQkFSX1NJWkVfTUFTSwkoMHgxRiA8PCA4KQkvKiBt YXNrIGZvciBCQVIgc2l6ZSAqLworI2RlZmluZSAgUENJX1JFQkFSX0NUUkxfQkFSX1NJWkVfU0hJ RlQJOAkvKiBzaGlmdCBmb3IgQkFSIHNpemUgKi8KIAogLyogRHluYW1pYyBQb3dlciBBbGxvY2F0 aW9uICovCiAjZGVmaW5lIFBDSV9EUEFfQ0FQCQk0CS8qIGNhcGFiaWxpdHkgcmVnaXN0ZXIgKi8K LS0gCjIuNy40CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f XwphbWQtZ2Z4IG1haWxpbmcgbGlzdAphbWQtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRw czovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2FtZC1nZngK