From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dave Martin Subject: [PATCH v5 18/30] arm64/sve: Probe SVE capabilities and usable vector lengths Date: Tue, 31 Oct 2017 15:51:10 +0000 Message-ID: <1509465082-30427-19-git-send-email-Dave.Martin@arm.com> References: <1509465082-30427-1-git-send-email-Dave.Martin@arm.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1509465082-30427-1-git-send-email-Dave.Martin@arm.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: kvmarm-bounces@lists.cs.columbia.edu Sender: kvmarm-bounces@lists.cs.columbia.edu To: linux-arm-kernel@lists.infradead.org Cc: linux-arch@vger.kernel.org, Okamoto Takayuki , libc-alpha@sourceware.org, Ard Biesheuvel , Szabolcs Nagy , Catalin Marinas , Will Deacon , kvmarm@lists.cs.columbia.edu List-Id: linux-arch.vger.kernel.org VGhpcyBwYXRjaCB1c2VzIHRoZSBjcHVmZWF0dXJlcyBmcmFtZXdvcmsgdG8gZGV0ZXJtaW5lIGNv bW1vbiBTVkUKY2FwYWJpbGl0aWVzIGFuZCB2ZWN0b3IgbGVuZ3RocywgYW5kIGNvbmZpZ3VyZXMg dGhlIHJ1bnRpbWUgU1ZFCnN1cHBvcnQgY29kZSBhcHByb3ByaWF0ZWx5LgoKWkNSX0VMeCBpcyBu b3QgcmVhbGx5IGEgZmVhdHVyZSByZWdpc3RlciwgYnV0IGl0IGlzIGNvbnZlbmllbnQgdG8KdXNl IGl0IGFzIGEgdGVtcGxhdGUgZm9yIHJlY29yZGluZyB0aGUgbWF4aW11bSB2ZWN0b3IgbGVuZ3Ro CnN1cHBvcnRlZCBieSBhIENQVSwgdXNpbmcgdGhlIExFTiBmaWVsZC4gIFRoaXMgZmllbGQgaXMg c2ltaWxhciB0bwphIGZlYXR1cmUgZmllbGQgaW4gdGhhdCBpdCBpcyBhIGNvbnRpZ3VvdXMgYml0 ZmllbGQgZm9yIHdoaWNoIHdlCndhbnQgdG8gZGV0ZXJtaW5lIHRoZSBtaW5pbXVtIHN5c3RlbS13 aWRlIHZhbHVlLiAgVGhpcyBwYXRjaCBhZGRzClpDUiBhcyBhIHBzZXVkby1yZWdpc3RlciBpbiBj cHVpbmZvL2NwdWZlYXR1cmVzLCB3aXRoIGFwcHJvcHJpYXRlCmN1c3RvbSBjb2RlIHRvIHBvcHVs YXRlIGl0LiAgRmluZGluZyB0aGUgbWluaW11bSBzdXBwb3J0ZWQgdmFsdWUgb2YKdGhlIExFTiBm aWVsZCBpcyBsZWZ0IHRvIHRoZSBjcHVmZWF0dXJlcyBmcmFtZXdvcmsgaW4gdGhlIHVzdWFsCndh eS4KClRoZSBtZWFuaW5nIG9mIElEX0FBNjRaRlIwX0VMMSBpcyBub3QgYXJjaGl0ZWN0dXJhbGx5 IGRlZmluZWQgeWV0LApzbyBmb3Igbm93IHdlIGp1c3QgcmVxdWlyZSBpdCB0byBiZSB6ZXJvLgoK Tm90ZSB0aGF0IG11Y2ggb2YgdGhpcyBjb2RlIGlzIGRvcm1hbnQgYW5kIFNWRSBzdGlsbCB3b24n dCBiZSB1c2VkCnlldCwgc2luY2Ugc3lzdGVtX3N1cHBvcnRzX3N2ZSgpIHJlbWFpbnMgaGFyZHdp cmVkIHRvIGZhbHNlLgoKU2lnbmVkLW9mZi1ieTogRGF2ZSBNYXJ0aW4gPERhdmUuTWFydGluQGFy bS5jb20+ClJldmlld2VkLWJ5OiBTdXp1a2kgSyBQb3Vsb3NlIDxzdXp1a2kucG91bG9zZUBhcm0u Y29tPgpSZXZpZXdlZC1ieTogQ2F0YWxpbiBNYXJpbmFzIDxjYXRhbGluLm1hcmluYXNAYXJtLmNv bT4KQ2M6IEFsZXggQmVubsOpZSA8YWxleC5iZW5uZWVAbGluYXJvLm9yZz4KCi0tLQoKKipEcm9w cGVkIGF0IHYzKiogUmV2aWV3ZWQtYnk6IEFsZXggQmVubsOpZSA8YWxleC5iZW5uZWVAbGluYXJv Lm9yZz4KU2VlIHYzIHBvc3RpbmcgZm9yIGhpc3RvcnkuCi0tLQogYXJjaC9hcm02NC9pbmNsdWRl L2FzbS9jcHUuaCAgICAgICAgfCAgIDQgKysKIGFyY2gvYXJtNjQvaW5jbHVkZS9hc20vY3B1ZmVh dHVyZS5oIHwgIDM2ICsrKysrKysrKysrKwogYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9mcHNpbWQu aCAgICAgfCAgMTQgKysrKysKIGFyY2gvYXJtNjQva2VybmVsL2NwdWZlYXR1cmUuYyAgICAgIHwg IDUyICsrKysrKysrKysrKysrKysKIGFyY2gvYXJtNjQva2VybmVsL2NwdWluZm8uYyAgICAgICAg IHwgICA2ICsrCiBhcmNoL2FybTY0L2tlcm5lbC9mcHNpbWQuYyAgICAgICAgICB8IDExNCArKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0KIDYgZmlsZXMgY2hhbmdlZCwgMjIzIGlu c2VydGlvbnMoKyksIDMgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9pbmNs dWRlL2FzbS9jcHUuaCBiL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20vY3B1LmgKaW5kZXggODg5MjI2 Yi4uODgzOTIyNyAxMDA2NDQKLS0tIGEvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9jcHUuaAorKysg Yi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2NwdS5oCkBAIC00MSw2ICs0MSw3IEBAIHN0cnVjdCBj cHVpbmZvX2FybTY0IHsKIAl1NjQJCXJlZ19pZF9hYTY0bW1mcjI7CiAJdTY0CQlyZWdfaWRfYWE2 NHBmcjA7CiAJdTY0CQlyZWdfaWRfYWE2NHBmcjE7CisJdTY0CQlyZWdfaWRfYWE2NHpmcjA7CiAK IAl1MzIJCXJlZ19pZF9kZnIwOwogCXUzMgkJcmVnX2lkX2lzYXIwOwpAQCAtNTksNiArNjAsOSBA QCBzdHJ1Y3QgY3B1aW5mb19hcm02NCB7CiAJdTMyCQlyZWdfbXZmcjA7CiAJdTMyCQlyZWdfbXZm cjE7CiAJdTMyCQlyZWdfbXZmcjI7CisKKwkvKiBwc2V1ZG8tWkNSIGZvciByZWNvcmRpbmcgbWF4 aW11bSBaQ1JfRUwxIExFTiB2YWx1ZTogKi8KKwl1NjQJCXJlZ196Y3I7CiB9OwogCiBERUNMQVJF X1BFUl9DUFUoc3RydWN0IGNwdWluZm9fYXJtNjQsIGNwdV9kYXRhKTsKZGlmZiAtLWdpdCBhL2Fy Y2gvYXJtNjQvaW5jbHVkZS9hc20vY3B1ZmVhdHVyZS5oIGIvYXJjaC9hcm02NC9pbmNsdWRlL2Fz bS9jcHVmZWF0dXJlLmgKaW5kZXggNGVhMzQ0MS4uOWIyN2U4YyAxMDA2NDQKLS0tIGEvYXJjaC9h cm02NC9pbmNsdWRlL2FzbS9jcHVmZWF0dXJlLmgKKysrIGIvYXJjaC9hcm02NC9pbmNsdWRlL2Fz bS9jcHVmZWF0dXJlLmgKQEAgLTEwLDcgKzEwLDkgQEAKICNkZWZpbmUgX19BU01fQ1BVRkVBVFVS RV9ICiAKICNpbmNsdWRlIDxhc20vY3B1Y2Fwcy5oPgorI2luY2x1ZGUgPGFzbS9mcHNpbWQuaD4K ICNpbmNsdWRlIDxhc20vaHdjYXAuaD4KKyNpbmNsdWRlIDxhc20vc2lnY29udGV4dC5oPgogI2lu Y2x1ZGUgPGFzbS9zeXNyZWcuaD4KIAogLyoKQEAgLTIyMyw2ICsyMjUsMTMgQEAgc3RhdGljIGlu bGluZSBib29sIGlkX2FhNjRwZnIwXzMyYml0X2VsMCh1NjQgcGZyMCkKIAlyZXR1cm4gdmFsID09 IElEX0FBNjRQRlIwX0VMMF8zMkJJVF82NEJJVDsKIH0KIAorc3RhdGljIGlubGluZSBib29sIGlk X2FhNjRwZnIwX3N2ZSh1NjQgcGZyMCkKK3sKKwl1MzIgdmFsID0gY3B1aWRfZmVhdHVyZV9leHRy YWN0X3Vuc2lnbmVkX2ZpZWxkKHBmcjAsIElEX0FBNjRQRlIwX1NWRV9TSElGVCk7CisKKwlyZXR1 cm4gdmFsID4gMDsKK30KKwogdm9pZCBfX2luaXQgc2V0dXBfY3B1X2ZlYXR1cmVzKHZvaWQpOwog CiB2b2lkIHVwZGF0ZV9jcHVfY2FwYWJpbGl0aWVzKGNvbnN0IHN0cnVjdCBhcm02NF9jcHVfY2Fw YWJpbGl0aWVzICpjYXBzLApAQCAtMjY3LDYgKzI3NiwzMyBAQCBzdGF0aWMgaW5saW5lIGJvb2wg c3lzdGVtX3N1cHBvcnRzX3N2ZSh2b2lkKQogCXJldHVybiBmYWxzZTsKIH0KIAorLyoKKyAqIFJl YWQgdGhlIHBzZXVkby1aQ1IgdXNlZCBieSBjcHVmZWF0dXJlcyB0byBpZGVudGlmeSB0aGUgc3Vw cG9ydGVkIFNWRQorICogdmVjdG9yIGxlbmd0aC4KKyAqCisgKiBVc2Ugb25seSBpZiBTVkUgaXMg cHJlc2VudC4KKyAqIFRoaXMgZnVuY3Rpb24gY2xvYmJlcnMgdGhlIFNWRSB2ZWN0b3IgbGVuZ3Ro LgorICovCitzdGF0aWMgaW5saW5lIHU2NCByZWFkX3pjcl9mZWF0dXJlcyh2b2lkKQoreworCXU2 NCB6Y3I7CisJdW5zaWduZWQgaW50IHZxX21heDsKKworCS8qCisJICogU2V0IHRoZSBtYXhpbXVt IHBvc3NpYmxlIFZMLCBhbmQgd3JpdGUgemVyb2VzIHRvIGFsbCBvdGhlcgorCSAqIGJpdHMgdG8g c2VlIGlmIHRoZXkgc3RpY2suCisJICovCisJc3ZlX2tlcm5lbF9lbmFibGUoTlVMTCk7CisJd3Jp dGVfc3lzcmVnX3MoWkNSX0VMeF9MRU5fTUFTSywgU1lTX1pDUl9FTDEpOworCisJemNyID0gcmVh ZF9zeXNyZWdfcyhTWVNfWkNSX0VMMSk7CisJemNyICY9IH4odTY0KVpDUl9FTHhfTEVOX01BU0s7 IC8qIGZpbmQgc3RpY2t5IDFzIG91dHNpZGUgTEVOIGZpZWxkICovCisJdnFfbWF4ID0gc3ZlX3Zx X2Zyb21fdmwoc3ZlX2dldF92bCgpKTsKKwl6Y3IgfD0gdnFfbWF4IC0gMTsgLyogc2V0IExFTiBm aWVsZCB0byBtYXhpbXVtIGVmZmVjdGl2ZSB2YWx1ZSAqLworCisJcmV0dXJuIHpjcjsKK30KKwog I2VuZGlmIC8qIF9fQVNTRU1CTFlfXyAqLwogCiAjZW5kaWYKZGlmZiAtLWdpdCBhL2FyY2gvYXJt NjQvaW5jbHVkZS9hc20vZnBzaW1kLmggYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2Zwc2ltZC5o CmluZGV4IDg2ZjU1MGMuLmQ4ZTBkYzkgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtNjQvaW5jbHVkZS9h c20vZnBzaW1kLmgKKysrIGIvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9mcHNpbWQuaApAQCAtNzgs NiArNzgsNyBAQCBleHRlcm4gdm9pZCBzdmVfc2F2ZV9zdGF0ZSh2b2lkICpzdGF0ZSwgdTMyICpw ZnBzcik7CiBleHRlcm4gdm9pZCBzdmVfbG9hZF9zdGF0ZSh2b2lkIGNvbnN0ICpzdGF0ZSwgdTMy IGNvbnN0ICpwZnBzciwKIAkJCSAgIHVuc2lnbmVkIGxvbmcgdnFfbWludXNfMSk7CiBleHRlcm4g dW5zaWduZWQgaW50IHN2ZV9nZXRfdmwodm9pZCk7CitleHRlcm4gaW50IHN2ZV9rZXJuZWxfZW5h YmxlKHZvaWQgKik7CiAKIGV4dGVybiBpbnQgX19yb19hZnRlcl9pbml0IHN2ZV9tYXhfdmw7CiAK QEAgLTkwLDEwICs5MSwyMyBAQCBleHRlcm4gdm9pZCBmcHNpbWRfcmVsZWFzZV90YXNrKHN0cnVj dCB0YXNrX3N0cnVjdCAqdGFzayk7CiBleHRlcm4gaW50IHN2ZV9zZXRfdmVjdG9yX2xlbmd0aChz dHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2ssCiAJCQkJIHVuc2lnbmVkIGxvbmcgdmwsIHVuc2lnbmVk IGxvbmcgZmxhZ3MpOwogCisvKgorICogUHJvYmluZyBhbmQgc2V0dXAgZnVuY3Rpb25zLgorICog Q2FsbHMgdG8gdGhlc2UgZnVuY3Rpb25zIG11c3QgYmUgc2VyaWFsaXNlZCB3aXRoIG9uZSBhbm90 aGVyLgorICovCitleHRlcm4gdm9pZCBfX2luaXQgc3ZlX2luaXRfdnFfbWFwKHZvaWQpOworZXh0 ZXJuIHZvaWQgc3ZlX3VwZGF0ZV92cV9tYXAodm9pZCk7CitleHRlcm4gaW50IHN2ZV92ZXJpZnlf dnFfbWFwKHZvaWQpOworZXh0ZXJuIHZvaWQgX19pbml0IHN2ZV9zZXR1cCh2b2lkKTsKKwogI2Vs c2UgLyogISBDT05GSUdfQVJNNjRfU1ZFICovCiAKIHN0YXRpYyBpbmxpbmUgdm9pZCBzdmVfYWxs b2Moc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKSB7IH0KIHN0YXRpYyBpbmxpbmUgdm9pZCBmcHNp bWRfcmVsZWFzZV90YXNrKHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaykgeyB9CitzdGF0aWMgaW5s aW5lIHZvaWQgc3ZlX2luaXRfdnFfbWFwKHZvaWQpIHsgfQorc3RhdGljIGlubGluZSB2b2lkIHN2 ZV91cGRhdGVfdnFfbWFwKHZvaWQpIHsgfQorc3RhdGljIGlubGluZSBpbnQgc3ZlX3ZlcmlmeV92 cV9tYXAodm9pZCkgeyByZXR1cm4gMDsgfQorc3RhdGljIGlubGluZSB2b2lkIHN2ZV9zZXR1cCh2 b2lkKSB7IH0KIAogI2VuZGlmIC8qICEgQ09ORklHX0FSTTY0X1NWRSAqLwogCmRpZmYgLS1naXQg YS9hcmNoL2FybTY0L2tlcm5lbC9jcHVmZWF0dXJlLmMgYi9hcmNoL2FybTY0L2tlcm5lbC9jcHVm ZWF0dXJlLmMKaW5kZXggZTIyNjc5OS4uMjE1NDM3MyAxMDA2NDQKLS0tIGEvYXJjaC9hcm02NC9r ZXJuZWwvY3B1ZmVhdHVyZS5jCisrKyBiL2FyY2gvYXJtNjQva2VybmVsL2NwdWZlYXR1cmUuYwpA QCAtMjcsNiArMjcsNyBAQAogI2luY2x1ZGUgPGFzbS9jcHUuaD4KICNpbmNsdWRlIDxhc20vY3B1 ZmVhdHVyZS5oPgogI2luY2x1ZGUgPGFzbS9jcHVfb3BzLmg+CisjaW5jbHVkZSA8YXNtL2Zwc2lt ZC5oPgogI2luY2x1ZGUgPGFzbS9tbXVfY29udGV4dC5oPgogI2luY2x1ZGUgPGFzbS9wcm9jZXNz b3IuaD4KICNpbmNsdWRlIDxhc20vc3lzcmVnLmg+CkBAIC0yODcsNiArMjg4LDEyIEBAIHN0YXRp YyBjb25zdCBzdHJ1Y3QgYXJtNjRfZnRyX2JpdHMgZnRyX2lkX2RmcjBbXSA9IHsKIAlBUk02NF9G VFJfRU5ELAogfTsKIAorc3RhdGljIGNvbnN0IHN0cnVjdCBhcm02NF9mdHJfYml0cyBmdHJfemNy W10gPSB7CisJQVJNNjRfRlRSX0JJVFMoRlRSX0hJRERFTiwgRlRSX05PTlNUUklDVCwgRlRSX0xP V0VSX1NBRkUsCisJCVpDUl9FTHhfTEVOX1NISUZULCBaQ1JfRUx4X0xFTl9TSVpFLCAwKSwJLyog TEVOICovCisJQVJNNjRfRlRSX0VORCwKK307CisKIC8qCiAgKiBDb21tb24gZnRyIGJpdHMgZm9y IGEgMzJiaXQgcmVnaXN0ZXIgd2l0aCBhbGwgaGlkZGVuLCBzdHJpY3QKICAqIGF0dHJpYnV0ZXMs IHdpdGggNGJpdCBmZWF0dXJlIGZpZWxkcyBhbmQgYSBkZWZhdWx0IHNhZmUgdmFsdWUgb2YKQEAg LTM1Myw2ICszNjAsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IF9fZnRyX3JlZ19lbnRyeSB7CiAJ LyogT3AxID0gMCwgQ1JuID0gMCwgQ1JtID0gNCAqLwogCUFSTTY0X0ZUUl9SRUcoU1lTX0lEX0FB NjRQRlIwX0VMMSwgZnRyX2lkX2FhNjRwZnIwKSwKIAlBUk02NF9GVFJfUkVHKFNZU19JRF9BQTY0 UEZSMV9FTDEsIGZ0cl9yYXopLAorCUFSTTY0X0ZUUl9SRUcoU1lTX0lEX0FBNjRaRlIwX0VMMSwg ZnRyX3JheiksCiAKIAkvKiBPcDEgPSAwLCBDUm4gPSAwLCBDUm0gPSA1ICovCiAJQVJNNjRfRlRS X1JFRyhTWVNfSURfQUE2NERGUjBfRUwxLCBmdHJfaWRfYWE2NGRmcjApLApAQCAtMzY3LDYgKzM3 NSw5IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgX19mdHJfcmVnX2VudHJ5IHsKIAlBUk02NF9GVFJf UkVHKFNZU19JRF9BQTY0TU1GUjFfRUwxLCBmdHJfaWRfYWE2NG1tZnIxKSwKIAlBUk02NF9GVFJf UkVHKFNZU19JRF9BQTY0TU1GUjJfRUwxLCBmdHJfaWRfYWE2NG1tZnIyKSwKIAorCS8qIE9wMSA9 IDAsIENSbiA9IDEsIENSbSA9IDIgKi8KKwlBUk02NF9GVFJfUkVHKFNZU19aQ1JfRUwxLCBmdHJf emNyKSwKKwogCS8qIE9wMSA9IDMsIENSbiA9IDAsIENSbSA9IDAgKi8KIAl7IFNZU19DVFJfRUww LCAmYXJtNjRfZnRyX3JlZ19jdHJlbDAgfSwKIAlBUk02NF9GVFJfUkVHKFNZU19EQ1pJRF9FTDAs IGZ0cl9kY3ppZCksCkBAIC01MDQsNiArNTE1LDcgQEAgdm9pZCBfX2luaXQgaW5pdF9jcHVfZmVh dHVyZXMoc3RydWN0IGNwdWluZm9fYXJtNjQgKmluZm8pCiAJaW5pdF9jcHVfZnRyX3JlZyhTWVNf SURfQUE2NE1NRlIyX0VMMSwgaW5mby0+cmVnX2lkX2FhNjRtbWZyMik7CiAJaW5pdF9jcHVfZnRy X3JlZyhTWVNfSURfQUE2NFBGUjBfRUwxLCBpbmZvLT5yZWdfaWRfYWE2NHBmcjApOwogCWluaXRf Y3B1X2Z0cl9yZWcoU1lTX0lEX0FBNjRQRlIxX0VMMSwgaW5mby0+cmVnX2lkX2FhNjRwZnIxKTsK Kwlpbml0X2NwdV9mdHJfcmVnKFNZU19JRF9BQTY0WkZSMF9FTDEsIGluZm8tPnJlZ19pZF9hYTY0 emZyMCk7CiAKIAlpZiAoaWRfYWE2NHBmcjBfMzJiaXRfZWwwKGluZm8tPnJlZ19pZF9hYTY0cGZy MCkpIHsKIAkJaW5pdF9jcHVfZnRyX3JlZyhTWVNfSURfREZSMF9FTDEsIGluZm8tPnJlZ19pZF9k ZnIwKTsKQEAgLTUyNCw2ICs1MzYsMTAgQEAgdm9pZCBfX2luaXQgaW5pdF9jcHVfZmVhdHVyZXMo c3RydWN0IGNwdWluZm9fYXJtNjQgKmluZm8pCiAJCWluaXRfY3B1X2Z0cl9yZWcoU1lTX01WRlIy X0VMMSwgaW5mby0+cmVnX212ZnIyKTsKIAl9CiAKKwlpZiAoaWRfYWE2NHBmcjBfc3ZlKGluZm8t PnJlZ19pZF9hYTY0cGZyMCkpIHsKKwkJaW5pdF9jcHVfZnRyX3JlZyhTWVNfWkNSX0VMMSwgaW5m by0+cmVnX3pjcik7CisJCXN2ZV9pbml0X3ZxX21hcCgpOworCX0KIH0KIAogc3RhdGljIHZvaWQg dXBkYXRlX2NwdV9mdHJfcmVnKHN0cnVjdCBhcm02NF9mdHJfcmVnICpyZWcsIHU2NCBuZXcpCkBA IC02MjcsNiArNjQzLDkgQEAgdm9pZCB1cGRhdGVfY3B1X2ZlYXR1cmVzKGludCBjcHUsCiAJdGFp bnQgfD0gY2hlY2tfdXBkYXRlX2Z0cl9yZWcoU1lTX0lEX0FBNjRQRlIxX0VMMSwgY3B1LAogCQkJ CSAgICAgIGluZm8tPnJlZ19pZF9hYTY0cGZyMSwgYm9vdC0+cmVnX2lkX2FhNjRwZnIxKTsKIAor CXRhaW50IHw9IGNoZWNrX3VwZGF0ZV9mdHJfcmVnKFNZU19JRF9BQTY0WkZSMF9FTDEsIGNwdSwK KwkJCQkgICAgICBpbmZvLT5yZWdfaWRfYWE2NHpmcjAsIGJvb3QtPnJlZ19pZF9hYTY0emZyMCk7 CisKIAkvKgogCSAqIElmIHdlIGhhdmUgQUFyY2gzMiwgd2UgY2FyZSBhYm91dCAzMi1iaXQgZmVh dHVyZXMgZm9yIGNvbXBhdC4KIAkgKiBJZiB0aGUgc3lzdGVtIGRvZXNuJ3Qgc3VwcG9ydCBBQXJj aDMyLCBkb24ndCB1cGRhdGUgdGhlbS4KQEAgLTY3NCw2ICs2OTMsMTYgQEAgdm9pZCB1cGRhdGVf Y3B1X2ZlYXR1cmVzKGludCBjcHUsCiAJCQkJCWluZm8tPnJlZ19tdmZyMiwgYm9vdC0+cmVnX212 ZnIyKTsKIAl9CiAKKwlpZiAoaWRfYWE2NHBmcjBfc3ZlKGluZm8tPnJlZ19pZF9hYTY0cGZyMCkp IHsKKwkJdGFpbnQgfD0gY2hlY2tfdXBkYXRlX2Z0cl9yZWcoU1lTX1pDUl9FTDEsIGNwdSwKKwkJ CQkJaW5mby0+cmVnX3pjciwgYm9vdC0+cmVnX3pjcik7CisKKwkJLyogUHJvYmUgdmVjdG9yIGxl bmd0aHMsIHVubGVzcyB3ZSBhbHJlYWR5IGdhdmUgdXAgb24gU1ZFICovCisJCWlmIChpZF9hYTY0 cGZyMF9zdmUocmVhZF9zYW5pdGlzZWRfZnRyX3JlZyhTWVNfSURfQUE2NFBGUjBfRUwxKSkgJiYK KwkJICAgICFzeXNfY2Fwc19pbml0aWFsaXNlZCkKKwkJCXN2ZV91cGRhdGVfdnFfbWFwKCk7CisJ fQorCiAJLyoKIAkgKiBNaXNtYXRjaGVkIENQVSBmZWF0dXJlcyBhcmUgYSByZWNpcGUgZm9yIGRp c2FzdGVyLiBEb24ndCBldmVuCiAJICogcHJldGVuZCB0byBzdXBwb3J0IHRoZW0uCkBAIC0xMTA2 LDYgKzExMzUsMjMgQEAgdmVyaWZ5X2xvY2FsX2NwdV9mZWF0dXJlcyhjb25zdCBzdHJ1Y3QgYXJt NjRfY3B1X2NhcGFiaWxpdGllcyAqY2FwcykKIAl9CiB9CiAKK3N0YXRpYyB2b2lkIHZlcmlmeV9z dmVfZmVhdHVyZXModm9pZCkKK3sKKwl1NjQgc2FmZV96Y3IgPSByZWFkX3Nhbml0aXNlZF9mdHJf cmVnKFNZU19aQ1JfRUwxKTsKKwl1NjQgemNyID0gcmVhZF96Y3JfZmVhdHVyZXMoKTsKKworCXVu c2lnbmVkIGludCBzYWZlX2xlbiA9IHNhZmVfemNyICYgWkNSX0VMeF9MRU5fTUFTSzsKKwl1bnNp Z25lZCBpbnQgbGVuID0gemNyICYgWkNSX0VMeF9MRU5fTUFTSzsKKworCWlmIChsZW4gPCBzYWZl X2xlbiB8fCBzdmVfdmVyaWZ5X3ZxX21hcCgpKSB7CisJCXByX2NyaXQoIkNQVSVkOiBTVkU6IHJl cXVpcmVkIHZlY3RvciBsZW5ndGgocykgbWlzc2luZ1xuIiwKKwkJCXNtcF9wcm9jZXNzb3JfaWQo KSk7CisJCWNwdV9kaWVfZWFybHkoKTsKKwl9CisKKwkvKiBBZGQgY2hlY2tzIG9uIG90aGVyIFpD UiBiaXRzIGhlcmUgaWYgbmVjZXNzYXJ5ICovCit9CisKIC8qCiAgKiBSdW4gdGhyb3VnaCB0aGUg ZW5hYmxlZCBzeXN0ZW0gY2FwYWJpbGl0aWVzIGFuZCBlbmFibGUoKSBpdCBvbiB0aGlzIENQVS4K ICAqIFRoZSBjYXBhYmlsaXRpZXMgd2VyZSBkZWNpZGVkIGJhc2VkIG9uIHRoZSBhdmFpbGFibGUg Q1BVcyBhdCB0aGUgYm9vdCB0aW1lLgpAQCAtMTExOSw4ICsxMTY1LDEyIEBAIHN0YXRpYyB2b2lk IHZlcmlmeV9sb2NhbF9jcHVfY2FwYWJpbGl0aWVzKHZvaWQpCiAJdmVyaWZ5X2xvY2FsX2NwdV9l cnJhdGFfd29ya2Fyb3VuZHMoKTsKIAl2ZXJpZnlfbG9jYWxfY3B1X2ZlYXR1cmVzKGFybTY0X2Zl YXR1cmVzKTsKIAl2ZXJpZnlfbG9jYWxfZWxmX2h3Y2Fwcyhhcm02NF9lbGZfaHdjYXBzKTsKKwog CWlmIChzeXN0ZW1fc3VwcG9ydHNfMzJiaXRfZWwwKCkpCiAJCXZlcmlmeV9sb2NhbF9lbGZfaHdj YXBzKGNvbXBhdF9lbGZfaHdjYXBzKTsKKworCWlmIChzeXN0ZW1fc3VwcG9ydHNfc3ZlKCkpCisJ CXZlcmlmeV9zdmVfZmVhdHVyZXMoKTsKIH0KIAogdm9pZCBjaGVja19sb2NhbF9jcHVfY2FwYWJp bGl0aWVzKHZvaWQpCkBAIC0xMTk4LDYgKzEyNDgsOCBAQCB2b2lkIF9faW5pdCBzZXR1cF9jcHVf ZmVhdHVyZXModm9pZCkKIAlpZiAoc3lzdGVtX3N1cHBvcnRzXzMyYml0X2VsMCgpKQogCQlzZXR1 cF9lbGZfaHdjYXBzKGNvbXBhdF9lbGZfaHdjYXBzKTsKIAorCXN2ZV9zZXR1cCgpOworCiAJLyog QWR2ZXJ0aXNlIHRoYXQgd2UgaGF2ZSBjb21wdXRlZCB0aGUgc3lzdGVtIGNhcGFiaWxpdGllcyAq LwogCXNldF9zeXNfY2Fwc19pbml0aWFsaXNlZCgpOwogCmRpZmYgLS1naXQgYS9hcmNoL2FybTY0 L2tlcm5lbC9jcHVpbmZvLmMgYi9hcmNoL2FybTY0L2tlcm5lbC9jcHVpbmZvLmMKaW5kZXggMWZm MWM1YS4uNThkYTUwNCAxMDA2NDQKLS0tIGEvYXJjaC9hcm02NC9rZXJuZWwvY3B1aW5mby5jCisr KyBiL2FyY2gvYXJtNjQva2VybmVsL2NwdWluZm8uYwpAQCAtMTksNiArMTksNyBAQAogI2luY2x1 ZGUgPGFzbS9jcHUuaD4KICNpbmNsdWRlIDxhc20vY3B1dHlwZS5oPgogI2luY2x1ZGUgPGFzbS9j cHVmZWF0dXJlLmg+CisjaW5jbHVkZSA8YXNtL2Zwc2ltZC5oPgogCiAjaW5jbHVkZSA8bGludXgv Yml0b3BzLmg+CiAjaW5jbHVkZSA8bGludXgvYnVnLmg+CkBAIC0zMzEsNiArMzMyLDcgQEAgc3Rh dGljIHZvaWQgX19jcHVpbmZvX3N0b3JlX2NwdShzdHJ1Y3QgY3B1aW5mb19hcm02NCAqaW5mbykK IAlpbmZvLT5yZWdfaWRfYWE2NG1tZnIyID0gcmVhZF9jcHVpZChJRF9BQTY0TU1GUjJfRUwxKTsK IAlpbmZvLT5yZWdfaWRfYWE2NHBmcjAgPSByZWFkX2NwdWlkKElEX0FBNjRQRlIwX0VMMSk7CiAJ aW5mby0+cmVnX2lkX2FhNjRwZnIxID0gcmVhZF9jcHVpZChJRF9BQTY0UEZSMV9FTDEpOworCWlu Zm8tPnJlZ19pZF9hYTY0emZyMCA9IHJlYWRfY3B1aWQoSURfQUE2NFpGUjBfRUwxKTsKIAogCS8q IFVwZGF0ZSB0aGUgMzJiaXQgSUQgcmVnaXN0ZXJzIG9ubHkgaWYgQUFyY2gzMiBpcyBpbXBsZW1l bnRlZCAqLwogCWlmIChpZF9hYTY0cGZyMF8zMmJpdF9lbDAoaW5mby0+cmVnX2lkX2FhNjRwZnIw KSkgewpAQCAtMzUzLDYgKzM1NSwxMCBAQCBzdGF0aWMgdm9pZCBfX2NwdWluZm9fc3RvcmVfY3B1 KHN0cnVjdCBjcHVpbmZvX2FybTY0ICppbmZvKQogCQlpbmZvLT5yZWdfbXZmcjIgPSByZWFkX2Nw dWlkKE1WRlIyX0VMMSk7CiAJfQogCisJaWYgKElTX0VOQUJMRUQoQ09ORklHX0FSTTY0X1NWRSkg JiYKKwkgICAgaWRfYWE2NHBmcjBfc3ZlKGluZm8tPnJlZ19pZF9hYTY0cGZyMCkpCisJCWluZm8t PnJlZ196Y3IgPSByZWFkX3pjcl9mZWF0dXJlcygpOworCiAJY3B1aW5mb19kZXRlY3RfaWNhY2hl X3BvbGljeShpbmZvKTsKIH0KIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9rZXJuZWwvZnBzaW1k LmMgYi9hcmNoL2FybTY0L2tlcm5lbC9mcHNpbWQuYwppbmRleCAxY2ViMDY5Li5jMTEyOTcyIDEw MDY0NAotLS0gYS9hcmNoL2FybTY0L2tlcm5lbC9mcHNpbWQuYworKysgYi9hcmNoL2FybTY0L2tl cm5lbC9mcHNpbWQuYwpAQCAtMTE0LDE5ICsxMTQsMTkgQEAKIHN0YXRpYyBERUZJTkVfUEVSX0NQ VShzdHJ1Y3QgZnBzaW1kX3N0YXRlICosIGZwc2ltZF9sYXN0X3N0YXRlKTsKIAogLyogRGVmYXVs dCBWTCBmb3IgdGFza3MgdGhhdCBkb24ndCBzZXQgaXQgZXhwbGljaXRseTogKi8KLXN0YXRpYyBp bnQgc3ZlX2RlZmF1bHRfdmwgPSBTVkVfVkxfTUlOOworc3RhdGljIGludCBzdmVfZGVmYXVsdF92 bCA9IC0xOwogCiAjaWZkZWYgQ09ORklHX0FSTTY0X1NWRQogCiAvKiBNYXhpbXVtIHN1cHBvcnRl ZCB2ZWN0b3IgbGVuZ3RoIGFjcm9zcyBhbGwgQ1BVcyAoaW5pdGlhbGx5IHBvaXNvbmVkKSAqLwog aW50IF9fcm9fYWZ0ZXJfaW5pdCBzdmVfbWF4X3ZsID0gLTE7CiAvKiBTZXQgb2YgYXZhaWxhYmxl IHZlY3RvciBsZW5ndGhzLCBhcyB2cV90b19iaXQodnEpOiAqLwotc3RhdGljIERFQ0xBUkVfQklU TUFQKHN2ZV92cV9tYXAsIFNWRV9WUV9NQVgpOworc3RhdGljIF9fcm9fYWZ0ZXJfaW5pdCBERUNM QVJFX0JJVE1BUChzdmVfdnFfbWFwLCBTVkVfVlFfTUFYKTsKIAogI2Vsc2UgLyogISBDT05GSUdf QVJNNjRfU1ZFICovCiAKIC8qIER1bW15IGRlY2xhcmF0aW9uIGZvciBjb2RlIHRoYXQgd2lsbCBi ZSBvcHRpbWlzZWQgb3V0OiAqLwotZXh0ZXJuIERFQ0xBUkVfQklUTUFQKHN2ZV92cV9tYXAsIFNW RV9WUV9NQVgpOworZXh0ZXJuIF9fcm9fYWZ0ZXJfaW5pdCBERUNMQVJFX0JJVE1BUChzdmVfdnFf bWFwLCBTVkVfVlFfTUFYKTsKIAogI2VuZGlmIC8qICEgQ09ORklHX0FSTTY0X1NWRSAqLwogCkBA IC00OTYsNiArNDk2LDExMSBAQCBpbnQgc3ZlX3NldF92ZWN0b3JfbGVuZ3RoKHN0cnVjdCB0YXNr X3N0cnVjdCAqdGFzaywKIH0KIAogLyoKKyAqIEJpdG1hcCBmb3IgdGVtcG9yYXJ5IHN0b3JhZ2Ug b2YgdGhlIHBlci1DUFUgc2V0IG9mIHN1cHBvcnRlZCB2ZWN0b3IgbGVuZ3RocworICogZHVyaW5n IHNlY29uZGFyeSBib290LgorICovCitzdGF0aWMgREVDTEFSRV9CSVRNQVAoc3ZlX3NlY29uZGFy eV92cV9tYXAsIFNWRV9WUV9NQVgpOworCitzdGF0aWMgdm9pZCBzdmVfcHJvYmVfdnFzKERFQ0xB UkVfQklUTUFQKG1hcCwgU1ZFX1ZRX01BWCkpCit7CisJdW5zaWduZWQgaW50IHZxLCB2bDsKKwl1 bnNpZ25lZCBsb25nIHpjcjsKKworCWJpdG1hcF96ZXJvKG1hcCwgU1ZFX1ZRX01BWCk7CisKKwl6 Y3IgPSBaQ1JfRUx4X0xFTl9NQVNLOworCXpjciA9IHJlYWRfc3lzcmVnX3MoU1lTX1pDUl9FTDEp ICYgfnpjcjsKKworCWZvciAodnEgPSBTVkVfVlFfTUFYOyB2cSA+PSBTVkVfVlFfTUlOOyAtLXZx KSB7CisJCXdyaXRlX3N5c3JlZ19zKHpjciB8ICh2cSAtIDEpLCBTWVNfWkNSX0VMMSk7IC8qIHNl bGYtc3luY2luZyAqLworCQl2bCA9IHN2ZV9nZXRfdmwoKTsKKwkJdnEgPSBzdmVfdnFfZnJvbV92 bCh2bCk7IC8qIHNraXAgaW50ZXJ2ZW5pbmcgbGVuZ3RocyAqLworCQlzZXRfYml0KHZxX3RvX2Jp dCh2cSksIG1hcCk7CisJfQorfQorCit2b2lkIF9faW5pdCBzdmVfaW5pdF92cV9tYXAodm9pZCkK K3sKKwlzdmVfcHJvYmVfdnFzKHN2ZV92cV9tYXApOworfQorCisvKgorICogSWYgd2UgaGF2ZW4n dCBjb21taXR0ZWQgdG8gdGhlIHNldCBvZiBzdXBwb3J0ZWQgVlFzIHlldCwgZmlsdGVyIG91dAor ICogdGhvc2Ugbm90IHN1cHBvcnRlZCBieSB0aGUgY3VycmVudCBDUFUuCisgKi8KK3ZvaWQgc3Zl X3VwZGF0ZV92cV9tYXAodm9pZCkKK3sKKwlzdmVfcHJvYmVfdnFzKHN2ZV9zZWNvbmRhcnlfdnFf bWFwKTsKKwliaXRtYXBfYW5kKHN2ZV92cV9tYXAsIHN2ZV92cV9tYXAsIHN2ZV9zZWNvbmRhcnlf dnFfbWFwLCBTVkVfVlFfTUFYKTsKK30KKworLyogQ2hlY2sgd2hldGhlciB0aGUgY3VycmVudCBD UFUgc3VwcG9ydHMgYWxsIFZRcyBpbiB0aGUgY29tbWl0dGVkIHNldCAqLworaW50IHN2ZV92ZXJp ZnlfdnFfbWFwKHZvaWQpCit7CisJaW50IHJldCA9IDA7CisKKwlzdmVfcHJvYmVfdnFzKHN2ZV9z ZWNvbmRhcnlfdnFfbWFwKTsKKwliaXRtYXBfYW5kbm90KHN2ZV9zZWNvbmRhcnlfdnFfbWFwLCBz dmVfdnFfbWFwLCBzdmVfc2Vjb25kYXJ5X3ZxX21hcCwKKwkJICAgICAgU1ZFX1ZRX01BWCk7CisJ aWYgKCFiaXRtYXBfZW1wdHkoc3ZlX3NlY29uZGFyeV92cV9tYXAsIFNWRV9WUV9NQVgpKSB7CisJ CXByX3dhcm4oIlNWRTogY3B1JWQ6IFJlcXVpcmVkIHZlY3RvciBsZW5ndGgocykgbWlzc2luZ1xu IiwKKwkJCXNtcF9wcm9jZXNzb3JfaWQoKSk7CisJCXJldCA9IC1FSU5WQUw7CisJfQorCisJcmV0 dXJuIHJldDsKK30KKworLyoKKyAqIEVuYWJsZSBTVkUgZm9yIEVMMS4KKyAqIEludGVuZGVkIGZv ciB1c2UgYnkgdGhlIGNwdWZlYXR1cmVzIGNvZGUgZHVyaW5nIENQVSBib290LgorICovCitpbnQg c3ZlX2tlcm5lbF9lbmFibGUodm9pZCAqX19hbHdheXNfdW51c2VkIHApCit7CisJd3JpdGVfc3lz cmVnKHJlYWRfc3lzcmVnKENQQUNSX0VMMSkgfCBDUEFDUl9FTDFfWkVOX0VMMUVOLCBDUEFDUl9F TDEpOworCWlzYigpOworCisJcmV0dXJuIDA7Cit9CisKK3ZvaWQgX19pbml0IHN2ZV9zZXR1cCh2 b2lkKQoreworCXU2NCB6Y3I7CisKKwlpZiAoIXN5c3RlbV9zdXBwb3J0c19zdmUoKSkKKwkJcmV0 dXJuOworCisJLyoKKwkgKiBUaGUgU1ZFIGFyY2hpdGVjdHVyZSBtYW5kYXRlcyBzdXBwb3J0IGZv ciAxMjgtYml0IHZlY3RvcnMsCisJICogc28gc3ZlX3ZxX21hcCBtdXN0IGhhdmUgYXQgbGVhc3Qg U1ZFX1ZRX01JTiBzZXQuCisJICogSWYgc29tZXRoaW5nIHdlbnQgd3JvbmcsIGF0IGxlYXN0IHRy eSB0byBwYXRjaCBpdCB1cDoKKwkgKi8KKwlpZiAoV0FSTl9PTighdGVzdF9iaXQodnFfdG9fYml0 KFNWRV9WUV9NSU4pLCBzdmVfdnFfbWFwKSkpCisJCXNldF9iaXQodnFfdG9fYml0KFNWRV9WUV9N SU4pLCBzdmVfdnFfbWFwKTsKKworCXpjciA9IHJlYWRfc2FuaXRpc2VkX2Z0cl9yZWcoU1lTX1pD Ul9FTDEpOworCXN2ZV9tYXhfdmwgPSBzdmVfdmxfZnJvbV92cSgoemNyICYgWkNSX0VMeF9MRU5f TUFTSykgKyAxKTsKKworCS8qCisJICogU2FuaXR5LWNoZWNrIHRoYXQgdGhlIG1heCBWTCB3ZSBk ZXRlcm1pbmVkIHRocm91Z2ggQ1BVIGZlYXR1cmVzCisJICogY29ycmVzcG9uZHMgcHJvcGVybHkg dG8gc3ZlX3ZxX21hcC4gIElmIG5vdCwgZG8gb3VyIGJlc3Q6CisJICovCisJaWYgKFdBUk5fT04o c3ZlX21heF92bCAhPSBmaW5kX3N1cHBvcnRlZF92ZWN0b3JfbGVuZ3RoKHN2ZV9tYXhfdmwpKSkK KwkJc3ZlX21heF92bCA9IGZpbmRfc3VwcG9ydGVkX3ZlY3Rvcl9sZW5ndGgoc3ZlX21heF92bCk7 CisKKwkvKgorCSAqIEZvciB0aGUgZGVmYXVsdCBWTCwgcGljayB0aGUgbWF4aW11bSBzdXBwb3J0 ZWQgdmFsdWUgPD0gNjQuCisJICogVkwgPT0gNjQgaXMgZ3VhcmFudGVlZCBub3QgdG8gZ3JvdyB0 aGUgc2lnbmFsIGZyYW1lLgorCSAqLworCXN2ZV9kZWZhdWx0X3ZsID0gZmluZF9zdXBwb3J0ZWRf dmVjdG9yX2xlbmd0aCg2NCk7CisKKwlwcl9pbmZvKCJTVkU6IG1heGltdW0gYXZhaWxhYmxlIHZl Y3RvciBsZW5ndGggJXUgYnl0ZXMgcGVyIHZlY3RvclxuIiwKKwkJc3ZlX21heF92bCk7CisJcHJf aW5mbygiU1ZFOiBkZWZhdWx0IHZlY3RvciBsZW5ndGggJXUgYnl0ZXMgcGVyIHZlY3RvclxuIiwK KwkJc3ZlX2RlZmF1bHRfdmwpOworfQorCisvKgogICogQ2FsbGVkIGZyb20gdGhlIHB1dF90YXNr X3N0cnVjdCgpIHBhdGgsIHdoaWNoIGNhbm5vdCBnZXQgaGVyZQogICogdW5sZXNzIGRlYWRfdGFz ayBpcyByZWFsbHkgZGVhZCBhbmQgbm90IHNjaGVkdWxhYmxlLgogICovCkBAIC02MzAsNiArNzM1 LDkgQEAgdm9pZCBmcHNpbWRfZmx1c2hfdGhyZWFkKHZvaWQpCiAJCSAqIFRoaXMgaXMgd2hlcmUg d2UgZW5zdXJlIHRoYXQgYWxsIHVzZXIgdGFza3MgaGF2ZSBhIHZhbGlkCiAJCSAqIHZlY3RvciBs ZW5ndGggY29uZmlndXJlZDogbm8ga2VybmVsIHRhc2sgY2FuIGJlY29tZSBhIHVzZXIKIAkJICog dGFzayB3aXRob3V0IGFuIGV4ZWMgYW5kIGhlbmNlIGEgY2FsbCB0byB0aGlzIGZ1bmN0aW9uLgor CQkgKiBCeSB0aGUgdGltZSB0aGUgZmlyc3QgY2FsbCB0byB0aGlzIGZ1bmN0aW9uIGlzIG1hZGUs IGFsbAorCQkgKiBlYXJseSBoYXJkd2FyZSBwcm9iaW5nIGlzIGNvbXBsZXRlLCBzbyBzdmVfZGVm YXVsdF92bAorCQkgKiBzaG91bGQgYmUgdmFsaWQuCiAJCSAqIElmIGEgYnVnIGNhdXNlcyB0aGlz IHRvIGdvIHdyb25nLCB3ZSBtYWtlIHNvbWUgbm9pc2UgYW5kCiAJCSAqIHRyeSB0byBmdWRnZSB0 aHJlYWQuc3ZlX3ZsIHRvIGEgc2FmZSB2YWx1ZSBoZXJlLgogCQkgKi8KLS0gCjIuMS40CgpfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwprdm1hcm0gbWFpbGlu ZyBsaXN0Cmt2bWFybUBsaXN0cy5jcy5jb2x1bWJpYS5lZHUKaHR0cHM6Ly9saXN0cy5jcy5jb2x1 bWJpYS5lZHUvbWFpbG1hbi9saXN0aW5mby9rdm1hcm0K From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from usa-sjc-mx-foss1.foss.arm.com ([217.140.101.70]:37764 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753808AbdJaPwG (ORCPT ); Tue, 31 Oct 2017 11:52:06 -0400 From: Dave Martin Subject: [PATCH v5 18/30] arm64/sve: Probe SVE capabilities and usable vector lengths Date: Tue, 31 Oct 2017 15:51:10 +0000 Message-ID: <1509465082-30427-19-git-send-email-Dave.Martin@arm.com> In-Reply-To: <1509465082-30427-1-git-send-email-Dave.Martin@arm.com> References: <1509465082-30427-1-git-send-email-Dave.Martin@arm.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-arch-owner@vger.kernel.org List-ID: To: linux-arm-kernel@lists.infradead.org Cc: Catalin Marinas , Will Deacon , Ard Biesheuvel , =?UTF-8?q?Alex=20Benn=C3=A9e?= , Szabolcs Nagy , Okamoto Takayuki , kvmarm@lists.cs.columbia.edu, libc-alpha@sourceware.org, linux-arch@vger.kernel.org Message-ID: <20171031155110.KmTKC00kPsijzp4Pr1WMCv523Gg6FVm6rsAIAYr8EQs@z> This patch uses the cpufeatures framework to determine common SVE capabilities and vector lengths, and configures the runtime SVE support code appropriately. ZCR_ELx is not really a feature register, but it is convenient to use it as a template for recording the maximum vector length supported by a CPU, using the LEN field. This field is similar to a feature field in that it is a contiguous bitfield for which we want to determine the minimum system-wide value. This patch adds ZCR as a pseudo-register in cpuinfo/cpufeatures, with appropriate custom code to populate it. Finding the minimum supported value of the LEN field is left to the cpufeatures framework in the usual way. The meaning of ID_AA64ZFR0_EL1 is not architecturally defined yet, so for now we just require it to be zero. Note that much of this code is dormant and SVE still won't be used yet, since system_supports_sve() remains hardwired to false. Signed-off-by: Dave Martin Reviewed-by: Suzuki K Poulose Reviewed-by: Catalin Marinas Cc: Alex Bennée --- **Dropped at v3** Reviewed-by: Alex Bennée See v3 posting for history. --- arch/arm64/include/asm/cpu.h | 4 ++ arch/arm64/include/asm/cpufeature.h | 36 ++++++++++++ arch/arm64/include/asm/fpsimd.h | 14 +++++ arch/arm64/kernel/cpufeature.c | 52 ++++++++++++++++ arch/arm64/kernel/cpuinfo.c | 6 ++ arch/arm64/kernel/fpsimd.c | 114 +++++++++++++++++++++++++++++++++++- 6 files changed, 223 insertions(+), 3 deletions(-) diff --git a/arch/arm64/include/asm/cpu.h b/arch/arm64/include/asm/cpu.h index 889226b..8839227 100644 --- a/arch/arm64/include/asm/cpu.h +++ b/arch/arm64/include/asm/cpu.h @@ -41,6 +41,7 @@ struct cpuinfo_arm64 { u64 reg_id_aa64mmfr2; u64 reg_id_aa64pfr0; u64 reg_id_aa64pfr1; + u64 reg_id_aa64zfr0; u32 reg_id_dfr0; u32 reg_id_isar0; @@ -59,6 +60,9 @@ struct cpuinfo_arm64 { u32 reg_mvfr0; u32 reg_mvfr1; u32 reg_mvfr2; + + /* pseudo-ZCR for recording maximum ZCR_EL1 LEN value: */ + u64 reg_zcr; }; DECLARE_PER_CPU(struct cpuinfo_arm64, cpu_data); diff --git a/arch/arm64/include/asm/cpufeature.h b/arch/arm64/include/asm/cpufeature.h index 4ea3441..9b27e8c 100644 --- a/arch/arm64/include/asm/cpufeature.h +++ b/arch/arm64/include/asm/cpufeature.h @@ -10,7 +10,9 @@ #define __ASM_CPUFEATURE_H #include +#include #include +#include #include /* @@ -223,6 +225,13 @@ static inline bool id_aa64pfr0_32bit_el0(u64 pfr0) return val == ID_AA64PFR0_EL0_32BIT_64BIT; } +static inline bool id_aa64pfr0_sve(u64 pfr0) +{ + u32 val = cpuid_feature_extract_unsigned_field(pfr0, ID_AA64PFR0_SVE_SHIFT); + + return val > 0; +} + void __init setup_cpu_features(void); void update_cpu_capabilities(const struct arm64_cpu_capabilities *caps, @@ -267,6 +276,33 @@ static inline bool system_supports_sve(void) return false; } +/* + * Read the pseudo-ZCR used by cpufeatures to identify the supported SVE + * vector length. + * + * Use only if SVE is present. + * This function clobbers the SVE vector length. + */ +static inline u64 read_zcr_features(void) +{ + u64 zcr; + unsigned int vq_max; + + /* + * Set the maximum possible VL, and write zeroes to all other + * bits to see if they stick. + */ + sve_kernel_enable(NULL); + write_sysreg_s(ZCR_ELx_LEN_MASK, SYS_ZCR_EL1); + + zcr = read_sysreg_s(SYS_ZCR_EL1); + zcr &= ~(u64)ZCR_ELx_LEN_MASK; /* find sticky 1s outside LEN field */ + vq_max = sve_vq_from_vl(sve_get_vl()); + zcr |= vq_max - 1; /* set LEN field to maximum effective value */ + + return zcr; +} + #endif /* __ASSEMBLY__ */ #endif diff --git a/arch/arm64/include/asm/fpsimd.h b/arch/arm64/include/asm/fpsimd.h index 86f550c..d8e0dc9 100644 --- a/arch/arm64/include/asm/fpsimd.h +++ b/arch/arm64/include/asm/fpsimd.h @@ -78,6 +78,7 @@ extern void sve_save_state(void *state, u32 *pfpsr); extern void sve_load_state(void const *state, u32 const *pfpsr, unsigned long vq_minus_1); extern unsigned int sve_get_vl(void); +extern int sve_kernel_enable(void *); extern int __ro_after_init sve_max_vl; @@ -90,10 +91,23 @@ extern void fpsimd_release_task(struct task_struct *task); extern int sve_set_vector_length(struct task_struct *task, unsigned long vl, unsigned long flags); +/* + * Probing and setup functions. + * Calls to these functions must be serialised with one another. + */ +extern void __init sve_init_vq_map(void); +extern void sve_update_vq_map(void); +extern int sve_verify_vq_map(void); +extern void __init sve_setup(void); + #else /* ! CONFIG_ARM64_SVE */ static inline void sve_alloc(struct task_struct *task) { } static inline void fpsimd_release_task(struct task_struct *task) { } +static inline void sve_init_vq_map(void) { } +static inline void sve_update_vq_map(void) { } +static inline int sve_verify_vq_map(void) { return 0; } +static inline void sve_setup(void) { } #endif /* ! CONFIG_ARM64_SVE */ diff --git a/arch/arm64/kernel/cpufeature.c b/arch/arm64/kernel/cpufeature.c index e226799..2154373 100644 --- a/arch/arm64/kernel/cpufeature.c +++ b/arch/arm64/kernel/cpufeature.c @@ -27,6 +27,7 @@ #include #include #include +#include #include #include #include @@ -287,6 +288,12 @@ static const struct arm64_ftr_bits ftr_id_dfr0[] = { ARM64_FTR_END, }; +static const struct arm64_ftr_bits ftr_zcr[] = { + ARM64_FTR_BITS(FTR_HIDDEN, FTR_NONSTRICT, FTR_LOWER_SAFE, + ZCR_ELx_LEN_SHIFT, ZCR_ELx_LEN_SIZE, 0), /* LEN */ + ARM64_FTR_END, +}; + /* * Common ftr bits for a 32bit register with all hidden, strict * attributes, with 4bit feature fields and a default safe value of @@ -353,6 +360,7 @@ static const struct __ftr_reg_entry { /* Op1 = 0, CRn = 0, CRm = 4 */ ARM64_FTR_REG(SYS_ID_AA64PFR0_EL1, ftr_id_aa64pfr0), ARM64_FTR_REG(SYS_ID_AA64PFR1_EL1, ftr_raz), + ARM64_FTR_REG(SYS_ID_AA64ZFR0_EL1, ftr_raz), /* Op1 = 0, CRn = 0, CRm = 5 */ ARM64_FTR_REG(SYS_ID_AA64DFR0_EL1, ftr_id_aa64dfr0), @@ -367,6 +375,9 @@ static const struct __ftr_reg_entry { ARM64_FTR_REG(SYS_ID_AA64MMFR1_EL1, ftr_id_aa64mmfr1), ARM64_FTR_REG(SYS_ID_AA64MMFR2_EL1, ftr_id_aa64mmfr2), + /* Op1 = 0, CRn = 1, CRm = 2 */ + ARM64_FTR_REG(SYS_ZCR_EL1, ftr_zcr), + /* Op1 = 3, CRn = 0, CRm = 0 */ { SYS_CTR_EL0, &arm64_ftr_reg_ctrel0 }, ARM64_FTR_REG(SYS_DCZID_EL0, ftr_dczid), @@ -504,6 +515,7 @@ void __init init_cpu_features(struct cpuinfo_arm64 *info) init_cpu_ftr_reg(SYS_ID_AA64MMFR2_EL1, info->reg_id_aa64mmfr2); init_cpu_ftr_reg(SYS_ID_AA64PFR0_EL1, info->reg_id_aa64pfr0); init_cpu_ftr_reg(SYS_ID_AA64PFR1_EL1, info->reg_id_aa64pfr1); + init_cpu_ftr_reg(SYS_ID_AA64ZFR0_EL1, info->reg_id_aa64zfr0); if (id_aa64pfr0_32bit_el0(info->reg_id_aa64pfr0)) { init_cpu_ftr_reg(SYS_ID_DFR0_EL1, info->reg_id_dfr0); @@ -524,6 +536,10 @@ void __init init_cpu_features(struct cpuinfo_arm64 *info) init_cpu_ftr_reg(SYS_MVFR2_EL1, info->reg_mvfr2); } + if (id_aa64pfr0_sve(info->reg_id_aa64pfr0)) { + init_cpu_ftr_reg(SYS_ZCR_EL1, info->reg_zcr); + sve_init_vq_map(); + } } static void update_cpu_ftr_reg(struct arm64_ftr_reg *reg, u64 new) @@ -627,6 +643,9 @@ void update_cpu_features(int cpu, taint |= check_update_ftr_reg(SYS_ID_AA64PFR1_EL1, cpu, info->reg_id_aa64pfr1, boot->reg_id_aa64pfr1); + taint |= check_update_ftr_reg(SYS_ID_AA64ZFR0_EL1, cpu, + info->reg_id_aa64zfr0, boot->reg_id_aa64zfr0); + /* * If we have AArch32, we care about 32-bit features for compat. * If the system doesn't support AArch32, don't update them. @@ -674,6 +693,16 @@ void update_cpu_features(int cpu, info->reg_mvfr2, boot->reg_mvfr2); } + if (id_aa64pfr0_sve(info->reg_id_aa64pfr0)) { + taint |= check_update_ftr_reg(SYS_ZCR_EL1, cpu, + info->reg_zcr, boot->reg_zcr); + + /* Probe vector lengths, unless we already gave up on SVE */ + if (id_aa64pfr0_sve(read_sanitised_ftr_reg(SYS_ID_AA64PFR0_EL1)) && + !sys_caps_initialised) + sve_update_vq_map(); + } + /* * Mismatched CPU features are a recipe for disaster. Don't even * pretend to support them. @@ -1106,6 +1135,23 @@ verify_local_cpu_features(const struct arm64_cpu_capabilities *caps) } } +static void verify_sve_features(void) +{ + u64 safe_zcr = read_sanitised_ftr_reg(SYS_ZCR_EL1); + u64 zcr = read_zcr_features(); + + unsigned int safe_len = safe_zcr & ZCR_ELx_LEN_MASK; + unsigned int len = zcr & ZCR_ELx_LEN_MASK; + + if (len < safe_len || sve_verify_vq_map()) { + pr_crit("CPU%d: SVE: required vector length(s) missing\n", + smp_processor_id()); + cpu_die_early(); + } + + /* Add checks on other ZCR bits here if necessary */ +} + /* * Run through the enabled system capabilities and enable() it on this CPU. * The capabilities were decided based on the available CPUs at the boot time. @@ -1119,8 +1165,12 @@ static void verify_local_cpu_capabilities(void) verify_local_cpu_errata_workarounds(); verify_local_cpu_features(arm64_features); verify_local_elf_hwcaps(arm64_elf_hwcaps); + if (system_supports_32bit_el0()) verify_local_elf_hwcaps(compat_elf_hwcaps); + + if (system_supports_sve()) + verify_sve_features(); } void check_local_cpu_capabilities(void) @@ -1198,6 +1248,8 @@ void __init setup_cpu_features(void) if (system_supports_32bit_el0()) setup_elf_hwcaps(compat_elf_hwcaps); + sve_setup(); + /* Advertise that we have computed the system capabilities */ set_sys_caps_initialised(); diff --git a/arch/arm64/kernel/cpuinfo.c b/arch/arm64/kernel/cpuinfo.c index 1ff1c5a..58da504 100644 --- a/arch/arm64/kernel/cpuinfo.c +++ b/arch/arm64/kernel/cpuinfo.c @@ -19,6 +19,7 @@ #include #include #include +#include #include #include @@ -331,6 +332,7 @@ static void __cpuinfo_store_cpu(struct cpuinfo_arm64 *info) info->reg_id_aa64mmfr2 = read_cpuid(ID_AA64MMFR2_EL1); info->reg_id_aa64pfr0 = read_cpuid(ID_AA64PFR0_EL1); info->reg_id_aa64pfr1 = read_cpuid(ID_AA64PFR1_EL1); + info->reg_id_aa64zfr0 = read_cpuid(ID_AA64ZFR0_EL1); /* Update the 32bit ID registers only if AArch32 is implemented */ if (id_aa64pfr0_32bit_el0(info->reg_id_aa64pfr0)) { @@ -353,6 +355,10 @@ static void __cpuinfo_store_cpu(struct cpuinfo_arm64 *info) info->reg_mvfr2 = read_cpuid(MVFR2_EL1); } + if (IS_ENABLED(CONFIG_ARM64_SVE) && + id_aa64pfr0_sve(info->reg_id_aa64pfr0)) + info->reg_zcr = read_zcr_features(); + cpuinfo_detect_icache_policy(info); } diff --git a/arch/arm64/kernel/fpsimd.c b/arch/arm64/kernel/fpsimd.c index 1ceb069..c112972 100644 --- a/arch/arm64/kernel/fpsimd.c +++ b/arch/arm64/kernel/fpsimd.c @@ -114,19 +114,19 @@ static DEFINE_PER_CPU(struct fpsimd_state *, fpsimd_last_state); /* Default VL for tasks that don't set it explicitly: */ -static int sve_default_vl = SVE_VL_MIN; +static int sve_default_vl = -1; #ifdef CONFIG_ARM64_SVE /* Maximum supported vector length across all CPUs (initially poisoned) */ int __ro_after_init sve_max_vl = -1; /* Set of available vector lengths, as vq_to_bit(vq): */ -static DECLARE_BITMAP(sve_vq_map, SVE_VQ_MAX); +static __ro_after_init DECLARE_BITMAP(sve_vq_map, SVE_VQ_MAX); #else /* ! CONFIG_ARM64_SVE */ /* Dummy declaration for code that will be optimised out: */ -extern DECLARE_BITMAP(sve_vq_map, SVE_VQ_MAX); +extern __ro_after_init DECLARE_BITMAP(sve_vq_map, SVE_VQ_MAX); #endif /* ! CONFIG_ARM64_SVE */ @@ -496,6 +496,111 @@ int sve_set_vector_length(struct task_struct *task, } /* + * Bitmap for temporary storage of the per-CPU set of supported vector lengths + * during secondary boot. + */ +static DECLARE_BITMAP(sve_secondary_vq_map, SVE_VQ_MAX); + +static void sve_probe_vqs(DECLARE_BITMAP(map, SVE_VQ_MAX)) +{ + unsigned int vq, vl; + unsigned long zcr; + + bitmap_zero(map, SVE_VQ_MAX); + + zcr = ZCR_ELx_LEN_MASK; + zcr = read_sysreg_s(SYS_ZCR_EL1) & ~zcr; + + for (vq = SVE_VQ_MAX; vq >= SVE_VQ_MIN; --vq) { + write_sysreg_s(zcr | (vq - 1), SYS_ZCR_EL1); /* self-syncing */ + vl = sve_get_vl(); + vq = sve_vq_from_vl(vl); /* skip intervening lengths */ + set_bit(vq_to_bit(vq), map); + } +} + +void __init sve_init_vq_map(void) +{ + sve_probe_vqs(sve_vq_map); +} + +/* + * If we haven't committed to the set of supported VQs yet, filter out + * those not supported by the current CPU. + */ +void sve_update_vq_map(void) +{ + sve_probe_vqs(sve_secondary_vq_map); + bitmap_and(sve_vq_map, sve_vq_map, sve_secondary_vq_map, SVE_VQ_MAX); +} + +/* Check whether the current CPU supports all VQs in the committed set */ +int sve_verify_vq_map(void) +{ + int ret = 0; + + sve_probe_vqs(sve_secondary_vq_map); + bitmap_andnot(sve_secondary_vq_map, sve_vq_map, sve_secondary_vq_map, + SVE_VQ_MAX); + if (!bitmap_empty(sve_secondary_vq_map, SVE_VQ_MAX)) { + pr_warn("SVE: cpu%d: Required vector length(s) missing\n", + smp_processor_id()); + ret = -EINVAL; + } + + return ret; +} + +/* + * Enable SVE for EL1. + * Intended for use by the cpufeatures code during CPU boot. + */ +int sve_kernel_enable(void *__always_unused p) +{ + write_sysreg(read_sysreg(CPACR_EL1) | CPACR_EL1_ZEN_EL1EN, CPACR_EL1); + isb(); + + return 0; +} + +void __init sve_setup(void) +{ + u64 zcr; + + if (!system_supports_sve()) + return; + + /* + * The SVE architecture mandates support for 128-bit vectors, + * so sve_vq_map must have at least SVE_VQ_MIN set. + * If something went wrong, at least try to patch it up: + */ + if (WARN_ON(!test_bit(vq_to_bit(SVE_VQ_MIN), sve_vq_map))) + set_bit(vq_to_bit(SVE_VQ_MIN), sve_vq_map); + + zcr = read_sanitised_ftr_reg(SYS_ZCR_EL1); + sve_max_vl = sve_vl_from_vq((zcr & ZCR_ELx_LEN_MASK) + 1); + + /* + * Sanity-check that the max VL we determined through CPU features + * corresponds properly to sve_vq_map. If not, do our best: + */ + if (WARN_ON(sve_max_vl != find_supported_vector_length(sve_max_vl))) + sve_max_vl = find_supported_vector_length(sve_max_vl); + + /* + * For the default VL, pick the maximum supported value <= 64. + * VL == 64 is guaranteed not to grow the signal frame. + */ + sve_default_vl = find_supported_vector_length(64); + + pr_info("SVE: maximum available vector length %u bytes per vector\n", + sve_max_vl); + pr_info("SVE: default vector length %u bytes per vector\n", + sve_default_vl); +} + +/* * Called from the put_task_struct() path, which cannot get here * unless dead_task is really dead and not schedulable. */ @@ -630,6 +735,9 @@ void fpsimd_flush_thread(void) * This is where we ensure that all user tasks have a valid * vector length configured: no kernel task can become a user * task without an exec and hence a call to this function. + * By the time the first call to this function is made, all + * early hardware probing is complete, so sve_default_vl + * should be valid. * If a bug causes this to go wrong, we make some noise and * try to fudge thread.sve_vl to a safe value here. */ -- 2.1.4