From patchwork Wed Mar 19 14:44:00 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Connor Abbott X-Patchwork-Id: 14022669 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 4369FC35FFA for ; Wed, 19 Mar 2025 14:49:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:List-Subscribe:List-Help :List-Post:List-Archive:List-Unsubscribe:List-Id:Cc:To:In-Reply-To:References :Message-Id:Content-Transfer-Encoding:Content-Type:MIME-Version:Subject:Date: From:Reply-To:Content-ID:Content-Description:Resent-Date:Resent-From: Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=AS2XW5pVq0bthsTGPB5Ou/UximnBEjkkBn7KlYu8Dbk=; b=OQiQELyXdl3nLCyjTl+8QR/Jbp uHzL8o3avTGlTIL6Zc5FGN1v1Z7ZwaLz79gkxC9+DHwgUWmdtfO12RtmSYXEIIyK6ZgVbEGGgFLNG w5fjciT0Zk4rvmwV7kw115CBzNARUKoRth/c/Dlg/+QFPBcvBz4Yo4OO9Pn0BF/SmFPeFAnMS/D9k CSKa8wE+oCaWSqxtG2y80RAs9HyV9YRPEEYFXpIGB3aThTXlqptb4dAg0V4eamLoeF1mp3LzXiAPH 3TpO0VNjhkVE4qzscbmxeYhC29gLdKzSTxL/ToUoM1kWHRIi5zqkWYQBS5QIZxw35zT9hHDpv9huX phMB7ucg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98 #2 (Red Hat Linux)) id 1tuujF-00000009FzE-2GxF; Wed, 19 Mar 2025 14:49:09 +0000 Received: from mail-qk1-x729.google.com ([2607:f8b0:4864:20::729]) by bombadil.infradead.org with esmtps (Exim 4.98 #2 (Red Hat Linux)) id 1tuueP-00000009FGH-2VOC for linux-arm-kernel@lists.infradead.org; Wed, 19 Mar 2025 14:44:10 +0000 Received: by mail-qk1-x729.google.com with SMTP id af79cd13be357-7c553948a30so20390285a.2 for ; Wed, 19 Mar 2025 07:44:09 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1742395448; x=1743000248; darn=lists.infradead.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=AS2XW5pVq0bthsTGPB5Ou/UximnBEjkkBn7KlYu8Dbk=; b=HVEzrFWUaSkitqG+DRc8sclTt3XnDBhvZEgD2JSPe//57Idj49kxoxpjO3NfQuhqYH rpzyYhZy+7vdgitd3gfmyltwM/rwsXQTWagtxeBZTdS1ETm4tjUWIUSoFSZfi6LHfEFv TZ79oBkz5mS7d6B87uBaDyGxT4frC3BELyXdl0mTRXOe88K2QxurKkVoAC3fZCE1T+rd P8vVTcZw4uBQ+bp93Y81EJoYPfQjUCbX6uitVFkjHzlqg5y9IAHiV3sj5rD0LScO2y6w XlZIIexE/L8v2JvwXiK3Djn9+wJ/flWsLPnm/wgb821EXkezSFyy+W2QTKLvxNhNywfG lF0A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1742395448; x=1743000248; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=AS2XW5pVq0bthsTGPB5Ou/UximnBEjkkBn7KlYu8Dbk=; b=eYyUoyJpCUdITC7ekHVSiFQS/xTDIzJtgLPlrOE/Q8hzkGe8Tte+ULZ1vN8iWFmF6u mJEvjrrzJzW4t3K5H3R4GIt47MD1D4Zhin4W4OfiLTcGKqaRZ8vpcOt8SI0UqRgA2TyJ 1XNAleIv4z3YWc0/R3IyOfcsSJXztqEv552S7Qmm7SXZvQk3Is4oIl2zIpHJYKXyOV5B /U5WJo2MdLiSzmCjk4LM6CCJrAsdyOeQbPseq3uje9otjkuSngBDxAQxuXAjpvlYkqdf RyoQ1tGMO47JfzBsGV82a8lFfVrk3VbErEHJ++7SE+rlPOE/EJwrRi8KtPX0lHkt13PV OFiA== X-Forwarded-Encrypted: i=1; AJvYcCUEwRevYj/ggALlu9ZZi6el5B/Gzvf26fdjfB19+cztLzVc9XfQCdgkqjrZqIivpxRh84vNLHGnIl7j/bsDcCmV@lists.infradead.org X-Gm-Message-State: AOJu0YySnzmqKo7lUAAm+dNzAuFjYmKUlRU9M84Xgq7nzxoCu4sNtsip PiSpOgbmPxmCtyitKgzZCie9zDbOYu7yN56dI1XZibgnx/CGlRnF X-Gm-Gg: ASbGncuQqoal9HifQjfywBgmiF7hzyazNO7hnuBuHMxotXDUUUd6wiRyx1eJ10pY/m3 5BEbNbf4zYz+fUQvO3E3FCO+vC4Q67T17bGAYkUyHRzqvOhs2WEAIyKJNRkJj1VYDCT5odL1owN vwEYaoneInFXUDExeFdDG6Fc2M+7HPI3UnX1YCn7mYpzAlRJ/gWgsm0qW8cueWpAtU+Ew378qu3 f8dvOayNq5seJowUaPTkUlW99Uc0WXTS281A/dhRkZ69XTpp1A1HwTTMia7xjfknFMtHtJs9qgq ESEcCaiedLKvCq9PUkjyVH6KSDYd2YQrBa4Eshx+04sDFCMiU5HF11P8FGuEP8gTCP9r/+zILC/ dsOA= X-Google-Smtp-Source: AGHT+IEUBVxNH3Lj7tUjS4Mop+GMxjYMq/idGTGfkbzDE/H+cThDC2WmGJXmJn8+8iyby/rSDnLTuw== X-Received: by 2002:a05:620a:2907:b0:7c5:606e:763 with SMTP id af79cd13be357-7c5a83dac18mr168535685a.6.1742395448390; Wed, 19 Mar 2025 07:44:08 -0700 (PDT) Received: from [192.168.1.99] (ool-4355b0da.dyn.optonline.net. [67.85.176.218]) by smtp.gmail.com with ESMTPSA id af79cd13be357-7c573c5201fsm868587485a.23.2025.03.19.07.44.07 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 19 Mar 2025 07:44:07 -0700 (PDT) From: Connor Abbott Date: Wed, 19 Mar 2025 10:44:00 -0400 Subject: [PATCH v5 1/5] iommu/arm-smmu: Save additional information on context fault MIME-Version: 1.0 Message-Id: <20250319-msm-gpu-fault-fixes-next-v5-1-97561209dd8c@gmail.com> References: <20250319-msm-gpu-fault-fixes-next-v5-0-97561209dd8c@gmail.com> In-Reply-To: <20250319-msm-gpu-fault-fixes-next-v5-0-97561209dd8c@gmail.com> To: Rob Clark , Will Deacon , Robin Murphy , Joerg Roedel , Sean Paul , Konrad Dybcio , Abhinav Kumar , Dmitry Baryshkov , Marijn Suijten Cc: iommu@lists.linux.dev, linux-arm-msm@vger.kernel.org, linux-arm-kernel@lists.infradead.org, freedreno@lists.freedesktop.org, Connor Abbott X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1742395446; l=6457; i=cwabbott0@gmail.com; s=20240426; h=from:subject:message-id; bh=/ySPkR/aTeuRK+/xkC1Wp/+XmiGAN99nf8Z+rdcy/nM=; b=pW8dnSeUfSbbfScY5Vu7vapW0rnsWlSENK31M8LwJ9ZeP96qlfErtrGGKpYyBtWsx1mMigWyp vKyhFyEZW4TCrO317brQ3fcTSH96lKmKEef17al8GUGD6CWZfeVLay9 X-Developer-Key: i=cwabbott0@gmail.com; a=ed25519; pk=dkpOeRSXLzVgqhy0Idr3nsBr4ranyERLMnoAgR4cHmY= X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20250319_074409_643853_4E9BCA1E X-CRM114-Status: GOOD ( 15.02 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org This will be used by drm/msm for GPU page faults, replacing the manual register reading it does. Signed-off-by: Connor Abbott Reviewed-by: Rob Clark --- drivers/iommu/arm/arm-smmu/arm-smmu-qcom-debug.c | 6 ++-- drivers/iommu/arm/arm-smmu/arm-smmu.c | 35 ++++++++++++++---------- drivers/iommu/arm/arm-smmu/arm-smmu.h | 7 +++-- 3 files changed, 29 insertions(+), 19 deletions(-) diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu-qcom-debug.c b/drivers/iommu/arm/arm-smmu/arm-smmu-qcom-debug.c index 548783f3f8e89fd978367afa65c473002f66e2e7..5bf1aa4aa941962710f1f14260e133d560aee86f 100644 --- a/drivers/iommu/arm/arm-smmu/arm-smmu-qcom-debug.c +++ b/drivers/iommu/arm/arm-smmu/arm-smmu-qcom-debug.c @@ -393,14 +393,14 @@ irqreturn_t qcom_smmu_context_fault(int irq, void *dev) DEFAULT_RATELIMIT_INTERVAL, DEFAULT_RATELIMIT_BURST); - arm_smmu_read_context_fault_info(smmu, idx, &cfi); + arm_smmu_read_context_fault_info(smmu_domain, &cfi); if (!(cfi.fsr & ARM_SMMU_CB_FSR_FAULT)) return IRQ_NONE; if (list_empty(&tbu_list)) { ret = report_iommu_fault(&smmu_domain->domain, NULL, cfi.iova, - cfi.fsynr & ARM_SMMU_CB_FSYNR0_WNR ? IOMMU_FAULT_WRITE : IOMMU_FAULT_READ); + cfi.fsynr0 & ARM_SMMU_CB_FSYNR0_WNR ? IOMMU_FAULT_WRITE : IOMMU_FAULT_READ); if (ret == -ENOSYS) arm_smmu_print_context_fault_info(smmu, idx, &cfi); @@ -412,7 +412,7 @@ irqreturn_t qcom_smmu_context_fault(int irq, void *dev) phys_soft = ops->iova_to_phys(ops, cfi.iova); tmp = report_iommu_fault(&smmu_domain->domain, NULL, cfi.iova, - cfi.fsynr & ARM_SMMU_CB_FSYNR0_WNR ? IOMMU_FAULT_WRITE : IOMMU_FAULT_READ); + cfi.fsynr0 & ARM_SMMU_CB_FSYNR0_WNR ? IOMMU_FAULT_WRITE : IOMMU_FAULT_READ); if (!tmp || tmp == -EBUSY) { ret = IRQ_HANDLED; resume = ARM_SMMU_RESUME_TERMINATE; diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c b/drivers/iommu/arm/arm-smmu/arm-smmu.c index ade4684c14c9b2724a71e2457288dbfaf7562c83..a02078eb968b81a35c1c086ed7007ea2a453ef94 100644 --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c @@ -405,13 +405,20 @@ static const struct iommu_flush_ops arm_smmu_s2_tlb_ops_v1 = { }; -void arm_smmu_read_context_fault_info(struct arm_smmu_device *smmu, int idx, +void arm_smmu_read_context_fault_info(struct arm_smmu_domain *smmu_domain, struct arm_smmu_context_fault_info *cfi) { + struct arm_smmu_device *smmu = smmu_domain->smmu; + int idx = smmu_domain->cfg.cbndx; + cfi->iova = arm_smmu_cb_readq(smmu, idx, ARM_SMMU_CB_FAR); + cfi->ttbr0 = arm_smmu_cb_readq(smmu, idx, ARM_SMMU_CB_TTBR0); cfi->fsr = arm_smmu_cb_read(smmu, idx, ARM_SMMU_CB_FSR); - cfi->fsynr = arm_smmu_cb_read(smmu, idx, ARM_SMMU_CB_FSYNR0); + cfi->fsynr0 = arm_smmu_cb_read(smmu, idx, ARM_SMMU_CB_FSYNR0); + cfi->fsynr1 = arm_smmu_cb_read(smmu, idx, ARM_SMMU_CB_FSYNR1); cfi->cbfrsynra = arm_smmu_gr1_read(smmu, ARM_SMMU_GR1_CBFRSYNRA(idx)); + if (smmu_domain->stage == ARM_SMMU_DOMAIN_S1) + cfi->contextidr = arm_smmu_cb_read(smmu, idx, ARM_SMMU_CB_CONTEXTIDR); } void arm_smmu_print_context_fault_info(struct arm_smmu_device *smmu, int idx, @@ -419,7 +426,7 @@ void arm_smmu_print_context_fault_info(struct arm_smmu_device *smmu, int idx, { dev_err(smmu->dev, "Unhandled context fault: fsr=0x%x, iova=0x%08lx, fsynr=0x%x, cbfrsynra=0x%x, cb=%d\n", - cfi->fsr, cfi->iova, cfi->fsynr, cfi->cbfrsynra, idx); + cfi->fsr, cfi->iova, cfi->fsynr0, cfi->cbfrsynra, idx); dev_err(smmu->dev, "FSR = %08x [%s%sFormat=%u%s%s%s%s%s%s%s%s], SID=0x%x\n", cfi->fsr, @@ -437,15 +444,15 @@ void arm_smmu_print_context_fault_info(struct arm_smmu_device *smmu, int idx, cfi->cbfrsynra); dev_err(smmu->dev, "FSYNR0 = %08x [S1CBNDX=%u%s%s%s%s%s%s PLVL=%u]\n", - cfi->fsynr, - (u32)FIELD_GET(ARM_SMMU_CB_FSYNR0_S1CBNDX, cfi->fsynr), - (cfi->fsynr & ARM_SMMU_CB_FSYNR0_AFR) ? " AFR" : "", - (cfi->fsynr & ARM_SMMU_CB_FSYNR0_PTWF) ? " PTWF" : "", - (cfi->fsynr & ARM_SMMU_CB_FSYNR0_NSATTR) ? " NSATTR" : "", - (cfi->fsynr & ARM_SMMU_CB_FSYNR0_IND) ? " IND" : "", - (cfi->fsynr & ARM_SMMU_CB_FSYNR0_PNU) ? " PNU" : "", - (cfi->fsynr & ARM_SMMU_CB_FSYNR0_WNR) ? " WNR" : "", - (u32)FIELD_GET(ARM_SMMU_CB_FSYNR0_PLVL, cfi->fsynr)); + cfi->fsynr0, + (u32)FIELD_GET(ARM_SMMU_CB_FSYNR0_S1CBNDX, cfi->fsynr0), + (cfi->fsynr0 & ARM_SMMU_CB_FSYNR0_AFR) ? " AFR" : "", + (cfi->fsynr0 & ARM_SMMU_CB_FSYNR0_PTWF) ? " PTWF" : "", + (cfi->fsynr0 & ARM_SMMU_CB_FSYNR0_NSATTR) ? " NSATTR" : "", + (cfi->fsynr0 & ARM_SMMU_CB_FSYNR0_IND) ? " IND" : "", + (cfi->fsynr0 & ARM_SMMU_CB_FSYNR0_PNU) ? " PNU" : "", + (cfi->fsynr0 & ARM_SMMU_CB_FSYNR0_WNR) ? " WNR" : "", + (u32)FIELD_GET(ARM_SMMU_CB_FSYNR0_PLVL, cfi->fsynr0)); } static irqreturn_t arm_smmu_context_fault(int irq, void *dev) @@ -458,13 +465,13 @@ static irqreturn_t arm_smmu_context_fault(int irq, void *dev) int idx = smmu_domain->cfg.cbndx; int ret; - arm_smmu_read_context_fault_info(smmu, idx, &cfi); + arm_smmu_read_context_fault_info(smmu_domain, &cfi); if (!(cfi.fsr & ARM_SMMU_CB_FSR_FAULT)) return IRQ_NONE; ret = report_iommu_fault(&smmu_domain->domain, NULL, cfi.iova, - cfi.fsynr & ARM_SMMU_CB_FSYNR0_WNR ? IOMMU_FAULT_WRITE : IOMMU_FAULT_READ); + cfi.fsynr0 & ARM_SMMU_CB_FSYNR0_WNR ? IOMMU_FAULT_WRITE : IOMMU_FAULT_READ); if (ret == -ENOSYS && __ratelimit(&rs)) arm_smmu_print_context_fault_info(smmu, idx, &cfi); diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.h b/drivers/iommu/arm/arm-smmu/arm-smmu.h index e2aeb511ae903302e3c15d2cf5f22e2a26ac2346..ef6915a0d9f62b0a1734a3ee57ea422615036094 100644 --- a/drivers/iommu/arm/arm-smmu/arm-smmu.h +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.h @@ -543,12 +543,15 @@ int arm_mmu500_reset(struct arm_smmu_device *smmu); struct arm_smmu_context_fault_info { unsigned long iova; + u64 ttbr0; u32 fsr; - u32 fsynr; + u32 fsynr0; + u32 fsynr1; u32 cbfrsynra; + u32 contextidr; }; -void arm_smmu_read_context_fault_info(struct arm_smmu_device *smmu, int idx, +void arm_smmu_read_context_fault_info(struct arm_smmu_domain *smmu_domain, struct arm_smmu_context_fault_info *cfi); void arm_smmu_print_context_fault_info(struct arm_smmu_device *smmu, int idx, From patchwork Wed Mar 19 14:44:01 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Connor Abbott X-Patchwork-Id: 14022670 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 B5385C35FFA for ; Wed, 19 Mar 2025 14:51:02 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:List-Subscribe:List-Help :List-Post:List-Archive:List-Unsubscribe:List-Id:Cc:To:In-Reply-To:References :Message-Id:Content-Transfer-Encoding:Content-Type:MIME-Version:Subject:Date: From:Reply-To:Content-ID:Content-Description:Resent-Date:Resent-From: Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=LVIOe6YO1QFlgbOaSVSB9MxST2MN7teDfhAEgXLqPn8=; b=zJr2FbBfbMj6Fn/Wm3lBcAuA8m OofT0VrLz81GgYUPOPSTk6OdWJI7x0qeET3mK5CwR3GvPe3MgLbcyjxnRPsGhYRCQrr5wxrkz61GA VDffntP+GhY438GH57uJyfiyaxOgIVP6pUztFDa83gbE2DNcOLVlWP16Wajk56wMboXgA/qo4Vbmr pzL+hdqhRPpnyzs+Wlyqw1XVPU9jVgq/huYOUkMAskqh6PyvRCvnQp0tvsfQTg/HrG7M2lgoQ4oCl 3ku+st0mlxf+zj6l9CVIVVeVAXbGzuAu0hUI7o6KHj3fLR/aqvHzuO6ab+z8EVG7VhincJVEcufYS V6WE8bpg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98 #2 (Red Hat Linux)) id 1tuuku-00000009GBF-0rRE; Wed, 19 Mar 2025 14:50:52 +0000 Received: from mail-qk1-x72f.google.com ([2607:f8b0:4864:20::72f]) by bombadil.infradead.org with esmtps (Exim 4.98 #2 (Red Hat Linux)) id 1tuueQ-00000009FGs-3QNs for linux-arm-kernel@lists.infradead.org; Wed, 19 Mar 2025 14:44:12 +0000 Received: by mail-qk1-x72f.google.com with SMTP id af79cd13be357-7c23aede3deso93204885a.3 for ; Wed, 19 Mar 2025 07:44:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1742395450; x=1743000250; darn=lists.infradead.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=LVIOe6YO1QFlgbOaSVSB9MxST2MN7teDfhAEgXLqPn8=; b=Hh2LzXT8jbv8xMFSWQ8zccWiXaqPACNkqEwPa6bMB4ljq/mq2H/KdXU7N1xlNCZ68i Qc3YxVcY7CbVC8nd5v2DcdVkmPQ4CfkUnF8KjfDA14hTm5WdW5JLzYsFb1/KA++wXEN5 tukqusVqliSdTHIRoQK2nR+BBprJjB2uHKMvzctUwcqveogdulUSchX0cq200+CR+45B KNkOQxqCRsRoUdbAITXqVVT/DM8LBF8OQxcTOEQCEM7tDmTyDx+/Mf8WBdWALRH2PByj CNHKDO72wv78K2Ypb721n+gQ72W4M1DB3rMug0dZz1KLFnAMks2ErJlBMu/8FYuILBX/ cXgw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1742395450; x=1743000250; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=LVIOe6YO1QFlgbOaSVSB9MxST2MN7teDfhAEgXLqPn8=; b=r9bDr3XNYQmCJhSWXCfVUs+kbq/yFx1LXEj3Uj1tta1+X2gr7QHY00WMlHW+ESAP2t xXPetNsN71a0ID9o+0ljQEnz+R456FdPbhx33gHhA9cfoFD4IM65rLUyD7vmVnkdM9Fs Rtypia70C/Wn7+VqCHc2gNhtFx7CrLBPzBGri24cEEQ55p8XbtyiWPspfYvzcZz7D7sU V9fenfyMuwWQcZlgXxHUFC1x8E8OSU06FSCrBw4CknQvCRnovscasEfkaif5pyFpLbVD CDDvoH3J4/KVI52wFflbFWJxzTFP1ah1ZhgpKgjLIuEQ/k/yDgbdvkd/kfeiLwUGApl5 4m0A== X-Forwarded-Encrypted: i=1; AJvYcCVGRefall5JMUcbt354Lsi+bhfrZfeQY1B3jI6fU3xoFNG+TvP9MNXe2rO69uF8hWzy4ruN5yMz8ajr95CtCs6z@lists.infradead.org X-Gm-Message-State: AOJu0YxlEpbpiifh2FYsV0Kzf495EMUWeMpi2aamYkPHwaiCHEgLN+XA m+8tFre2KaY0TS2A7fe7k/Kmwh4fbco8w017+jL7lEn+zTJeryh+ X-Gm-Gg: ASbGnctrZSjRFHV/xEFfbgJPpipzCA3jMbWy2wolz50Y3MEGYeEWkh9d5NmMh44Sf0I lYKVgxFAR9C2IosKIhVrL3O8DEd+VjEiRtoDlMpfrreFhp0UKN5ihsBzn+eZxLefcNCS2XzhzmF dZ1K+P7y4vcuSaOY+lAouSPMKw84S8eKI8VEKm0RTJMRbORWBMpNAm+qTZPWAf8cb734mxtS8Kb djto0cah7Znr5CRGn/Iep5bwS5arxC3U26vO2qUvhE6OL+TuCs5vcLbnDZjma+hdgLQqWA2Q6pQ 9rmfp9ecXhhaTR+e4eVeQC4cSeoitGpk6QmgZAzkENhoIDI/8cnfJ4kbjz4HmZ7h+y50hRI+fxT x2k8= X-Google-Smtp-Source: AGHT+IFNRUs3nv+7+hsvhyD1099wEYjZlC8bdXc8Jfmcl+lTK2hcYAEosbvXtZXZvJ/hQAwsmaiwrg== X-Received: by 2002:a05:620a:2485:b0:7c0:b018:5930 with SMTP id af79cd13be357-7c5a849ceb4mr150552885a.15.1742395449476; Wed, 19 Mar 2025 07:44:09 -0700 (PDT) Received: from [192.168.1.99] (ool-4355b0da.dyn.optonline.net. [67.85.176.218]) by smtp.gmail.com with ESMTPSA id af79cd13be357-7c573c5201fsm868587485a.23.2025.03.19.07.44.08 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 19 Mar 2025 07:44:09 -0700 (PDT) From: Connor Abbott Date: Wed, 19 Mar 2025 10:44:01 -0400 Subject: [PATCH v5 2/5] iommu/arm-smmu-qcom: Don't read fault registers directly MIME-Version: 1.0 Message-Id: <20250319-msm-gpu-fault-fixes-next-v5-2-97561209dd8c@gmail.com> References: <20250319-msm-gpu-fault-fixes-next-v5-0-97561209dd8c@gmail.com> In-Reply-To: <20250319-msm-gpu-fault-fixes-next-v5-0-97561209dd8c@gmail.com> To: Rob Clark , Will Deacon , Robin Murphy , Joerg Roedel , Sean Paul , Konrad Dybcio , Abhinav Kumar , Dmitry Baryshkov , Marijn Suijten Cc: iommu@lists.linux.dev, linux-arm-msm@vger.kernel.org, linux-arm-kernel@lists.infradead.org, freedreno@lists.freedesktop.org, Connor Abbott X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1742395446; l=5867; i=cwabbott0@gmail.com; s=20240426; h=from:subject:message-id; bh=tTTpB0Ao5UrDtWkZT9tEFwgF3Yy2+aFm7zr2QcY9Sdk=; b=SbxyVBfCazjMcZnOBvSnP6XYVUpV1d+ECUu5MQSlhmDcQ2Sqe2AtsfGxR81gtgborBDdYHY9U 6zMkNpecHzPArS1lpqtpzbf/QtWVL0UWm99pJ9QFFbo6w9vGuBQfa1U X-Developer-Key: i=cwabbott0@gmail.com; a=ed25519; pk=dkpOeRSXLzVgqhy0Idr3nsBr4ranyERLMnoAgR4cHmY= X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20250319_074410_871868_7F8511E9 X-CRM114-Status: GOOD ( 17.87 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org In some cases drm/msm has to resume a stalled transaction directly in its fault handler. Experimentally this doesn't work on SMMU500 if the fault hasn't already been acknowledged by clearing FSR. Rather than trying to clear FSR in msm's fault handler and implementing a tricky handshake to avoid accidentally clearing FSR twice, we want to clear FSR before calling the fault handlers, but this means that the contents of registers can change underneath us in the fault handler and msm currently uses a private function to read the register contents for its own purposes in its fault handler, such as using the implementation-defined FSYNR1 to determine which block caused the fault. Fix this by making msm use the register values already read by arm-smmu itself before clearing FSR rather than messing around with reading registers directly. Signed-off-by: Connor Abbott Reviewed-by: Rob Clark --- drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c | 19 +++++++++---------- drivers/iommu/arm/arm-smmu/arm-smmu.c | 14 +++++++------- drivers/iommu/arm/arm-smmu/arm-smmu.h | 21 +++++++++++---------- 3 files changed, 27 insertions(+), 27 deletions(-) diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c b/drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c index 6372f3e25c4bc24cb52f9233095170e8aa510a53..186d6ad4fd1c990398df4dec53f4d58ada9e658c 100644 --- a/drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c +++ b/drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c @@ -62,16 +62,15 @@ static void qcom_adreno_smmu_get_fault_info(const void *cookie, struct adreno_smmu_fault_info *info) { struct arm_smmu_domain *smmu_domain = (void *)cookie; - struct arm_smmu_cfg *cfg = &smmu_domain->cfg; - struct arm_smmu_device *smmu = smmu_domain->smmu; - - info->fsr = arm_smmu_cb_read(smmu, cfg->cbndx, ARM_SMMU_CB_FSR); - info->fsynr0 = arm_smmu_cb_read(smmu, cfg->cbndx, ARM_SMMU_CB_FSYNR0); - info->fsynr1 = arm_smmu_cb_read(smmu, cfg->cbndx, ARM_SMMU_CB_FSYNR1); - info->far = arm_smmu_cb_readq(smmu, cfg->cbndx, ARM_SMMU_CB_FAR); - info->cbfrsynra = arm_smmu_gr1_read(smmu, ARM_SMMU_GR1_CBFRSYNRA(cfg->cbndx)); - info->ttbr0 = arm_smmu_cb_readq(smmu, cfg->cbndx, ARM_SMMU_CB_TTBR0); - info->contextidr = arm_smmu_cb_read(smmu, cfg->cbndx, ARM_SMMU_CB_CONTEXTIDR); + struct arm_smmu_context_fault_info *cfi = &smmu_domain->cfi; + + info->fsr = cfi->fsr; + info->fsynr0 = cfi->fsynr0; + info->fsynr1 = cfi->fsynr1; + info->far = cfi->iova; + info->cbfrsynra = cfi->cbfrsynra; + info->ttbr0 = cfi->ttbr0; + info->contextidr = cfi->contextidr; } static void qcom_adreno_smmu_set_stall(const void *cookie, bool enabled) diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c b/drivers/iommu/arm/arm-smmu/arm-smmu.c index a02078eb968b81a35c1c086ed7007ea2a453ef94..c7b5d7c093e71050d29a834c8d33125e96b04d81 100644 --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c @@ -457,26 +457,26 @@ void arm_smmu_print_context_fault_info(struct arm_smmu_device *smmu, int idx, static irqreturn_t arm_smmu_context_fault(int irq, void *dev) { - struct arm_smmu_context_fault_info cfi; struct arm_smmu_domain *smmu_domain = dev; + struct arm_smmu_context_fault_info *cfi = &smmu_domain->cfi; struct arm_smmu_device *smmu = smmu_domain->smmu; static DEFINE_RATELIMIT_STATE(rs, DEFAULT_RATELIMIT_INTERVAL, DEFAULT_RATELIMIT_BURST); int idx = smmu_domain->cfg.cbndx; int ret; - arm_smmu_read_context_fault_info(smmu_domain, &cfi); + arm_smmu_read_context_fault_info(smmu_domain, cfi); - if (!(cfi.fsr & ARM_SMMU_CB_FSR_FAULT)) + if (!(cfi->fsr & ARM_SMMU_CB_FSR_FAULT)) return IRQ_NONE; - ret = report_iommu_fault(&smmu_domain->domain, NULL, cfi.iova, - cfi.fsynr0 & ARM_SMMU_CB_FSYNR0_WNR ? IOMMU_FAULT_WRITE : IOMMU_FAULT_READ); + ret = report_iommu_fault(&smmu_domain->domain, NULL, cfi->iova, + cfi->fsynr0 & ARM_SMMU_CB_FSYNR0_WNR ? IOMMU_FAULT_WRITE : IOMMU_FAULT_READ); if (ret == -ENOSYS && __ratelimit(&rs)) - arm_smmu_print_context_fault_info(smmu, idx, &cfi); + arm_smmu_print_context_fault_info(smmu, idx, cfi); - arm_smmu_cb_write(smmu, idx, ARM_SMMU_CB_FSR, cfi.fsr); + arm_smmu_cb_write(smmu, idx, ARM_SMMU_CB_FSR, cfi->fsr); return IRQ_HANDLED; } diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.h b/drivers/iommu/arm/arm-smmu/arm-smmu.h index ef6915a0d9f62b0a1734a3ee57ea422615036094..ff84ce3b8d8567d3402e945e8277ca2a87df9a4e 100644 --- a/drivers/iommu/arm/arm-smmu/arm-smmu.h +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.h @@ -373,6 +373,16 @@ enum arm_smmu_domain_stage { ARM_SMMU_DOMAIN_NESTED, }; +struct arm_smmu_context_fault_info { + unsigned long iova; + u64 ttbr0; + u32 fsr; + u32 fsynr0; + u32 fsynr1; + u32 cbfrsynra; + u32 contextidr; +}; + struct arm_smmu_domain { struct arm_smmu_device *smmu; struct io_pgtable_ops *pgtbl_ops; @@ -380,6 +390,7 @@ struct arm_smmu_domain { const struct iommu_flush_ops *flush_ops; struct arm_smmu_cfg cfg; enum arm_smmu_domain_stage stage; + struct arm_smmu_context_fault_info cfi; struct mutex init_mutex; /* Protects smmu pointer */ spinlock_t cb_lock; /* Serialises ATS1* ops and TLB syncs */ struct iommu_domain domain; @@ -541,16 +552,6 @@ struct arm_smmu_device *qcom_smmu_impl_init(struct arm_smmu_device *smmu); void arm_smmu_write_context_bank(struct arm_smmu_device *smmu, int idx); int arm_mmu500_reset(struct arm_smmu_device *smmu); -struct arm_smmu_context_fault_info { - unsigned long iova; - u64 ttbr0; - u32 fsr; - u32 fsynr0; - u32 fsynr1; - u32 cbfrsynra; - u32 contextidr; -}; - void arm_smmu_read_context_fault_info(struct arm_smmu_domain *smmu_domain, struct arm_smmu_context_fault_info *cfi); From patchwork Wed Mar 19 14:44:02 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Connor Abbott X-Patchwork-Id: 14022747 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 283CDC35FFA for ; Wed, 19 Mar 2025 14:52:46 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:List-Subscribe:List-Help :List-Post:List-Archive:List-Unsubscribe:List-Id:Cc:To:In-Reply-To:References :Message-Id:Content-Transfer-Encoding:Content-Type:MIME-Version:Subject:Date: From:Reply-To:Content-ID:Content-Description:Resent-Date:Resent-From: Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=+LLdaHjk6LfckJUTjGZM3sRGKIR5OKfK0XW8wTVhaxM=; b=nbfoDHnFnWlANlo2q83RfELcOz klUWP7dUzflbf+ZWB6BsEMGOc/Tb98ColYZcxYnOI2Aoq3CfZsHyrQkwhMcEA7Ul+mtYa2Vg37egf mI3B5EDviuA0+wt7y/u/w8VvOSq77aDGUh9owvGpSI+Yehk3GEyIIbLK8+R1sOaG48OQFfUHp4tid oaDfuf48CUzJYC7qvL49a1zJSH5IaC1VNrcAFFiJWoh2hHqGarQTOYaCgvcTN0OGKDzFKk2CKT8uX brfF8M+OnoeVCqCinFslxPyb136HsaZDZPbtkSGwG1aOjYd6eoiNt2/oz19Gpei48gYYcfAu8HrVd p66PimKA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98 #2 (Red Hat Linux)) id 1tuumY-00000009GNP-3ZCt; Wed, 19 Mar 2025 14:52:34 +0000 Received: from mail-qk1-x72e.google.com ([2607:f8b0:4864:20::72e]) by bombadil.infradead.org with esmtps (Exim 4.98 #2 (Red Hat Linux)) id 1tuueR-00000009FHO-3Gpi for linux-arm-kernel@lists.infradead.org; Wed, 19 Mar 2025 14:44:12 +0000 Received: by mail-qk1-x72e.google.com with SMTP id af79cd13be357-7c0e36b823fso109633285a.2 for ; Wed, 19 Mar 2025 07:44:11 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1742395450; x=1743000250; darn=lists.infradead.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=+LLdaHjk6LfckJUTjGZM3sRGKIR5OKfK0XW8wTVhaxM=; b=ez0YhtGxag/9hR6X3wapf7IInw11VF0swh6CXVrwUXKZBeP3Q2lUvZoNbvGaTQp3bY /Ap54Ymdfk3rMJAMBPjCW0FOY8gwf42NFoVwoAFFcRqQ9y33TIhCBFOxnHysyc6JvwEB WH6+d55Wz78qBLbCtuibeYfI7/05BUhgdpSEXPR4AEj+n9YwVmKdsC0gVT+UhGuOhsJy MDJ7T4rll0Kpei+uoamI1vZzNDLEGidOaIVBZWscciyK8sQdKejFclA15bNkUGOXQlL8 k3XtV9Y8Loe2pDrYuLGSX/YRse9iwEXoTdc69p7W2mNThXTqmSJc7pzOhV70j6M5Guhb /XZA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1742395450; x=1743000250; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=+LLdaHjk6LfckJUTjGZM3sRGKIR5OKfK0XW8wTVhaxM=; b=VrjUOzfIeXQ1tEFe46xYdLsS0dIkfq3pBE/hW6DGdv6JvX4ZiNgEHlIgeU43303ffm KqrkE5ryHC9e7/ET6mvwDXA9Q51yMJBj8KuxJAj0AdPNsnrB1nbMn4waOz26EbtwzN82 gSwewl7+aBMgaAVV0qhi3+znp8GOXgIs95lMUjEvdCamiLSdgDgAVn97y2OImUBRuOd7 75whHYO/CcE7PjAVtETUvPESdOOhlWWM5b0r6CAIP/s9TOJDwpCkKXJVQ/GGvSRozoV7 c564umr2UefmHNusv9wvRqM8hgS1+s1j8zmUNInMlaSay53EzAd0LMx1VV1U8FqwuL8Y nHCg== X-Forwarded-Encrypted: i=1; AJvYcCUS7me5Cyjx9GMsb5iluaJT5Dmsisp2M68PEnzDfCdD4vw3V+sr4LY5tMDfbnZJ6DWeE+omqpKcpfuCUk6EoiTm@lists.infradead.org X-Gm-Message-State: AOJu0YyaPT569JNpM5T6m/sFUsQd0yYedrSyv1vBvXCrVmqf70oZKBZ4 fMsK9MeeM1lBhYs+BhDOGyTb6WrG/nrxCBjbawDDWIM7kDEJf9yp X-Gm-Gg: ASbGnctl+iBj2bOCkxRo7eK3uSYFPuYeboiIKujpEoZOul13LRUcD8p+n0CnGjTfMwl FTXAloALBePkC6CrrVRhwySZ4h4h2NjZ3fCVfIMrf0+YTdp7xR8o26FNNL9MAq8pikdXUFSu88X si8CrTN679WHpwDWf1shZ5DTLrkx5kwBiLTAUsGEICrbjy49VCytC7qhDiDmbIWP1bLySxnPA/G CK26/4zowDhJ2m6m6B3tegzM7YStcO1Kv99BfW/kqWSUhHINISYRHRMVPk9kPeSpsIPE0WaMFuo VZpNZHVe2CwV9PTcc8bW59k/fDFlQRcvN+cirP0lgYsQ3egESK4h+4YBVEYfuUHU2Ad4K+PktwX ug9MQbLZXY4aLlg== X-Google-Smtp-Source: AGHT+IGJzwPA7xFugV/gHd8kGB+HC3gNYxm8R5XDRyDYRFdFlfsw4mDQ1M7uG0fiXgibnbX/DsVqqQ== X-Received: by 2002:a05:620a:2950:b0:7c3:d3a0:578d with SMTP id af79cd13be357-7c5a849d18cmr170321485a.14.1742395450533; Wed, 19 Mar 2025 07:44:10 -0700 (PDT) Received: from [192.168.1.99] (ool-4355b0da.dyn.optonline.net. [67.85.176.218]) by smtp.gmail.com with ESMTPSA id af79cd13be357-7c573c5201fsm868587485a.23.2025.03.19.07.44.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 19 Mar 2025 07:44:10 -0700 (PDT) From: Connor Abbott Date: Wed, 19 Mar 2025 10:44:02 -0400 Subject: [PATCH v5 3/5] iommu/arm-smmu: Fix spurious interrupts with stall-on-fault MIME-Version: 1.0 Message-Id: <20250319-msm-gpu-fault-fixes-next-v5-3-97561209dd8c@gmail.com> References: <20250319-msm-gpu-fault-fixes-next-v5-0-97561209dd8c@gmail.com> In-Reply-To: <20250319-msm-gpu-fault-fixes-next-v5-0-97561209dd8c@gmail.com> To: Rob Clark , Will Deacon , Robin Murphy , Joerg Roedel , Sean Paul , Konrad Dybcio , Abhinav Kumar , Dmitry Baryshkov , Marijn Suijten Cc: iommu@lists.linux.dev, linux-arm-msm@vger.kernel.org, linux-arm-kernel@lists.infradead.org, freedreno@lists.freedesktop.org, Connor Abbott X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1742395446; l=5823; i=cwabbott0@gmail.com; s=20240426; h=from:subject:message-id; bh=cvbBfcrcrYk3UnmMx/KO0uUo0M7TL3yWEuY4tEPNpHg=; b=UZQkmNfH0RGJd1lvBOxnDXADDr5RhY1byqdtyjRjpdnp5UCv9mXjLsS9upst5mGaXUMBilPnv v4blVUGBABuDPjzrloGXgW0NMFK7fU5241VJJj2bb9qgGouKFPpoJZT X-Developer-Key: i=cwabbott0@gmail.com; a=ed25519; pk=dkpOeRSXLzVgqhy0Idr3nsBr4ranyERLMnoAgR4cHmY= X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20250319_074411_824698_0DF35225 X-CRM114-Status: GOOD ( 24.66 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org On some SMMUv2 implementations, including MMU-500, SMMU_CBn_FSR.SS asserts an interrupt. The only way to clear that bit is to resume the transaction by writing SMMU_CBn_RESUME, but typically resuming the transaction requires complex operations (copying in pages, etc.) that can't be done in IRQ context. drm/msm already has a problem, because its fault handler sometimes schedules a job to dump the GPU state and doesn't resume translation until this is complete. Work around this by disabling context fault interrupts until after the transaction is resumed. Because other context banks can share an IRQ line, we may still get an interrupt intended for another context bank, but in this case only SMMU_CBn_FSR.SS will be asserted and we can skip it assuming that interrupts are disabled which is accomplished by removing the bit from ARM_SMMU_CB_FSR_FAULT. SMMU_CBn_FSR.SS won't be asserted unless an external user enabled stall-on-fault, and they are expected to resume the translation and re-enable interrupts. Signed-off-by: Connor Abbott Reviewed-by Robin Murphy Reviewed-by: Rob Clark --- drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c | 15 ++++++++++- drivers/iommu/arm/arm-smmu/arm-smmu.c | 41 +++++++++++++++++++++++++++++- drivers/iommu/arm/arm-smmu/arm-smmu.h | 1 - 3 files changed, 54 insertions(+), 3 deletions(-) diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c b/drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c index 186d6ad4fd1c990398df4dec53f4d58ada9e658c..a428e53add08d451fb2152e3ab80e0fba936e214 100644 --- a/drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c +++ b/drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c @@ -90,12 +90,25 @@ static void qcom_adreno_smmu_resume_translation(const void *cookie, bool termina struct arm_smmu_domain *smmu_domain = (void *)cookie; struct arm_smmu_cfg *cfg = &smmu_domain->cfg; struct arm_smmu_device *smmu = smmu_domain->smmu; - u32 reg = 0; + u32 reg = 0, sctlr; + unsigned long flags; if (terminate) reg |= ARM_SMMU_RESUME_TERMINATE; + spin_lock_irqsave(&smmu_domain->cb_lock, flags); + arm_smmu_cb_write(smmu, cfg->cbndx, ARM_SMMU_CB_RESUME, reg); + + /* + * Re-enable interrupts after they were disabled by + * arm_smmu_context_fault(). + */ + sctlr = arm_smmu_cb_read(smmu, cfg->cbndx, ARM_SMMU_CB_SCTLR); + sctlr |= ARM_SMMU_SCTLR_CFIE; + arm_smmu_cb_write(smmu, cfg->cbndx, ARM_SMMU_CB_SCTLR, sctlr); + + spin_unlock_irqrestore(&smmu_domain->cb_lock, flags); } #define QCOM_ADRENO_SMMU_GPU_SID 0 diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c b/drivers/iommu/arm/arm-smmu/arm-smmu.c index c7b5d7c093e71050d29a834c8d33125e96b04d81..9927f3431a2eab913750e6079edc6393d1938c98 100644 --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c @@ -470,13 +470,52 @@ static irqreturn_t arm_smmu_context_fault(int irq, void *dev) if (!(cfi->fsr & ARM_SMMU_CB_FSR_FAULT)) return IRQ_NONE; + /* + * On some implementations FSR.SS asserts a context fault + * interrupt. We do not want this behavior, because resolving the + * original context fault typically requires operations that cannot be + * performed in IRQ context but leaving the stall unacknowledged will + * immediately lead to another spurious interrupt as FSR.SS is still + * set. Work around this by disabling interrupts for this context bank. + * It's expected that interrupts are re-enabled after resuming the + * translation. + * + * We have to do this before report_iommu_fault() so that we don't + * leave interrupts disabled in case the downstream user decides the + * fault can be resolved inside its fault handler. + * + * There is a possible race if there are multiple context banks sharing + * the same interrupt and both signal an interrupt in between writing + * RESUME and SCTLR. We could disable interrupts here before we + * re-enable them in the resume handler, leaving interrupts enabled. + * Lock the write to serialize it with the resume handler. + */ + if (cfi->fsr & ARM_SMMU_CB_FSR_SS) { + u32 val; + + spin_lock(&smmu_domain->cb_lock); + val = arm_smmu_cb_read(smmu, idx, ARM_SMMU_CB_SCTLR); + val &= ~ARM_SMMU_SCTLR_CFIE; + arm_smmu_cb_write(smmu, idx, ARM_SMMU_CB_SCTLR, val); + spin_unlock(&smmu_domain->cb_lock); + } + + /* + * The SMMUv2 architecture specification says that if stall-on-fault is + * enabled the correct sequence is to write to SMMU_CBn_FSR to clear + * the fault and then write to SMMU_CBn_RESUME. Clear the interrupt + * first before running the user's fault handler to make sure we follow + * this sequence. It should be ok if there is another fault in the + * meantime because we have already read the fault info. + */ + arm_smmu_cb_write(smmu, idx, ARM_SMMU_CB_FSR, cfi->fsr); + ret = report_iommu_fault(&smmu_domain->domain, NULL, cfi->iova, cfi->fsynr0 & ARM_SMMU_CB_FSYNR0_WNR ? IOMMU_FAULT_WRITE : IOMMU_FAULT_READ); if (ret == -ENOSYS && __ratelimit(&rs)) arm_smmu_print_context_fault_info(smmu, idx, cfi); - arm_smmu_cb_write(smmu, idx, ARM_SMMU_CB_FSR, cfi->fsr); return IRQ_HANDLED; } diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.h b/drivers/iommu/arm/arm-smmu/arm-smmu.h index ff84ce3b8d8567d3402e945e8277ca2a87df9a4e..5fe8e482457f905529a08aea14ea5656d3e31328 100644 --- a/drivers/iommu/arm/arm-smmu/arm-smmu.h +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.h @@ -214,7 +214,6 @@ enum arm_smmu_cbar_type { ARM_SMMU_CB_FSR_TLBLKF) #define ARM_SMMU_CB_FSR_FAULT (ARM_SMMU_CB_FSR_MULTI | \ - ARM_SMMU_CB_FSR_SS | \ ARM_SMMU_CB_FSR_UUT | \ ARM_SMMU_CB_FSR_EF | \ ARM_SMMU_CB_FSR_PF | \ From patchwork Wed Mar 19 14:44:03 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Connor Abbott X-Patchwork-Id: 14022748 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 5375EC35FFA for ; Wed, 19 Mar 2025 14:54:30 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:List-Subscribe:List-Help :List-Post:List-Archive:List-Unsubscribe:List-Id:Cc:To:In-Reply-To:References :Message-Id:Content-Transfer-Encoding:Content-Type:MIME-Version:Subject:Date: From:Reply-To:Content-ID:Content-Description:Resent-Date:Resent-From: Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=HPN0fQB0H/8KK70kj8NlZTzNxC/Qn5H/Tut0vpbeXbg=; b=hbvW5UUKb57YiyGOXaf92YXjHz ioqacxChXu7dkAhBESft4grXHQoXCCusnBIkyvu6nl/gI2RHKu+f7E+SB7bsxPdKPv78ACIoAL58Z uzyYfLlKv6miGu57DvOwO524oBZTwaGHBLU+HwAKczRupSWEuAKJ4FKKjVqCZn4qsyZPIeojebVB1 yIKOeJN2h2XUUq6nOrIwCKsyE5EDxOwJJakNP94WDZTvJ3LtZl0CbKkwPY4gur0vszoLxb7WtgYUJ sOCpaNhFBVMYYWm7Bfw4cLeZrO+3W+0sgbsow+O4WvR7il0KBNVzDJycQSRJkSjfwD4wlNhA/UKRb IOSsx0RA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98 #2 (Red Hat Linux)) id 1tuuoE-00000009Gap-2WUc; Wed, 19 Mar 2025 14:54:18 +0000 Received: from mail-qk1-x736.google.com ([2607:f8b0:4864:20::736]) by bombadil.infradead.org with esmtps (Exim 4.98 #2 (Red Hat Linux)) id 1tuueS-00000009FHj-3LyU for linux-arm-kernel@lists.infradead.org; Wed, 19 Mar 2025 14:44:13 +0000 Received: by mail-qk1-x736.google.com with SMTP id af79cd13be357-7c0b5065557so16624985a.3 for ; Wed, 19 Mar 2025 07:44:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1742395451; x=1743000251; darn=lists.infradead.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=HPN0fQB0H/8KK70kj8NlZTzNxC/Qn5H/Tut0vpbeXbg=; b=hO64IbbvCEm1ahiGWdNfriAfhWPIQFCI3nmlOPIh4IjS6meZGTcN7Fs/I1/oH7JnfU /hBX4rSC9i/9IlHwaYRGqnhmLnhlVI70wR/W5RQMsCwewg/dc9Gtzgk59KVtf/CYIDGQ 1K2s6+FaAFeqyvfWGbipv+7lI/2XtuhDYVeez8+lL5jQ3qV7B/CtbgXA++sSIvwQvjkz nbwpABls0eQWn9OzMAH281JoBYc7N5o312xGWsV0wmmMkNHGLEO3pBkSeBONL/9XoOCI b4YUEWeDbERNz+W9XkjqApgmKph/v4XzVina69+1Lumjg47wuyUSlGV2Gg77kkmTTeyL ypLQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1742395451; x=1743000251; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=HPN0fQB0H/8KK70kj8NlZTzNxC/Qn5H/Tut0vpbeXbg=; b=Gul8GoyV87rP3JaPgzEp8+aorWPkBbmQhJIPo2qU5+s9Ljox1QnCD8diT2qgFvbngN GY1sD6Djun4sZ3zRuUNi/DcPi8wXOR4eKt+C1QtQAiGgKrHoKJUHGPgn4qRbuAg1isXD j07zujfMPCyjlRcJWziAbDbciNcRMHyT7m//aaKBDygs84A5C4qVgCk7D4bMI2RnEyta i8ZUvUBMleJHpan31EQaXIkGWx2pHd+Y2CCBS0+EeiI0WI+efsPZVWH2gl3lLPwavueD Sius5qRrfS6sxhGrg2QH1OAil4LtIxCdjOvis2lG7Kod7fVYf/QaZIYxFli3uUsOwlAt 6ZxA== X-Forwarded-Encrypted: i=1; AJvYcCVVmxvdoelMn7lX8AOK1JwEzWdkPvEPoNu/dJr+OJK8QwjBS6MLWwd7FAAbIziMnTjU/wlPVxD18Zh+5ing4wE/@lists.infradead.org X-Gm-Message-State: AOJu0Yx7S1D/6F4bZ1dnCUcC8pxRrOtX3jB2Gru94uCq80Wrhp2sLjkG 0iRJFgucNLXxQPbIRqKoxRKrelgUPw3dRL+0WQsa5xsEVdDbMS+G X-Gm-Gg: ASbGncuh5tGXctSH2jc5ZHJLwoWSh079aiMBFZ2M5Rhy6PfCRiyZJ71h+/HSQzkp/Y4 jSFpusDXGpQrpD9XNt8YTCT4EjDLDabKEX0P8LQkn4Gifkh9SqwllX4Fw0rwDm6AhdkQQtPGo3B o5C0iHMS6166bIkPMSItik9DCoNguPGeWzOEDnUZxptJpSmoEFIjbNzbvrpV8EmorbNq3lj8wID quwW4A4IdVL3RennMt+lqyDW67Eo+EgLkWze9wrl/BL2RTZsJ6MLovxlJCLJONaCO5QfEsIVAjL sGqjpulRPM8RrxdLvaWqfB8olgocyDaOyUMq00NQ5dAwgS1zoy6KI6jkfDVf/HSUSJYTgs+s58E IR5g= X-Google-Smtp-Source: AGHT+IEpDQ6Iq7EL34BOyUpZMWjHvcPvh/lkrIFcpZHlUwWtyFmoiBx6pZ8T713YT9KI50QLqxMdOA== X-Received: by 2002:a05:620a:25cb:b0:7c3:e399:3289 with SMTP id af79cd13be357-7c5a83d609amr122312985a.4.1742395451490; Wed, 19 Mar 2025 07:44:11 -0700 (PDT) Received: from [192.168.1.99] (ool-4355b0da.dyn.optonline.net. [67.85.176.218]) by smtp.gmail.com with ESMTPSA id af79cd13be357-7c573c5201fsm868587485a.23.2025.03.19.07.44.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 19 Mar 2025 07:44:11 -0700 (PDT) From: Connor Abbott Date: Wed, 19 Mar 2025 10:44:03 -0400 Subject: [PATCH v5 4/5] iommu/arm-smmu-qcom: Make set_stall work when the device is on MIME-Version: 1.0 Message-Id: <20250319-msm-gpu-fault-fixes-next-v5-4-97561209dd8c@gmail.com> References: <20250319-msm-gpu-fault-fixes-next-v5-0-97561209dd8c@gmail.com> In-Reply-To: <20250319-msm-gpu-fault-fixes-next-v5-0-97561209dd8c@gmail.com> To: Rob Clark , Will Deacon , Robin Murphy , Joerg Roedel , Sean Paul , Konrad Dybcio , Abhinav Kumar , Dmitry Baryshkov , Marijn Suijten Cc: iommu@lists.linux.dev, linux-arm-msm@vger.kernel.org, linux-arm-kernel@lists.infradead.org, freedreno@lists.freedesktop.org, Connor Abbott X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1742395446; l=2356; i=cwabbott0@gmail.com; s=20240426; h=from:subject:message-id; bh=dyr7GkrtgLsig+n5TUngdYzO6eV3oK7bTiLJtUDHAnM=; b=RKN5nvvDGIxbm5UBumrBYsNQjDxpkr0KCnP1Iaw92xOCRP/yvUGsivMyDJOaRMEhdhlM/3hlS Gw3WyY2nTiICpPLJZ1sNNIRZU6cstKEpnuXrASFBZYibV9DoVEO/0gX X-Developer-Key: i=cwabbott0@gmail.com; a=ed25519; pk=dkpOeRSXLzVgqhy0Idr3nsBr4ranyERLMnoAgR4cHmY= X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20250319_074412_846183_A1E4E3F3 X-CRM114-Status: GOOD ( 16.00 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org Up until now we have only called the set_stall callback during initialization when the device is off. But we will soon start calling it to temporarily disable stall-on-fault when the device is on, so handle that by checking if the device is on and writing SCTLR. Signed-off-by: Connor Abbott Reviewed-by: Rob Clark --- drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c | 33 +++++++++++++++++++++++++++--- 1 file changed, 30 insertions(+), 3 deletions(-) diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c b/drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c index a428e53add08d451fb2152e3ab80e0fba936e214..f6bb405573be0ed480a2587a5a780dd711b8d2aa 100644 --- a/drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c +++ b/drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c @@ -77,12 +77,39 @@ static void qcom_adreno_smmu_set_stall(const void *cookie, bool enabled) { struct arm_smmu_domain *smmu_domain = (void *)cookie; struct arm_smmu_cfg *cfg = &smmu_domain->cfg; - struct qcom_smmu *qsmmu = to_qcom_smmu(smmu_domain->smmu); + struct arm_smmu_device *smmu = smmu_domain->smmu; + struct qcom_smmu *qsmmu = to_qcom_smmu(smmu); + u32 mask = BIT(cfg->cbndx); + bool stall_changed = !!(qsmmu->stall_enabled & mask) != enabled; + unsigned long flags; if (enabled) - qsmmu->stall_enabled |= BIT(cfg->cbndx); + qsmmu->stall_enabled |= mask; else - qsmmu->stall_enabled &= ~BIT(cfg->cbndx); + qsmmu->stall_enabled &= ~mask; + + /* + * If the device is on and we changed the setting, update the register. + * The spec pseudocode says that CFCFG is resampled after a fault, and + * we believe that no implementations cache it in the TLB, so it should + * be safe to change it without a TLB invalidation. + */ + if (stall_changed && pm_runtime_get_if_active(smmu->dev) > 0) { + spin_lock_irqsave(&smmu_domain->cb_lock, flags); + + u32 reg = arm_smmu_cb_read(smmu, cfg->cbndx, ARM_SMMU_CB_SCTLR); + + if (enabled) + reg |= ARM_SMMU_SCTLR_CFCFG; + else + reg &= ~ARM_SMMU_SCTLR_CFCFG; + + arm_smmu_cb_write(smmu, cfg->cbndx, ARM_SMMU_CB_SCTLR, reg); + + spin_unlock_irqrestore(&smmu_domain->cb_lock, flags); + + pm_runtime_put_autosuspend(smmu->dev); + } } static void qcom_adreno_smmu_resume_translation(const void *cookie, bool terminate) From patchwork Wed Mar 19 14:44:04 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Connor Abbott X-Patchwork-Id: 14022749 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 533E5C36000 for ; Wed, 19 Mar 2025 14:56:14 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:List-Subscribe:List-Help :List-Post:List-Archive:List-Unsubscribe:List-Id:Cc:To:In-Reply-To:References :Message-Id:Content-Transfer-Encoding:Content-Type:MIME-Version:Subject:Date: From:Reply-To:Content-ID:Content-Description:Resent-Date:Resent-From: Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=8nLyvaotott0DF5YTNTIkFLdWiK7/jsmUUyniYPMfxs=; b=qZLAAyZcapEsrx/wFu55ewvHMH 1zuFcMYcbgEE5N+5Ip4qrowcAQh9I875S+nsVOOYovIjr0sxe1h08jXzgODj++KVoD7vGYDzT9ra5 pzuiW6G7aQB7ZE8g0uAgXcsoneEIAyKr8MVJp1oPH+d118zdDW/qEOwGREvsn19L8KRdFIagkpcTR ur+iytexd7qLSdcQIUfKVxldbHkrgjHvuh4cyNi3QlquDh6BHdyw8Hds6e4Gq+pV+MGhoK6dRkZVq Yfl5VUbKGDBpBPVbyuvlG14h+8u1/8UqkPeAaZ8mcRxxCCEHO6jeVKuHwecbFC2ukDb80Nl+BtSKp DOEQMiqg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98 #2 (Red Hat Linux)) id 1tuupu-00000009H4R-16BE; Wed, 19 Mar 2025 14:56:02 +0000 Received: from mail-qk1-x72f.google.com ([2607:f8b0:4864:20::72f]) by bombadil.infradead.org with esmtps (Exim 4.98 #2 (Red Hat Linux)) id 1tuueT-00000009FI6-2Rny for linux-arm-kernel@lists.infradead.org; Wed, 19 Mar 2025 14:44:15 +0000 Received: by mail-qk1-x72f.google.com with SMTP id af79cd13be357-7c5528c98bdso28944585a.1 for ; Wed, 19 Mar 2025 07:44:13 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1742395453; x=1743000253; darn=lists.infradead.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=8nLyvaotott0DF5YTNTIkFLdWiK7/jsmUUyniYPMfxs=; b=FXEOjmbwdVx8Biwr5osPu2Axu15nkLVsSngM7IGdxyKSsyc+0bzz4NCk29CgcWzHaQ mK8j+y4R0Z9FhcTC8pI0rU1lccCJrFYQ89fyhRHdA9ZQZg4TcYWb2u0/5Ob112W+HlQm TOhs/Fjo8ywrkPwuDX8lrfFMLpeOnTJd250oJWNmWkf8HMLENuL5uiCMendUb3OOvJWH 6Pm9iISeLMVeykg3K98N3rnAvkpXpymG+mN5eRAhet+bNHsG999ySNvhHx6YIYnoklNw f7cjHuGbxwpt+ZgBDNurUn/TjnXhTygk6QT1Os4EiXxYrrjPw8qoPXaOXrUscl5TOxS8 14vw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1742395453; x=1743000253; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=8nLyvaotott0DF5YTNTIkFLdWiK7/jsmUUyniYPMfxs=; b=W38pDzt/S1lv3lcYmEfzZ2Fkq+umJCuAdRtkgWHXfSNf/vsKdOlUK6J4Vigoc9Jqlt 8rUFuAwvGzNbl61G8ClmZkC7fGmX1/XrbDqi8JMMyE8/ZDkrMjBCuUVoF+1bKhIAuVyd y5MMAUb0tCoP0VGF8gaSHJ0slHtqRcSBPtRYo/GVQP/P1wxE2f5xMgwgNMCutv2B/2BX umLbwfig7VBFHAJtRz3mJ3NLmohteAm4ReCcoKyypo40BJYJXOXscI/llfoJEaF8JJBs ZSPogJ76CpeBnZKUN2EwEimx7hPqhVy2axd6+QO5W/l2frwXhO2vLYe9z/8znBwMjgsY Dmzg== X-Forwarded-Encrypted: i=1; AJvYcCVh8n7WoFmX+I7q/wx43TNd1glRmV2FQThEm+pfuVRmmqBGrgDceMMfrtzdbAcS7UGkYfNYM72aRbzgl7a+5HS+@lists.infradead.org X-Gm-Message-State: AOJu0YztFPfrshep+wTR3ovuQiZCM05zTivCIFp0DahZDaiKfR138W3V 0yfAvJrjh76wWn5fO1UM4rpCT2nRVlm8yPOC2l+ehyfXjcjnqqdD X-Gm-Gg: ASbGncsBJjzjdyI8bt4NyYU+D9uEkF42PrvHzo3eLLnrbzmG2TR1JAhHkqNt/CtWIK8 aMhQ/piiu5P8LyzgMsqj/8n1/8n7VbFwZ0k7Y/eG3cnjw3z8PKB9nhmm/9dTC23Cdu2Mg3SNnwJ LGz2pI5LVQAfM++9ohtvU4iAtcTAD29TQ0xy3C0XquudqZS8APiVpIKK4ylwztkxEe9JxxHsA4J h7MaLlF9H+1qFAhtU/vpSjaKvq/SjyeAJLY3g+qCowm6WZzoTdhLVI1UIJhGmR82NPcAhFyOmcT LgU9GKFjHXZRQTLA52gCNZrRE6BQsaq72PgZ7fpY8Pnw80yEnw7iAg73NS/LliXKULcO43u7EJx 368I= X-Google-Smtp-Source: AGHT+IHRuFKMCfRKsajCRUTe1VyWz+iBut3DjbxfT02pd7HFFQHbhJ1zfvOx01Zp7ZXE/LfFpuszxg== X-Received: by 2002:a05:620a:4413:b0:7c0:bd67:7dd9 with SMTP id af79cd13be357-7c5a84a8706mr118072585a.11.1742395452521; Wed, 19 Mar 2025 07:44:12 -0700 (PDT) Received: from [192.168.1.99] (ool-4355b0da.dyn.optonline.net. [67.85.176.218]) by smtp.gmail.com with ESMTPSA id af79cd13be357-7c573c5201fsm868587485a.23.2025.03.19.07.44.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 19 Mar 2025 07:44:12 -0700 (PDT) From: Connor Abbott Date: Wed, 19 Mar 2025 10:44:04 -0400 Subject: [PATCH v5 5/5] drm/msm: Temporarily disable stall-on-fault after a page fault MIME-Version: 1.0 Message-Id: <20250319-msm-gpu-fault-fixes-next-v5-5-97561209dd8c@gmail.com> References: <20250319-msm-gpu-fault-fixes-next-v5-0-97561209dd8c@gmail.com> In-Reply-To: <20250319-msm-gpu-fault-fixes-next-v5-0-97561209dd8c@gmail.com> To: Rob Clark , Will Deacon , Robin Murphy , Joerg Roedel , Sean Paul , Konrad Dybcio , Abhinav Kumar , Dmitry Baryshkov , Marijn Suijten Cc: iommu@lists.linux.dev, linux-arm-msm@vger.kernel.org, linux-arm-kernel@lists.infradead.org, freedreno@lists.freedesktop.org, Connor Abbott X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1742395446; l=9409; i=cwabbott0@gmail.com; s=20240426; h=from:subject:message-id; bh=cSu3wr2OPZA25FwTnt0uRRtX/Si/NazjUU2gfv6K0KE=; b=As0UrByF3rvzBnmzJ8pOaRObhsNBWExBMsVIvSu+zCnP35Nx5WeOmN7N44N8gLN85VsAP7w5P +CwCJc8YUxOAqvVykM+G4vyIAABsM/h86xz95SFB8GQ9KImFyT1xAZO X-Developer-Key: i=cwabbott0@gmail.com; a=ed25519; pk=dkpOeRSXLzVgqhy0Idr3nsBr4ranyERLMnoAgR4cHmY= X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20250319_074413_711974_01EF9CA8 X-CRM114-Status: GOOD ( 28.23 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org When things go wrong, the GPU is capable of quickly generating millions of faulting translation requests per second. When that happens, in the stall-on-fault model each access will stall until it wins the race to signal the fault and then the RESUME register is written. This slows processing page faults to a crawl as the GPU can generate faults much faster than the CPU can acknowledge them. It also means that all available resources in the SMMU are saturated waiting for the stalled transactions, so that other transactions such as transactions generated by the GMU, which shares translation resources with the GPU, cannot proceed. This causes a GMU watchdog timeout, which leads to a failed reset because GX cannot collapse when there is a transaction pending and a permanently hung GPU. On older platforms with qcom,smmu-v2, it seems that when one transaction is stalled subsequent faulting transactions are terminated, which avoids this problem, but the MMU-500 follows the spec here. To work around these problems, disable stall-on-fault as soon as we get a page fault until a cooldown period after pagefaults stop. This allows the GMU some guaranteed time to continue working. We only use stall-on-fault to halt the GPU while we collect a devcoredump and we always terminate the transaction afterward, so it's fine to miss some subsequent page faults. We also keep it disabled so long as the current devcoredump hasn't been deleted, because in that case we likely won't capture another one if there's a fault. After this commit HFI messages still occasionally time out, because the crashdump handler doesn't run fast enough to let the GMU resume, but the driver seems to recover from it. This will probably go away after the HFI timeout is increased. Signed-off-by: Connor Abbott Reviewed-by: Rob Clark --- drivers/gpu/drm/msm/adreno/a5xx_gpu.c | 2 ++ drivers/gpu/drm/msm/adreno/a6xx_gpu.c | 4 ++++ drivers/gpu/drm/msm/adreno/adreno_gpu.c | 42 ++++++++++++++++++++++++++++++++- drivers/gpu/drm/msm/adreno/adreno_gpu.h | 26 ++++++++++++++++++++ drivers/gpu/drm/msm/msm_iommu.c | 9 +++++++ drivers/gpu/drm/msm/msm_mmu.h | 1 + 6 files changed, 83 insertions(+), 1 deletion(-) diff --git a/drivers/gpu/drm/msm/adreno/a5xx_gpu.c b/drivers/gpu/drm/msm/adreno/a5xx_gpu.c index 71dca78cd7a5324e9ff5b14f173e2209fa42e196..670141531112c9d29cef8ef1fd51b74759fdd6d2 100644 --- a/drivers/gpu/drm/msm/adreno/a5xx_gpu.c +++ b/drivers/gpu/drm/msm/adreno/a5xx_gpu.c @@ -131,6 +131,8 @@ static void a5xx_submit(struct msm_gpu *gpu, struct msm_gem_submit *submit) struct msm_ringbuffer *ring = submit->ring; unsigned int i, ibs = 0; + adreno_check_and_reenable_stall(adreno_gpu); + if (IS_ENABLED(CONFIG_DRM_MSM_GPU_SUDO) && submit->in_rb) { ring->cur_ctx_seqno = 0; a5xx_submit_in_rb(gpu, submit); diff --git a/drivers/gpu/drm/msm/adreno/a6xx_gpu.c b/drivers/gpu/drm/msm/adreno/a6xx_gpu.c index 0ae29a7c8a4d3f74236a35cc919f69d5c0a384a0..5a34cd2109a2d74c92841448a61ccb0d4f34e264 100644 --- a/drivers/gpu/drm/msm/adreno/a6xx_gpu.c +++ b/drivers/gpu/drm/msm/adreno/a6xx_gpu.c @@ -212,6 +212,8 @@ static void a6xx_submit(struct msm_gpu *gpu, struct msm_gem_submit *submit) struct msm_ringbuffer *ring = submit->ring; unsigned int i, ibs = 0; + adreno_check_and_reenable_stall(adreno_gpu); + a6xx_set_pagetable(a6xx_gpu, ring, submit); get_stats_counter(ring, REG_A6XX_RBBM_PERFCTR_CP(0), @@ -335,6 +337,8 @@ static void a7xx_submit(struct msm_gpu *gpu, struct msm_gem_submit *submit) struct msm_ringbuffer *ring = submit->ring; unsigned int i, ibs = 0; + adreno_check_and_reenable_stall(adreno_gpu); + /* * Toggle concurrent binning for pagetable switch and set the thread to * BR since only it can execute the pagetable switch packets. diff --git a/drivers/gpu/drm/msm/adreno/adreno_gpu.c b/drivers/gpu/drm/msm/adreno/adreno_gpu.c index 1238f326597808eb28b4c6822cbd41a26e555eb9..bac586101dc0494f46b069a8440a45825dfe9b5e 100644 --- a/drivers/gpu/drm/msm/adreno/adreno_gpu.c +++ b/drivers/gpu/drm/msm/adreno/adreno_gpu.c @@ -246,16 +246,53 @@ u64 adreno_private_address_space_size(struct msm_gpu *gpu) return SZ_4G; } +void adreno_check_and_reenable_stall(struct adreno_gpu *adreno_gpu) +{ + struct msm_gpu *gpu = &adreno_gpu->base; + unsigned long flags; + + /* + * Wait until the cooldown period has passed and we would actually + * collect a crashdump to re-enable stall-on-fault. + */ + spin_lock_irqsave(&adreno_gpu->fault_stall_lock, flags); + if (!adreno_gpu->stall_enabled && + ktime_after(ktime_get(), adreno_gpu->stall_reenable_time) && + !READ_ONCE(gpu->crashstate)) { + adreno_gpu->stall_enabled = true; + + gpu->aspace->mmu->funcs->set_stall(gpu->aspace->mmu, true); + } + spin_unlock_irqrestore(&adreno_gpu->fault_stall_lock, flags); +} + #define ARM_SMMU_FSR_TF BIT(1) #define ARM_SMMU_FSR_PF BIT(3) #define ARM_SMMU_FSR_EF BIT(4) +#define ARM_SMMU_FSR_SS BIT(30) int adreno_fault_handler(struct msm_gpu *gpu, unsigned long iova, int flags, struct adreno_smmu_fault_info *info, const char *block, u32 scratch[4]) { + struct adreno_gpu *adreno_gpu = to_adreno_gpu(gpu); const char *type = "UNKNOWN"; - bool do_devcoredump = info && !READ_ONCE(gpu->crashstate); + bool do_devcoredump = info && (info->fsr & ARM_SMMU_FSR_SS) && + !READ_ONCE(gpu->crashstate); + unsigned long irq_flags; + + /* + * In case there is a subsequent storm of pagefaults, disable + * stall-on-fault for at least half a second. + */ + spin_lock_irqsave(&adreno_gpu->fault_stall_lock, irq_flags); + if (adreno_gpu->stall_enabled) { + adreno_gpu->stall_enabled = false; + + gpu->aspace->mmu->funcs->set_stall(gpu->aspace->mmu, false); + } + adreno_gpu->stall_reenable_time = ktime_add_ms(ktime_get(), 500); + spin_unlock_irqrestore(&adreno_gpu->fault_stall_lock, irq_flags); /* * If we aren't going to be resuming later from fault_worker, then do @@ -1143,6 +1180,9 @@ int adreno_gpu_init(struct drm_device *drm, struct platform_device *pdev, adreno_gpu->info->inactive_period); pm_runtime_use_autosuspend(dev); + spin_lock_init(&adreno_gpu->fault_stall_lock); + adreno_gpu->stall_enabled = true; + return msm_gpu_init(drm, pdev, &adreno_gpu->base, &funcs->base, gpu_name, &adreno_gpu_config); } diff --git a/drivers/gpu/drm/msm/adreno/adreno_gpu.h b/drivers/gpu/drm/msm/adreno/adreno_gpu.h index dcf454629ce037b2a8274a6699674ad754ce1f07..868d22fde1396def35e2f46bc2b2f4eff611d8fd 100644 --- a/drivers/gpu/drm/msm/adreno/adreno_gpu.h +++ b/drivers/gpu/drm/msm/adreno/adreno_gpu.h @@ -205,6 +205,30 @@ struct adreno_gpu { /* firmware: */ const struct firmware *fw[ADRENO_FW_MAX]; + /** + * @fault_stall_lock: + * + * Serialize changes to stall-on-fault state. + */ + spinlock_t fault_stall_lock; + + /** + * @fault_stall_reenable_time: + * + * If stall_enabled is false, when to reenable stall-on-fault. + * Protected by @fault_stall_lock. + */ + ktime_t stall_reenable_time; + + /** + * @stall_enabled: + * + * Whether stall-on-fault is currently enabled. Protected by + * @fault_stall_lock. + */ + bool stall_enabled; + + struct { /** * @rgb565_predicator: Unknown, introduced with A650 family, @@ -629,6 +653,8 @@ int adreno_fault_handler(struct msm_gpu *gpu, unsigned long iova, int flags, struct adreno_smmu_fault_info *info, const char *block, u32 scratch[4]); +void adreno_check_and_reenable_stall(struct adreno_gpu *gpu); + int adreno_read_speedbin(struct device *dev, u32 *speedbin); /* diff --git a/drivers/gpu/drm/msm/msm_iommu.c b/drivers/gpu/drm/msm/msm_iommu.c index 2a94e82316f95c5f9dcc37ef0a4664a29e3492b2..8d5380e6dcc217c7c209b51527bf15748b3ada71 100644 --- a/drivers/gpu/drm/msm/msm_iommu.c +++ b/drivers/gpu/drm/msm/msm_iommu.c @@ -351,6 +351,14 @@ static void msm_iommu_resume_translation(struct msm_mmu *mmu) adreno_smmu->resume_translation(adreno_smmu->cookie, true); } +static void msm_iommu_set_stall(struct msm_mmu *mmu, bool enable) +{ + struct adreno_smmu_priv *adreno_smmu = dev_get_drvdata(mmu->dev); + + if (adreno_smmu->set_stall) + adreno_smmu->set_stall(adreno_smmu->cookie, enable); +} + static void msm_iommu_detach(struct msm_mmu *mmu) { struct msm_iommu *iommu = to_msm_iommu(mmu); @@ -399,6 +407,7 @@ static const struct msm_mmu_funcs funcs = { .unmap = msm_iommu_unmap, .destroy = msm_iommu_destroy, .resume_translation = msm_iommu_resume_translation, + .set_stall = msm_iommu_set_stall, }; struct msm_mmu *msm_iommu_new(struct device *dev, unsigned long quirks) diff --git a/drivers/gpu/drm/msm/msm_mmu.h b/drivers/gpu/drm/msm/msm_mmu.h index 88af4f490881f2a6789ae2d03e1c02d10046331a..2694a356a17904e7572b767b16ed0cee806406cf 100644 --- a/drivers/gpu/drm/msm/msm_mmu.h +++ b/drivers/gpu/drm/msm/msm_mmu.h @@ -16,6 +16,7 @@ struct msm_mmu_funcs { int (*unmap)(struct msm_mmu *mmu, uint64_t iova, size_t len); void (*destroy)(struct msm_mmu *mmu); void (*resume_translation)(struct msm_mmu *mmu); + void (*set_stall)(struct msm_mmu *mmu, bool enable); }; enum msm_mmu_type {