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 kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 28949C77B7C for ; Tue, 24 Jun 2025 15:51:20 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id B971F6B00B8; Tue, 24 Jun 2025 11:51:19 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id B6EDD6B00B9; Tue, 24 Jun 2025 11:51:19 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id A84C86B00C1; Tue, 24 Jun 2025 11:51:19 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0015.hostedemail.com [216.40.44.15]) by kanga.kvack.org (Postfix) with ESMTP id 948036B00B8 for ; Tue, 24 Jun 2025 11:51:19 -0400 (EDT) Received: from smtpin27.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay02.hostedemail.com (Postfix) with ESMTP id 470B8121D5D for ; Tue, 24 Jun 2025 15:51:19 +0000 (UTC) X-FDA: 83590733478.27.BBD3E37 Received: from frasgout.his.huawei.com (frasgout.his.huawei.com [185.176.79.56]) by imf09.hostedemail.com (Postfix) with ESMTP id 443E214000A for ; Tue, 24 Jun 2025 15:51:17 +0000 (UTC) Authentication-Results: imf09.hostedemail.com; dkim=none; dmarc=pass (policy=quarantine) header.from=huawei.com; spf=pass (imf09.hostedemail.com: domain of jonathan.cameron@huawei.com designates 185.176.79.56 as permitted sender) smtp.mailfrom=jonathan.cameron@huawei.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1750780277; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=YcuLTj3Bnq2aiby9GhV+wmvILooRQYP4tUJOoURBST0=; b=0cQGoGUTP1/onrBO6ZqEkUZNVH+cdXC6IaQddwkbiSm5ETeZyJXh0wJfCCieZU6Bns8AFZ hYkiGxKnaARaIHxEpsiCGAPU5iQnTaS6wLrHJCmz4AUvM0O23LywKJpWqhu0XFUQzEtw8u ghqICrWR8NHutATRhiyeOOXh24clm2E= ARC-Authentication-Results: i=1; imf09.hostedemail.com; dkim=none; dmarc=pass (policy=quarantine) header.from=huawei.com; spf=pass (imf09.hostedemail.com: domain of jonathan.cameron@huawei.com designates 185.176.79.56 as permitted sender) smtp.mailfrom=jonathan.cameron@huawei.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1750780277; a=rsa-sha256; cv=none; b=KxF4AKxoGMWx8EI9JU+LcO2jbdni3aSl6y18p7+Ne3KPCKRYq1H4blrG+f5wM2/hsw0osS WBlmcDN39D2F9z+N6zylB+1nsNjTNqXZ7lMM//RTlbG+f6EbaE6Be1dlgi9WidI/MlOxEX ElCv55PDjiii8GKxw7al06pXHNn7cjo= Received: from mail.maildlp.com (unknown [172.18.186.31]) by frasgout.his.huawei.com (SkyGuard) with ESMTP id 4bRTng62Tbz6J6kD; Tue, 24 Jun 2025 23:46:15 +0800 (CST) Received: from frapeml500008.china.huawei.com (unknown [7.182.85.71]) by mail.maildlp.com (Postfix) with ESMTPS id 9155F1402C3; Tue, 24 Jun 2025 23:51:15 +0800 (CST) Received: from SecurePC-101-06.china.huawei.com (10.122.19.247) by frapeml500008.china.huawei.com (7.182.85.71) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.1.2507.39; Tue, 24 Jun 2025 17:51:14 +0200 From: Jonathan Cameron To: Catalin Marinas , , , , , , , , Will Deacon , Dan Williams , Davidlohr Bueso CC: Yicong Yang , , Yushan Wang , Lorenzo Pieralisi , Mark Rutland , Dave Hansen , Thomas Gleixner , Ingo Molnar , Borislav Petkov , , H Peter Anvin , Andy Lutomirski , Peter Zijlstra Subject: [PATCH v2 6/8] cache: Support cache maintenance for HiSilicon SoC Hydra Home Agent Date: Tue, 24 Jun 2025 16:48:02 +0100 Message-ID: <20250624154805.66985-7-Jonathan.Cameron@huawei.com> X-Mailer: git-send-email 2.48.1 In-Reply-To: <20250624154805.66985-1-Jonathan.Cameron@huawei.com> References: <20250624154805.66985-1-Jonathan.Cameron@huawei.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Content-Type: text/plain X-Originating-IP: [10.122.19.247] X-ClientProxiedBy: lhrpeml500004.china.huawei.com (7.191.163.9) To frapeml500008.china.huawei.com (7.182.85.71) X-Rspamd-Queue-Id: 443E214000A X-Rspam-User: X-Rspamd-Server: rspam07 X-Stat-Signature: ypqagyt8kaqyo4p7dktc6bmfdhx6gwzs X-HE-Tag: 1750780277-184599 X-HE-Meta: U2FsdGVkX1+8VU5nGw6FXn6eYMzep6uj0oS+I5Kkf3X8NcugiKvz+9+9o2ZKrvx1C0khL+SpydCCQMhWlfNdk7TqVxPrheU19wPfZikWYvGV3+l+byJqblGQQMadlGLHuokGM+prbN4EkEc0gnJ4516YW+ywgOiAUDsX3G6i7rAsxqadQTFITmSqxaS1nSa3rpIbn8S4Yb7H1+djtiI2e4hGbxmh5j3tnobIUhcPxrKfBObcnyDN6bcznuPAq3UbaWghfQ5Tfn+BROYS1qtcnpW0RaXJDgz57v8Cgp61YyH7WUz7PDsRYY3g84AImbNq/9i+3y/1UEqBEbp3q5QsmPy4DV+9Xw6wFl61voUBJZHSh5aQlVa6KONvMg2EALTuYhOHbMKGo0ieEdExJmstGyXncPQqb41cxIQOXDHeHuAiFXdD9niPUgLyO3QqmEc3Q+DnNpx/+bcyU4wiG/CuTpa+wiwZDLJ0JAwX++lx4kLnIZ+wXQhiWfCjSeHfRznsoIdK9abfVyrrINkwB3jN+6FwvPGuTfg1YLiJ6cC/zlQfkrcWfAvpvoxhx3tp/IdIDsgcf+DJ5VL0Ilo2+NlmDX7wWWLZs0lVIxhVAeKEplsdgn21CkbAtSFmkKCagKCwOHU+83Too2qw+uJg3Lc1wmEzNuSE6ox8rcSiFmntKW3FcLSAAUxxXt6qZW9TTfkO7NU5xU0cadObDz1twI3yoqb/7s90GrArZ1BSOij3O913JHN4dsVwwmfkOGDYTczI4bKRewPEc5UKRkWqtAty/+wznmjV8QHyc0tudKnC0Bo++QmEQxi9hkvGZ47Vd63hGSP4YDyUDdBahrdOJ4oNz3ulw9WDlhmwpiNjZkeQGkFtILFi8tFVKVPoUSnymDwt92QbKdcErAl/rABjr7I3Ka5Mr8rwNdaxeGF08FYioQS5MaAreIcSGe9NILRUsRsisWfTSHssiqKLzVEygQF rKY6nBsz Pm8Ccj9notY0xN0aAcJD7X+dqW85NcAR/GeEfBReX/akjSt5D56Ux7KYBA55lLzv/PPQk2whzgvyJ0zqDSC59H+m2ztpfg9qYFyhVCQ636rkpyrdmGg/YP+xFS2Wdutk3rkHpkRk286o2T3oGpvGL+m072gvj6VigkY7oR05kmmPvW6jc3+6UeayMqTqD6q8zqyyq77kzBNqWO9fg5AYjk6ztWf7fV5iyHa90FgFtTFTyE+VrpIj3SqVZWLeszSwG9cc7bMVcxSKUKHOsIX9tv/VxgA== X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: From: Yushan Wang Hydra Home Agent is a device used for maintain cache coherency, add support of cache maintenance operations for it. Memory resource of HHA conflicts with that of HHA PMU. Workaround is implemented here by replacing devm_ioremap_resource() to devm_ioremap() to workaround resource conflict check. Signed-off-by: Yicong Yang Co-developed-by: Yicong Yang Signed-off-by: Yushan Wang Signed-off-by: Jonathan Cameron --- drivers/cache/Kconfig | 14 +++ drivers/cache/Makefile | 1 + drivers/cache/hisi_soc_hha.c | 185 +++++++++++++++++++++++++++++++++++ 3 files changed, 200 insertions(+) diff --git a/drivers/cache/Kconfig b/drivers/cache/Kconfig index bedc51bea1d1..0ed87f25bd69 100644 --- a/drivers/cache/Kconfig +++ b/drivers/cache/Kconfig @@ -10,6 +10,20 @@ config CACHE_COHERENCY_SUBSYSTEM kernel subsystems to issue invalidations and similar coherency operations. +if CACHE_COHERENCY_SUBSYSTEM + +config HISI_SOC_HHA + tristate "HiSilicon Hydra Home Agent (HHA) device driver" + depends on (ARM64 && ACPI) || COMPILE_TEST + help + The Hydra Home Agent (HHA) is responsible of cache coherency + on SoC. This drivers provides cache maintenance functions of HHA. + + This driver can be built as a module. If so, the module will be + called hisi_soc_hha. + +endif + config AX45MP_L2_CACHE bool "Andes Technology AX45MP L2 Cache controller" depends on RISCV diff --git a/drivers/cache/Makefile b/drivers/cache/Makefile index b193c3d1a06e..dfc98273ff09 100644 --- a/drivers/cache/Makefile +++ b/drivers/cache/Makefile @@ -5,3 +5,4 @@ obj-$(CONFIG_SIFIVE_CCACHE) += sifive_ccache.o obj-$(CONFIG_STARFIVE_STARLINK_CACHE) += starfive_starlink_cache.o obj-$(CONFIG_CACHE_COHERENCY_SUBSYSTEM) += coherency_core.o +obj-$(CONFIG_HISI_SOC_HHA) += hisi_soc_hha.o diff --git a/drivers/cache/hisi_soc_hha.c b/drivers/cache/hisi_soc_hha.c new file mode 100644 index 000000000000..f37990e4c0c7 --- /dev/null +++ b/drivers/cache/hisi_soc_hha.c @@ -0,0 +1,185 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Driver for HiSilicon Hydra Home Agent (HHA). + * + * Copyright (c) 2025 HiSilicon Technologies Co., Ltd. + * Author: Yicong Yang + * Yushan Wang + */ + +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define HISI_HHA_CTRL 0x5004 +#define HISI_HHA_CTRL_EN BIT(0) +#define HISI_HHA_CTRL_RANGE BIT(1) +#define HISI_HHA_CTRL_TYPE GENMASK(3, 2) +#define HISI_HHA_START_L 0x5008 +#define HISI_HHA_START_H 0x500c +#define HISI_HHA_LEN_L 0x5010 +#define HISI_HHA_LEN_H 0x5014 + +/* The maintain operation performs in a 128 Byte granularity */ +#define HISI_HHA_MAINT_ALIGN 128 + +#define HISI_HHA_POLL_GAP_US 10 +#define HISI_HHA_POLL_TIMEOUT_US 50000 + +struct hisi_soc_hha { + struct cache_coherency_device ccd; + /* Locks HHA instance to forbid overlapping access. */ + spinlock_t lock; + void __iomem *base; +}; + +static bool hisi_hha_cache_maintain_wait_finished(struct hisi_soc_hha *soc_hha) +{ + u32 val; + + return !readl_poll_timeout_atomic(soc_hha->base + HISI_HHA_CTRL, val, + !(val & HISI_HHA_CTRL_EN), + HISI_HHA_POLL_GAP_US, + HISI_HHA_POLL_TIMEOUT_US); +} + +static int hisi_soc_hha_wbinv(struct cache_coherency_device *ccd, struct cc_inval_params *invp) +{ + struct hisi_soc_hha *soc_hha = container_of(ccd, struct hisi_soc_hha, ccd); + phys_addr_t addr = invp->addr; + size_t size = invp->size; + u32 reg; + + if (!size) + return -EINVAL; + + guard(spinlock)(&soc_hha->lock); + + if (!hisi_hha_cache_maintain_wait_finished(soc_hha)) + return -EBUSY; + + /* + * Hardware will search for addresses ranging [addr, addr + size - 1], + * last byte included, and perform maintain in 128 byte granule + * on those cachelines which contain the addresses. + */ + size -= 1; + + writel(lower_32_bits(addr), soc_hha->base + HISI_HHA_START_L); + writel(upper_32_bits(addr), soc_hha->base + HISI_HHA_START_H); + writel(lower_32_bits(size), soc_hha->base + HISI_HHA_LEN_L); + writel(upper_32_bits(size), soc_hha->base + HISI_HHA_LEN_H); + + reg = FIELD_PREP(HISI_HHA_CTRL_TYPE, 1); /* Clean Invalid */ + reg |= HISI_HHA_CTRL_RANGE | HISI_HHA_CTRL_EN; + writel(reg, soc_hha->base + HISI_HHA_CTRL); + + return 0; +} + +static int hisi_soc_hha_done(struct cache_coherency_device *ccd) +{ + struct hisi_soc_hha *soc_hha = container_of(ccd, struct hisi_soc_hha, ccd); + + guard(spinlock)(&soc_hha->lock); + if (!hisi_hha_cache_maintain_wait_finished(soc_hha)) + return -ETIMEDOUT; + + return 0; +} + +static const struct coherency_ops hha_ops = { + .wbinv = hisi_soc_hha_wbinv, + .done = hisi_soc_hha_done, +}; + +static int hisi_soc_hha_probe(struct platform_device *pdev) +{ + struct hisi_soc_hha *soc_hha; + struct resource *mem; + int ret; + + soc_hha = (struct hisi_soc_hha *) + cache_coherency_alloc_device(&pdev->dev, &hha_ops, + sizeof(*soc_hha)); + if (!soc_hha) + return -ENOMEM; + + platform_set_drvdata(pdev, soc_hha); + + spin_lock_init(&soc_hha->lock); + + mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); + if (!mem) + return -ENODEV; + + /* + * HHA cache driver share the same register region with HHA uncore PMU + * driver in hardware's perspective, none of them should reserve the + * resource to itself only. Here exclusive access verification is + * avoided by calling devm_ioremap instead of devm_ioremap_resource to + * allow both drivers to exist at the same time. + */ + soc_hha->base = ioremap(mem->start, resource_size(mem)); + if (IS_ERR_OR_NULL(soc_hha->base)) { + ret = dev_err_probe(&pdev->dev, PTR_ERR(soc_hha->base), + "failed to remap io memory"); + goto err_free_ccd; + } + + ret = cache_coherency_device_register(&soc_hha->ccd); + if (ret) + goto err_iounmap; + + return 0; + +err_iounmap: + iounmap(soc_hha->base); +err_free_ccd: + cache_coherency_device_free(&soc_hha->ccd); + return ret; +} + +static void hisi_soc_hha_remove(struct platform_device *pdev) +{ + struct hisi_soc_hha *soc_hha = platform_get_drvdata(pdev); + + cache_coherency_device_unregister(&soc_hha->ccd); + iounmap(soc_hha->base); + cache_coherency_device_free(&soc_hha->ccd); +} + +static const struct acpi_device_id hisi_soc_hha_ids[] = { + { "HISI0511", }, + { } +}; +MODULE_DEVICE_TABLE(acpi, hisi_soc_hha_ids); + +static struct platform_driver hisi_soc_hha_driver = { + .driver = { + .name = "hisi_soc_hha", + .acpi_match_table = hisi_soc_hha_ids, + }, + .probe = hisi_soc_hha_probe, + .remove = hisi_soc_hha_remove, +}; + +module_platform_driver(hisi_soc_hha_driver); + +MODULE_IMPORT_NS("CACHE_COHERENCY"); +MODULE_DESCRIPTION("HiSilicon Hydra Home Agent driver supporting cache maintenance"); +MODULE_AUTHOR("Yicong Yang "); +MODULE_AUTHOR("Yushan Wang "); +MODULE_LICENSE("GPL"); -- 2.48.1