From mboxrd@z Thu Jan 1 00:00:00 1970 From: Toshi Kani Subject: [PATCH v2 1/7] ACPI / blacklist: add acpi_match_oemlist() interface Date: Thu, 3 Aug 2017 15:57:47 -0600 Message-ID: <20170803215753.30553-2-toshi.kani@hpe.com> References: <20170803215753.30553-1-toshi.kani@hpe.com> Return-path: Received: from g2t2352.austin.hpe.com ([15.233.44.25]:48134 "EHLO g2t2352.austin.hpe.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751914AbdHCWH1 (ORCPT ); Thu, 3 Aug 2017 18:07:27 -0400 In-Reply-To: <20170803215753.30553-1-toshi.kani@hpe.com> Sender: linux-acpi-owner@vger.kernel.org List-Id: linux-acpi@vger.kernel.org To: rjw@rjwysocki.net, bp@alien8.de Cc: mchehab@kernel.org, tony.luck@intel.com, lenb@kernel.org, linux-acpi@vger.kernel.org, linux-edac@vger.kernel.org, linux-kernel@vger.kernel.org, Toshi Kani ACPI OEM ID / OEM Table ID / Revision can be used to identify a platform based on ACPI firmware info. acpi_blacklisted(), intel_pstate_platform_pwr_mgmt_exists(), and some other funcs, have been using similar check to detect a list of platforms that require special handlings. Move the platform check in acpi_blacklisted() to a new common utility function, acpi_match_oemlist(), so that other drivers do not have to implement their own version. There is no change in functionality. Signed-off-by: Toshi Kani Cc: "Rafael J. Wysocki" Cc: Borislav Petkov --- drivers/acpi/blacklist.c | 83 ++++++++-------------------------------------- drivers/acpi/utils.c | 40 ++++++++++++++++++++++ include/linux/acpi.h | 19 +++++++++++ 3 files changed, 73 insertions(+), 69 deletions(-) diff --git a/drivers/acpi/blacklist.c b/drivers/acpi/blacklist.c index bb542ac..bf44573 100644 --- a/drivers/acpi/blacklist.c +++ b/drivers/acpi/blacklist.c @@ -30,30 +30,13 @@ #include "internal.h" -enum acpi_blacklist_predicates { - all_versions, - less_than_or_equal, - equal, - greater_than_or_equal, -}; - -struct acpi_blacklist_item { - char oem_id[7]; - char oem_table_id[9]; - u32 oem_revision; - char *table; - enum acpi_blacklist_predicates oem_revision_predicate; - char *reason; - u32 is_critical_error; -}; - static struct dmi_system_id acpi_rev_dmi_table[] __initdata; /* * POLICY: If *anything* doesn't work, put it on the blacklist. * If they are critical errors, mark it critical, and abort driver load. */ -static struct acpi_blacklist_item acpi_blacklist[] __initdata = { +static struct acpi_oemlist acpi_blacklist[] __initdata = { /* Compaq Presario 1700 */ {"PTLTD ", " DSDT ", 0x06040000, ACPI_SIG_DSDT, less_than_or_equal, "Multiple problems", 1}, @@ -67,65 +50,27 @@ static struct acpi_blacklist_item acpi_blacklist[] __initdata = { {"IBM ", "TP600E ", 0x00000105, ACPI_SIG_DSDT, less_than_or_equal, "Incorrect _ADR", 1}, - {""} + { } }; int __init acpi_blacklisted(void) { - int i = 0; + int i; int blacklisted = 0; - struct acpi_table_header table_header; - - while (acpi_blacklist[i].oem_id[0] != '\0') { - if (acpi_get_table_header(acpi_blacklist[i].table, 0, &table_header)) { - i++; - continue; - } - - if (strncmp(acpi_blacklist[i].oem_id, table_header.oem_id, 6)) { - i++; - continue; - } - - if (strncmp - (acpi_blacklist[i].oem_table_id, table_header.oem_table_id, - 8)) { - i++; - continue; - } - - if ((acpi_blacklist[i].oem_revision_predicate == all_versions) - || (acpi_blacklist[i].oem_revision_predicate == - less_than_or_equal - && table_header.oem_revision <= - acpi_blacklist[i].oem_revision) - || (acpi_blacklist[i].oem_revision_predicate == - greater_than_or_equal - && table_header.oem_revision >= - acpi_blacklist[i].oem_revision) - || (acpi_blacklist[i].oem_revision_predicate == equal - && table_header.oem_revision == - acpi_blacklist[i].oem_revision)) { - printk(KERN_ERR PREFIX - "Vendor \"%6.6s\" System \"%8.8s\" " - "Revision 0x%x has a known ACPI BIOS problem.\n", - acpi_blacklist[i].oem_id, - acpi_blacklist[i].oem_table_id, - acpi_blacklist[i].oem_revision); + i = acpi_match_oemlist(acpi_blacklist); + if (i >= 0) { + pr_err(PREFIX "Vendor \"%6.6s\" System \"%8.8s\" Revision 0x%x has a known ACPI BIOS problem.\n", + acpi_blacklist[i].oem_id, + acpi_blacklist[i].oem_table_id, + acpi_blacklist[i].oem_revision); - printk(KERN_ERR PREFIX - "Reason: %s. This is a %s error\n", - acpi_blacklist[i].reason, - (acpi_blacklist[i]. - is_critical_error ? "non-recoverable" : - "recoverable")); + pr_err(PREFIX "Reason: %s. This is a %s error\n", + acpi_blacklist[i].reason, + (acpi_blacklist[i].data ? + "non-recoverable" : "recoverable")); - blacklisted = acpi_blacklist[i].is_critical_error; - break; - } else { - i++; - } + blacklisted = acpi_blacklist[i].data; } (void)early_acpi_osi_init(); diff --git a/drivers/acpi/utils.c b/drivers/acpi/utils.c index b9d956c..78b9422 100644 --- a/drivers/acpi/utils.c +++ b/drivers/acpi/utils.c @@ -816,3 +816,43 @@ static int __init acpi_backlight(char *str) return 1; } __setup("acpi_backlight=", acpi_backlight); + +/** + * acpi_match_oemlist - Check if the system matches with an oem list + * @oem: pointer to acpi_oemlist table terminated by a NULL entry + * + * Return the matched index if the system is found in the oem list. + * Otherwise, return a negative error code. + */ +int acpi_match_oemlist(const struct acpi_oemlist *oem) +{ + struct acpi_table_header hdr; + int idx = 0; + + if (acpi_disabled) + return -ENODEV; + + for (; oem->oem_id[0]; oem++, idx++) { + if (ACPI_FAILURE(acpi_get_table_header(oem->table, 0, &hdr))) + continue; + + if (strncmp(oem->oem_id, hdr.oem_id, ACPI_OEM_ID_SIZE)) + continue; + + if (strncmp(oem->oem_table_id, hdr.oem_table_id, + ACPI_OEM_TABLE_ID_SIZE)) + continue; + + if ((oem->pred == all_versions) || + (oem->pred == less_than_or_equal + && hdr.oem_revision <= oem->oem_revision) || + (oem->pred == greater_than_or_equal + && hdr.oem_revision >= oem->oem_revision) || + (oem->pred == equal + && hdr.oem_revision == oem->oem_revision)) + return idx; + } + + return -ENODEV; +} +EXPORT_SYMBOL(acpi_match_oemlist); diff --git a/include/linux/acpi.h b/include/linux/acpi.h index c749eef..6053acb 100644 --- a/include/linux/acpi.h +++ b/include/linux/acpi.h @@ -556,6 +556,25 @@ extern acpi_status acpi_pci_osc_control_set(acpi_handle handle, #define ACPI_OST_SC_DRIVER_LOAD_FAILURE 0x81 #define ACPI_OST_SC_INSERT_NOT_SUPPORTED 0x82 +enum acpi_predicate { + all_versions, + less_than_or_equal, + equal, + greater_than_or_equal, +}; + +/* Table must be terminted by a NULL entry */ +struct acpi_oemlist { + char oem_id[ACPI_OEM_ID_SIZE]; + char oem_table_id[ACPI_OEM_TABLE_ID_SIZE]; + u32 oem_revision; + char *table; + enum acpi_predicate pred; + char *reason; + u32 data; +}; +int acpi_match_oemlist(const struct acpi_oemlist *oem); + extern void acpi_early_init(void); extern void acpi_subsystem_init(void); From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [v2,1/7] ACPI / blacklist: add acpi_match_oemlist() interface From: Toshi Kani Message-Id: <20170803215753.30553-2-toshi.kani@hpe.com> Date: Thu, 3 Aug 2017 15:57:47 -0600 To: rjw@rjwysocki.net, bp@alien8.de Cc: mchehab@kernel.org, tony.luck@intel.com, lenb@kernel.org, linux-acpi@vger.kernel.org, linux-edac@vger.kernel.org, linux-kernel@vger.kernel.org, Toshi Kani List-ID: QUNQSSBPRU0gSUQgLyBPRU0gVGFibGUgSUQgLyBSZXZpc2lvbiBjYW4gYmUgdXNlZCB0byBpZGVu dGlmeQphIHBsYXRmb3JtIGJhc2VkIG9uIEFDUEkgZmlybXdhcmUgaW5mby4gIGFjcGlfYmxhY2ts aXN0ZWQoKSwKaW50ZWxfcHN0YXRlX3BsYXRmb3JtX3B3cl9tZ210X2V4aXN0cygpLCBhbmQgc29t ZSBvdGhlciBmdW5jcywKaGF2ZSBiZWVuIHVzaW5nIHNpbWlsYXIgY2hlY2sgdG8gZGV0ZWN0IGEg bGlzdCBvZiBwbGF0Zm9ybXMKdGhhdCByZXF1aXJlIHNwZWNpYWwgaGFuZGxpbmdzLgoKTW92ZSB0 aGUgcGxhdGZvcm0gY2hlY2sgaW4gYWNwaV9ibGFja2xpc3RlZCgpIHRvIGEgbmV3IGNvbW1vbgp1 dGlsaXR5IGZ1bmN0aW9uLCBhY3BpX21hdGNoX29lbWxpc3QoKSwgc28gdGhhdCBvdGhlciBkcml2 ZXJzCmRvIG5vdCBoYXZlIHRvIGltcGxlbWVudCB0aGVpciBvd24gdmVyc2lvbi4KClRoZXJlIGlz IG5vIGNoYW5nZSBpbiBmdW5jdGlvbmFsaXR5LgoKU2lnbmVkLW9mZi1ieTogVG9zaGkgS2FuaSA8 dG9zaGkua2FuaUBocGUuY29tPgpDYzogIlJhZmFlbCBKLiBXeXNvY2tpIiA8cmp3QHJqd3lzb2Nr aS5uZXQ+CkNjOiBCb3Jpc2xhdiBQZXRrb3YgPGJwQGFsaWVuOC5kZT4KLS0tCiBkcml2ZXJzL2Fj cGkvYmxhY2tsaXN0LmMgfCAgIDgzICsrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0KIGRyaXZlcnMvYWNwaS91dGlscy5jICAgICB8ICAgNDAgKysrKysrKysrKysr KysrKysrKysrKwogaW5jbHVkZS9saW51eC9hY3BpLmggICAgIHwgICAxOSArKysrKysrKysrKwog MyBmaWxlcyBjaGFuZ2VkLCA3MyBpbnNlcnRpb25zKCspLCA2OSBkZWxldGlvbnMoLSkKCi0tClRv IHVuc3Vic2NyaWJlIGZyb20gdGhpcyBsaXN0OiBzZW5kIHRoZSBsaW5lICJ1bnN1YnNjcmliZSBs aW51eC1lZGFjIiBpbgp0aGUgYm9keSBvZiBhIG1lc3NhZ2UgdG8gbWFqb3Jkb21vQHZnZXIua2Vy bmVsLm9yZwpNb3JlIG1ham9yZG9tbyBpbmZvIGF0ICBodHRwOi8vdmdlci5rZXJuZWwub3JnL21h am9yZG9tby1pbmZvLmh0bWwKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYmxhY2tsaXN0LmMg Yi9kcml2ZXJzL2FjcGkvYmxhY2tsaXN0LmMKaW5kZXggYmI1NDJhYy4uYmY0NDU3MyAxMDA2NDQK LS0tIGEvZHJpdmVycy9hY3BpL2JsYWNrbGlzdC5jCisrKyBiL2RyaXZlcnMvYWNwaS9ibGFja2xp c3QuYwpAQCAtMzAsMzAgKzMwLDEzIEBACiAKICNpbmNsdWRlICJpbnRlcm5hbC5oIgogCi1lbnVt IGFjcGlfYmxhY2tsaXN0X3ByZWRpY2F0ZXMgewotCWFsbF92ZXJzaW9ucywKLQlsZXNzX3RoYW5f b3JfZXF1YWwsCi0JZXF1YWwsCi0JZ3JlYXRlcl90aGFuX29yX2VxdWFsLAotfTsKLQotc3RydWN0 IGFjcGlfYmxhY2tsaXN0X2l0ZW0gewotCWNoYXIgb2VtX2lkWzddOwotCWNoYXIgb2VtX3RhYmxl X2lkWzldOwotCXUzMiBvZW1fcmV2aXNpb247Ci0JY2hhciAqdGFibGU7Ci0JZW51bSBhY3BpX2Js YWNrbGlzdF9wcmVkaWNhdGVzIG9lbV9yZXZpc2lvbl9wcmVkaWNhdGU7Ci0JY2hhciAqcmVhc29u OwotCXUzMiBpc19jcml0aWNhbF9lcnJvcjsKLX07Ci0KIHN0YXRpYyBzdHJ1Y3QgZG1pX3N5c3Rl bV9pZCBhY3BpX3Jldl9kbWlfdGFibGVbXSBfX2luaXRkYXRhOwogCiAvKgogICogUE9MSUNZOiBJ ZiAqYW55dGhpbmcqIGRvZXNuJ3Qgd29yaywgcHV0IGl0IG9uIHRoZSBibGFja2xpc3QuCiAgKgkg ICBJZiB0aGV5IGFyZSBjcml0aWNhbCBlcnJvcnMsIG1hcmsgaXQgY3JpdGljYWwsIGFuZCBhYm9y dCBkcml2ZXIgbG9hZC4KICAqLwotc3RhdGljIHN0cnVjdCBhY3BpX2JsYWNrbGlzdF9pdGVtIGFj cGlfYmxhY2tsaXN0W10gX19pbml0ZGF0YSA9IHsKK3N0YXRpYyBzdHJ1Y3QgYWNwaV9vZW1saXN0 IGFjcGlfYmxhY2tsaXN0W10gX19pbml0ZGF0YSA9IHsKIAkvKiBDb21wYXEgUHJlc2FyaW8gMTcw MCAqLwogCXsiUFRMVEQgIiwgIiAgRFNEVCAgIiwgMHgwNjA0MDAwMCwgQUNQSV9TSUdfRFNEVCwg bGVzc190aGFuX29yX2VxdWFsLAogCSAiTXVsdGlwbGUgcHJvYmxlbXMiLCAxfSwKQEAgLTY3LDY1 ICs1MCwyNyBAQCBzdGF0aWMgc3RydWN0IGFjcGlfYmxhY2tsaXN0X2l0ZW0gYWNwaV9ibGFja2xp c3RbXSBfX2luaXRkYXRhID0gewogCXsiSUJNICAgIiwgIlRQNjAwRSAgIiwgMHgwMDAwMDEwNSwg QUNQSV9TSUdfRFNEVCwgbGVzc190aGFuX29yX2VxdWFsLAogCSAiSW5jb3JyZWN0IF9BRFIiLCAx fSwKIAotCXsiIn0KKwl7IH0KIH07CiAKIGludCBfX2luaXQgYWNwaV9ibGFja2xpc3RlZCh2b2lk KQogewotCWludCBpID0gMDsKKwlpbnQgaTsKIAlpbnQgYmxhY2tsaXN0ZWQgPSAwOwotCXN0cnVj dCBhY3BpX3RhYmxlX2hlYWRlciB0YWJsZV9oZWFkZXI7Ci0KLQl3aGlsZSAoYWNwaV9ibGFja2xp c3RbaV0ub2VtX2lkWzBdICE9ICdcMCcpIHsKLQkJaWYgKGFjcGlfZ2V0X3RhYmxlX2hlYWRlcihh Y3BpX2JsYWNrbGlzdFtpXS50YWJsZSwgMCwgJnRhYmxlX2hlYWRlcikpIHsKLQkJCWkrKzsKLQkJ CWNvbnRpbnVlOwotCQl9Ci0KLQkJaWYgKHN0cm5jbXAoYWNwaV9ibGFja2xpc3RbaV0ub2VtX2lk LCB0YWJsZV9oZWFkZXIub2VtX2lkLCA2KSkgewotCQkJaSsrOwotCQkJY29udGludWU7Ci0JCX0K LQotCQlpZiAoc3RybmNtcAotCQkgICAgKGFjcGlfYmxhY2tsaXN0W2ldLm9lbV90YWJsZV9pZCwg dGFibGVfaGVhZGVyLm9lbV90YWJsZV9pZCwKLQkJICAgICA4KSkgewotCQkJaSsrOwotCQkJY29u dGludWU7Ci0JCX0KLQotCQlpZiAoKGFjcGlfYmxhY2tsaXN0W2ldLm9lbV9yZXZpc2lvbl9wcmVk aWNhdGUgPT0gYWxsX3ZlcnNpb25zKQotCQkgICAgfHwgKGFjcGlfYmxhY2tsaXN0W2ldLm9lbV9y ZXZpc2lvbl9wcmVkaWNhdGUgPT0KLQkJCWxlc3NfdGhhbl9vcl9lcXVhbAotCQkJJiYgdGFibGVf aGVhZGVyLm9lbV9yZXZpc2lvbiA8PQotCQkJYWNwaV9ibGFja2xpc3RbaV0ub2VtX3JldmlzaW9u KQotCQkgICAgfHwgKGFjcGlfYmxhY2tsaXN0W2ldLm9lbV9yZXZpc2lvbl9wcmVkaWNhdGUgPT0K LQkJCWdyZWF0ZXJfdGhhbl9vcl9lcXVhbAotCQkJJiYgdGFibGVfaGVhZGVyLm9lbV9yZXZpc2lv biA+PQotCQkJYWNwaV9ibGFja2xpc3RbaV0ub2VtX3JldmlzaW9uKQotCQkgICAgfHwgKGFjcGlf YmxhY2tsaXN0W2ldLm9lbV9yZXZpc2lvbl9wcmVkaWNhdGUgPT0gZXF1YWwKLQkJCSYmIHRhYmxl X2hlYWRlci5vZW1fcmV2aXNpb24gPT0KLQkJCWFjcGlfYmxhY2tsaXN0W2ldLm9lbV9yZXZpc2lv bikpIHsKIAotCQkJcHJpbnRrKEtFUk5fRVJSIFBSRUZJWAotCQkJICAgICAgICJWZW5kb3IgXCIl Ni42c1wiIFN5c3RlbSBcIiU4LjhzXCIgIgotCQkJICAgICAgICJSZXZpc2lvbiAweCV4IGhhcyBh IGtub3duIEFDUEkgQklPUyBwcm9ibGVtLlxuIiwKLQkJCSAgICAgICBhY3BpX2JsYWNrbGlzdFtp XS5vZW1faWQsCi0JCQkgICAgICAgYWNwaV9ibGFja2xpc3RbaV0ub2VtX3RhYmxlX2lkLAotCQkJ ICAgICAgIGFjcGlfYmxhY2tsaXN0W2ldLm9lbV9yZXZpc2lvbik7CisJaSA9IGFjcGlfbWF0Y2hf b2VtbGlzdChhY3BpX2JsYWNrbGlzdCk7CisJaWYgKGkgPj0gMCkgeworCQlwcl9lcnIoUFJFRklY ICJWZW5kb3IgXCIlNi42c1wiIFN5c3RlbSBcIiU4LjhzXCIgUmV2aXNpb24gMHgleCBoYXMgYSBr bm93biBBQ1BJIEJJT1MgcHJvYmxlbS5cbiIsCisJCSAgICAgICBhY3BpX2JsYWNrbGlzdFtpXS5v ZW1faWQsCisJCSAgICAgICBhY3BpX2JsYWNrbGlzdFtpXS5vZW1fdGFibGVfaWQsCisJCSAgICAg ICBhY3BpX2JsYWNrbGlzdFtpXS5vZW1fcmV2aXNpb24pOwogCi0JCQlwcmludGsoS0VSTl9FUlIg UFJFRklYCi0JCQkgICAgICAgIlJlYXNvbjogJXMuIFRoaXMgaXMgYSAlcyBlcnJvclxuIiwKLQkJ CSAgICAgICBhY3BpX2JsYWNrbGlzdFtpXS5yZWFzb24sCi0JCQkgICAgICAgKGFjcGlfYmxhY2ts aXN0W2ldLgotCQkJCWlzX2NyaXRpY2FsX2Vycm9yID8gIm5vbi1yZWNvdmVyYWJsZSIgOgotCQkJ CSJyZWNvdmVyYWJsZSIpKTsKKwkJcHJfZXJyKFBSRUZJWCAiUmVhc29uOiAlcy4gVGhpcyBpcyBh ICVzIGVycm9yXG4iLAorCQkgICAgICAgYWNwaV9ibGFja2xpc3RbaV0ucmVhc29uLAorCQkgICAg ICAgKGFjcGlfYmxhY2tsaXN0W2ldLmRhdGEgPworCQkJIm5vbi1yZWNvdmVyYWJsZSIgOiAicmVj b3ZlcmFibGUiKSk7CiAKLQkJCWJsYWNrbGlzdGVkID0gYWNwaV9ibGFja2xpc3RbaV0uaXNfY3Jp dGljYWxfZXJyb3I7Ci0JCQlicmVhazsKLQkJfSBlbHNlIHsKLQkJCWkrKzsKLQkJfQorCQlibGFj a2xpc3RlZCA9IGFjcGlfYmxhY2tsaXN0W2ldLmRhdGE7CiAJfQogCiAJKHZvaWQpZWFybHlfYWNw aV9vc2lfaW5pdCgpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL3V0aWxzLmMgYi9kcml2ZXJz L2FjcGkvdXRpbHMuYwppbmRleCBiOWQ5NTZjLi43OGI5NDIyIDEwMDY0NAotLS0gYS9kcml2ZXJz L2FjcGkvdXRpbHMuYworKysgYi9kcml2ZXJzL2FjcGkvdXRpbHMuYwpAQCAtODE2LDMgKzgxNiw0 MyBAQCBzdGF0aWMgaW50IF9faW5pdCBhY3BpX2JhY2tsaWdodChjaGFyICpzdHIpCiAJcmV0dXJu IDE7CiB9CiBfX3NldHVwKCJhY3BpX2JhY2tsaWdodD0iLCBhY3BpX2JhY2tsaWdodCk7CisKKy8q KgorICogYWNwaV9tYXRjaF9vZW1saXN0IC0gQ2hlY2sgaWYgdGhlIHN5c3RlbSBtYXRjaGVzIHdp dGggYW4gb2VtIGxpc3QKKyAqIEBvZW06IHBvaW50ZXIgdG8gYWNwaV9vZW1saXN0IHRhYmxlIHRl cm1pbmF0ZWQgYnkgYSBOVUxMIGVudHJ5CisgKgorICogUmV0dXJuIHRoZSBtYXRjaGVkIGluZGV4 IGlmIHRoZSBzeXN0ZW0gaXMgZm91bmQgaW4gdGhlIG9lbSBsaXN0LgorICogT3RoZXJ3aXNlLCBy ZXR1cm4gYSBuZWdhdGl2ZSBlcnJvciBjb2RlLgorICovCitpbnQgYWNwaV9tYXRjaF9vZW1saXN0 KGNvbnN0IHN0cnVjdCBhY3BpX29lbWxpc3QgKm9lbSkKK3sKKwlzdHJ1Y3QgYWNwaV90YWJsZV9o ZWFkZXIgaGRyOworCWludCBpZHggPSAwOworCisJaWYgKGFjcGlfZGlzYWJsZWQpCisJCXJldHVy biAtRU5PREVWOworCisJZm9yICg7IG9lbS0+b2VtX2lkWzBdOyBvZW0rKywgaWR4KyspIHsKKwkJ aWYgKEFDUElfRkFJTFVSRShhY3BpX2dldF90YWJsZV9oZWFkZXIob2VtLT50YWJsZSwgMCwgJmhk cikpKQorCQkJY29udGludWU7CisKKwkJaWYgKHN0cm5jbXAob2VtLT5vZW1faWQsIGhkci5vZW1f aWQsIEFDUElfT0VNX0lEX1NJWkUpKQorCQkJY29udGludWU7CisKKwkJaWYgKHN0cm5jbXAob2Vt LT5vZW1fdGFibGVfaWQsIGhkci5vZW1fdGFibGVfaWQsCisJCQkgICAgQUNQSV9PRU1fVEFCTEVf SURfU0laRSkpCisJCQljb250aW51ZTsKKworCQlpZiAoKG9lbS0+cHJlZCA9PSBhbGxfdmVyc2lv bnMpIHx8CisJCSAgICAob2VtLT5wcmVkID09IGxlc3NfdGhhbl9vcl9lcXVhbAorCQkJJiYgaGRy Lm9lbV9yZXZpc2lvbiA8PSBvZW0tPm9lbV9yZXZpc2lvbikgfHwKKwkJICAgIChvZW0tPnByZWQg PT0gZ3JlYXRlcl90aGFuX29yX2VxdWFsCisJCQkmJiBoZHIub2VtX3JldmlzaW9uID49IG9lbS0+ b2VtX3JldmlzaW9uKSB8fAorCQkgICAgKG9lbS0+cHJlZCA9PSBlcXVhbAorCQkJJiYgaGRyLm9l bV9yZXZpc2lvbiA9PSBvZW0tPm9lbV9yZXZpc2lvbikpCisJCQlyZXR1cm4gaWR4OworCX0KKwor CXJldHVybiAtRU5PREVWOworfQorRVhQT1JUX1NZTUJPTChhY3BpX21hdGNoX29lbWxpc3QpOwpk aWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9hY3BpLmggYi9pbmNsdWRlL2xpbnV4L2FjcGkuaApp bmRleCBjNzQ5ZWVmLi42MDUzYWNiIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2FjcGkuaAor KysgYi9pbmNsdWRlL2xpbnV4L2FjcGkuaApAQCAtNTU2LDYgKzU1NiwyNSBAQCBleHRlcm4gYWNw aV9zdGF0dXMgYWNwaV9wY2lfb3NjX2NvbnRyb2xfc2V0KGFjcGlfaGFuZGxlIGhhbmRsZSwKICNk ZWZpbmUgQUNQSV9PU1RfU0NfRFJJVkVSX0xPQURfRkFJTFVSRQkJMHg4MQogI2RlZmluZSBBQ1BJ X09TVF9TQ19JTlNFUlRfTk9UX1NVUFBPUlRFRAkweDgyCiAKK2VudW0gYWNwaV9wcmVkaWNhdGUg eworCWFsbF92ZXJzaW9ucywKKwlsZXNzX3RoYW5fb3JfZXF1YWwsCisJZXF1YWwsCisJZ3JlYXRl cl90aGFuX29yX2VxdWFsLAorfTsKKworLyogVGFibGUgbXVzdCBiZSB0ZXJtaW50ZWQgYnkgYSBO VUxMIGVudHJ5ICovCitzdHJ1Y3QgYWNwaV9vZW1saXN0IHsKKwljaGFyCW9lbV9pZFtBQ1BJX09F TV9JRF9TSVpFXTsKKwljaGFyCW9lbV90YWJsZV9pZFtBQ1BJX09FTV9UQUJMRV9JRF9TSVpFXTsK Kwl1MzIJb2VtX3JldmlzaW9uOworCWNoYXIJKnRhYmxlOworCWVudW0gYWNwaV9wcmVkaWNhdGUg cHJlZDsKKwljaGFyCSpyZWFzb247CisJdTMyCWRhdGE7Cit9OworaW50IGFjcGlfbWF0Y2hfb2Vt bGlzdChjb25zdCBzdHJ1Y3QgYWNwaV9vZW1saXN0ICpvZW0pOworCiBleHRlcm4gdm9pZCBhY3Bp X2Vhcmx5X2luaXQodm9pZCk7CiBleHRlcm4gdm9pZCBhY3BpX3N1YnN5c3RlbV9pbml0KHZvaWQp OwogCg==