From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 60A50C7EE2D for ; Sun, 21 May 2023 11:47:39 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=BKOGE+IelYz3dzV3Nsn3AqCY1l+iLIfYSaj8+bwnCIg=; b=Je0eJs67gJfo/N aQujBVaHvctum0ve5UQ3jgWbscIuH9v82timw6xQGf5xR4RYp8EwN72E5cEoxob0anw86HHj85c3r a/cCjZ6HPwl3rSPn8Y/sK+bSaVRDtR1Yv/kSUZQKjrvk6UxF9ga3vqvmlGslLqZ1ENgjF3/WlXUIV IE1Q986cONbn8kWZjUdDCBVdWMdMVh0lfPM8ad8L3ca6AFqIOR+Sj5Ul+GGMcAqsrROniMgdXAsAA tRBCy0C/BcP1wpAKxFMAHaM44LIuq6ABXQ2tmJSHoBGNP8bC0uXnlYqzTeIgyys2Wq/HcNx71dsP8 A70Gf0ygdxfppqvk9M4w==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1q0hX7-003nNY-31; Sun, 21 May 2023 11:47:29 +0000 Received: from gloria.sntech.de ([185.11.138.130]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1q0hX3-003nLP-1Y for linux-riscv@lists.infradead.org; Sun, 21 May 2023 11:47:28 +0000 Received: from ip5b412278.dynamic.kabel-deutschland.de ([91.65.34.120] helo=phil.lan) by gloria.sntech.de with esmtpsa (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1q0hWv-0008T6-9y; Sun, 21 May 2023 13:47:17 +0200 From: Heiko Stuebner To: linux-riscv@lists.infradead.org, palmer@dabbelt.com, paul.walmsley@sifive.com Cc: linux-kernel@vger.kernel.org, christoph.muellner@vrull.eu, David.Laight@ACULAB.COM, Heiko Stuebner Subject: [PATCH v3 2/2] riscv: Add Zawrs support for spinlocks Date: Sun, 21 May 2023 13:47:15 +0200 Message-Id: <20230521114715.955823-3-heiko.stuebner@vrull.eu> X-Mailer: git-send-email 2.39.0 In-Reply-To: <20230521114715.955823-1-heiko.stuebner@vrull.eu> References: <20230521114715.955823-1-heiko.stuebner@vrull.eu> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20230521_044725_658873_FBE06956 X-CRM114-Status: GOOD ( 21.18 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org RnJvbTogQ2hyaXN0b3BoIE3DvGxsbmVyIDxjaHJpc3RvcGgubXVlbGxuZXJAdnJ1bGwuZXU+CgpU aGUgY3VycmVudCBSSVNDLVYgY29kZSB1c2VzIHRoZSBnZW5lcmljIHRpY2tldCBsb2NrIGltcGxl bWVudGF0aW9uLAp0aGF0IGNhbGxzIHRoZSBtYWNyb3Mgc21wX2NvbmRfbG9hZF9yZWxheGVkKCkg YW5kIHNtcF9jb25kX2xvYWRfYWNxdWlyZSgpLgpDdXJyZW50bHksIFJJU0MtViB1c2VzIHRoZSBn ZW5lcmljIGltcGxlbWVudGF0aW9uIG9mIHRoZXNlIG1hY3Jvcy4KVGhpcyBwYXRjaCBpbnRyb2R1 Y2VzIGEgUklTQy1WIHNwZWNpZmljIGltcGxlbWVudGF0aW9uLCBvZiB0aGVzZQptYWNyb3MsIHRo YXQgcGVlbHMgb2ZmIHRoZSBmaXJzdCBsb29wIGl0ZXJhdGlvbiBhbmQgbW9kaWZpZXMgdGhlIHdh aXRpbmcKbG9vcCBzdWNoLCB0aGF0IGl0IGlzIHBvc3NpYmxlIHRvIHVzZSB0aGUgV1JTLlNUTyBp bnN0cnVjdGlvbiBvZiB0aGUgWmF3cnMKSVNBIGV4dGVuc2lvbiB0byBzdGFsbCB0aGUgQ1BVLgoK VGhlIHJlc3VsdGluZyBpbXBsZW1lbnRhdGlvbiBvZiBzbXBfY29uZF9sb2FkXyooKSB3aWxsIG9u bHkgd29yayBmb3IKMzItYml0IG9yIDY0LWJpdCB0eXBlcyBmb3IgUlY2NCBhbmQgMzItYml0IHR5 cGVzIGZvciBSVjMyLgpUaGlzIGlzIGNhdXNlZCBieSB0aGUgcmVzdHJpY3Rpb25zIG9mIHRoZSBM UiBpbnN0cnVjdGlvbiAoUklTQy1WIG9ubHkKaGFzIExSLlcgYW5kIExSLkQpLiBDb21waWxlciBh c3NlcnRpb25zIGd1YXJkIHRoaXMgbmV3IHJlc3RyaWN0aW9uLgoKVGhpcyBwYXRjaCB1c2VzIHRo ZSBleGlzdGluZyBSSVNDLVYgSVNBIGV4dGVuc2lvbiBmcmFtZXdvcmsKdG8gZGV0ZWN0IHRoZSBw cmVzZW5jZSBvZiBaYXdycyBhdCBydW4tdGltZS4KSWYgYXZhaWxhYmxlIGEgTk9QIGluc3RydWN0 aW9uIHdpbGwgYmUgcmVwbGFjZWQgYnkgV1JTLk5UTyBvciBXUlMuU1RPLgoKVGhlIHdob2xlIG1l Y2hhbmlzbSBpcyBnYXRlZCBieSBLY29uZmlnIHNldHRpbmcsIHdoaWNoIGRlZmF1bHRzIHRvIFku CgpUaGUgWmF3cnMgc3BlY2lmaWNhdGlvbiBjYW4gYmUgZm91bmQgaGVyZToKaHR0cHM6Ly9naXRo dWIuY29tL3Jpc2N2L3Jpc2N2LXphd3JzL2Jsb2IvbWFpbi96YXdycy5hZG9jCgpTaWduZWQtb2Zm LWJ5OiBDaHJpc3RvcGggTcO8bGxuZXIgPGNocmlzdG9waC5tdWVsbG5lckB2cnVsbC5ldT4KW3Jl YmFzZSwgdXBkYXRlIHRvIHJldmlldyBjb21tZW50c10KU2lnbmVkLW9mZi1ieTogSGVpa28gU3R1 ZWJuZXIgPGhlaWtvLnN0dWVibmVyQHZydWxsLmV1PgotLS0KIGFyY2gvcmlzY3YvS2NvbmZpZyAg ICAgICAgICAgICAgICAgICB8IDEwICsrKysrCiBhcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL2JhcnJp ZXIuaCAgICAgfCA2NCArKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBhcmNoL3Jpc2N2L2lu Y2x1ZGUvYXNtL2VycmF0YV9saXN0LmggfCAxNCArKysrKysKIGFyY2gvcmlzY3YvaW5jbHVkZS9h c20vaHdjYXAuaCAgICAgICB8ICAxICsKIGFyY2gvcmlzY3Yva2VybmVsL2NwdS5jICAgICAgICAg ICAgICB8ICAxICsKIGFyY2gvcmlzY3Yva2VybmVsL2NwdWZlYXR1cmUuYyAgICAgICB8ICAxICsK IDYgZmlsZXMgY2hhbmdlZCwgOTEgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL2FyY2gvcmlz Y3YvS2NvbmZpZyBiL2FyY2gvcmlzY3YvS2NvbmZpZwppbmRleCAzNDhjMGZhMWZjOGMuLjYwZmYz MDNmZjU4YSAxMDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9LY29uZmlnCisrKyBiL2FyY2gvcmlzY3Yv S2NvbmZpZwpAQCAtNDYwLDYgKzQ2MCwxNiBAQCBjb25maWcgUklTQ1ZfSVNBX1NWUEJNVAogCiAJ ICAgSWYgeW91IGRvbid0IGtub3cgd2hhdCB0byBkbyBoZXJlLCBzYXkgWS4KIAorY29uZmlnIFJJ U0NWX0lTQV9aQVdSUworCWJvb2wgIlphd3JzIGV4dGVuc2lvbiBzdXBwb3J0IgorCWRlcGVuZHMg b24gUklTQ1ZfQUxURVJOQVRJVkUKKwlkZWZhdWx0IHkKKwloZWxwCisJICAgQWRkcyBzdXBwb3J0 IHRvIGR5bmFtaWNhbGx5IGRldGVjdCB0aGUgcHJlc2VuY2Ugb2YgdGhlIFphd3JzIGV4dGVuc2lv bgorCSAgICh3YWl0IGZvciByZXNlcnZhdGlvbiBzZXQpIGFuZCBlbmFibGUgaXRzIHVzYWdlLgor CisJICAgSWYgeW91IGRvbid0IGtub3cgd2hhdCB0byBkbyBoZXJlLCBzYXkgWS4KKwogY29uZmln IFRPT0xDSEFJTl9IQVNfWkJCCiAJYm9vbAogCWRlZmF1bHQgeQpkaWZmIC0tZ2l0IGEvYXJjaC9y aXNjdi9pbmNsdWRlL2FzbS9iYXJyaWVyLmggYi9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL2JhcnJp ZXIuaAppbmRleCAxMTA3NTI1OTQyMjguLmJkNjRjZmU1YWUxMCAxMDA2NDQKLS0tIGEvYXJjaC9y aXNjdi9pbmNsdWRlL2FzbS9iYXJyaWVyLmgKKysrIGIvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9i YXJyaWVyLmgKQEAgLTEyLDYgKzEyLDggQEAKIAogI2lmbmRlZiBfX0FTU0VNQkxZX18KIAorI2lu Y2x1ZGUgPGFzbS9lcnJhdGFfbGlzdC5oPgorCiAjZGVmaW5lIG5vcCgpCQlfX2FzbV9fIF9fdm9s YXRpbGVfXyAoIm5vcCIpCiAjZGVmaW5lIF9fbm9wcyhuKQkiLnJlcHQJIiAjbiAiXG5ub3Bcbi5l bmRyXG4iCiAjZGVmaW5lIG5vcHMobikJCV9fYXNtX18gX192b2xhdGlsZV9fIChfX25vcHMobikp CkBAIC00NCw2ICs0NiwzNiBAQCBkbyB7CQkJCQkJCQkJXAogCV9fX3AxOwkJCQkJCQkJXAogfSkK IAorI2RlZmluZSBfX19zbXBfbG9hZF9yZXNlcnZlZE4ocGZ4LCBwdHIpCQkJCQlcCisoewkJCQkJ CQkJCVwKKwl0eXBlb2YoKnB0cikgX19fcDE7CQkJCQkJXAorCV9fYXNtX18gX192b2xhdGlsZV9f ICgibHIuIiBwZnggIgklW3BdLCAlW2NdXG4iCQlcCisJCQkgICAgICA6IFtwXSI9JnIiIChfX19w MSksIFtjXSIrQSIoKnB0cikpOwlcCisJX19fcDE7CQkJCQkJCQlcCit9KQorCisjZGVmaW5lIF9f c21wX2xvYWRfcmVzZXJ2ZWRfcmVsYXhlZChwdHIpCQkJCVwKKyh7CQkJCQkJCQkJXAorCXR5cGVv ZigqcHRyKSBfX19wMTsJCQkJCQlcCisJaWYgKHNpemVvZigqcHRyKSA9PSBzaXplb2YoaW50KSkJ CQkJXAorCQlfX19wMSA9IF9fX3NtcF9sb2FkX3Jlc2VydmVkTigidyIsIHB0cik7CQlcCisJZWxz ZSBpZiAoc2l6ZW9mKCpwdHIpID09IHNpemVvZihsb25nKSkJCQkJXAorCQlfX19wMSA9IF9fX3Nt cF9sb2FkX3Jlc2VydmVkTigiZCIsIHB0cik7CQlcCisJZWxzZQkJCQkJCQkJXAorCQljb21waWxl dGltZV9hc3NlcnQoMCwJCQkJCVwKKwkJCSJOZWVkIHR5cGUgY29tcGF0aWJsZSB3aXRoIExSL1ND IGluc3RydWN0aW9ucyAiCVwKKwkJCSJmb3IgIiBfX3N0cmluZ2lmeShwdHIpKTsJCQlcCisJX19f cDE7CQkJCQkJCQlcCit9KQorCisjZGVmaW5lIF9fc21wX2xvYWRfcmVzZXJ2ZWRfYWNxdWlyZShw dHIpCQkJCVwKKyh7CQkJCQkJCQkJXAorCXR5cGVvZigqcHRyKSBfX19wMTsJCQkJCQlcCisJX19f cDEgPSBfX3NtcF9sb2FkX3Jlc2VydmVkX3JlbGF4ZWQocHRyKTsJCQlcCisJUklTQ1ZfRkVOQ0Uo ciwgcncpOwkJCQkJCVwKKwlfX19wMTsJCQkJCQkJCVwKK30pCisKIC8qCiAgKiBUaGlzIGlzIGEg dmVyeSBzcGVjaWZpYyBiYXJyaWVyOiBpdCdzIGN1cnJlbnRseSBvbmx5IHVzZWQgaW4gdHdvIHBs YWNlcyBpbgogICogdGhlIGtlcm5lbCwgYm90aCBpbiB0aGUgc2NoZWR1bGVyLiAgU2VlIGluY2x1 ZGUvbGludXgvc3BpbmxvY2suaCBmb3IgdGhlIHR3bwpAQCAtNzEsNiArMTAzLDM4IEBAIGRvIHsJ CQkJCQkJCQlcCiAgKi8KICNkZWZpbmUgc21wX21iX19hZnRlcl9zcGlubG9jaygpCVJJU0NWX0ZF TkNFKGlvcncsaW9ydykKIAorI2RlZmluZSBzbXBfY29uZF9sb2FkX3JlbGF4ZWQocHRyLCBjb25k X2V4cHIpCQkJCVwKKyh7CQkJCQkJCQkJXAorCXR5cGVvZihwdHIpIF9fUFRSID0gKHB0cik7CQkJ CQlcCisJX191bnF1YWxfc2NhbGFyX3R5cGVvZigqcHRyKSBWQUw7CQkJCVwKKwlWQUwgPSBSRUFE X09OQ0UoKl9fUFRSKTsJCQkJCVwKKwlpZiAoIWNvbmRfZXhwcikgewkJCQkJCVwKKwkJZm9yICg7 OykgewkJCQkJCVwKKwkJCVZBTCA9IF9fc21wX2xvYWRfcmVzZXJ2ZWRfcmVsYXhlZChfX1BUUik7 CVwKKwkJCWlmIChjb25kX2V4cHIpCQkJCQlcCisJCQkJYnJlYWs7CQkJCQlcCisJCQlBTFRfV1JT X1NUTygpOwkJCQkJXAorCQl9CQkJCQkJCVwKKwl9CQkJCQkJCQlcCisJKHR5cGVvZigqcHRyKSlW QUw7CQkJCQkJXAorfSkKKworI2RlZmluZSBzbXBfY29uZF9sb2FkX2FjcXVpcmUocHRyLCBjb25k X2V4cHIpCQkJCVwKKyh7CQkJCQkJCQkJXAorCXR5cGVvZihwdHIpIF9fUFRSID0gKHB0cik7CQkJ CQlcCisJX191bnF1YWxfc2NhbGFyX3R5cGVvZigqcHRyKSBWQUw7CQkJCVwKKwlWQUwgPSBzbXBf bG9hZF9hY3F1aXJlKF9fUFRSKTsJCQkJCVwKKwlpZiAoIWNvbmRfZXhwcikgewkJCQkJCVwKKwkJ Zm9yICg7OykgewkJCQkJCVwKKwkJCVZBTCA9IF9fc21wX2xvYWRfcmVzZXJ2ZWRfYWNxdWlyZShf X1BUUik7CVwKKwkJCWlmIChjb25kX2V4cHIpCQkJCQlcCisJCQkJYnJlYWs7CQkJCQlcCisJCQlB TFRfV1JTX1NUTygpOwkJCQkJXAorCQl9CQkJCQkJCVwKKwl9CQkJCQkJCQlcCisJKHR5cGVvZigq cHRyKSlWQUw7CQkJCQkJXAorfSkKKwogI2luY2x1ZGUgPGFzbS1nZW5lcmljL2JhcnJpZXIuaD4K IAogI2VuZGlmIC8qIF9fQVNTRU1CTFlfXyAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9pbmNs dWRlL2FzbS9lcnJhdGFfbGlzdC5oIGIvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9lcnJhdGFfbGlz dC5oCmluZGV4IGZiMWE4MTBmM2Q4Yy4uMzZhNzJhMDdkNjJjIDEwMDY0NAotLS0gYS9hcmNoL3Jp c2N2L2luY2x1ZGUvYXNtL2VycmF0YV9saXN0LmgKKysrIGIvYXJjaC9yaXNjdi9pbmNsdWRlL2Fz bS9lcnJhdGFfbGlzdC5oCkBAIC00NCw2ICs0NCwyMCBAQCBhc20oQUxURVJOQVRJVkUoInNmZW5j ZS52bWEgJTAiLCAic2ZlbmNlLnZtYSIsIFNJRklWRV9WRU5ET1JfSUQsCVwKIAkJRVJSQVRBX1NJ RklWRV9DSVBfMTIwMCwgQ09ORklHX0VSUkFUQV9TSUZJVkVfQ0lQXzEyMDApCVwKIAkJOiA6ICJy IiAoYWRkcikgOiAibWVtb3J5IikKIAorI2RlZmluZSBaQVdSU19XUlNfTlRPCSIubG9uZyAweDAw ZDAwMDczIgorI2RlZmluZSBBTFRfV1JTX05UTygpCQkJCQkJCVwKK2FzbSB2b2xhdGlsZShBTFRF Uk5BVElWRSgJCQkJCQlcCisJIm5vcFxuXHQiLAkJCQkJCQlcCisJWkFXUlNfV1JTX05UTyAiXG5c dCIsCQkJCQkJXAorCTAsIFJJU0NWX0lTQV9FWFRfWkFXUlMsIENPTkZJR19SSVNDVl9JU0FfWkFX UlMpKQorCisjZGVmaW5lIFpBV1JTX1dSU19TVE8JIi5sb25nIDB4MDFkMDAwNzMiCisjZGVmaW5l IEFMVF9XUlNfU1RPKCkJCQkJCQkJXAorYXNtIHZvbGF0aWxlKEFMVEVSTkFUSVZFKAkJCQkJCVwK Kwkibm9wXG5cdCIsCQkJCQkJCVwKKwlaQVdSU19XUlNfU1RPICJcblx0IiwJCQkJCQlcCisJMCwg UklTQ1ZfSVNBX0VYVF9aQVdSUywgQ09ORklHX1JJU0NWX0lTQV9aQVdSUykpCisKIC8qCiAgKiBf dmFsIGlzIG1hcmtlZCBhcyAid2lsbCBiZSBvdmVyd3JpdHRlbiIsIHNvIG5lZWQgdG8gc2V0IGl0 IHRvIDAKICAqIGluIHRoZSBkZWZhdWx0IGNhc2UuCmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2lu Y2x1ZGUvYXNtL2h3Y2FwLmggYi9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL2h3Y2FwLmgKaW5kZXgg ZTBjNDBhNGM2M2Q1Li40MjMzZDg3NTM5YWIgMTAwNjQ0Ci0tLSBhL2FyY2gvcmlzY3YvaW5jbHVk ZS9hc20vaHdjYXAuaAorKysgYi9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL2h3Y2FwLmgKQEAgLTQ2 LDYgKzQ2LDcgQEAKICNkZWZpbmUgUklTQ1ZfSVNBX0VYVF9aSUNCT1oJCTM0CiAjZGVmaW5lIFJJ U0NWX0lTQV9FWFRfU01BSUEJCTM1CiAjZGVmaW5lIFJJU0NWX0lTQV9FWFRfU1NBSUEJCTM2Cisj ZGVmaW5lIFJJU0NWX0lTQV9FWFRfWkFXUlMJCTM3CiAKICNkZWZpbmUgUklTQ1ZfSVNBX0VYVF9N QVgJCTY0CiAjZGVmaW5lIFJJU0NWX0lTQV9FWFRfTkFNRV9MRU5fTUFYCTMyCmRpZmYgLS1naXQg YS9hcmNoL3Jpc2N2L2tlcm5lbC9jcHUuYyBiL2FyY2gvcmlzY3Yva2VybmVsL2NwdS5jCmluZGV4 IGM5NmFhNTZjZjFjNy4uYWM5YzYwNGQ4OTM2IDEwMDY0NAotLS0gYS9hcmNoL3Jpc2N2L2tlcm5l bC9jcHUuYworKysgYi9hcmNoL3Jpc2N2L2tlcm5lbC9jcHUuYwpAQCAtMTg0LDYgKzE4NCw3IEBA IHN0YXRpYyBzdHJ1Y3QgcmlzY3ZfaXNhX2V4dF9kYXRhIGlzYV9leHRfYXJyW10gPSB7CiAJX19S SVNDVl9JU0FfRVhUX0RBVEEoemljYm9tLCBSSVNDVl9JU0FfRVhUX1pJQ0JPTSksCiAJX19SSVND Vl9JU0FfRVhUX0RBVEEoemljYm96LCBSSVNDVl9JU0FfRVhUX1pJQ0JPWiksCiAJX19SSVNDVl9J U0FfRVhUX0RBVEEoemloaW50cGF1c2UsIFJJU0NWX0lTQV9FWFRfWklISU5UUEFVU0UpLAorCV9f UklTQ1ZfSVNBX0VYVF9EQVRBKHphd3JzLCBSSVNDVl9JU0FfRVhUX1pBV1JTKSwKIAlfX1JJU0NW X0lTQV9FWFRfREFUQSh6YmIsIFJJU0NWX0lTQV9FWFRfWkJCKSwKIAlfX1JJU0NWX0lTQV9FWFRf REFUQShzbWFpYSwgUklTQ1ZfSVNBX0VYVF9TTUFJQSksCiAJX19SSVNDVl9JU0FfRVhUX0RBVEEo c3NhaWEsIFJJU0NWX0lTQV9FWFRfU1NBSUEpLApkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9rZXJu ZWwvY3B1ZmVhdHVyZS5jIGIvYXJjaC9yaXNjdi9rZXJuZWwvY3B1ZmVhdHVyZS5jCmluZGV4IGIx ZDZiN2U0YjgyOS4uZDRhMjJhN2FlZDk5IDEwMDY0NAotLS0gYS9hcmNoL3Jpc2N2L2tlcm5lbC9j cHVmZWF0dXJlLmMKKysrIGIvYXJjaC9yaXNjdi9rZXJuZWwvY3B1ZmVhdHVyZS5jCkBAIC0yMzYs NiArMjM2LDcgQEAgdm9pZCBfX2luaXQgcmlzY3ZfZmlsbF9od2NhcCh2b2lkKQogCQkJCVNFVF9J U0FfRVhUX01BUCgic3ZpbnZhbCIsIFJJU0NWX0lTQV9FWFRfU1ZJTlZBTCk7CiAJCQkJU0VUX0lT QV9FWFRfTUFQKCJzdm5hcG90IiwgUklTQ1ZfSVNBX0VYVF9TVk5BUE9UKTsKIAkJCQlTRVRfSVNB X0VYVF9NQVAoInN2cGJtdCIsIFJJU0NWX0lTQV9FWFRfU1ZQQk1UKTsKKwkJCQlTRVRfSVNBX0VY VF9NQVAoInphd3JzIiwgUklTQ1ZfSVNBX0VYVF9aQVdSUyk7CiAJCQkJU0VUX0lTQV9FWFRfTUFQ KCJ6YmIiLCBSSVNDVl9JU0FfRVhUX1pCQik7CiAJCQkJU0VUX0lTQV9FWFRfTUFQKCJ6aWNib20i LCBSSVNDVl9JU0FfRVhUX1pJQ0JPTSk7CiAJCQkJU0VUX0lTQV9FWFRfTUFQKCJ6aWNib3oiLCBS SVNDVl9JU0FfRVhUX1pJQ0JPWik7Ci0tIAoyLjM5LjAKCgpfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1yaXNjdiBtYWlsaW5nIGxpc3QKbGludXgt cmlzY3ZAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWls bWFuL2xpc3RpbmZvL2xpbnV4LXJpc2N2Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 00024C7EE23 for ; Sun, 21 May 2023 11:50:32 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231124AbjEULub (ORCPT ); Sun, 21 May 2023 07:50:31 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44294 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230527AbjEULt0 (ORCPT ); Sun, 21 May 2023 07:49:26 -0400 Received: from gloria.sntech.de (gloria.sntech.de [185.11.138.130]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id DF9DE10F0 for ; Sun, 21 May 2023 04:47:20 -0700 (PDT) Received: from ip5b412278.dynamic.kabel-deutschland.de ([91.65.34.120] helo=phil.lan) by gloria.sntech.de with esmtpsa (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1q0hWv-0008T6-9y; Sun, 21 May 2023 13:47:17 +0200 From: Heiko Stuebner To: linux-riscv@lists.infradead.org, palmer@dabbelt.com, paul.walmsley@sifive.com Cc: linux-kernel@vger.kernel.org, christoph.muellner@vrull.eu, David.Laight@ACULAB.COM, Heiko Stuebner Subject: [PATCH v3 2/2] riscv: Add Zawrs support for spinlocks Date: Sun, 21 May 2023 13:47:15 +0200 Message-Id: <20230521114715.955823-3-heiko.stuebner@vrull.eu> X-Mailer: git-send-email 2.39.0 In-Reply-To: <20230521114715.955823-1-heiko.stuebner@vrull.eu> References: <20230521114715.955823-1-heiko.stuebner@vrull.eu> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Christoph Müllner The current RISC-V code uses the generic ticket lock implementation, that calls the macros smp_cond_load_relaxed() and smp_cond_load_acquire(). Currently, RISC-V uses the generic implementation of these macros. This patch introduces a RISC-V specific implementation, of these macros, that peels off the first loop iteration and modifies the waiting loop such, that it is possible to use the WRS.STO instruction of the Zawrs ISA extension to stall the CPU. The resulting implementation of smp_cond_load_*() will only work for 32-bit or 64-bit types for RV64 and 32-bit types for RV32. This is caused by the restrictions of the LR instruction (RISC-V only has LR.W and LR.D). Compiler assertions guard this new restriction. This patch uses the existing RISC-V ISA extension framework to detect the presence of Zawrs at run-time. If available a NOP instruction will be replaced by WRS.NTO or WRS.STO. The whole mechanism is gated by Kconfig setting, which defaults to Y. The Zawrs specification can be found here: https://github.com/riscv/riscv-zawrs/blob/main/zawrs.adoc Signed-off-by: Christoph Müllner [rebase, update to review comments] Signed-off-by: Heiko Stuebner --- arch/riscv/Kconfig | 10 +++++ arch/riscv/include/asm/barrier.h | 64 ++++++++++++++++++++++++++++ arch/riscv/include/asm/errata_list.h | 14 ++++++ arch/riscv/include/asm/hwcap.h | 1 + arch/riscv/kernel/cpu.c | 1 + arch/riscv/kernel/cpufeature.c | 1 + 6 files changed, 91 insertions(+) diff --git a/arch/riscv/Kconfig b/arch/riscv/Kconfig index 348c0fa1fc8c..60ff303ff58a 100644 --- a/arch/riscv/Kconfig +++ b/arch/riscv/Kconfig @@ -460,6 +460,16 @@ config RISCV_ISA_SVPBMT If you don't know what to do here, say Y. +config RISCV_ISA_ZAWRS + bool "Zawrs extension support" + depends on RISCV_ALTERNATIVE + default y + help + Adds support to dynamically detect the presence of the Zawrs extension + (wait for reservation set) and enable its usage. + + If you don't know what to do here, say Y. + config TOOLCHAIN_HAS_ZBB bool default y diff --git a/arch/riscv/include/asm/barrier.h b/arch/riscv/include/asm/barrier.h index 110752594228..bd64cfe5ae10 100644 --- a/arch/riscv/include/asm/barrier.h +++ b/arch/riscv/include/asm/barrier.h @@ -12,6 +12,8 @@ #ifndef __ASSEMBLY__ +#include + #define nop() __asm__ __volatile__ ("nop") #define __nops(n) ".rept " #n "\nnop\n.endr\n" #define nops(n) __asm__ __volatile__ (__nops(n)) @@ -44,6 +46,36 @@ do { \ ___p1; \ }) +#define ___smp_load_reservedN(pfx, ptr) \ +({ \ + typeof(*ptr) ___p1; \ + __asm__ __volatile__ ("lr." pfx " %[p], %[c]\n" \ + : [p]"=&r" (___p1), [c]"+A"(*ptr)); \ + ___p1; \ +}) + +#define __smp_load_reserved_relaxed(ptr) \ +({ \ + typeof(*ptr) ___p1; \ + if (sizeof(*ptr) == sizeof(int)) \ + ___p1 = ___smp_load_reservedN("w", ptr); \ + else if (sizeof(*ptr) == sizeof(long)) \ + ___p1 = ___smp_load_reservedN("d", ptr); \ + else \ + compiletime_assert(0, \ + "Need type compatible with LR/SC instructions " \ + "for " __stringify(ptr)); \ + ___p1; \ +}) + +#define __smp_load_reserved_acquire(ptr) \ +({ \ + typeof(*ptr) ___p1; \ + ___p1 = __smp_load_reserved_relaxed(ptr); \ + RISCV_FENCE(r, rw); \ + ___p1; \ +}) + /* * This is a very specific barrier: it's currently only used in two places in * the kernel, both in the scheduler. See include/linux/spinlock.h for the two @@ -71,6 +103,38 @@ do { \ */ #define smp_mb__after_spinlock() RISCV_FENCE(iorw,iorw) +#define smp_cond_load_relaxed(ptr, cond_expr) \ +({ \ + typeof(ptr) __PTR = (ptr); \ + __unqual_scalar_typeof(*ptr) VAL; \ + VAL = READ_ONCE(*__PTR); \ + if (!cond_expr) { \ + for (;;) { \ + VAL = __smp_load_reserved_relaxed(__PTR); \ + if (cond_expr) \ + break; \ + ALT_WRS_STO(); \ + } \ + } \ + (typeof(*ptr))VAL; \ +}) + +#define smp_cond_load_acquire(ptr, cond_expr) \ +({ \ + typeof(ptr) __PTR = (ptr); \ + __unqual_scalar_typeof(*ptr) VAL; \ + VAL = smp_load_acquire(__PTR); \ + if (!cond_expr) { \ + for (;;) { \ + VAL = __smp_load_reserved_acquire(__PTR); \ + if (cond_expr) \ + break; \ + ALT_WRS_STO(); \ + } \ + } \ + (typeof(*ptr))VAL; \ +}) + #include #endif /* __ASSEMBLY__ */ diff --git a/arch/riscv/include/asm/errata_list.h b/arch/riscv/include/asm/errata_list.h index fb1a810f3d8c..36a72a07d62c 100644 --- a/arch/riscv/include/asm/errata_list.h +++ b/arch/riscv/include/asm/errata_list.h @@ -44,6 +44,20 @@ asm(ALTERNATIVE("sfence.vma %0", "sfence.vma", SIFIVE_VENDOR_ID, \ ERRATA_SIFIVE_CIP_1200, CONFIG_ERRATA_SIFIVE_CIP_1200) \ : : "r" (addr) : "memory") +#define ZAWRS_WRS_NTO ".long 0x00d00073" +#define ALT_WRS_NTO() \ +asm volatile(ALTERNATIVE( \ + "nop\n\t", \ + ZAWRS_WRS_NTO "\n\t", \ + 0, RISCV_ISA_EXT_ZAWRS, CONFIG_RISCV_ISA_ZAWRS)) + +#define ZAWRS_WRS_STO ".long 0x01d00073" +#define ALT_WRS_STO() \ +asm volatile(ALTERNATIVE( \ + "nop\n\t", \ + ZAWRS_WRS_STO "\n\t", \ + 0, RISCV_ISA_EXT_ZAWRS, CONFIG_RISCV_ISA_ZAWRS)) + /* * _val is marked as "will be overwritten", so need to set it to 0 * in the default case. diff --git a/arch/riscv/include/asm/hwcap.h b/arch/riscv/include/asm/hwcap.h index e0c40a4c63d5..4233d87539ab 100644 --- a/arch/riscv/include/asm/hwcap.h +++ b/arch/riscv/include/asm/hwcap.h @@ -46,6 +46,7 @@ #define RISCV_ISA_EXT_ZICBOZ 34 #define RISCV_ISA_EXT_SMAIA 35 #define RISCV_ISA_EXT_SSAIA 36 +#define RISCV_ISA_EXT_ZAWRS 37 #define RISCV_ISA_EXT_MAX 64 #define RISCV_ISA_EXT_NAME_LEN_MAX 32 diff --git a/arch/riscv/kernel/cpu.c b/arch/riscv/kernel/cpu.c index c96aa56cf1c7..ac9c604d8936 100644 --- a/arch/riscv/kernel/cpu.c +++ b/arch/riscv/kernel/cpu.c @@ -184,6 +184,7 @@ static struct riscv_isa_ext_data isa_ext_arr[] = { __RISCV_ISA_EXT_DATA(zicbom, RISCV_ISA_EXT_ZICBOM), __RISCV_ISA_EXT_DATA(zicboz, RISCV_ISA_EXT_ZICBOZ), __RISCV_ISA_EXT_DATA(zihintpause, RISCV_ISA_EXT_ZIHINTPAUSE), + __RISCV_ISA_EXT_DATA(zawrs, RISCV_ISA_EXT_ZAWRS), __RISCV_ISA_EXT_DATA(zbb, RISCV_ISA_EXT_ZBB), __RISCV_ISA_EXT_DATA(smaia, RISCV_ISA_EXT_SMAIA), __RISCV_ISA_EXT_DATA(ssaia, RISCV_ISA_EXT_SSAIA), diff --git a/arch/riscv/kernel/cpufeature.c b/arch/riscv/kernel/cpufeature.c index b1d6b7e4b829..d4a22a7aed99 100644 --- a/arch/riscv/kernel/cpufeature.c +++ b/arch/riscv/kernel/cpufeature.c @@ -236,6 +236,7 @@ void __init riscv_fill_hwcap(void) SET_ISA_EXT_MAP("svinval", RISCV_ISA_EXT_SVINVAL); SET_ISA_EXT_MAP("svnapot", RISCV_ISA_EXT_SVNAPOT); SET_ISA_EXT_MAP("svpbmt", RISCV_ISA_EXT_SVPBMT); + SET_ISA_EXT_MAP("zawrs", RISCV_ISA_EXT_ZAWRS); SET_ISA_EXT_MAP("zbb", RISCV_ISA_EXT_ZBB); SET_ISA_EXT_MAP("zicbom", RISCV_ISA_EXT_ZICBOM); SET_ISA_EXT_MAP("zicboz", RISCV_ISA_EXT_ZICBOZ); -- 2.39.0