From nobody Tue Sep 29 08:26:17 2026 Received: from mx0a-0031df01.pphosted.com (mx0a-0031df01.pphosted.com [205.220.168.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 70F0A40F8EB for ; Mon, 10 Aug 2026 15:23:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=205.220.168.131 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375399; cv=none; b=oNansHJSNcaOVZrH8eo7Nca1RGxh77R1NTSxJ/qctZNz58JDDa3rpPzMXnzEL7LZ3sfuD72OKTTPAe26GQwbCzjooJd1baRZU3AudOfphmLVvRhW1AJIwHcu5/bTuMgIAvIs/JLBqcKz/yRPo2KBsanHEuu9phs66wdF/NVj6sg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375399; c=relaxed/simple; bh=NcWh+3cRWPBUkWPKYUjopSr0PuS9CdGo8db+mB/eUFE=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=I/L3QojIJ09kMZIRxyqJoNk9SPUu3arf9QScVD0GDCxlxXQY0V2djjdsWKYJoFIyO7b2tIA2QKTo1bUUqn9r/d+C7ztyH3+Jh7qZBrCknida0+ury6A4ENUcnhDYUrRpTBvkCiblwAzYnDCMqdL0UbW0jEezT+JUdr9a7ipNHoo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=oss.qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=g5diXRZc; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b=OejQx87n; arc=none smtp.client-ip=205.220.168.131 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="g5diXRZc"; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b="OejQx87n" Received: from pps.filterd (m0279863.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 67ACj72n1706815 for ; Mon, 10 Aug 2026 15:23:17 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qualcomm.com; h= cc:content-transfer-encoding:date:from:in-reply-to:message-id :mime-version:references:subject:to; s=qcppdkim1; bh=O8v8yIaQJEs t5NLok5icCkr9lpo4Go8g22QAHh4O4hI=; b=g5diXRZcCw54/IoE0HVxU7Z5xRG bQBy6lEw6IUtpytPqpsTaNIppX96kasiMkEsPY71L11fEyu7Pq+ATnwtz35PvnBV +TYz57TdLJ9zRg6WhBW4DyO/dfj5LH52I16hZUDT1DXUhkC4sm9YU7jr8etn7Lx6 65V+iyPqlZlQFohBc0pt2gSi59uy/mCr/08ix8tXdDWCLG0tCYoTsEWbgqbGjeJ8 fXr1PVqXbhVf/AQvJZqCeWOfL8VgSa1YxGlLP3s4ATSFog4dHRWzUGSxzp2Ipeus dojeD5c3QHUQHPIZjfly7W4lnACKa6djnNA3dq0ntQ60aEsZz7/uQvNaqcw== Received: from mail-pj1-f69.google.com (mail-pj1-f69.google.com [209.85.216.69]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4fybh59mg4-1 (version=TLSv1.3 cipher=TLS_AES_128_GCM_SHA256 bits=128 verify=NOT) for ; Mon, 10 Aug 2026 15:23:17 +0000 (GMT) Received: by mail-pj1-f69.google.com with SMTP id 98e67ed59e1d1-38e7621655eso3813174a91.0 for ; Mon, 10 Aug 2026 08:23:17 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oss.qualcomm.com; s=google; t=1786375397; x=1786980197; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=O8v8yIaQJEst5NLok5icCkr9lpo4Go8g22QAHh4O4hI=; b=OejQx87nAIZwW2dMFAeRFJnIVdvuFFA9FEBpIoQGoYuVtzj8IF9foXo5PcGEQx1Rxx bekuKd+KMf3YExUSKeSODHAMgxVkXtNJJCr1Hf+bRKry2UGN4qgO2Vc60SWIqxuHX4Al qbJTKyXrPGrHAz253IlflA5lOV53NE5Q1/msrI3C8/2NYArWYm2tctSyD/IvMGx/7MjR ullqJo82i1ZnsuaCbXPUwGrn39RZoqlQPVyFAwOvt0jfzKxe+6TnyfP9OJyziVCvFoEN g3Ic/y0hRg0FR1abWNFaQsPQnMehllFIFhqQmtR84wsZQGdgfO0OaMk6qI2wKhSLnWq4 h8og== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1786375397; x=1786980197; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=O8v8yIaQJEst5NLok5icCkr9lpo4Go8g22QAHh4O4hI=; b=Z9OVZp/WY+zoHLXK9G9MT4ALTi6ogYhHBm5JZK7Q5lN9ZJ9MhegJzxOxNUVX25m9by du82+WLpKuJ1bC9ho9I4BG7Z57vIPUyUQvQ4dGtTC5YPkq13i5DYUBTLq6qebYlRfw7v WTxpX9sH3S3X0eDs6GrKSXpi90UAqVEPaRZyureWgAtlfkwSJ/NydMrl1g2F7QtToBYa cR+e1aBe1aVQOr0EVJ+k5//X2Un+2FEeRw9BlTlHBo+T1+ZNfgEPTYQ1nfaw/C1yaLAQ +1UPQ7Ur8+8j9O7HssKr5muoUP1NHE+5wlBf4NVG75dK3U+zKodhthcRMwlnF3QuDEww 317w== X-Forwarded-Encrypted: i=1; AHgh+Ro4N04Znaps9e9lNJbRJLJbrTRIyyN+ex0Fd1kVJDAEkWwfG8AmELxSOWzchziU4G+YblcaVNzekdGuVPk=@vger.kernel.org X-Gm-Message-State: AOJu0Yxn+JoYzIR20oj1Hnl9ZH+Phuufuu8jbdYkmiNZjY1ij5At/bhE /mFYosQV4TvBQsX+2wo6LE8VYSW0Ll5SjJHKzdGwNG8dO0x44dj/VDlNsJxnSxOK+Iy1g5K8wZM YqkoBED40fHeO8jSPySUoFkpr2bur+5mHHWyylSKGpTHM8yKgkyTc2A0rCI+bK+LUJNE= X-Gm-Gg: AR+sD12QwNLFdTq6LbfWLlowOYrMDzmrdzBgihxkm7DZMMAvKBo8ggbt2etnm0xwtQT V5a1SgN3d8HhZFxxfvcuLEPL1DR7Zn9aN8K5ytP4QkkZrloVO7xEFwD47MGs6xJJgeieYnB746n jITjo8kd6aAWtrZkcKvpqluY7B1STO0iRARl6rD6s6UaiYSe5jDPEdrX/MlIHHgFJFG2+xM4b2s zatBmEy7UYCCkHPaMl6rzxEfR+WXRax/Gp6sY3eODAzeB7uzz6Ta/LSUFb4++ZDDzUQ307ngd6V W2iU8lSzCZ9rZYPkFFB4RTCaikHTIsG4RJPRlU75LSZbPw+0CI1O97emFz0ACrxqKN5NVN1Y/8s zYFro0Wjc6DWNn9GxdTrsRqCh2VS10MldISv1E8JWtlpuzcugM7jMFq8jhniBz5zWPdGyaGEv4G NiYqWOogiXScI0FZxM9W5DVLPEXQ== X-Received: by 2002:a05:6a20:e347:b0:3bd:3800:7538 with SMTP id adf61e73a8af0-3cb85ffdacamr47203002637.33.1786375396800; Mon, 10 Aug 2026 08:23:16 -0700 (PDT) X-Received: by 2002:a05:6a20:e347:b0:3bd:3800:7538 with SMTP id adf61e73a8af0-3cb85ffdacamr47202942637.33.1786375396337; Mon, 10 Aug 2026 08:23:16 -0700 (PDT) Received: from hu-mchitale-blr.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com. [103.229.18.19]) by smtp.googlemail.com with ESMTPSA id 41be03b00d2f7-cbe8f1af985sm4282634a12.11.2026.08.10.08.23.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Aug 2026 08:23:15 -0700 (PDT) From: Mayuresh Chitale To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Anup Patel , Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Mayuresh Chitale , Anup Patel , Atish Patra , Andrew Jones , Sunil V L , linux-riscv@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, Mayuresh Chitale Subject: [PATCH v5 01/14] dt-bindings: Add RISC-V trace component bindings Date: Mon, 10 Aug 2026 20:52:03 +0530 Message-ID: <20260810152223.3946743-2-mayuresh.chitale@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> References: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Authority-Analysis: v=2.4 cv=O4YJeh9W c=1 sm=1 tr=0 ts=6a79ece5 cx=c_pps a=vVfyC5vLCtgYJKYeQD43oA==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=Sv0fKeRqtYgA:10 a=s4-Qcg_JpJYA:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=yOCtJkima9RkubShWh1s:22 a=gEfo2CItAAAA:8 a=EUspDBNiAAAA:8 a=VwQbUJbxAAAA:8 a=W-_n0kkjAAAA:8 a=f9mqD-BOXdQ1R_-L-AkA:9 a=rl5im9kqc5Lf4LNbBjHf:22 a=sptkURWiP4Gy88Gu7hUp:22 a=qeNa2pbTr82C0GpJEZFS:22 X-Proofpoint-ORIG-GUID: SKQdweFIJtiiXVcd48Y3PtQZ0OvtGJKO X-Proofpoint-Spam-Info: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfXzlPPL3KWCJ6/ 74XXR4pznGtPDd02Di0BIXBM7DAOwHUliAvKluZ2d8Ew3rS6MxbmKMmSitUUd8Va5t4Svhj2vlQ S66K2hGE/AJbTNikQ2CEifji36J3r5M= X-Proofpoint-GUID: SKQdweFIJtiiXVcd48Y3PtQZ0OvtGJKO X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfXyPnvPeP0EJbH QB3Fs0Pq1IYWiHNZAxLz21oQs3j0wGj/PJoT8AInzGokR8QogZzADvmip7ueWjIfoDinip1jQxy bTJrIM0YBs+O75TBRQ5j1GT2z3DOpg0uhEVEs9GaHnCskR9x03Dv/tvRa0WO88wLKwja+M/Y9Gc kKQ9AHB/b0n7hzlwM99/3i1EW5qtY6yzwU+dTWenU7ugSuTsyPYqgoyQnJKgrbwXhRdmm6hLw91 iegjPCTqDuocokPiq1x0czrFhp4xDnQObgBE5TbUaTeWtcQUgPhW94guUXb+UD7lFmJfWFU9dKZ KJU3y+U5Qwc6dx+eXA7ci9b1O/pQyr+AO98320S4TxGGh2zpEuMhx5tI/6/2tyfjt3eh06BOd1C 4mrwr4mPBp7wOEm+ZHghh23O0hki+jm+nM8chwYlXvNwSJifdWWy8xmLeveHRexbUMIlhXeeS7t OGhYRoPYjV2/43hp+4g== X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1176,Hydra:6.1.134,FMLib:17.12.100.49 definitions=2026-08-10_03,2026-08-07_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 spamscore=0 priorityscore=1501 adultscore=0 clxscore=1011 malwarescore=0 phishscore=0 bulkscore=0 lowpriorityscore=0 suspectscore=0 impostorscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2606150000 definitions=main-2608100132 Content-Type: text/plain; charset="utf-8" From: Anup Patel Add device tree bindings for the memory mapped RISC-V trace components which support both the RISC-V efficient trace (E-trace) protocol and the RISC-V Nexus-based trace (N-trace) protocol. The RISC-V trace components are defined by the RISC-V trace control interface specification. Signed-off-by: Anup Patel Signed-off-by: Mayuresh Chitale Reviewed-by: Rob Herring (Arm) --- .../bindings/riscv/riscv,trace-component.yaml | 120 ++++++++++++++++++ 1 file changed, 120 insertions(+) create mode 100644 Documentation/devicetree/bindings/riscv/riscv,trace-com= ponent.yaml diff --git a/Documentation/devicetree/bindings/riscv/riscv,trace-component.= yaml b/Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml new file mode 100644 index 000000000000..bb519bc4a163 --- /dev/null +++ b/Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml @@ -0,0 +1,120 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/riscv/riscv,trace-component.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: RISC-V Trace Component + +maintainers: + - Anup Patel + +description: + The RISC-V trace control interface specification standard memory mapped + components (or devices) which support both the RISC-V efficient trace + (E-trace) protocol and the RISC-V Nexus-based trace (N-trace) protocol. + The RISC-V trace components have implementation specific directed acyclic + graph style interdependency where output of one component serves as input + to another component and certain components (such as funnel) can take in= puts + from multiple components. The type and version of a RISC-V trace compone= nt + can be discovered from it's IMPL memory mapped register hence component + specific compatible strings are not needed. + +properties: + compatible: + items: + - enum: + - qemu,trace-component + - const: riscv,trace-component + + reg: + maxItems: 1 + + cpus: + maxItems: 1 + description: + phandle to the cpu to which the RISC-V trace component is bound. + + in-ports: + $ref: /schemas/graph.yaml#/properties/ports + patternProperties: + '^port(@[0-7])?$': + description: Input connections from RISC-V trace component + $ref: /schemas/graph.yaml#/properties/port + + out-ports: + $ref: /schemas/graph.yaml#/properties/ports + patternProperties: + '^port(@[0-7])?$': + description: Output connections from RISC-V trace component + $ref: /schemas/graph.yaml#/properties/port + +required: + - compatible + - reg + +anyOf: + - required: [ in-ports ] + - required: [ out-ports ] + +unevaluatedProperties: false + +examples: + - | + // Example 1 (Per-hart encoder and ramsink components): + + trace@c000000 { + compatible =3D "qemu,trace-component", "riscv,trace-component"; + reg =3D <0xc000000 0x1000>; + cpus =3D <&CPU0>; + + out-ports { + port { + CPU0_ENCODER_OUTPUT: endpoint { + remote-endpoint =3D <&CPU0_RAMSINK_INPUT>; + }; + }; + }; + }; + + trace@c001000 { + compatible =3D "qemu,trace-component", "riscv,trace-component"; + reg =3D <0xc001000 0x1000>; + cpus =3D <&CPU0>; + + in-ports { + port { + CPU0_RAMSINK_INPUT: endpoint { + }; + }; + }; + }; + + trace@c002000 { + compatible =3D "qemu,trace-component", "riscv,trace-component"; + reg =3D <0xc002000 0x1000>; + cpus =3D <&CPU1>; + + out-ports { + port { + CPU1_ENCODER_OUTPUT: endpoint { + remote-endpoint =3D <&CPU1_RAMSINK_INPUT>; + }; + }; + }; + }; + + trace@c003000 { + compatible =3D "qemu,trace-component", "riscv,trace-component"; + reg =3D <0xc003000 0x1000>; + cpus =3D <&CPU1>; + + in-ports { + port { + CPU1_RAMSINK_INPUT: endpoint { + }; + }; + }; + }; + +... --=20 2.43.0 From nobody Tue Sep 29 08:26:17 2026 Received: from mx0a-0031df01.pphosted.com (mx0a-0031df01.pphosted.com [205.220.168.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id BBEDD407CC6 for ; Mon, 10 Aug 2026 15:23:26 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=205.220.168.131 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375408; cv=none; b=t1mUawSX4/kg0cU831VyJzgs3umCBbdZL4Ldhz/D7eVAXJYjDohZdFjLI94GRCB/w9zFVkiYVS/pnvMXVxwkg76xEEmX5944Srb7uSSFadoImDdzTB73gOODwOfkOD0C/IWJ4bZ0Z9ouONRB6WZrfSJgWHTjbu2DUZHVvTbDL4k= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375408; c=relaxed/simple; bh=n+I17YK5f06RgvQsaK7MYZjdinXk4SMckrjXbihEjU0=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=kUuT/1fZPvedNfZT0MoxY1LCZjcDt1H4RvmbsWlVjMnrp54c3+7zEyzelzAjxq+yzyuM223S+Ws4WM63mJiJfeCMPshOkxhRkLi9oFqAP8EQ4ktbim6i1l3gVNvetRnGhUNyFgoyZhSEjy9Cg8UFEyly41wx9zoDWNRIdL1hW4s= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=oss.qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=I3EUiGVT; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b=GfmLOFDh; arc=none smtp.client-ip=205.220.168.131 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="I3EUiGVT"; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b="GfmLOFDh" Received: from pps.filterd (m0279862.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 67ACj5Or1343209 for ; Mon, 10 Aug 2026 15:23:26 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qualcomm.com; h= cc:content-transfer-encoding:date:from:in-reply-to:message-id :mime-version:references:subject:to; s=qcppdkim1; bh=bTTnPEh7D4i h9EvnotZPDDWz9xg7ucFp62s5u7zxdfs=; b=I3EUiGVTjoZlzdilQFcBjiC1s98 +c9VOYO+ROVucg3kmVai8bhdI4qxUXN/roEKO+TMlaOWHv8UVm6qnTq3VElXpXPE XVmdVuLcvZc2+MqEHshGiyFtYasVs4oOnaBZLe3oUSfUCIbNbI6FXO3ofOyKfm+6 CP+7t5JDGFhUJuXlDMmYv8Q62WCJp+Uc2cZMmiGk4iIU6W0sLBoGxSYeJ+7kfqC+ Sd0TsBBBoxAaGc3gobx5GMSIz/XvzJGDETCZyiuO4y6SAdvbocZL5LEO80OR+awD oABJOd9PxxcTLHdqoaju4yD+Y/0bGdobynvX7j3+JfVCXJS5DNEy9sz7irg== Received: from mail-pf1-f200.google.com (mail-pf1-f200.google.com [209.85.210.200]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4fy8v5a77w-1 (version=TLSv1.3 cipher=TLS_AES_128_GCM_SHA256 bits=128 verify=NOT) for ; Mon, 10 Aug 2026 15:23:25 +0000 (GMT) Received: by mail-pf1-f200.google.com with SMTP id d2e1a72fcca58-84e048a801dso3023582b3a.3 for ; Mon, 10 Aug 2026 08:23:25 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oss.qualcomm.com; s=google; t=1786375405; x=1786980205; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=bTTnPEh7D4ih9EvnotZPDDWz9xg7ucFp62s5u7zxdfs=; b=GfmLOFDhRvF5izUpmHYFdce/RJMzc8n63VWIF0vrDT6yF1WJz2jFaB64qFIbURbFJO bMq+83u3hrIyOlJAg/3HMi3xFgvRpLMAL1cffAu7OiXUeFWGzmKiaDmjW8CVwZpdJWCP M5UrgOTpNXKdL/tbkCQ+Z3xJXmX36jkVR00hiFse7WHanF+IocUmfs1ZHLDomiAv/2fu gQPN69vzhYcsNd9AHazhtn43H0mx0EyLLZr7gnNrpYFlS57+J/F6pav+KhSagb1tJGCI vJVwo7uJvzs4Ob2VROxqPucgn94Ghq0RdYpr6GHhm9CDvq+F9WqUtCLig3+YdmWlduxr usOQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1786375405; x=1786980205; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=bTTnPEh7D4ih9EvnotZPDDWz9xg7ucFp62s5u7zxdfs=; b=ASFx/xDT8AgUZw6VBmB2lPBBtAL4ybqOc45FXS1pyMhZOhBLG/pQe6G9fnxeBza6zZ sF6NvRjk468yKtTnCzmrMHtw7Ap8o0CJwFEi1ie1YRdOsfLgf0UD2/RN/HifPGUyGU3X EPInqeePXdCPkH4m5XvX+iADvVnOJzSuNTeO/5BDjTXf7GKZjPxBouePEUhLhAw1lroZ cqNoa0VCbU6PCfmZ5iX52a7FffnsINfHL9MjHRvswZwHtH3mkgYLH441FrgZHsNj10z2 OHvYxc+ZoxPBx89nogYhrRvSdaxhdlbOVTZ7AOWWwwre+WnMoufFl5n0WcNBnmUL6ox8 2qxQ== X-Forwarded-Encrypted: i=1; AHgh+RppW1hEUfSlmVQqRlMnATDGvxNPVKaCVu5gjfg5n9hsprJVgqZ0I2bhFGT7uX8KvnAnCxCfBHRfGSEYk8k=@vger.kernel.org X-Gm-Message-State: AOJu0YwwHhbuc5J0MSKKDsQZetNeQE30voMnl8olmqb81NPXow5MUwSB gNQlgVzu+qed6qBvBGus2tlUtD7f0pLx+OGJHZGRjfKg5+6gaDeODlHkAyKdJV9GSVavxld2sBv U+BfFkHiUsytvZIgF74ePk8fQinB+uyB/nLWPBBC+95qc4ejaRboTJqUT7iidY9RKCXs= X-Gm-Gg: AR+sD104B4es3VeP7F0jfaaDLUzAwGAphD/1q9nfomIKpXdfm6VHMCvjFiqiOLU0N7E uTDAjhhDtVjeEtEv3hBcO/QtKZlxzwlJ8nfFoRGjkOTH+RlnPQVgQg+9VX/3FsZpOTMGIOw8/Fe uHmQ0Wkg8mgRXI+1ossyhq4W3FWHcNOLgmCQb61dAj1jEjUK/QKIebdXeh+a905xNN3btU3wVY8 dj0+b2mBegq/q2MzU6LYL542HP4GYRiJsb0+GEvOogJ8ST8eIKjUdo1ztEEhKiXjSUOarcvoJNs Wi2ybPvBjKiPd9K2XR31b28mbAI/jhfxg6Zd05pQOYRBS9iLqAiq+G8CGOLE93fp/ij9sYkMsKe I2gItddLLFb4a/tSN0iidqffZUbM5oK/oZn8p6AmrTX3ThKldvL7ToWYB6duQL8J1uym+lu1XZP NU0MutB3PEMUywmzyFmYV8dzFhXQ== X-Received: by 2002:a05:6a00:4c1a:b0:848:2b8f:c9d7 with SMTP id d2e1a72fcca58-84f9c965a9dmr2684705b3a.18.1786375404690; Mon, 10 Aug 2026 08:23:24 -0700 (PDT) X-Received: by 2002:a05:6a00:4c1a:b0:848:2b8f:c9d7 with SMTP id d2e1a72fcca58-84f9c965a9dmr2684605b3a.18.1786375403955; Mon, 10 Aug 2026 08:23:23 -0700 (PDT) Received: from hu-mchitale-blr.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com. [103.229.18.19]) by smtp.googlemail.com with ESMTPSA id 41be03b00d2f7-cbe8f1af985sm4282634a12.11.2026.08.10.08.23.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Aug 2026 08:23:23 -0700 (PDT) From: Mayuresh Chitale To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Anup Patel , Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Mayuresh Chitale , Anup Patel , Atish Patra , Andrew Jones , Sunil V L , linux-riscv@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, Mayuresh Chitale Subject: [PATCH v5 02/14] hwtracing: gtrace: Initial implementation of gtrace framework Date: Mon, 10 Aug 2026 20:52:04 +0530 Message-ID: <20260810152223.3946743-3-mayuresh.chitale@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> References: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-Spam-Info: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX46mZ6WFIq/W9 2fj5wmeyEvn/gCOlFPz8UYfVfIwpNaFk01+68wJhKzMcMjU3u0pt83mdfjWI+Q62eeFp2AkMSL/ 1SFEbtniEXQRFEbKFltAjaE0g510bpU= X-Authority-Analysis: v=2.4 cv=J6qaKgnS c=1 sm=1 tr=0 ts=6a79ecee cx=c_pps a=mDZGXZTwRPZaeRUbqKGCBw==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=Sv0fKeRqtYgA:10 a=s4-Qcg_JpJYA:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=_K5XuSEh1TEqbUxoQ0s3:22 a=EUspDBNiAAAA:8 a=gM5wKXem3R3DcKQ8I4kA:9 a=zc0IvFSfCIW2DFIPzwfm:22 X-Proofpoint-GUID: dG0iXPdbVl2fo-YBW1t-Kvfb-TkfoUMw X-Proofpoint-ORIG-GUID: dG0iXPdbVl2fo-YBW1t-Kvfb-TkfoUMw X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfXx+61VtFp6q50 F5WmqhjwCvELf2LzSHsv7lzPTwvkHo7ZetDHd0O8b7hPYVZMTCf3Cj8wgSb0oHsJheY7jbjDedu Vf1MQT2ICeR3xD8QY1KOVsyIuvBn60rdJ4BbD6RlBToIk3GrgzRtEYg3ap+rcxsq/mzSIQxRn/T rz+FSh/6/7npU+D7cfIDnZhbrC7J92XWP6JpzMwm7w/QmyZL690YM50CJXdCjS1mIQl1Gg+421V /V4fV901muYM1TZtMmRA4ELq2jC5tH6TgtJV8P08clbWPMIxEJ5OswGviXwX39P+Xm1qxSxje9V uyE9U3j1eWkuGzA1nUge92Odi9GpeQCGsk2dLZxaqZHpM6K6yTR/WYgR2hOKGOpLdVm0zOzgIE0 TxAh3UB+DITCmXC34WmuOuG7k9zeVOBuv+kwZWoPBv0T2Y5VQ9KWJX+lKNrlhgRejqaFUGaA5RP A/dHgRdp+tL0NEQjjjw== X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1176,Hydra:6.1.134,FMLib:17.12.100.49 definitions=2026-08-10_03,2026-08-07_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 suspectscore=0 phishscore=0 spamscore=0 lowpriorityscore=0 priorityscore=1501 impostorscore=0 clxscore=1015 adultscore=0 bulkscore=0 malwarescore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2606150000 definitions=main-2608100132 Content-Type: text/plain; charset="utf-8" From: Anup Patel Implement a generic and architecture neutral trace framework (gtrace) in which trace components are organized in a graph-like topology. The framework provides a bus for the trace components along with helpers to register components, build the topology and access the hardware registers. Co-developed-by: Mayuresh Chitale Signed-off-by: Mayuresh Chitale Signed-off-by: Anup Patel --- drivers/Makefile | 1 + drivers/hwtracing/Kconfig | 2 + drivers/hwtracing/gtrace/Kconfig | 15 + drivers/hwtracing/gtrace/Makefile | 4 + drivers/hwtracing/gtrace/gtrace-core.c | 442 +++++++++++++++++++++++++ include/linux/gtrace.h | 266 +++++++++++++++ 6 files changed, 730 insertions(+) create mode 100644 drivers/hwtracing/gtrace/Kconfig create mode 100644 drivers/hwtracing/gtrace/Makefile create mode 100644 drivers/hwtracing/gtrace/gtrace-core.c create mode 100644 include/linux/gtrace.h diff --git a/drivers/Makefile b/drivers/Makefile index 0841ea851847..e018cc915f62 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -178,6 +178,7 @@ obj-$(CONFIG_CORESIGHT) +=3D hwtracing/coresight/ obj-y +=3D hwtracing/intel_th/ obj-$(CONFIG_STM) +=3D hwtracing/stm/ obj-$(CONFIG_HISI_PTT) +=3D hwtracing/ptt/ +obj-$(CONFIG_GTRACE) +=3D hwtracing/gtrace/ obj-y +=3D android/ obj-$(CONFIG_NVMEM) +=3D nvmem/ obj-$(CONFIG_FPGA) +=3D fpga/ diff --git a/drivers/hwtracing/Kconfig b/drivers/hwtracing/Kconfig index 911ee977103c..ef53f5c8429f 100644 --- a/drivers/hwtracing/Kconfig +++ b/drivers/hwtracing/Kconfig @@ -7,4 +7,6 @@ source "drivers/hwtracing/intel_th/Kconfig" =20 source "drivers/hwtracing/ptt/Kconfig" =20 +source "drivers/hwtracing/gtrace/Kconfig" + endmenu diff --git a/drivers/hwtracing/gtrace/Kconfig b/drivers/hwtracing/gtrace/Kc= onfig new file mode 100644 index 000000000000..bcc3b4169a76 --- /dev/null +++ b/drivers/hwtracing/gtrace/Kconfig @@ -0,0 +1,15 @@ +# SPDX-License-Identifier: GPL-2.0-only + +menuconfig GTRACE + tristate "Generic Hardware Trace Support" + depends on OF + help + This framework provides an architecture-neutral kernel interface + for hardware trace drivers. It builds a topological view of the + trace components and configures the correct series of components + when trace is enabled. It is intended to be shared across RISC-V + and ARM trace components so that a single trace path may span + components of different architectures. + + To compile this driver as a module, choose M here: the module + will be called gtrace. diff --git a/drivers/hwtracing/gtrace/Makefile b/drivers/hwtracing/gtrace/M= akefile new file mode 100644 index 000000000000..3f90fb99c514 --- /dev/null +++ b/drivers/hwtracing/gtrace/Makefile @@ -0,0 +1,4 @@ +# SPDX-License-Identifier: GPL-2.0 + +obj-$(CONFIG_GTRACE) +=3D gtrace.o +gtrace-y :=3D gtrace-core.o diff --git a/drivers/hwtracing/gtrace/gtrace-core.c b/drivers/hwtracing/gtr= ace/gtrace-core.c new file mode 100644 index 000000000000..97398f2b7cbb --- /dev/null +++ b/drivers/hwtracing/gtrace/gtrace-core.c @@ -0,0 +1,442 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2026 Qualcomm Technologies, Inc. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +/* Mutex to serialize component registration/unregistration */ +static DEFINE_MUTEX(gtrace_mutex); + +/* Per-CPU source instances */ +static DEFINE_PER_CPU(struct gtrace_component *, gtrace_cpu_source_comp); + +/* Component type based id generator */ +struct gtrace_type_idx { + /* Lock to protect the type ID generator */ + struct mutex lock; + struct xarray xa; +}; + +/* Array of component type based id generator */ +static struct gtrace_type_idx gtrace_type_idx_array[GTRACE_COMPONENT_TYPE_= MAX]; + +static int gtrace_alloc_type_idx(struct gtrace_component *comp) +{ + struct gtrace_type_idx *gidx; + u32 idx; + int ret; + + if (comp->id.type >=3D GTRACE_COMPONENT_TYPE_MAX) + return -EINVAL; + + gidx =3D >race_type_idx_array[comp->id.type]; + mutex_lock(&gidx->lock); + ret =3D xa_alloc(&gidx->xa, &idx, comp, xa_limit_32b, GFP_KERNEL); + mutex_unlock(&gidx->lock); + if (ret) + return ret; + + comp->type_idx =3D idx; + return 0; +} + +static void gtrace_free_type_idx(struct gtrace_component *comp) +{ + struct gtrace_type_idx *gidx; + + if (comp->id.type >=3D GTRACE_COMPONENT_TYPE_MAX) + return; + + gidx =3D >race_type_idx_array[comp->id.type]; + mutex_lock(&gidx->lock); + xa_erase(&gidx->xa, comp->type_idx); + mutex_unlock(&gidx->lock); +} + +static void __init gtrace_init_type_idx(void) +{ + struct gtrace_type_idx *gidx; + int i; + + for (i =3D 0; i < GTRACE_COMPONENT_TYPE_MAX; i++) { + gidx =3D >race_type_idx_array[i]; + mutex_init(&gidx->lock); + xa_init_flags(&gidx->xa, XA_FLAGS_ALLOC); + } +} + +const struct gtrace_component_id *gtrace_match_id(struct gtrace_component = *comp, + const struct gtrace_component_id *ids) +{ + const struct gtrace_component_id *id; + + for (id =3D ids; id->version; id++) { + if (comp->id.type !=3D id->type) + continue; + + return id; + } + + return NULL; +} +EXPORT_SYMBOL_GPL(gtrace_match_id); + +static int gtrace_match_device(struct device *dev, const struct device_dri= ver *drv) +{ + const struct gtrace_driver *gtdrv =3D to_gtrace_driver(drv); + struct gtrace_component *comp =3D to_gtrace_component(dev); + + return gtrace_match_id(comp, gtdrv->id_table) ? 1 : 0; +} + +static int gtrace_probe(struct device *dev) +{ + const struct gtrace_driver *gtdrv =3D to_gtrace_driver(dev->driver); + struct gtrace_component *comp =3D to_gtrace_component(dev); + int ret =3D 0; + + if (gtdrv->probe) + ret =3D gtdrv->probe(comp); + + if (!ret) + comp->ready =3D true; + + return ret; +} + +static void gtrace_remove(struct device *dev) +{ + const struct gtrace_driver *gtdrv =3D to_gtrace_driver(dev->driver); + struct gtrace_component *comp =3D to_gtrace_component(dev); + + comp->ready =3D false; + if (gtdrv->remove) + gtdrv->remove(comp); +} + +static const struct bus_type gtrace_bustype =3D { + .name =3D "gtrace", + .match =3D gtrace_match_device, + .probe =3D gtrace_probe, + .remove =3D gtrace_remove, +}; + +struct gtrace_fwnode_match_data { + struct fwnode_handle *fwnode; + struct gtrace_component *match; +}; + +static int gtrace_match_fwnode(struct device *dev, void *data) +{ + struct gtrace_component *comp =3D to_gtrace_component(dev); + struct gtrace_fwnode_match_data *d =3D data; + + if (device_match_fwnode(&comp->dev, d->fwnode)) { + d->match =3D comp; + return 1; + } + + return 0; +} + +struct gtrace_component *gtrace_find_by_fwnode(struct fwnode_handle *fwnod= e) +{ + struct gtrace_fwnode_match_data d =3D { .fwnode =3D fwnode, .match =3D NU= LL }; + int ret; + + ret =3D bus_for_each_dev(>race_bustype, NULL, &d, gtrace_match_fwnode); + if (ret < 0) + return ERR_PTR(ret); + + return d.match; +} +EXPORT_SYMBOL_GPL(gtrace_find_by_fwnode); + +int gtrace_poll_bit(struct gtrace_platform_data *pdata, int offset, + int bit, int bitval, int timeout) +{ + u32 val; + + while (timeout--) { + val =3D gtrace_read32(pdata, offset); + if (((val >> bit) & 0x1) =3D=3D bitval) + break; + udelay(1); + } + + return (timeout < 0) ? -ETIMEDOUT : 0; +} +EXPORT_SYMBOL_GPL(gtrace_poll_bit); + +int gtrace_enable_component(struct gtrace_component *comp) +{ + const struct gtrace_hw_ops *ops =3D comp->pdata->hw_ops; + + if (!ops || !ops->enable) + return -EOPNOTSUPP; + + return ops->enable(comp->pdata); +} +EXPORT_SYMBOL_GPL(gtrace_enable_component); + +int gtrace_disable_component(struct gtrace_component *comp) +{ + const struct gtrace_hw_ops *ops =3D comp->pdata->hw_ops; + + if (!ops || !ops->disable) + return -EOPNOTSUPP; + + return ops->disable(comp->pdata); +} +EXPORT_SYMBOL_GPL(gtrace_disable_component); + +int gtrace_reset_component(struct gtrace_component *comp) +{ + const struct gtrace_hw_ops *ops =3D comp->pdata->hw_ops; + + if (!ops || !ops->reset) + return -EOPNOTSUPP; + + return ops->reset(comp->pdata); +} +EXPORT_SYMBOL_GPL(gtrace_reset_component); + +struct gtrace_component *gtrace_cpu_source(unsigned int cpu) +{ + if (!cpu_present(cpu)) + return NULL; + + return per_cpu(gtrace_cpu_source_comp, cpu); +} +EXPORT_SYMBOL_GPL(gtrace_cpu_source); + +static int gtrace_cleanup_inconn(struct device *dev, void *data) +{ + struct gtrace_component *comp =3D to_gtrace_component(dev); + struct gtrace_platform_data *pdata =3D comp->pdata; + struct gtrace_connection *conn =3D data; + int i; + + if (device_match_fwnode(&comp->dev, conn->dest_fwnode)) { + for (i =3D 0; i < pdata->nr_inconns; i++) { + if (pdata->inconns[i] !=3D conn) + continue; + pdata->inconns[i] =3D NULL; + return 1; + } + } + + return 0; +} + +static void gtrace_cleanup_inconns_from_outconns(struct gtrace_component *= comp) +{ + struct gtrace_platform_data *pdata =3D comp->pdata; + struct gtrace_connection *conn; + int i; + + lockdep_assert_held(>race_mutex); + + for (i =3D 0; i < pdata->nr_outconns; i++) { + conn =3D pdata->outconns[i]; + bus_for_each_dev(>race_bustype, NULL, conn, gtrace_cleanup_inconn); + } +} + +static int gtrace_setup_inconn(struct device *dev, void *data) +{ + struct gtrace_component *comp =3D to_gtrace_component(dev); + struct gtrace_platform_data *pdata =3D comp->pdata; + struct gtrace_connection *conn =3D data; + int i; + + if (device_match_fwnode(&comp->dev, conn->dest_fwnode)) { + for (i =3D 0; i < pdata->nr_inconns; i++) { + if (pdata->inconns[i]) + continue; + pdata->inconns[i] =3D conn; + return 1; + } + } + + return 0; +} + +static int gtrace_setup_inconns_from_outconns(struct gtrace_component *com= p) +{ + struct gtrace_platform_data *pdata =3D comp->pdata; + struct gtrace_connection *conn; + int i, ret; + + lockdep_assert_held(>race_mutex); + + for (i =3D 0; i < pdata->nr_outconns; i++) { + conn =3D pdata->outconns[i]; + ret =3D bus_for_each_dev(>race_bustype, NULL, conn, gtrace_setup_incon= n); + if (ret < 0) { + gtrace_cleanup_inconns_from_outconns(comp); + return ret; + } + } + + return 0; +} + +static void gtrace_component_release(struct device *dev) +{ + struct gtrace_component *comp =3D to_gtrace_component(dev); + + fwnode_handle_put(comp->dev.fwnode); + gtrace_free_type_idx(comp); + kfree(comp); +} + +struct gtrace_component *gtrace_register_component(struct gtrace_component= _id *id, + const char *name, + struct gtrace_platform_data *pdata) +{ + struct gtrace_connection *conn; + struct gtrace_component *comp; + int i, ret =3D 0; + + if (!id || id->type >=3D GTRACE_COMPONENT_TYPE_MAX) { + ret =3D -EINVAL; + goto err_out; + } + + if (!pdata || !pdata->dev) { + ret =3D -EINVAL; + goto err_out; + } + + for (i =3D 0; i < pdata->nr_inconns; i++) { + if (pdata->inconns[i]) { + ret =3D -EINVAL; + goto err_out; + } + } + + for (i =3D 0; i < pdata->nr_outconns; i++) { + conn =3D pdata->outconns[i]; + if (!conn || conn->src_port < 0 || conn->src_comp || + !device_match_fwnode(pdata->dev, conn->src_fwnode) || + conn->dest_port < 0 || !conn->dest_fwnode || !conn->dest_comp) { + ret =3D -EINVAL; + goto err_out; + } + } + + if (pdata->bound_cpu >=3D 0 && !cpu_present(pdata->bound_cpu)) { + ret =3D -EINVAL; + goto err_out; + } + + comp =3D kzalloc(sizeof(*comp), GFP_KERNEL); + if (!comp) { + ret =3D -ENOMEM; + goto err_out; + } + comp->pdata =3D pdata; + comp->id =3D *id; + ret =3D gtrace_alloc_type_idx(comp); + if (ret) { + kfree(comp); + goto err_out; + } + + comp->dev.parent =3D pdata->dev; + comp->dev.coherent_dma_mask =3D pdata->dev->coherent_dma_mask; + comp->dev.release =3D gtrace_component_release; + comp->dev.bus =3D >race_bustype; + comp->dev.fwnode =3D fwnode_handle_get(dev_fwnode(pdata->dev)); + dev_set_name(&comp->dev, "%s-%u", name ? name : "comp", comp->type_idx); + + mutex_lock(>race_mutex); + + ret =3D device_register(&comp->dev); + if (ret) { + put_device(&comp->dev); + goto err_out_unlock; + } + + for (i =3D 0; i < pdata->nr_outconns; i++) { + conn =3D pdata->outconns[i]; + conn->src_comp =3D comp; + } + + ret =3D gtrace_setup_inconns_from_outconns(comp); + if (ret < 0) { + device_unregister(&comp->dev); + goto err_out_unlock; + } + + if (comp->pdata->bound_cpu >=3D 0) { + gtrace_get_component(comp); + per_cpu(gtrace_cpu_source_comp, comp->pdata->bound_cpu) =3D comp; + } + + mutex_unlock(>race_mutex); + + return comp; + +err_out_unlock: + mutex_unlock(>race_mutex); +err_out: + return ERR_PTR(ret); +} +EXPORT_SYMBOL_GPL(gtrace_register_component); + +void gtrace_unregister_component(struct gtrace_component *comp) +{ + struct gtrace_component *c; + + mutex_lock(>race_mutex); + + if (comp->pdata->bound_cpu >=3D 0) { + c =3D per_cpu(gtrace_cpu_source_comp, comp->pdata->bound_cpu); + per_cpu(gtrace_cpu_source_comp, comp->pdata->bound_cpu) =3D NULL; + gtrace_put_component(c); + } + + gtrace_cleanup_inconns_from_outconns(comp); + device_unregister(&comp->dev); + + mutex_unlock(>race_mutex); +} +EXPORT_SYMBOL_GPL(gtrace_unregister_component); + +int __gtrace_register_driver(struct module *owner, struct gtrace_driver *g= tdrv) +{ + gtdrv->driver.owner =3D owner; + gtdrv->driver.bus =3D >race_bustype; + + return driver_register(>drv->driver); +} +EXPORT_SYMBOL_GPL(__gtrace_register_driver); + +static int __init gtrace_init(void) +{ + gtrace_init_type_idx(); + + return bus_register(>race_bustype); +} + +static void __exit gtrace_exit(void) +{ + bus_unregister(>race_bustype); +} + +subsys_initcall(gtrace_init); +module_exit(gtrace_exit); + +MODULE_LICENSE("GPL"); +MODULE_DESCRIPTION("Generic hardware trace (gtrace) framework core"); diff --git a/include/linux/gtrace.h b/include/linux/gtrace.h new file mode 100644 index 000000000000..e8ca2bd46e67 --- /dev/null +++ b/include/linux/gtrace.h @@ -0,0 +1,266 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2026 Qualcomm Technologies, Inc. + */ + +#ifndef __LINUX_GTRACE_H__ +#define __LINUX_GTRACE_H__ + +#include +#include +#include +#include +#include +#include +#include + +/* + * Global list of trace component types across all architectures. Each bac= kend + * uses the entries relevant to it. + */ +enum gtrace_component_type { + GTRACE_RVTRACE_ENCODER, + GTRACE_RVTRACE_FUNNEL, + GTRACE_RVTRACE_RAMSINK, + GTRACE_RVTRACE_PIBSINK, + GTRACE_RVTRACE_ATBBRIDGE, + GTRACE_COMPONENT_TYPE_MAX +}; + +/* Supported usage modes for trace components */ +enum gtrace_component_mode { + GTRACE_COMPONENT_MODE_PERF, + GTRACE_COMPONENT_MODE_MAX +}; + +/** + * struct gtrace_connection - Physical connection between two trace compon= ents. + * @src_port: A connection's source port number. + * @src_fwnode: Source component's fwnode handle. + * @src_comp: Source component's pointer. + * @dest_port: A connection's destination port number. + * @dest_fwnode: Destination component's fwnode handle. + * @dest_comp: Destination component's pointer. + */ +struct gtrace_connection { + int src_port; + struct fwnode_handle *src_fwnode; + int dest_port; + struct fwnode_handle *dest_fwnode; + struct gtrace_component *src_comp; + struct gtrace_component *dest_comp; +}; + +struct gtrace_platform_data; + +/** + * struct gtrace_hw_ops - Architecture-specific low level control of a com= ponent. + * @enable: Enable the component's hardware block. + * @disable: Disable the component's hardware block. + * @reset: Reset the component's hardware block. + * + * These operate on the component's platform data rather than a full + * gtrace_component so that they can be invoked before the component is + * registered with the gtrace core (e.g. to reset the hardware during prob= e). + * + * These abstract the register-level programming that differs between + * architectures (RISC-V Trace Control registers vs ARM CoreSight, etc.). = The + * core never touches component registers directly; it invokes these ops. + */ +struct gtrace_hw_ops { + int (*enable)(struct gtrace_platform_data *pdata); + int (*disable)(struct gtrace_platform_data *pdata); + int (*reset)(struct gtrace_platform_data *pdata); +}; + +/** + * struct gtrace_platform_data - Platform-level data for a trace component + * discovered from DT or ACPI. + * @dev: Parent device. + * @impid: Opaque, architecture-specific implementation ID. + * @hw_ops: Architecture-specific low level control ops. + * @io_mem: Flag showing whether component registers are memory mappe= d. + * @base: If io_mem =3D=3D true then base address of the mapped reg= isters. + * @read: If io_mem =3D=3D false then read register from the given = offset. + * @write: If io_mem =3D=3D false then write register to the given o= ffset. + * @bound_cpu: CPU to which the component is bound, or -1 if unbound. Fo= r a + * source component bound to a CPU this must not be -1. + * @control_poll_timeout_usecs: Delay in usecs when polling control bits. + * @nr_inconns: Number of input connections. + * @inconns: Array of pointers to input connections. + * @nr_outconns: Number of output connections. + * @outconns: Array of pointers to output connections. + */ +struct gtrace_platform_data { + struct device *dev; + + u32 impid; + + const struct gtrace_hw_ops *hw_ops; + + bool io_mem; + union { + void __iomem *base; + struct { + u32 (*read)(struct gtrace_platform_data *pdata, + u32 offset, bool relaxed); + void (*write)(struct gtrace_platform_data *pdata, + u32 val, u32 offset, bool relaxed); + }; + }; + + int bound_cpu; + + /* Delay in microseconds when polling control register bits */ + int control_poll_timeout_usecs; + + /* + * Platform driver must only populate empty pointer array without + * any actual input connections. + */ + unsigned int nr_inconns; + struct gtrace_connection **inconns; + + /* + * Platform driver must fully populate pointer array with individual + * array elements pointing to actual output connections. The src_comp + * of each output connection is automatically updated at the time of + * registering component. + */ + unsigned int nr_outconns; + struct gtrace_connection **outconns; +}; + +static inline u32 gtrace_read32(struct gtrace_platform_data *pdata, u32 of= fset) +{ + if (likely(pdata->io_mem)) + return readl(pdata->base + offset); + + return pdata->read(pdata, offset, false); +} + +static inline u32 gtrace_relaxed_read32(struct gtrace_platform_data *pdata= , u32 offset) +{ + if (likely(pdata->io_mem)) + return readl_relaxed(pdata->base + offset); + + return pdata->read(pdata, offset, true); +} + +static inline void gtrace_write32(struct gtrace_platform_data *pdata, u32 = val, u32 offset) +{ + if (likely(pdata->io_mem)) + writel(val, pdata->base + offset); + else + pdata->write(pdata, val, offset, false); +} + +static inline void gtrace_relaxed_write32(struct gtrace_platform_data *pda= ta, + u32 val, u32 offset) +{ + if (likely(pdata->io_mem)) + writel_relaxed(val, pdata->base + offset); + else + pdata->write(pdata, val, offset, true); +} + +static inline bool gtrace_is_source(struct gtrace_platform_data *pdata) +{ + return !pdata->nr_inconns ? true : false; +} + +static inline bool gtrace_is_sink(struct gtrace_platform_data *pdata) +{ + return !pdata->nr_outconns ? true : false; +} + +/** + * struct gtrace_component_id - Details to identify or match a trace compo= nent. + * @type: Component type from the global gtrace_component_type list. + * @version: Architecture-specific version (opaque to the core). + * @data: Data pointer for driver use. + */ +struct gtrace_component_id { + enum gtrace_component_type type; + u32 version; + void *data; +}; + +/** + * struct gtrace_component - Representation of a trace component. + * @pdata: Pointer to underlying platform data. + * @id: Details to match the component. + * @type_idx: Unique number based on component type. + * @dev: Device instance. + * @ready: Flag showing whether the driver was probed successfully. + */ +struct gtrace_component { + struct gtrace_platform_data *pdata; + struct gtrace_component_id id; + u32 type_idx; + struct device dev; + bool ready; +}; + +#define to_gtrace_component(__dev) container_of_const(__dev, struct gtrace= _component, dev) + +static inline void gtrace_get_component(struct gtrace_component *comp) +{ + get_device(&comp->dev); +} + +static inline void gtrace_put_component(struct gtrace_component *comp) +{ + put_device(&comp->dev); +} + +const struct gtrace_component_id *gtrace_match_id(struct gtrace_component = *comp, + const struct gtrace_component_id *ids); +struct gtrace_component *gtrace_find_by_fwnode(struct fwnode_handle *fwnod= e); + +int gtrace_poll_bit(struct gtrace_platform_data *pdata, int offset, + int bit, int bitval, int timeout); +int gtrace_enable_component(struct gtrace_component *comp); +int gtrace_disable_component(struct gtrace_component *comp); +int gtrace_reset_component(struct gtrace_component *comp); + +struct gtrace_component *gtrace_cpu_source(unsigned int cpu); + +struct gtrace_component *gtrace_register_component(struct gtrace_component= _id *id, + const char *name, + struct gtrace_platform_data *pdata); +void gtrace_unregister_component(struct gtrace_component *comp); + +/** + * struct gtrace_driver - Representation of a trace driver. + * @id_table: Table to match components handled by the driver. + * @probe: Driver probe() function. + * @remove: Driver remove() function. + * @get_trace_id: Get/allocate a trace ID. + * @put_trace_id: Put/free a trace ID. + * @driver: Device driver instance. + */ +struct gtrace_driver { + const struct gtrace_component_id *id_table; + int (*probe)(struct gtrace_component *comp); + void (*remove)(struct gtrace_component *comp); + int (*get_trace_id)(struct gtrace_component *comp, + enum gtrace_component_mode mode); + void (*put_trace_id)(struct gtrace_component *comp, + enum gtrace_component_mode mode, + u32 trace_id); + struct device_driver driver; +}; + +#define to_gtrace_driver(__drv) \ + ((__drv) ? container_of_const((__drv), struct gtrace_driver, driver) : NU= LL) + +int __gtrace_register_driver(struct module *owner, struct gtrace_driver *g= tdrv); +#define gtrace_register_driver(driver) __gtrace_register_driver(THIS_MODUL= E, driver) +static inline void gtrace_unregister_driver(struct gtrace_driver *gtdrv) +{ + if (gtdrv) + driver_unregister(>drv->driver); +} + +#endif /* __LINUX_GTRACE_H__ */ --=20 2.43.0 From nobody Tue Sep 29 08:26:17 2026 Received: from mx0b-0031df01.pphosted.com (mx0b-0031df01.pphosted.com [205.220.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 43767410D15 for ; Mon, 10 Aug 2026 15:23:35 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=205.220.180.131 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375417; cv=none; b=FVsLs8A0n8O1H6lsakGjPJ57vrTOU1ZkWrcvkKWRbTcRLDR/y7Ozvy/hI1CzYi5cii09x6BnWhgmIdj5bQzgTNI3Ggagxm3f83I8RUgPVD2kRxoifmhI+bFi5KaOSbTjHXXeYbyWohsuWoFGS2a7KZ/zraNV1DIY5Id7JsAtq8Q= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375417; c=relaxed/simple; bh=taM84vFCSDxU9T4PpLRoFiDqoqkeHiWHwB/RuWcTBsE=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=ar8gF3YolIQ2Y6eLz7cKth1QZmbUJKioEyTkeEcPBhvtEzKBb28sqFsdbcAVchYCsKRjvOcwE1h+QejEGWBbKvLIRfsOyQ1Esym5XhJHSs3kcpvWaN4fTtyEpxn8LqWU9aOA0JlwNDRhxfJjdfu6jse0sq0aYBrtZN7gJPIYYIw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=oss.qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=XpD0Ag9l; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b=iQIfk9Dq; arc=none smtp.client-ip=205.220.180.131 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="XpD0Ag9l"; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b="iQIfk9Dq" Received: from pps.filterd (m0279872.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 67ACjrc51369197 for ; Mon, 10 Aug 2026 15:23:34 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qualcomm.com; h= cc:content-transfer-encoding:date:from:in-reply-to:message-id :mime-version:references:subject:to; s=qcppdkim1; bh=z+dM5DDsiVw nL9fNxml86eFgdNNsx+UOg0u0nQ6709c=; b=XpD0Ag9lMXWg1tJ+HQGfO578BtG vYik51BVA6uBtVVqaw+BKsfCx5jJxKLQAcEgebBAwcLLc6AAG+cBk1rw/LTupbAG jTN20Y9Zs60msmOyC7NYbTh6gEYlpGst2uus75k7CSeaZT1rIF1jdMjBHa6nSvww TgpKQFooIQjbP1zLCh1d+6uCftidYLJNqRNxOGD5a8GTzTnORWyQi7G8vQStz+VE 9mS5U4xMBW136VN0eb8KHAFqeHEFbjgb+Pt6rbnWQhxCntuePI4qkVKKzXfLp7Nz x3xJk2aBgxHM7BU689WMLg5dxvtWSmoMYNku5SZYZlOGY1pTyCZoGugyzAg== Received: from mail-pf1-f200.google.com (mail-pf1-f200.google.com [209.85.210.200]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4fy8v4a7pm-1 (version=TLSv1.3 cipher=TLS_AES_128_GCM_SHA256 bits=128 verify=NOT) for ; Mon, 10 Aug 2026 15:23:33 +0000 (GMT) Received: by mail-pf1-f200.google.com with SMTP id d2e1a72fcca58-84842381150so3795625b3a.3 for ; Mon, 10 Aug 2026 08:23:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oss.qualcomm.com; s=google; t=1786375412; x=1786980212; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=z+dM5DDsiVwnL9fNxml86eFgdNNsx+UOg0u0nQ6709c=; b=iQIfk9DqGWMnfGoTvxz/wVaf0X5mUdsrN89VWFRskuhNPOOGDp2E8z8UsPpp7xSg9V HiuCVM3hnblJIqd5/3X1k2tUZ81/4CmStXdROsxFqptHzS6ymbZpxPIF70E5YYB2W8ba xZ/buFq0fjMAfn8/KCI9ZsmEu51SIrThv0NxkQD6qn+Xz3DZHNxXH/P6L5vC+s54d6dF fu5DIvIZqhYbC8OMbPBoDI6sQYkjkzF4hy2BlsS9IZOcVrf8BAq6EuKQTOTDNbkxpWo5 asOZL0H+zXiUEjbQkNrTimVd6CEY2Dzo7VZiZn65U8GZRZcYHWHgHX0rvNKvXyt4re9x 10mg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1786375412; x=1786980212; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=z+dM5DDsiVwnL9fNxml86eFgdNNsx+UOg0u0nQ6709c=; b=WQpc6s4w9Rk/omW1LqecrAaabAlKxoWuHRXvr4i0dzGevpQmXqNtXI0J9kUNBVGQ1s U6onoSxWw4BxpJVFFO405T77+PPP07JwAtCMt5XSVM/bR9R+3ciZoeoPmKVl20HT12Tg ZX8noPyBn8r/XowKLNR52DvtRON/kaItkxx7D5uPvQxiH59xuyqitwLEvfGLSMU8vkIt G5QUmKhe3UD07DtAymQSz+2YwM63Idp1SigHYWgEcRPuDM2EPng1o3iV6yKgWWE4gpPj RwJ9gsizuXSIj5QaYltYj8YdGLc7dehGN5X0WS4uJ8CDiyIufNrZLF9XYvF6wWl5dqPC Wy0w== X-Forwarded-Encrypted: i=1; AHgh+RqImnnI/XBFRZVjxX7B5WrlBATCCfv5G9SwGg6RlgLt0r+CaPxdd4ZnpaoLdMVdDwUXSa56ql4mbRY23Jw=@vger.kernel.org X-Gm-Message-State: AOJu0YwMCprH/hDdNUDE63wdiHK95USVfoJMnysexpuP6/+j7LCRCQ0f nh0OqOditQOaBjkPapu63Gg1MUOVVBPZgf3o5ZIRIny8H6jSOjGffP63a2rO+w8iN2AxEFmii8P fLh/rb5Te5mZVBW6OatF27JGsimVAUzrmtpuQTd7ElwljgfzhVO0YGhiV8FMwLgQkSeE= X-Gm-Gg: AR+sD10YlsPhBokcGoI6iQGUBqQfFGK+xmm7oYYAeG42r+MV4KAw4hlw4QJcCkttXLl 1Vs9jBJGy/f0WnOHxwUjyC+H7A9I8fkrttuaS4hgFegR0ASkDOxblXfnxZR5mvd1oIYSc1IUZKq JcfM87p7HQlMjwJ6sfGj88BK5JoEWPGAzKbxR88j95VDPdLhK6rqTP21kI+HLBCVv5czeBpb1Qc CMEHBumC4UuQTvCloMYJMhoWJk818FZrQOYSMOLhIV45x9+aELEVBqziUM5U9O0maBvps/WGRyS 2Bl+fGZWMZ92hsIXE+F63YM0qo6oStDlN8d9Jie86nhWU0Sd+IRmGj9s6OGTBvo44aY9R726Uru d6FtowHs386du4jmKQgoSYgXXK6U3C76rI/YWBqp47sclG9wz6OLefrjfDy+5DYMFvO2AJ6qBpR WbFsR+UGkBLNxAVTSLdwoy6z3vCw== X-Received: by 2002:a05:6a00:2999:b0:848:67ca:bfd with SMTP id d2e1a72fcca58-84f2dff1913mr51002052b3a.16.1786375412188; Mon, 10 Aug 2026 08:23:32 -0700 (PDT) X-Received: by 2002:a05:6a00:2999:b0:848:67ca:bfd with SMTP id d2e1a72fcca58-84f2dff1913mr51001953b3a.16.1786375411535; Mon, 10 Aug 2026 08:23:31 -0700 (PDT) Received: from hu-mchitale-blr.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com. [103.229.18.19]) by smtp.googlemail.com with ESMTPSA id 41be03b00d2f7-cbe8f1af985sm4282634a12.11.2026.08.10.08.23.24 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Aug 2026 08:23:31 -0700 (PDT) From: Mayuresh Chitale To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Anup Patel , Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Mayuresh Chitale , Anup Patel , Atish Patra , Andrew Jones , Sunil V L , linux-riscv@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, Mayuresh Chitale Subject: [PATCH v5 03/14] gtrace: Add RISC-V platform driver for the gtrace framework Date: Mon, 10 Aug 2026 20:52:05 +0530 Message-ID: <20260810152223.3946743-4-mayuresh.chitale@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> References: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-ORIG-GUID: YO0cWP_279_C8YjaekD58PLTet3nGC22 X-Proofpoint-Spam-Info: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX4ESOYj5qb1kO fhsd31ZNR5o3sTq4BVwcKhKpurwGYc4nAaT+AnRzgzUdxpZ9LGw0v+BtUsVj/bYycbx5KdxilQ1 1/3XMD0W7KmA/57Xbq9IDWVy1dQ0YXs= X-Authority-Analysis: v=2.4 cv=W5EIkxWk c=1 sm=1 tr=0 ts=6a79ecf5 cx=c_pps a=mDZGXZTwRPZaeRUbqKGCBw==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=Sv0fKeRqtYgA:10 a=s4-Qcg_JpJYA:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=yx91gb_oNiZeI1HMLzn7:22 a=EUspDBNiAAAA:8 a=t0Z0ZKfJV8hCQccVx-oA:9 a=zc0IvFSfCIW2DFIPzwfm:22 X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX/B6k5NyzQei5 IGCIVUgvZbkTvSIJij3Qy9OeMDg5sZHWnIoJYRjUQ5GKIdLmacLpiqnSQ08LMYV6F3OEfn3jLHw sOEDRVbwyJKGSNhWEng3rFdyJKgWPr59NCtBlmi41X/tAy/RpKkr8b+I7XKA17OynbgdaP7YPPB u+1qGigmg5g6By2Qb9GkhgMThhq3JPKegWkJ406L7lzkU/f5Fw0pf06CZjP/GuaMrNTnw3h+sd/ DxLOIVdPN3C2uwhzU53Mwg9JCBcM8aPju1saQRvgrDZUn8KQIFwJdsH12rutK667sWKsBHM6Uca VEBD9zQAOJZBs7PrTCP9KjsrNKTzF5kMvay+f5MGLaarEd96BwCjfxXgv5SXU6Nxh4VV83rhMej Hk15QLuH1aarM+isL8E5BugA2KTxvoBdrTtUda32Ei95wuyaR6wq9wdeDCNIyIloxrvCpWnhUyV eYLZRWJaOAH5Ww0rWRw== X-Proofpoint-GUID: YO0cWP_279_C8YjaekD58PLTet3nGC22 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1176,Hydra:6.1.134,FMLib:17.12.100.49 definitions=2026-08-10_03,2026-08-07_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 suspectscore=0 lowpriorityscore=0 priorityscore=1501 phishscore=0 clxscore=1015 adultscore=0 bulkscore=0 spamscore=0 impostorscore=0 malwarescore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2606150000 definitions=main-2608100132 Content-Type: text/plain; charset="utf-8" From: Anup Patel The RISC-V trace components defined by the RISC-V Trace Control Interface Specification are memory mapped devices which are organized in a graph-like topology and described in the device tree. Add the RISC-V platform driver for the gtrace framework. The driver parses the RISC-V component topology from the device tree, discovers the type and version of each component from its IMPL register, provides the RISC-V register level control ops and registers each component with the gtrace core. Co-developed-by: Mayuresh Chitale Signed-off-by: Mayuresh Chitale Signed-off-by: Anup Patel --- drivers/hwtracing/gtrace/Kconfig | 15 + drivers/hwtracing/gtrace/Makefile | 2 + drivers/hwtracing/gtrace/rvtrace-platform.c | 286 ++++++++++++++++++++ drivers/hwtracing/gtrace/rvtrace.h | 121 +++++++++ 4 files changed, 424 insertions(+) create mode 100644 drivers/hwtracing/gtrace/rvtrace-platform.c create mode 100644 drivers/hwtracing/gtrace/rvtrace.h diff --git a/drivers/hwtracing/gtrace/Kconfig b/drivers/hwtracing/gtrace/Kc= onfig index bcc3b4169a76..04986f216549 100644 --- a/drivers/hwtracing/gtrace/Kconfig +++ b/drivers/hwtracing/gtrace/Kconfig @@ -13,3 +13,18 @@ menuconfig GTRACE =20 To compile this driver as a module, choose M here: the module will be called gtrace. + +config RVTRACE + tristate "RISC-V Trace Support" + depends on RISCV + depends on OF + depends on GTRACE + default RISCV + help + This provides the RISC-V backend for the generic hardware trace + (gtrace) framework. It parses the RISC-V trace component topology, + provides the RISC-V register-level control ops and registers each + component with the gtrace core. + + To compile this driver as a module, choose M here: the module + will be called rvtrace. diff --git a/drivers/hwtracing/gtrace/Makefile b/drivers/hwtracing/gtrace/M= akefile index 3f90fb99c514..cf02316c1bbf 100644 --- a/drivers/hwtracing/gtrace/Makefile +++ b/drivers/hwtracing/gtrace/Makefile @@ -2,3 +2,5 @@ =20 obj-$(CONFIG_GTRACE) +=3D gtrace.o gtrace-y :=3D gtrace-core.o + +obj-$(CONFIG_RVTRACE) +=3D rvtrace-platform.o diff --git a/drivers/hwtracing/gtrace/rvtrace-platform.c b/drivers/hwtracin= g/gtrace/rvtrace-platform.c new file mode 100644 index 000000000000..f34de9183d9a --- /dev/null +++ b/drivers/hwtracing/gtrace/rvtrace-platform.c @@ -0,0 +1,286 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2026 Qualcomm Technologies, Inc. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "rvtrace.h" + +static int rvtrace_hw_enable(struct gtrace_platform_data *pdata) +{ + u32 val; + + val =3D gtrace_read32(pdata, RVTRACE_COMPONENT_CTRL_OFFSET); + val |=3D BIT(RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT); + gtrace_write32(pdata, val, RVTRACE_COMPONENT_CTRL_OFFSET); + return gtrace_poll_bit(pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT, 1, + pdata->control_poll_timeout_usecs); +} + +static int rvtrace_hw_disable(struct gtrace_platform_data *pdata) +{ + u32 val; + + val =3D gtrace_read32(pdata, RVTRACE_COMPONENT_CTRL_OFFSET); + val &=3D ~BIT(RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT); + gtrace_write32(pdata, val, RVTRACE_COMPONENT_CTRL_OFFSET); + return gtrace_poll_bit(pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT, 0, + pdata->control_poll_timeout_usecs); +} + +static int rvtrace_hw_reset(struct gtrace_platform_data *pdata) +{ + int ret; + + gtrace_write32(pdata, 0, RVTRACE_COMPONENT_CTRL_OFFSET); + ret =3D gtrace_poll_bit(pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ACTIVE_SHIFT, 0, + pdata->control_poll_timeout_usecs); + if (ret) + return ret; + + gtrace_write32(pdata, RVTRACE_COMPONENT_CTRL_ACTIVE_MASK, + RVTRACE_COMPONENT_CTRL_OFFSET); + return gtrace_poll_bit(pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ACTIVE_SHIFT, 1, + pdata->control_poll_timeout_usecs); +} + +const struct gtrace_hw_ops rvtrace_hw_ops =3D { + .enable =3D rvtrace_hw_enable, + .disable =3D rvtrace_hw_disable, + .reset =3D rvtrace_hw_reset, +}; + +static int rvtrace_of_parse_outconns(struct gtrace_platform_data *pdata) +{ + struct device_node *parent, *ep_node, *rep_node, *rdev_node; + struct gtrace_connection *conn; + struct of_endpoint ep, rep; + int ret =3D 0, i =3D 0; + + parent =3D of_get_child_by_name(dev_of_node(pdata->dev), "out-ports"); + if (!parent) + return 0; + + pdata->nr_outconns =3D of_graph_get_endpoint_count(parent); + pdata->outconns =3D devm_kcalloc(pdata->dev, pdata->nr_outconns, + sizeof(*pdata->outconns), GFP_KERNEL); + if (!pdata->outconns) { + ret =3D -ENOMEM; + goto done; + } + + for_each_endpoint_of_node(parent, ep_node) { + conn =3D devm_kzalloc(pdata->dev, sizeof(*conn), GFP_KERNEL); + if (!conn) { + of_node_put(ep_node); + ret =3D -ENOMEM; + break; + } + + ret =3D of_graph_parse_endpoint(ep_node, &ep); + if (ret) { + of_node_put(ep_node); + break; + } + + rep_node =3D of_graph_get_remote_endpoint(ep_node); + if (!rep_node) { + ret =3D -ENODEV; + of_node_put(ep_node); + break; + } + rdev_node =3D of_graph_get_port_parent(rep_node); + + ret =3D of_graph_parse_endpoint(rep_node, &rep); + if (ret) { + of_node_put(ep_node); + of_node_put(rep_node); + of_node_put(rdev_node); + break; + } + + conn->src_port =3D ep.port; + conn->src_fwnode =3D dev_fwnode(pdata->dev); + /* The 'src_comp' is set by gtrace_register_component() */ + conn->src_comp =3D NULL; + conn->dest_port =3D rep.port; + conn->dest_fwnode =3D of_fwnode_handle(rdev_node); + fwnode_handle_get(conn->dest_fwnode); + conn->dest_comp =3D gtrace_find_by_fwnode(conn->dest_fwnode); + if (!conn->dest_comp) { + ret =3D -EPROBE_DEFER; + of_node_put(ep_node); + of_node_put(rep_node); + of_node_put(rdev_node); + break; + } + + pdata->outconns[i] =3D conn; + i++; + } + +done: + if (ret) { + for (i =3D 0; i < pdata->nr_outconns && pdata->outconns; i++) { + conn =3D pdata->outconns[i]; + if (conn && conn->dest_fwnode) + fwnode_handle_put(conn->dest_fwnode); + } + } + of_node_put(parent); + return ret; +} + +static int rvtrace_of_parse_inconns(struct gtrace_platform_data *pdata) +{ + struct device_node *parent; + int ret =3D 0; + + parent =3D of_get_child_by_name(dev_of_node(pdata->dev), "in-ports"); + if (!parent) + return 0; + + pdata->nr_inconns =3D of_graph_get_endpoint_count(parent); + pdata->inconns =3D devm_kcalloc(pdata->dev, pdata->nr_inconns, + sizeof(*pdata->inconns), GFP_KERNEL); + if (!pdata->inconns) + ret =3D -ENOMEM; + + of_node_put(parent); + return ret; +} + +static int rvtrace_platform_probe(struct platform_device *pdev) +{ + struct gtrace_platform_data *pdata; + struct device *dev =3D &pdev->dev; + struct gtrace_component_id id; + struct gtrace_component *comp; + u32 impl, type, major, minor; + struct device_node *node; + struct resource *res; + int gtype; + int ret; + + pdata =3D devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); + if (!pdata) + return -ENOMEM; + pdata->dev =3D dev; + pdata->impid =3D RVTRACE_COMPONENT_IMPID_UNKNOWN; + pdata->hw_ops =3D &rvtrace_hw_ops; + + res =3D platform_get_resource(pdev, IORESOURCE_MEM, 0); + if (!res) + return -EINVAL; + + pdata->io_mem =3D true; + pdata->base =3D devm_ioremap(&pdev->dev, res->start, resource_size(res)); + if (!pdata->base) + return dev_err_probe(dev, -ENOMEM, "failed to ioremap %pR\n", res); + + pdata->bound_cpu =3D -1; + node =3D of_parse_phandle(dev_of_node(dev), "cpus", 0); + if (node) { + ret =3D of_cpu_node_to_id(node); + of_node_put(node); + if (ret < 0) + return dev_err_probe(dev, ret, "failed to get CPU id for %pOF\n", node); + pdata->bound_cpu =3D ret; + } + + /* Default control poll timeout */ + pdata->control_poll_timeout_usecs =3D 10; + + ret =3D rvtrace_of_parse_outconns(pdata); + if (ret) + return dev_err_probe(dev, ret, "failed to parse output connections\n"); + + ret =3D rvtrace_of_parse_inconns(pdata); + if (ret) + return dev_err_probe(dev, ret, "failed to parse input connections\n"); + + /* Reset the component before it is registered with the gtrace core. */ + ret =3D rvtrace_hw_reset(pdata); + if (ret) + return dev_err_probe(dev, ret, "failed to reset component\n"); + + impl =3D gtrace_read32(pdata, RVTRACE_COMPONENT_IMPL_OFFSET); + type =3D (impl >> RVTRACE_COMPONENT_IMPL_TYPE_SHIFT) & + RVTRACE_COMPONENT_IMPL_TYPE_MASK; + major =3D (impl >> RVTRACE_COMPONENT_IMPL_VERMAJOR_SHIFT) & + RVTRACE_COMPONENT_IMPL_VERMAJOR_MASK; + minor =3D (impl >> RVTRACE_COMPONENT_IMPL_VERMINOR_SHIFT) & + RVTRACE_COMPONENT_IMPL_VERMINOR_MASK; + + gtype =3D rvtrace_type_to_gtrace(type); + if (gtype < 0) + return dev_err_probe(dev, -ENODEV, "unsupported component type %u\n", ty= pe); + + id.type =3D gtype; + id.version =3D rvtrace_component_mkversion(major, minor); + + comp =3D gtrace_register_component(&id, rvtrace_type_name(gtype), pdata); + if (IS_ERR(comp)) + return PTR_ERR(comp); + + platform_set_drvdata(pdev, comp); + return 0; +} + +static void rvtrace_platform_remove(struct platform_device *pdev) +{ + struct gtrace_component *comp =3D platform_get_drvdata(pdev); + struct gtrace_platform_data *pdata =3D comp->pdata; + struct gtrace_connection *conn; + int i; + + for (i =3D 0; i < pdata->nr_outconns; i++) { + conn =3D pdata->outconns[i]; + if (conn && conn->dest_fwnode) + fwnode_handle_put(conn->dest_fwnode); + } + + gtrace_unregister_component(comp); +} + +static const struct of_device_id rvtrace_platform_match[] =3D { + { .compatible =3D "riscv,trace-component" }, + {} +}; + +static struct platform_driver rvtrace_platform_driver =3D { + .driver =3D { + .name =3D "rvtrace", + .of_match_table =3D rvtrace_platform_match, + }, + .probe =3D rvtrace_platform_probe, + .remove =3D rvtrace_platform_remove, +}; + +static int __init rvtrace_platform_init(void) +{ + return platform_driver_register(&rvtrace_platform_driver); +} + +static void __exit rvtrace_platform_exit(void) +{ + platform_driver_unregister(&rvtrace_platform_driver); +} + +module_init(rvtrace_platform_init); +module_exit(rvtrace_platform_exit); + +MODULE_AUTHOR("Anup Patel"); +MODULE_DESCRIPTION("RISC-V backend for the generic trace framework"); +MODULE_LICENSE("GPL"); diff --git a/drivers/hwtracing/gtrace/rvtrace.h b/drivers/hwtracing/gtrace/= rvtrace.h new file mode 100644 index 000000000000..e6be1ce303cc --- /dev/null +++ b/drivers/hwtracing/gtrace/rvtrace.h @@ -0,0 +1,121 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2026 Qualcomm Technologies, Inc. + * + * RISC-V trace component register layout and helpers for the RISC-V backe= nd + * of the generic trace (gtrace) framework. These definitions are specific= to + * the RISC-V Trace Control Interface and must not be used by the generic = core. + */ + +#ifndef __LINUX_RVTRACE_H__ +#define __LINUX_RVTRACE_H__ + +#include +#include + +/* Control register common across all RISC-V trace components */ +#define RVTRACE_COMPONENT_CTRL_OFFSET 0x000 +#define RVTRACE_COMPONENT_CTRL_ACTIVE_MASK 0x1 +#define RVTRACE_COMPONENT_CTRL_ACTIVE_SHIFT 0 +#define RVTRACE_COMPONENT_CTRL_ENABLE_MASK 0x1 +#define RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT 1 +#define RVTRACE_COMPONENT_CTRL_EMPTY_SHIFT 3 + +/* Implementation register common across all RISC-V trace components */ +#define RVTRACE_COMPONENT_IMPL_OFFSET 0x004 +#define RVTRACE_COMPONENT_IMPL_VERMAJOR_MASK 0xf +#define RVTRACE_COMPONENT_IMPL_VERMAJOR_SHIFT 0 +#define RVTRACE_COMPONENT_IMPL_VERMINOR_MASK 0xf +#define RVTRACE_COMPONENT_IMPL_VERMINOR_SHIFT 4 +#define RVTRACE_COMPONENT_IMPL_TYPE_MASK 0xf +#define RVTRACE_COMPONENT_IMPL_TYPE_SHIFT 8 + +/* Component types defined by the RISC-V Trace Control Interface */ +enum rvtrace_component_type { + RVTRACE_COMPONENT_TYPE_RESV0, + RVTRACE_COMPONENT_TYPE_ENCODER, /* 0x1 */ + RVTRACE_COMPONENT_TYPE_RESV2, + RVTRACE_COMPONENT_TYPE_RESV3, + RVTRACE_COMPONENT_TYPE_RESV4, + RVTRACE_COMPONENT_TYPE_RESV5, + RVTRACE_COMPONENT_TYPE_RESV6, + RVTRACE_COMPONENT_TYPE_RESV7, + RVTRACE_COMPONENT_TYPE_FUNNEL, /* 0x8 */ + RVTRACE_COMPONENT_TYPE_RAMSINK, /* 0x9 */ + RVTRACE_COMPONENT_TYPE_PIBSINK, /* 0xA */ + RVTRACE_COMPONENT_TYPE_RESV11, + RVTRACE_COMPONENT_TYPE_RESV12, + RVTRACE_COMPONENT_TYPE_RESV13, + RVTRACE_COMPONENT_TYPE_ATBBRIDGE, /* 0xE */ + RVTRACE_COMPONENT_TYPE_RESV15, + RVTRACE_COMPONENT_TYPE_MAX +}; + +/* + * Possible component implementation IDs discovered from DT or ACPI + * shared across the RISC-V trace drivers to infer trace parameters, + * quirks, and work-arounds. These component implementation IDs are + * internal to Linux and must not be exposed to user-space. + * + * The component implementation ID should be named as follows: + * RVTRACE_COMPONENT_IMPID__ + */ +enum rvtrace_component_impid { + RVTRACE_COMPONENT_IMPID_UNKNOWN, + RVTRACE_COMPONENT_IMPID_MAX +}; + +#define rvtrace_component_version_major(__version) \ + (((__version) >> 16) & 0xffff) +#define rvtrace_component_version_minor(__version) \ + ((__version) & 0xffff) +#define rvtrace_component_mkversion(__major, __minor) \ + ((((__major) & 0xffff) << 16) | ((__minor) & 0xffff)) + +/* Map a RISC-V hardware component type to the global gtrace type */ +static inline int rvtrace_type_to_gtrace(enum rvtrace_component_type type) +{ + switch (type) { + case RVTRACE_COMPONENT_TYPE_ENCODER: + return GTRACE_RVTRACE_ENCODER; + case RVTRACE_COMPONENT_TYPE_FUNNEL: + return GTRACE_RVTRACE_FUNNEL; + case RVTRACE_COMPONENT_TYPE_RAMSINK: + return GTRACE_RVTRACE_RAMSINK; + case RVTRACE_COMPONENT_TYPE_PIBSINK: + return GTRACE_RVTRACE_PIBSINK; + case RVTRACE_COMPONENT_TYPE_ATBBRIDGE: + return GTRACE_RVTRACE_ATBBRIDGE; + default: + return -EINVAL; + } +} + +static inline const char *rvtrace_type_name(enum gtrace_component_type typ= e) +{ + switch (type) { + case GTRACE_RVTRACE_ENCODER: + return "encoder"; + case GTRACE_RVTRACE_FUNNEL: + return "funnel"; + case GTRACE_RVTRACE_RAMSINK: + return "ramsink"; + case GTRACE_RVTRACE_PIBSINK: + return "pibsink"; + case GTRACE_RVTRACE_ATBBRIDGE: + return "atbbridge"; + default: + return NULL; + } +} + +static inline int rvtrace_comp_poll_empty(struct gtrace_component *comp) +{ + return gtrace_poll_bit(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_EMPTY_SHIFT, 1, + comp->pdata->control_poll_timeout_usecs); +} + +extern const struct gtrace_hw_ops rvtrace_hw_ops; + +#endif /* __LINUX_RVTRACE_H__ */ --=20 2.43.0 From nobody Tue Sep 29 08:26:17 2026 Received: from mx0a-0031df01.pphosted.com (mx0a-0031df01.pphosted.com [205.220.168.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B16D6417BF9 for ; Mon, 10 Aug 2026 15:23:41 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=205.220.168.131 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375423; cv=none; b=tWHftu/8gWp4yihWhvWhreJiT85Yo5ah2Xc7kcg6p0LkqeM2GVConSLIACcGB8y0sZNKpXnXJ6hco9F/DhhJNbyZ5NbFeNSZn2lbf/KIou7D0TpPdowxaukvmiAIxpLEi74FO7Xbxi2dtBjxjzkzLe6G5f5KaqzebvjwLZjA4Qo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375423; c=relaxed/simple; bh=/qaIWdPczgfTg2JuUKchYXyLOX26UzBCYHfxx72y8UE=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=RF3c6ysujzow9RYTlFuFZf7WHQsWCBCGB8nvJGipFSnDr7L5sdiIdF4t/23Cj46Ev34qdDI4Z1s06Kib7naZ1LZhHm8bmI56XzWQm/+nhrE9FE7RZFakzhZgBIw4zUJFLf1WjfUaupnlQLxwa+IMpCVBXqww/fVpbfEq5dZwcZg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=oss.qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=X69xIKWu; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b=Sr1Tj0Cu; arc=none smtp.client-ip=205.220.168.131 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="X69xIKWu"; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b="Sr1Tj0Cu" Received: from pps.filterd (m0279864.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 67ACj3FL915820 for ; Mon, 10 Aug 2026 15:23:41 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qualcomm.com; h= cc:content-transfer-encoding:date:from:in-reply-to:message-id :mime-version:references:subject:to; s=qcppdkim1; bh=ppv6/+v9uVe vJFb5FIxPNtQrsBx+IieOd9pY+4ba1bM=; b=X69xIKWu6fWyQ+ZVwupH7YJO3nK ahBgH4pOCGfltc34ioXuUkM+fU+KQ6pkNe6HZfUMpWBrXHn8EuaebiIHpHUQKQjI V3Z1k6dmRY/YGzVeRsfG2uRhhs1/+EtMl9446pBW9TZSOCSReHqkm6pz78HxMyXV ppUbagr50tFFuAibSsQ7GpB1EaiapuN8cvySIub/tIzJ8ZfclJBVcFmARW2hdeAd ifafM02ZOKrqVoK8TiN2EVEqho9mOcNNQtyk3a8wuHtUW+yeIHdqVhOSkwGs0hPX ltho4+atljcoF/Nuap4FKLdKczGh+ib3mrCmKei9heFdwSuEEFzgIKTCltw== Received: from mail-pg1-f200.google.com (mail-pg1-f200.google.com [209.85.215.200]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4fy8v92741-1 (version=TLSv1.3 cipher=TLS_AES_128_GCM_SHA256 bits=128 verify=NOT) for ; Mon, 10 Aug 2026 15:23:40 +0000 (GMT) Received: by mail-pg1-f200.google.com with SMTP id 41be03b00d2f7-ca6bd8a190cso3118976a12.0 for ; Mon, 10 Aug 2026 08:23:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oss.qualcomm.com; s=google; t=1786375420; x=1786980220; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=ppv6/+v9uVevJFb5FIxPNtQrsBx+IieOd9pY+4ba1bM=; b=Sr1Tj0Cux+yvt9veVKh6/gB5sC60HNNkjdLiiNg2pbrvD/FevXGNVZUZ+4RYr6a5+u uWrpbqU8giiAfduWrR61qYJC/89dVoqPhsW6WhKWhsLT1Zo2BVHAbZRiY42ERPjHKmw8 D+YY9SqXutzL5uC5vb6QnCdx1duHVfPgvy9SFdY9pSOaw9ni9TPR7m+UtdnfMAAeLFZJ RqSdtmwJLbXoTwOmi5I3NzYoVxrQsum6r/h3FLlnktL53akBXiiBLcbV7pVrHcVyYKl5 B/b1kT0m1BD/0buJToiWBDkaEFVYP/vyuWy+gS/OyOYix9BEGFZmoQAR6y3mH9AgokoU CFuQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1786375420; x=1786980220; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=ppv6/+v9uVevJFb5FIxPNtQrsBx+IieOd9pY+4ba1bM=; b=s3DcPbZyCiLUkqT//qGPqX5N8s3LIX3n+QTKLPdvCaPWptj8WDHspdhqDo6bmoELKN ThECXW3niXa3BebmHJIZllI6eqpkILnHSNzR2kXdCI0WU4M1CxNDp5Gwt97R+PAL8VlS W6+EHrUrr0qu3uc9W6YtU1DQH8awIKCmlfG2Jr7NO4hf8EHkjcdCHnbg9Rh0Xqv7+UJY VGLlwUxWUY2vOOl2PnTfJpGKg8HoMyupqF53jBW+B2tom/0PV7gJt32NEB4tnp/RMDHX i/xazY570Pmohn2tltHZetFSMaCfLH5xAOz1meAfG1bs9LIKB5/qUEfKPUJwndtV8+Tm 6F/w== X-Forwarded-Encrypted: i=1; AHgh+Rr/ldAjwI9EByvJFZjVdg8KZQwxTsOPVt7ZQFs6BrXBmvWsMTarUnK6tuW6374W5sDYbOe6PV08dHT3r+Q=@vger.kernel.org X-Gm-Message-State: AOJu0Yy+03Zk8mVjqpI6S77CazTiscrJjNUmB7U+Wz+dbhMk3YcK11gi acROsPe/qHxTXuALpIOM+1fzwaRiqBTEyjPwKINmJLcpMbv1o6KR+F1+wN146AKjt/UkSOZk5hW xVeJ1tbm/YwKcGhJLVJ2LERCf0RLEey1wmHdaM5DifjBNaubV0kvkEkdWVhHHQUT4xQg= X-Gm-Gg: AR+sD10jcjJx5xFIhXS6G7QgWpzQS2YQPlUdTlXOt6gYFLZIlc6gBEOMG0EVc1LpOTH obzy3FmLMq9ZLXFnniPfB0tDK4CTYXAiwZrdSxHOPz7yc+yvyNAfR/3tzhxywCiiA6X+S4jgJ0R fDKJp231ix5NcPU8e24D6lnevFhjrYD2LS7yGXqTsh91E9YCX1eXzXFz4cv6rLJacB1+rCCTSJt 0we9mYMgxfhS4cHfWeh3I5xmsWHPwmCFyQSConiqfTugBeIfYyDz82a/tylLpPzd41zISwe6pAk SsVPiWqUBVNPKU0HhYErVTXS0g3KAzxHndbpE3bZQvGr6fxs3nkKlvCdxc49N8loXN9y7J8+oQl IA7wDE1GvRjxsLGLtwNNCku1Vm3sNp9U6kvwK1ywmu7tT4FJBvkpaCVMoK2unqZqkYR2nCgnh3Z b07czFCqJ3SeX5T5Bg/71nF5Fo8w== X-Received: by 2002:a05:6a21:6e03:b0:3cb:9bb0:27a2 with SMTP id adf61e73a8af0-3cbce9e4f6cmr25124029637.34.1786375419844; Mon, 10 Aug 2026 08:23:39 -0700 (PDT) X-Received: by 2002:a05:6a21:6e03:b0:3cb:9bb0:27a2 with SMTP id adf61e73a8af0-3cbce9e4f6cmr25123911637.34.1786375419087; Mon, 10 Aug 2026 08:23:39 -0700 (PDT) Received: from hu-mchitale-blr.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com. [103.229.18.19]) by smtp.googlemail.com with ESMTPSA id 41be03b00d2f7-cbe8f1af985sm4282634a12.11.2026.08.10.08.23.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Aug 2026 08:23:38 -0700 (PDT) From: Mayuresh Chitale To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Anup Patel , Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Mayuresh Chitale , Anup Patel , Atish Patra , Andrew Jones , Sunil V L , linux-riscv@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, Mayuresh Chitale Subject: [PATCH v5 04/14] gtrace: Add functions to create/destroy a trace component path Date: Mon, 10 Aug 2026 20:52:06 +0530 Message-ID: <20260810152223.3946743-5-mayuresh.chitale@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> References: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-Spam-Info: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX2DFCJ7QWaZJG GU9eRbRjlywTCwwU/raLr4kgHsjI6DgBfTNiIRGQtSw3krUZU+desuuilUiZATZlSqNv/LX1IHs DuxcQzal8goMFEFZqM20H+ZF1X8UCYs= X-Proofpoint-ORIG-GUID: t69Wi-PLks98sNDdKFLRvebrF0lY3Drj X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX3YhbGd6QGPVu Alvzut12qT6FTwIlfWgv2I+cdfMAZl9dJ5BWIl98ySYakTcCpRfe5MzEVogcchemjp/XO9a0Eji SOqnmmcdbjvAmNDpIdIPkpM7lR7XSPQZbpMIPSVMa0jt5khednXwdmZnAjwxFsq1iUFFuRl8umY 0f0rqBMdhrAk2B34xa1tMH+RBqJS1paOknmQN9yBw9d2Dk22n421rTm8gQzWQYgrkscGqf97Dl2 6i9youQPmmhnqa0bIemXzrK7LyK0sv0qOM2Tby58KoOAnP3cgPedIklzmISCH/j0caI0VDpOKw9 W3QZ2gWBt5RIFLCtB1Msu2fi62iiChIB83o6KIhogNDixuEX64E1aKUOlt3e2x0ZUrHIj0TsDWd JKVF64679XA+ML784y6F7NkxF0x3BOHPD5Jb7u141TmOAXRKhy9B7ad2C9t0PCXt2m/DQ34YG2H GN4JbjW1oCQpwxEeDDA== X-Authority-Analysis: v=2.4 cv=T5m8ifKQ c=1 sm=1 tr=0 ts=6a79ecfc cx=c_pps a=oF/VQ+ItUULfLr/lQ2/icg==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=Sv0fKeRqtYgA:10 a=s4-Qcg_JpJYA:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=DJpcGTmdVt4CTyJn9g5Z:22 a=EUspDBNiAAAA:8 a=rnG_eT2C7D_P6d9BKjkA:9 a=3WC7DwWrALyhR5TkjVHa:22 X-Proofpoint-GUID: t69Wi-PLks98sNDdKFLRvebrF0lY3Drj X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1176,Hydra:6.1.134,FMLib:17.12.100.49 definitions=2026-08-10_03,2026-08-07_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 impostorscore=0 adultscore=0 clxscore=1015 suspectscore=0 phishscore=0 spamscore=0 malwarescore=0 priorityscore=1501 bulkscore=0 lowpriorityscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2606150000 definitions=main-2608100132 Content-Type: text/plain; charset="utf-8" From: Anup Patel Trace needs to be configured on a chain of trace components which are connected to each other. These chain of components is also referred to as trace component path. Add functions to create/destroy a trace component path which will be later used by gtrace perf support. Co-developed-by: Mayuresh Chitale Signed-off-by: Mayuresh Chitale Signed-off-by: Anup Patel --- drivers/hwtracing/gtrace/gtrace-core.c | 223 +++++++++++++++++++++++++ include/linux/gtrace.h | 24 +++ 2 files changed, 247 insertions(+) diff --git a/drivers/hwtracing/gtrace/gtrace-core.c b/drivers/hwtracing/gtr= ace/gtrace-core.c index 97398f2b7cbb..a89d195ab5b8 100644 --- a/drivers/hwtracing/gtrace/gtrace-core.c +++ b/drivers/hwtracing/gtrace/gtrace-core.c @@ -210,6 +210,53 @@ int gtrace_reset_component(struct gtrace_component *co= mp) } EXPORT_SYMBOL_GPL(gtrace_reset_component); =20 +static int __gtrace_walk_output_components(struct gtrace_component *comp, + bool *stop, void *priv, + int (*fn)(struct gtrace_component *comp, bool *stop, + struct gtrace_connection *stop_conn, + void *priv)) +{ + struct gtrace_connection *conn, *stop_conn =3D NULL; + struct gtrace_platform_data *pdata =3D comp->pdata; + int i, ret; + + for (i =3D 0; i < pdata->nr_outconns; i++) { + conn =3D pdata->outconns[i]; + ret =3D __gtrace_walk_output_components(conn->dest_comp, stop, priv, fn); + if (ret) + return ret; + if (*stop) { + stop_conn =3D conn; + break; + } + } + + ret =3D fn(comp, stop, stop_conn, priv); + if (ret) + return ret; + + return 0; +} + +int gtrace_walk_output_components(struct gtrace_component *comp, void *pri= v, + int (*fn)(struct gtrace_component *comp, bool *stop, + struct gtrace_connection *stop_conn, + void *priv)) +{ + bool stop =3D false; + int ret; + + if (!comp || !fn) + return -EINVAL; + + mutex_lock(>race_mutex); + ret =3D __gtrace_walk_output_components(comp, &stop, priv, fn); + mutex_unlock(>race_mutex); + + return ret; +} +EXPORT_SYMBOL_GPL(gtrace_walk_output_components); + struct gtrace_component *gtrace_cpu_source(unsigned int cpu) { if (!cpu_present(cpu)) @@ -414,6 +461,182 @@ void gtrace_unregister_component(struct gtrace_compon= ent *comp) } EXPORT_SYMBOL_GPL(gtrace_unregister_component); =20 +struct gtrace_path_node { + struct list_head head; + struct gtrace_component *comp; + struct gtrace_connection *conn; +}; + +struct gtrace_component *gtrace_path_source(struct gtrace_path *path) +{ + struct gtrace_path_node *node; + + node =3D list_first_entry(&path->comp_list, struct gtrace_path_node, head= ); + return node->comp; +} +EXPORT_SYMBOL_GPL(gtrace_path_source); + +struct gtrace_component *gtrace_path_sink(struct gtrace_path *path) +{ + struct gtrace_path_node *node; + + node =3D list_last_entry(&path->comp_list, struct gtrace_path_node, head); + return node->comp; +} +EXPORT_SYMBOL_GPL(gtrace_path_sink); + +static int gtrace_assign_trace_id(struct gtrace_path *path) +{ + const struct gtrace_driver *gtdrv; + struct gtrace_component *comp; + struct gtrace_path_node *node; + int trace_id; + + list_for_each_entry(node, &path->comp_list, head) { + comp =3D node->comp; + gtdrv =3D to_gtrace_driver(comp->dev.driver); + + if (!gtdrv->get_trace_id) + continue; + + trace_id =3D gtdrv->get_trace_id(comp, path->mode); + if (trace_id > 0) { + path->trace_id =3D trace_id; + return 0; + } else if (trace_id < 0) { + return trace_id; + } + } + + return 0; +} + +static void gtrace_unassign_trace_id(struct gtrace_path *path) +{ + const struct gtrace_driver *gtdrv; + struct gtrace_component *comp; + struct gtrace_path_node *node; + + list_for_each_entry(node, &path->comp_list, head) { + comp =3D node->comp; + gtdrv =3D to_gtrace_driver(comp->dev.driver); + + if (!gtdrv->put_trace_id) + continue; + + gtdrv->put_trace_id(comp, path->mode, path->trace_id); + } +} + +static bool gtrace_path_ready(struct gtrace_path *path) +{ + struct gtrace_path_node *node; + + list_for_each_entry(node, &path->comp_list, head) { + if (!node->comp->ready) + return false; + } + + return true; +} + +struct build_path_walk_priv { + struct gtrace_path *path; + struct gtrace_component *sink; +}; + +static int build_path_walk_fn(struct gtrace_component *comp, bool *stop, + struct gtrace_connection *stop_conn, + void *priv) +{ + struct build_path_walk_priv *ppriv =3D priv; + struct gtrace_path *path =3D ppriv->path; + struct gtrace_path_node *node; + + if ((!ppriv->sink && gtrace_is_sink(comp->pdata)) || + (ppriv->sink && ppriv->sink =3D=3D comp)) + *stop =3D true; + + if (*stop) { + node =3D kzalloc_obj(*node); + if (!node) + return -ENOMEM; + INIT_LIST_HEAD(&node->head); + gtrace_get_component(comp); + node->comp =3D comp; + node->conn =3D stop_conn; + list_add(&node->head, &path->comp_list); + } + + return 0; +} + +static void gtrace_release_path_nodes(struct gtrace_path *path) +{ + struct gtrace_path_node *node, *node1; + + list_for_each_entry_safe(node, node1, &path->comp_list, head) { + list_del(&node->head); + gtrace_put_component(node->comp); + kfree(node); + } +} + +struct gtrace_path *gtrace_create_path(struct gtrace_component *source, + struct gtrace_component *sink, + enum gtrace_component_mode mode) +{ + struct build_path_walk_priv priv; + struct gtrace_path *path; + int ret =3D 0; + + if (!source || mode >=3D GTRACE_COMPONENT_MODE_MAX) { + ret =3D -EINVAL; + goto err_out; + } + + path =3D kzalloc(sizeof(*path), GFP_KERNEL); + if (!path) { + ret =3D -ENOMEM; + goto err_out; + } + INIT_LIST_HEAD(&path->comp_list); + path->mode =3D mode; + path->trace_id =3D GTRACE_INVALID_TRACE_ID; + + priv.path =3D path; + priv.sink =3D sink; + ret =3D gtrace_walk_output_components(source, &priv, build_path_walk_fn); + if (ret < 0) + goto err_release_path_nodes; + + if (!gtrace_path_ready(path)) { + ret =3D -EOPNOTSUPP; + goto err_release_path_nodes; + } + + ret =3D gtrace_assign_trace_id(path); + if (ret < 0) + goto err_release_path_nodes; + + return path; + +err_release_path_nodes: + gtrace_release_path_nodes(path); + kfree(path); +err_out: + return ERR_PTR(ret); +} +EXPORT_SYMBOL_GPL(gtrace_create_path); + +void gtrace_destroy_path(struct gtrace_path *path) +{ + gtrace_unassign_trace_id(path); + gtrace_release_path_nodes(path); + kfree(path); +} +EXPORT_SYMBOL_GPL(gtrace_destroy_path); + int __gtrace_register_driver(struct module *owner, struct gtrace_driver *g= tdrv) { gtdrv->driver.owner =3D owner; diff --git a/include/linux/gtrace.h b/include/linux/gtrace.h index e8ca2bd46e67..b74d4b83b141 100644 --- a/include/linux/gtrace.h +++ b/include/linux/gtrace.h @@ -224,6 +224,10 @@ int gtrace_enable_component(struct gtrace_component *c= omp); int gtrace_disable_component(struct gtrace_component *comp); int gtrace_reset_component(struct gtrace_component *comp); =20 +int gtrace_walk_output_components(struct gtrace_component *comp, void *pri= v, + int (*fn)(struct gtrace_component *comp, bool *stop, + struct gtrace_connection *stop_conn, + void *priv)); struct gtrace_component *gtrace_cpu_source(unsigned int cpu); =20 struct gtrace_component *gtrace_register_component(struct gtrace_component= _id *id, @@ -231,6 +235,26 @@ struct gtrace_component *gtrace_register_component(str= uct gtrace_component_id *i struct gtrace_platform_data *pdata); void gtrace_unregister_component(struct gtrace_component *comp); =20 +/** + * struct gtrace_path - Representation of a trace path from source to sink. + * @comp_list: List of trace components in the path. + * @mode: Usage mode for trace components. + * @trace_id: ID of the trace source (typically hart/CPU id). + */ +struct gtrace_path { + struct list_head comp_list; + enum gtrace_component_mode mode; + u32 trace_id; +#define GTRACE_INVALID_TRACE_ID 0 +}; + +struct gtrace_component *gtrace_path_source(struct gtrace_path *path); +struct gtrace_component *gtrace_path_sink(struct gtrace_path *path); +struct gtrace_path *gtrace_create_path(struct gtrace_component *source, + struct gtrace_component *sink, + enum gtrace_component_mode mode); +void gtrace_destroy_path(struct gtrace_path *path); + /** * struct gtrace_driver - Representation of a trace driver. * @id_table: Table to match components handled by the driver. --=20 2.43.0 From nobody Tue Sep 29 08:26:17 2026 Received: from mx0b-0031df01.pphosted.com (mx0b-0031df01.pphosted.com [205.220.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id BB47D4195C0 for ; Mon, 10 Aug 2026 15:24:09 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=205.220.180.131 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375451; cv=none; b=i1Ti8x/OIGVbo9Tzd1bDGmCP+ccFtKxXYYS/XMdVHIZ+37lIdD9Kd7o3gcbsX5354SrbmtZZ9fJvfPVcaZsXVskWamwindWnaGSpsuEP/xUhJeOB44+r/cwfe/pIINFPtR82Q+UKnmmruvXi2pes3DLlvv2v49iECgox21o/Mus= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375451; c=relaxed/simple; bh=eo7S+d8ZiEB7Vx60jyef3VLs9lEX5txX5kILnQCzzUE=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=svzaV5EZnrptZ0vHmW65LQFlCEEkZ6P75Ssd25AaHiFVFJQXpNQb8nhNeAlamAwzGDIQ7YaNY/OyN1PnFVBE227K57Ti0S2MzIoiJ4O4kHU9ugPZsAC2dWvJi+fekmq1OHPd93FIUxzXaT4kLGk+z995+WxS0OUaztBhLEGws0o= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=oss.qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=K2YqF+bn; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b=EXHt6m5p; arc=none smtp.client-ip=205.220.180.131 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="K2YqF+bn"; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b="EXHt6m5p" Received: from pps.filterd (m0279871.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 67ACjHOM1959740 for ; Mon, 10 Aug 2026 15:24:08 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qualcomm.com; h= cc:content-transfer-encoding:date:from:in-reply-to:message-id :mime-version:references:subject:to; s=qcppdkim1; bh=XI+TWSI9Lo5 Uxa4GBWQbvSKGeik/xwrPtHlF4bh58q4=; b=K2YqF+bnIXCh1qAEk55VNI5le2w pXvJkXtVJAjM6TXEIbwBBsjbl/CkldxatBj0t7EFk2xB/5pndnIieN7pkgZ2uDif r+cY4PTUFfrg3NLXzqhQOjAenfeSqyT1AqVaMNpPjTFiPecnRyHPFePFmUqcL5me A0UZJFZ+BsN2MCt1snvE8jV/eYNB3TOfy5vt+AOBCfhI7RMzr7LJ72/TZB5AWnG0 bU+4b1W2HnM4EsGDFBUfFODUR2qGs+Qwe5BWFvo3X9UVymnXGtnFOvfNyiAGS1ES c6EOMLMKHZIodhDxEhHNatLk/8senGvFFFdQf8w11oMSZQp3mSb1ZxNpmCw== Received: from mail-pf1-f198.google.com (mail-pf1-f198.google.com [209.85.210.198]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4fy18xu9ee-1 (version=TLSv1.3 cipher=TLS_AES_128_GCM_SHA256 bits=128 verify=NOT) for ; Mon, 10 Aug 2026 15:24:08 +0000 (GMT) Received: by mail-pf1-f198.google.com with SMTP id d2e1a72fcca58-848544a8496so2269249b3a.0 for ; Mon, 10 Aug 2026 08:24:08 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oss.qualcomm.com; s=google; t=1786375447; x=1786980247; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=XI+TWSI9Lo5Uxa4GBWQbvSKGeik/xwrPtHlF4bh58q4=; b=EXHt6m5pr5IHWoeBVsILUEUmlG/cDX46TbI5OfGEDDykgpbKBF2zFF0IRiPrAtLvVJ XpS/XAvO0TxPKKe6Gx1GFDrocGTWMd5EsdanHe2UixSVgxD/iWbAj/KnuzN8J/Nvsgyz O6cd/BJD5IhCeyxzKE1hamFNckq0Tb4bv90LvqG6TnB5VrMmfXuazO0eUaBMHjo98acz ztxoJVnro5xEy2XbLl91vWBnQiz8jgjI+xzYnp35MD3ulxHWwwdExv2iPe7THRHxXvvz dVUvqXQjD2fSf/msueM7EKqesY33BwFAWNm7pr2CATFTGW7e8J+FDwX2KY84NPokEmHS Q7mQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1786375447; x=1786980247; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=XI+TWSI9Lo5Uxa4GBWQbvSKGeik/xwrPtHlF4bh58q4=; b=Ig3Esl4vWX1Yy4r/ghc/tVzbuRiSKMvz1FD5m39Zm+ZyCzMG48VdLh6mazSC+2+TU/ WkuO4lP4VsY4Z+dgu/F3uO53xjPeeK9vo31RmxeL9b9rSUOqcZVxPj0M44TSta3seGjR VO/WbJZFVd0LQANpedmSziFgLEsvD65Bxwgdp4/0t75boY/ZyDQt1nBQBSGvHW8PGYYP qWzTLhznm11NxY2y7K+wTF7t4bpMJWLWesHS+4Q4F/zsuvHjoMb+4jgh8siPFOPYDYw1 4goPtTkfJtzJwIqdFb1IesXRMAqICWXHWpnl4u0Abo3xWb4tBi0e/tct7HeyClgD4LWN ckYw== X-Forwarded-Encrypted: i=1; AHgh+RqRPgtnra1Gn6nBn3Fk/zqPR8jwNDRDFtHs2mSC13Ibr8ZN1Lu1Zf4jyt83BXZk2r+TeSBetixadmEDing=@vger.kernel.org X-Gm-Message-State: AOJu0Yxx0Q3hxL+B7PJpN97cJrovuTcvKo9kBUbKIaZbZACoMOQK0xTG PCJb9xcMX03xJtmzx1gD8OvZHtPCFyt0ngdOv85aOLf/Unz9f3B6AarcdT9/LQcHNVqd7CR7hSi WG95Fq3RX9z6fdKqErfU936dsxmIpQypi7+8JWtYy4rcEGPRu3soMeE+gP1yMFKK/lL4= X-Gm-Gg: AR+sD12GNz+RK7jvIeCX/3zswUV/K/2+OCXR/LPFaJQz+FUocYI1PcanQAeQQs5x5Yl rafa0Mzvw9StPWgTzWxncPoAyDONxuC6g4pwvdJJBFUTAHHJKBuH/mJNtUEt3AsIPUh256F5jSn SBJOv89qi3q8Wla1BtYZ8Q1kP2ffOprBh0Kb8rO7RrE9EVa+f9PG+6WLhHScBz6FZy42LI3fF8W SZ7S1wl41a5ffYGUCorE5OztevRmQ0wGU63RXyuAZ7ITfr1n6UD+3a42G0R/4L29Ow4FFyBrlBg qppLRJf+8inEBoKDebQVMRf9vIZWsEKA+2Al1r60rwqRYGL7iWaLKQqJXiqma1VggOHXl84SU/w YhgufUKzdBy3qalxmCQESylltc442nhES9AbcOJCw6q8im2B/gLcAqgzwwakAbZ71zoqhDj2xff Ec6SDzojp4oAqLUNYfP3XoPJwQ7Q== X-Received: by 2002:a05:6a00:ab89:b0:84e:24df:3870 with SMTP id d2e1a72fcca58-84f4fb800c9mr35806050b3a.0.1786375447134; Mon, 10 Aug 2026 08:24:07 -0700 (PDT) X-Received: by 2002:a05:6a00:ab89:b0:84e:24df:3870 with SMTP id d2e1a72fcca58-84f4fb800c9mr35803483b3a.0.1786375426778; Mon, 10 Aug 2026 08:23:46 -0700 (PDT) Received: from hu-mchitale-blr.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com. [103.229.18.19]) by smtp.googlemail.com with ESMTPSA id 41be03b00d2f7-cbe8f1af985sm4282634a12.11.2026.08.10.08.23.39 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Aug 2026 08:23:46 -0700 (PDT) From: Mayuresh Chitale To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Mayuresh Chitale , Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Mayuresh Chitale , Anup Patel , Atish Patra , Andrew Jones , Sunil V L , linux-riscv@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, Anup Patel Subject: [PATCH v5 05/14] gtrace: Add functions to start/stop tracing on a component path Date: Mon, 10 Aug 2026 20:52:07 +0530 Message-ID: <20260810152223.3946743-6-mayuresh.chitale@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> References: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-Spam-Info: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfXxI0kvrT9RY8W TZH4Vpne2TV+5BKJnRbms3Q7M+NN6Sts1+cAACxUPx0pCK1YYVTkUubooFVZNnpXcbpmqOEL0a7 HXiALYmeUqwZvTWwmykXbStAIsMn8ww= X-Proofpoint-ORIG-GUID: xa8nluqXxRBAdeB2o-CHYVCbyRfe2sm2 X-Proofpoint-GUID: xa8nluqXxRBAdeB2o-CHYVCbyRfe2sm2 X-Authority-Analysis: v=2.4 cv=bfZbluPB c=1 sm=1 tr=0 ts=6a79ed18 cx=c_pps a=m5Vt/hrsBiPMCU0y4gIsQw==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=Sv0fKeRqtYgA:10 a=s4-Qcg_JpJYA:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=3WHJM1ZQz_JShphwDgj5:22 a=EUspDBNiAAAA:8 a=a8cUU4qgmBzOD3ajWOcA:9 a=IoOABgeZipijB_acs4fv:22 X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX1EmS/tFsvsQX xAACp4dvcK7th5F3nwAQfb3Bi130m9R3I+AaZaiNrKlKgF1fuItIs3fPncdZKPOvqX72ofYZoQ9 Px0kxhKy8WYhueJm4l4plW2ogBOXO0dOBRCGXwK6ty6CEopqOywPqxGxxB1PbQUMSPmHf1KnLRR cblDGw6i6aVKuZ3+/2i0pyBG5QDdt/UzBGmBNo730NSzd68SkUjKHvdlczxbQzZhuLcrRANj9qm AesuGNc6DLYXDS+yT18vVcdQE3buSG2YPr556TtcvWlbVfLYl/VABBJfyiDrgebgopOj7BGyI9f xNjD3l1kUWjq8Li7Uqf+RCMoe9zYmMaaKxCCE+YKkdNMil1MkRU1MaxKC4d0zNlxK2qYc4TatFx Qq3jLkU0CYyWbhtyy9OdFTSNOrHy6ZUHv2Yw+gjQiLw+n+bZt9WAixHqxMWqFYeq3xiw76H8Han kgWeRWGSpUx1NDm/RDg== X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1176,Hydra:6.1.134,FMLib:17.12.100.49 definitions=2026-08-10_03,2026-08-07_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 impostorscore=0 spamscore=0 lowpriorityscore=0 malwarescore=0 clxscore=1015 priorityscore=1501 phishscore=0 bulkscore=0 suspectscore=0 adultscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2606150000 definitions=main-2608100132 Content-Type: text/plain; charset="utf-8" The perf driver framework needs to be able to start / stop all components in a trace component path during its operation. Add gtrace_path_start() and gtrace_path_stop() functions for this purpose. Co-developed-by: Anup Patel Signed-off-by: Anup Patel Signed-off-by: Mayuresh Chitale --- drivers/hwtracing/gtrace/gtrace-core.c | 44 ++++++++++++++++++++++++++ include/linux/gtrace.h | 6 ++++ 2 files changed, 50 insertions(+) diff --git a/drivers/hwtracing/gtrace/gtrace-core.c b/drivers/hwtracing/gtr= ace/gtrace-core.c index a89d195ab5b8..6ff1b3087947 100644 --- a/drivers/hwtracing/gtrace/gtrace-core.c +++ b/drivers/hwtracing/gtrace/gtrace-core.c @@ -582,6 +582,50 @@ static void gtrace_release_path_nodes(struct gtrace_pa= th *path) } } =20 +int gtrace_path_start(struct gtrace_path *path) +{ + const struct gtrace_driver *gtdrv; + struct gtrace_component *comp; + struct gtrace_path_node *node; + int ret; + + list_for_each_entry_reverse(node, &path->comp_list, head) { + comp =3D node->comp; + gtdrv =3D to_gtrace_driver(comp->dev.driver); + if (!gtdrv->start) + continue; + + ret =3D gtdrv->start(comp); + if (ret) + return ret; + } + + return 0; +} +EXPORT_SYMBOL_GPL(gtrace_path_start); + +int gtrace_path_stop(struct gtrace_path *path) +{ + const struct gtrace_driver *gtdrv; + struct gtrace_component *comp; + struct gtrace_path_node *node; + int ret; + + list_for_each_entry(node, &path->comp_list, head) { + comp =3D node->comp; + gtdrv =3D to_gtrace_driver(comp->dev.driver); + if (!gtdrv->stop) + continue; + + ret =3D gtdrv->stop(comp); + if (ret) + return ret; + } + + return 0; +} +EXPORT_SYMBOL_GPL(gtrace_path_stop); + struct gtrace_path *gtrace_create_path(struct gtrace_component *source, struct gtrace_component *sink, enum gtrace_component_mode mode) diff --git a/include/linux/gtrace.h b/include/linux/gtrace.h index b74d4b83b141..78e2ead3db8e 100644 --- a/include/linux/gtrace.h +++ b/include/linux/gtrace.h @@ -254,10 +254,14 @@ struct gtrace_path *gtrace_create_path(struct gtrace_= component *source, struct gtrace_component *sink, enum gtrace_component_mode mode); void gtrace_destroy_path(struct gtrace_path *path); +int gtrace_path_start(struct gtrace_path *path); +int gtrace_path_stop(struct gtrace_path *path); =20 /** * struct gtrace_driver - Representation of a trace driver. * @id_table: Table to match components handled by the driver. + * @start: Callback to start tracing. + * @stop: Callback to stop tracing. * @probe: Driver probe() function. * @remove: Driver remove() function. * @get_trace_id: Get/allocate a trace ID. @@ -266,6 +270,8 @@ void gtrace_destroy_path(struct gtrace_path *path); */ struct gtrace_driver { const struct gtrace_component_id *id_table; + int (*start)(struct gtrace_component *comp); + int (*stop)(struct gtrace_component *comp); int (*probe)(struct gtrace_component *comp); void (*remove)(struct gtrace_component *comp); int (*get_trace_id)(struct gtrace_component *comp, --=20 2.43.0 From nobody Tue Sep 29 08:26:17 2026 Received: from mx0b-0031df01.pphosted.com (mx0b-0031df01.pphosted.com [205.220.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4C91E41A50A for ; Mon, 10 Aug 2026 15:24:17 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=205.220.180.131 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375458; cv=none; b=ZFi9dY+fKv/jNktCw/KBJJy0EnXvCcm2SHH8uceHm8DCZcYIA0LkKDhqrAJIkTiCVifL5Sc2FPSvRn8DyAnihXYK1Z4bhvl+vUMGYtVcksufWjBxnSwG/FqUwA4kViXH4DSDuW3/1j0JOpo34VUMDwUH2NwVfyg1wfa8J/XkTMY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375458; c=relaxed/simple; bh=ppCg7T+F2a0m3dWd48ljFA/znfvwAukFlUexPE3kd9Y=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=E2mpdOCFKBveupy4gqQvFYILp/CGQIC9sAWi5UzInRLx7UXZgDGDyYRRwZQFh8TD6N0PjzO83xFVgMbEM5RA1w7xE0YVh7P4o5nFn18H94XMxMpckw5FYL84lg7BTKXRAv2MxgR5OVnEpERV9gpajPNl/CS7HxSfY5dTai7jTKE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=oss.qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=YVXZp3D8; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b=gHGEOr8t; arc=none smtp.client-ip=205.220.180.131 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="YVXZp3D8"; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b="gHGEOr8t" Received: from pps.filterd (m0279872.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 67ACjAZs1367883 for ; Mon, 10 Aug 2026 15:24:16 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qualcomm.com; h= cc:content-transfer-encoding:date:from:in-reply-to:message-id :mime-version:references:subject:to; s=qcppdkim1; bh=F3lO+z9pBhh CrUuVUAW46lJD8XPxBVHzFGVCYA/LlGY=; b=YVXZp3D8mt/0Jio5Z7KGC+NPlES tLo58Q3z6Nb0i5IM2p/0wyv3xMm7hgqV7LaGKSCxlTFU+DpZgvEj7p9WCKTAJZLj /OliV9VPv435lefvM3NZsuUgeaRVDASXjtEypSkw6IAgZCXe1RvxQMeHXJOTR2wh k3J3NhFkRexn0Sl1CtDNZB2xgar9FhmKFPYY5Z8w3Ax3Rs9Gpi4ttf3kNhE3KZiM Tl0Jk0pYKD8cBDAd8h+PeoEsycymSZr6aOBwzY73klhmudhDg6UkPy5jkK+C790Z g1iBgGLn+JCE6RWwt615yiOjb0dMvjVK9OJ7RXT0P49smjdi/oVg3TftLnw== Received: from mail-pj1-f72.google.com (mail-pj1-f72.google.com [209.85.216.72]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4fy8v4a7rt-1 (version=TLSv1.3 cipher=TLS_AES_128_GCM_SHA256 bits=128 verify=NOT) for ; Mon, 10 Aug 2026 15:24:15 +0000 (GMT) Received: by mail-pj1-f72.google.com with SMTP id 98e67ed59e1d1-38ec0f510a9so5313852a91.2 for ; Mon, 10 Aug 2026 08:24:15 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oss.qualcomm.com; s=google; t=1786375455; x=1786980255; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=F3lO+z9pBhhCrUuVUAW46lJD8XPxBVHzFGVCYA/LlGY=; b=gHGEOr8tSS/m+GPIXS4SbapvXWFxfRJVNh9KHAWWY9O4zzFqX5rn1jJEEEhyzz4VAq LlMuT3XJw6IFdVEAhCg7zxgG8L3izmCrytUuWk0oxaZe9gm2//wHwpYQ5eMtaVAY/RER qGkSx0dO1eYqxnDpLjKzh5pjFahU2cKDr955pOAOJeD0S5KTiFohrDCP+Uhsovan0MZr Zjzm9ceV91JbnMI4XKfqebfjuZe2TIxcC1ioqdpR2BpLGDZaawVw8R681SCN44OSZ7XZ MgScnxmuG8RlCm5HPym1m8nahWGoqFRyTvKxgF8rTkuWfsToAiliFeoiM7lIpvXdM3JS cOhg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1786375455; x=1786980255; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=F3lO+z9pBhhCrUuVUAW46lJD8XPxBVHzFGVCYA/LlGY=; b=azObDgNd2cnjBbLtRPM1/3PtdPvzzKRQ6EICbPTHa4pjxiY8YnfS8YmHpVY4BCj85b F2W2yFtjWuRkXRoGZeNiK5tLMFwOYBPB1LI04CypdSreQ/tE7Ec6nR+pcOMP3yA0Amt2 +QMTrlII7Tl+grPxjf1IUor5MIOGG0nP6paI3CwHvbmt3fzlXxo7GViTQmcVgQ8FGeI0 l2ZeActVb6ilKcPzRPTYKe0y9/TU3RzkYcyG7jte7XK0Pdv8CED56sajzb78iZnLEEAj fjYU8b3jSEtg+qn9VpPBuoyAiSU+WfaEvl9rZ9lfOARbI3lHXDhvpeLor9rtAgqMk5Yw ZSEQ== X-Forwarded-Encrypted: i=1; AHgh+RoeHp3/nuIyURmJcm6ATOo2KI04mX3Ts+/E/NhZ0wZ6jtPzs3Snik8/nucpucPicSdTqAQYUFXdH7ROUfE=@vger.kernel.org X-Gm-Message-State: AOJu0Yy/E8h5VcnWeiKaJ5KJfD3vLGqR/o3kDPZXwvzu2C7p9iPLlt+a 3SQIuOfTBTvlIrfD30rgtDZoCFmCmX7OnwyIfpg53B0afMRfeYNWPD1Eb/nSLs9gMQvljyA7jaG bHztfSVddQsJe3qA0iM+oagcBsYqb3u1zOu/mnts7WmZ/kZNCow3JvpJ7cZ3XXtmzm5g= X-Gm-Gg: AR+sD13zywJ3y+x8XA4vX0ZFxxHzUiQKH80hyUz4NXZtfrL92bTSUTILvjbWcYVfd3a pHjf88lgKgha3xZ009FHnq9Lr5aElMRDgXOdIpThtPoebRMjD0WLMFrW3sL8K9bjlrFiKRMzwMd yF8e/2xSTqg2xfNhiSCqXzzIid9gjqkQuGo5ye53B/XUfRVsf6Hb8CwOGKRRAP2+HR+JJp1cVeP sfDsTmSTvN0sN2R0IkYBu0QZuw46rTDC/hjF/WLS4d2f8TdJ16pTu4IJo+J/+B5Z/0ArVyB/0ZL ADF/XYOBSJ6aig5PuRX+XtlkZG5Sn21T+W4ryYyyyZikV49Z85ILhW75LJBauYNDufWh+bDVCPS oUkjHiU4zxS3RP8AAPzU/fKXKydmRnBM4tuYEi0b32AKkR296z6hTLCEKnFUE2ZIVyF7wwDTzIb bjQZ+hD8zHbDc2+W+99+Y6PZ/kkQ== X-Received: by 2002:a05:6a20:43a9:b0:3b3:216b:2743 with SMTP id adf61e73a8af0-3cbc0103abcmr28768566637.4.1786375454613; Mon, 10 Aug 2026 08:24:14 -0700 (PDT) X-Received: by 2002:a05:6a20:43a9:b0:3b3:216b:2743 with SMTP id adf61e73a8af0-3cbc0103abcmr28768494637.4.1786375454158; Mon, 10 Aug 2026 08:24:14 -0700 (PDT) Received: from hu-mchitale-blr.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com. [103.229.18.19]) by smtp.googlemail.com with ESMTPSA id 41be03b00d2f7-cbe8f1af985sm4282634a12.11.2026.08.10.08.24.06 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Aug 2026 08:24:13 -0700 (PDT) From: Mayuresh Chitale To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Mayuresh Chitale , Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Mayuresh Chitale , Anup Patel , Atish Patra , Andrew Jones , Sunil V L , linux-riscv@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, Anup Patel Subject: [PATCH v5 06/14] gtrace: Add RISC-V Trace encoder driver Date: Mon, 10 Aug 2026 20:52:08 +0530 Message-ID: <20260810152223.3946743-7-mayuresh.chitale@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> References: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-ORIG-GUID: 25-YWQ6sGnl6aUj-KLHjIJ1Ka0oqE_O6 X-Proofpoint-Spam-Info: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX0Mk2gQrsXGTU dURuS29Ld0BCKAUWnoEx+G7ddobuDJRYj8stthkOsUunTM0C/vtlPEDxST93ks0vBmI8vWRsqks w4Ch5s6t2Vp/52N7APkq8DfP70U7pL8= X-Authority-Analysis: v=2.4 cv=W5EIkxWk c=1 sm=1 tr=0 ts=6a79ed1f cx=c_pps a=RP+M6JBNLl+fLTcSJhASfg==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=Sv0fKeRqtYgA:10 a=s4-Qcg_JpJYA:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=yx91gb_oNiZeI1HMLzn7:22 a=EUspDBNiAAAA:8 a=vQ3DPo-oxR4YcLRavt4A:9 a=iS9zxrgQBfv6-_F4QbHw:22 X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX2Tn2ZufO1ByL Md1oWvav1O6bxCyKzf48r6RTsjirYr6M/QRInd/FhE+lrhlEAm+oqquyllV7vXJLpqXGMyjGfim qvJuy9YRYu6/Uq764M9+h1M6Jq4f6XyNA+P1Xdk+G+GB6glGQHOjVxgRmur3kv5Ycrp8lMzLirA c68EJgfGqz4y3cs0W0bywfcbY4YWGGsZiv2SBwHtC+TJvyAv7VO3tQmr4zHr9P5nGQx4JiBU+1l 2hU+JAmx66iUATa2WJrfsqAEiX/1H0i1zJsQ1UY5TOdwI4omFIYTMyHJQtNCaQ93Ur4vliO4hVw DRP6ACyKrM/GogJKSLEmCo7kuadlmdK0ncoTrLnbFlLc7JJjO0U9ShDQOtP0cSqd+2gPSfIVITc Sxe6TLzXhqowihW8IHrBk0xwwGeqF7g6EhYZL13tKBa4ri7fzbEMcTbDqQEmAfJ3DgUJzToheIC vRGAk9R3ICQ2Oj6LqBg== X-Proofpoint-GUID: 25-YWQ6sGnl6aUj-KLHjIJ1Ka0oqE_O6 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1176,Hydra:6.1.134,FMLib:17.12.100.49 definitions=2026-08-10_03,2026-08-07_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 suspectscore=0 lowpriorityscore=0 priorityscore=1501 phishscore=0 clxscore=1015 adultscore=0 bulkscore=0 spamscore=0 impostorscore=0 malwarescore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2606150000 definitions=main-2608100132 Content-Type: text/plain; charset="utf-8" Add initial implementation of RISC-V E-Trace encoder driver. The encoder is defined in the RISC-V Trace Control Interface specification. Co-developed-by: Anup Patel Signed-off-by: Anup Patel Signed-off-by: Mayuresh Chitale --- drivers/hwtracing/gtrace/Kconfig | 13 +++ drivers/hwtracing/gtrace/Makefile | 1 + drivers/hwtracing/gtrace/rvtrace-encoder.c | 99 ++++++++++++++++++++++ 3 files changed, 113 insertions(+) create mode 100644 drivers/hwtracing/gtrace/rvtrace-encoder.c diff --git a/drivers/hwtracing/gtrace/Kconfig b/drivers/hwtracing/gtrace/Kc= onfig index 04986f216549..e3a621b59913 100644 --- a/drivers/hwtracing/gtrace/Kconfig +++ b/drivers/hwtracing/gtrace/Kconfig @@ -28,3 +28,16 @@ config RVTRACE =20 To compile this driver as a module, choose M here: the module will be called rvtrace. + +config RVTRACE_ENCODER + tristate "RISC-V Trace Encoder driver" + depends on RVTRACE + default y + help + This driver provides support for the RISC-V trace encoder component + which is defined by the RISC-V Trace Control Interface specification. + The encoder is bound to a CPU and generates the trace data for that + CPU. + + To compile this driver as a module, choose M here: the module + will be called rvtrace-encoder. diff --git a/drivers/hwtracing/gtrace/Makefile b/drivers/hwtracing/gtrace/M= akefile index cf02316c1bbf..10a74f852115 100644 --- a/drivers/hwtracing/gtrace/Makefile +++ b/drivers/hwtracing/gtrace/Makefile @@ -4,3 +4,4 @@ obj-$(CONFIG_GTRACE) +=3D gtrace.o gtrace-y :=3D gtrace-core.o =20 obj-$(CONFIG_RVTRACE) +=3D rvtrace-platform.o +obj-$(CONFIG_RVTRACE_ENCODER) +=3D rvtrace-encoder.o diff --git a/drivers/hwtracing/gtrace/rvtrace-encoder.c b/drivers/hwtracing= /gtrace/rvtrace-encoder.c new file mode 100644 index 000000000000..9ff3413d1aa4 --- /dev/null +++ b/drivers/hwtracing/gtrace/rvtrace-encoder.c @@ -0,0 +1,99 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2026 Qualcomm Technologies, Inc. + */ + +#include +#include +#include +#include "rvtrace.h" + +#define RVTRACE_COMPONENT_CTRL_ITRACE_SHIFT 2 +#define RVTRACE_COMPONENT_CTRL_INSTMODE_SHIFT 4 +#define RVTRACE_COMPONENT_CTRL_INSTMODE_OPIT 0x6 + +static int rvtrace_encoder_start(struct gtrace_component *comp) +{ + struct gtrace_platform_data *pdata =3D comp->pdata; + int ret; + u32 val; + + ret =3D gtrace_enable_component(comp); + if (ret) { + dev_err(&comp->dev, "failed to enable encoder.\n"); + return ret; + } + + /* set mode */ + val =3D gtrace_read32(pdata, RVTRACE_COMPONENT_CTRL_OFFSET); + val |=3D (RVTRACE_COMPONENT_CTRL_INSTMODE_OPIT << RVTRACE_COMPONENT_CTRL_= INSTMODE_SHIFT); + gtrace_write32(pdata, val, RVTRACE_COMPONENT_CTRL_OFFSET); + + val =3D gtrace_read32(pdata, RVTRACE_COMPONENT_CTRL_OFFSET); + val |=3D BIT(RVTRACE_COMPONENT_CTRL_ITRACE_SHIFT); + gtrace_write32(pdata, val, RVTRACE_COMPONENT_CTRL_OFFSET); + ret =3D gtrace_poll_bit(pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ITRACE_SHIFT, 1, + pdata->control_poll_timeout_usecs); + if (ret) + dev_err(&comp->dev, "failed to enable tracing.\n"); + + return ret; +} + +static int rvtrace_encoder_stop(struct gtrace_component *comp) +{ + struct gtrace_platform_data *pdata =3D comp->pdata; + int ret; + u32 val; + + val =3D gtrace_read32(pdata, RVTRACE_COMPONENT_CTRL_OFFSET); + val &=3D ~BIT(RVTRACE_COMPONENT_CTRL_ITRACE_SHIFT); + gtrace_write32(pdata, val, RVTRACE_COMPONENT_CTRL_OFFSET); + ret =3D gtrace_poll_bit(pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ITRACE_SHIFT, 0, + pdata->control_poll_timeout_usecs); + if (ret) { + dev_err(&comp->dev, "failed to stop tracing.\n"); + return ret; + } + + ret =3D gtrace_disable_component(comp); + if (ret) + dev_err(&comp->dev, "failed to disable encoder.\n"); + + return ret; +} + +static const struct gtrace_component_id rvtrace_encoder_ids[] =3D { + { .type =3D GTRACE_RVTRACE_ENCODER, + .version =3D rvtrace_component_mkversion(1, 0), }, + {}, +}; + +static struct gtrace_driver rvtrace_encoder_driver =3D { + .id_table =3D rvtrace_encoder_ids, + .start =3D rvtrace_encoder_start, + .stop =3D rvtrace_encoder_stop, + .driver =3D { + .name =3D "rvtrace-encoder", + }, +}; + +static int __init rvtrace_encoder_init(void) +{ + return gtrace_register_driver(&rvtrace_encoder_driver); +} + +static void __exit rvtrace_encoder_exit(void) +{ + gtrace_unregister_driver(&rvtrace_encoder_driver); +} + +module_init(rvtrace_encoder_init); +module_exit(rvtrace_encoder_exit); + +/* Module information */ +MODULE_AUTHOR("Mayuresh Chitale"); +MODULE_DESCRIPTION("RISC-V Trace Encoder Driver"); +MODULE_LICENSE("GPL"); --=20 2.43.0 From nobody Tue Sep 29 08:26:17 2026 Received: from mx0b-0031df01.pphosted.com (mx0b-0031df01.pphosted.com [205.220.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 1EDE6409623 for ; Mon, 10 Aug 2026 15:24:24 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=205.220.180.131 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375466; cv=none; b=bcSPHvhQswPEWblQ2fq9f1GBRo1a/aaO1TQZHbqcet07Zs+FIy2gr/lXhZcHnJx/9HMTHGesQxFfCp+BaxdehJF0Xn9IRfB5uc7PVP1JaYQirFqdevGyjACi7vjyaHA6cG8szVOIWYya9tpXnSKA1mqc6kcarbx8fhGfIBHW28c= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375466; c=relaxed/simple; bh=SHPac3/YNhNPWsUtpPuxaSQoRBAGpNcm7mF5ZLHMc4s=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=EJbAkNDuB7GCCACB1jfsUzjG0goe0ryTBCsTUYrX1OfxCcKTDj/3zjCXNyU/9lNnoy4VKyOkDVvjmm5ODRnDt3x9WxOyUBTbeqCoUn5ARnL8nUsbDkIwVNx7Ut3GHt3jounPtRU5MxmomxH0nOgiN2Oop8n0eVpOmKoyaX+mzWo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=oss.qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=pFd32wVp; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b=O007DXGY; arc=none smtp.client-ip=205.220.180.131 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="pFd32wVp"; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b="O007DXGY" Received: from pps.filterd (m0279868.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 67ACjVkm1596820 for ; Mon, 10 Aug 2026 15:24:24 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qualcomm.com; h= cc:content-transfer-encoding:date:from:in-reply-to:message-id :mime-version:references:subject:to; s=qcppdkim1; bh=SXSG2wb2TZi XtJzB1T1a7hCG1Hby4CtDQXZZTgX0OkM=; b=pFd32wVpll8LxNuLEM3A6bKTvq8 IdnWlw/vm5muYzIg/eHeCWVdmBaig1y6KaGS10dx18FVuJEncjd/G3xk5tueB1Ao ce8c+Zfz5Fnwotkii1MBgibPz/vv9GILwmoM2V/igu+p//LtC5sxx06+rQVg27mc Zhtb1cyjKEabNie3/l/2EqvGlebsdeAvS5Xg0tSluHDMLmiMBKVNr/Xb6F970YCh 8GP04comFwhrrdv6Qlj5tKGJ9EW30xyGBROpi5/dzh7OEbI4zoXooi5OSO+occeA yk/9IWA6DCVF3kK/vCFdb4XUCnrNocZLkO/lkH3GtL/c1GaIdro4jvj6V9g== Received: from mail-pg1-f197.google.com (mail-pg1-f197.google.com [209.85.215.197]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4fy8v6t9px-1 (version=TLSv1.3 cipher=TLS_AES_128_GCM_SHA256 bits=128 verify=NOT) for ; Mon, 10 Aug 2026 15:24:23 +0000 (GMT) Received: by mail-pg1-f197.google.com with SMTP id 41be03b00d2f7-cab3e9cd922so1382195a12.0 for ; Mon, 10 Aug 2026 08:24:23 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oss.qualcomm.com; s=google; t=1786375462; x=1786980262; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=SXSG2wb2TZiXtJzB1T1a7hCG1Hby4CtDQXZZTgX0OkM=; b=O007DXGYdUq7xtdoToT+HHfoU8xEEQ8vUpb/3WV/c/pGZcdlhcDnOxUZ5oSBLa6s9p fTGfeEImL3fohW+j4X6mVwli95xtf2L6e3hbsTP8gnCGyfaDfcjuESwEgSDqCUN5ZqQp 9IOy+niL+mX3dA93jUbNHzHPqqY1BVJ2S/iWCsLWWBu+4D++bwRT5Wfm3XlPrmvaP67i sEwMM53lEXymXonhYFS+ovSjmVaNbrvyOr0jVu0MHEiTZ20b189Naqy15ka8kDqlM6xD 1U0ybMGsGIgEkE2GZdN2sAH/nJkDVA5aZWYtJeRiz651f4C/Jfm0qlRXBETKNudyv7kA 6yBA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1786375462; x=1786980262; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=SXSG2wb2TZiXtJzB1T1a7hCG1Hby4CtDQXZZTgX0OkM=; b=g89OdF/YrJ+wuZpkhiClZit4zLfCzpi1/a3/GjgZVgE0Q4WNE0d+feUjy/jKSPU2G9 McwkdaZ/uKkOHDgug7FeXSH16d8ZYbKmVQa9kaNCwYFaMcY1SVJgQjaANTW46r7Ul9NK KmwRcTOxW9z7tGsID3o/WdXFiSlfmm+eU6ptY0Di3aIoTTJpJs02zrsw0SF7DtgOEASS 1fKI8l7/s2knuoEr2Az7qODHgB3rNh04AdL4/8LIPqYlbY08Zp9fSYV2z+v0xrfVdL1Y b5UtE/fuLjArOFqXzfqAHsHi75eoN7SJO8WntvTJgyrt00gPvhCA7ln2p7laZOPbcMKf 1iew== X-Forwarded-Encrypted: i=1; AHgh+Rp9Pmc1Wuh6BgX6npRhLzVIvN+zrRFTfpxaE9+mO+Avppfv8gHKqtEGDeoIOBD1DesyRWP+OpoLD1A8RFM=@vger.kernel.org X-Gm-Message-State: AOJu0YwHb4le742huXPLz5nG8X1BabyqInymQwYCwoC6Vtx1mvpWrFbu WKOe3bWjJqe0etL7KcLQ1G/gCjILkdGyqjhUgiu1p/LUBSDUZ1JTjfuGT16iGz/581iCna6Or5S X0u/uh4WVCLPsJPKbSVng8AfAm5CvlvxiKvDaRTTPm21dhovNk9QJN+ePuU1x41kQ/jw= X-Gm-Gg: AR+sD11qVscdaDxucCXw7nWlzs+32i7xbwJi+xGRSPcEGYrAAAI5GxBSFb8L19a0gW4 /n/XVMCOAben7Ndarl0rGpkRNSQr9yXaUSrKiGT9PvPRXFYUdOple/O2i4Olk5S8SzTfx2kViUt PbXSVBxFaB0OjH98qC6zOptJBkjYp/zmpKhnsjUlK9huB9qfEcLrbU/yKL10dQyJiQBddPQOHnF R/AAiizHh16IX/rqMYRzMWYEflQx6rdOQNWpEDEMb9+pQMW5EhZHdEEkapSLTlu3p7ix1IZfmtC cDyA85//DpBp6YJqOJN+GtMKALWqgl4nYv8uWR13FYaE75QdYq69IBNZvD9d2myxNx3e6BTNknS YBsx+lMTN0jRrYiXn0HUjAIvEpeBaAs96D+3ehVgJkqfD1PUUJF52f3s7cfP8HMyNBrVx2hSXoU MLozOV+iKiUK631zjJBy736Vo1gQ== X-Received: by 2002:a05:6a20:7fa0:b0:3c3:76a8:c0f with SMTP id adf61e73a8af0-3cbce6f17b9mr20866802637.4.1786375462245; Mon, 10 Aug 2026 08:24:22 -0700 (PDT) X-Received: by 2002:a05:6a20:7fa0:b0:3c3:76a8:c0f with SMTP id adf61e73a8af0-3cbce6f17b9mr20866754637.4.1786375461670; Mon, 10 Aug 2026 08:24:21 -0700 (PDT) Received: from hu-mchitale-blr.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com. [103.229.18.19]) by smtp.googlemail.com with ESMTPSA id 41be03b00d2f7-cbe8f1af985sm4282634a12.11.2026.08.10.08.24.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Aug 2026 08:24:21 -0700 (PDT) From: Mayuresh Chitale To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Anup Patel , Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Mayuresh Chitale , Anup Patel , Atish Patra , Andrew Jones , Sunil V L , linux-riscv@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, Mayuresh Chitale Subject: [PATCH v5 07/14] gtrace: Add function to copy into perf AUX buffer Date: Mon, 10 Aug 2026 20:52:09 +0530 Message-ID: <20260810152223.3946743-8-mayuresh.chitale@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> References: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-Spam-Info: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX6lYfdE2e4pAo P3H6Y4NdCUomHt8rn/yLs+F0o9GkNCnVx3hlzuAOCuFUqBzmRdotkcKAHHHHIFBSaxBQ9+6Pehd EDtKojWvyzuIABkGaHqk2a8azf/EU3I= X-Authority-Analysis: v=2.4 cv=PvijqQM3 c=1 sm=1 tr=0 ts=6a79ed27 cx=c_pps a=rz3CxIlbcmazkYymdCej/Q==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=Sv0fKeRqtYgA:10 a=s4-Qcg_JpJYA:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=ZpdpYltYx_vBUK5n70dp:22 a=EUspDBNiAAAA:8 a=MNQjnuzN1gR2RwVUj5UA:9 a=bFCP_H2QrGi7Okbo017w:22 X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX+MGATJ5OA9Gj THRqAGjyuV0Yjk+OfE7j0Ujvb3nJwhUUyPhQFn+/0nVumETJfDgGOojbhQpl8+SJXZZoh+KAqEV LucuNShpxTb8MksczLePEKZSQgZgwrvBeF055jkWe+JIjnQnRAbQrg/6H00rS69iZngBrax8tt5 JxVsCwI1D7+CM/Eb5zlPN7+0SnfSxlM/fijZuQjGZG/11icZk66fMmWlpaAEYb3uhOluYPVtjca ZZs6Jl/tiCAHRDFDY5UqZFNcDNVrSrKCHCEfO0/ccadV+SAiHjsyiN8er5AyLFtSscZp3AzRSB0 yuTrvs6OyvSWmMJeKC8rQvnAYtMDFiS+HzG8J4sN/ELbxwsLglKVmKo7DzEx0azRNndT9K3N+Yd 1U+B6ZYxUtENh88R2Cp/F8xn4/ggJ4PVDzklDHV69Up6/5KktnntVRjKjOuM2lQIbjt23L45E8V Q6vG2gdrJazDSz1I6YA== X-Proofpoint-GUID: H9Ho-fvxDevfHl-AgIKyum8WgXRXKSy7 X-Proofpoint-ORIG-GUID: H9Ho-fvxDevfHl-AgIKyum8WgXRXKSy7 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1176,Hydra:6.1.134,FMLib:17.12.100.49 definitions=2026-08-10_03,2026-08-07_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 malwarescore=0 impostorscore=0 suspectscore=0 spamscore=0 clxscore=1015 phishscore=0 adultscore=0 priorityscore=1501 lowpriorityscore=0 bulkscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2606150000 definitions=main-2608100132 Content-Type: text/plain; charset="utf-8" From: Anup Patel The RISC-V trace ramsink will need a mechanism to copy trace data into the perf AUX buffer. Add gtrace_path_copyto_auxbuf() function and corresponding trace driver callback copyto_auxbuf() for this purpose. Co-developed-by: Mayuresh Chitale Signed-off-by: Mayuresh Chitale Signed-off-by: Anup Patel --- drivers/hwtracing/gtrace/gtrace-core.c | 22 ++++++++++++++++++++++ include/linux/gtrace.h | 24 ++++++++++++++++++++++++ 2 files changed, 46 insertions(+) diff --git a/drivers/hwtracing/gtrace/gtrace-core.c b/drivers/hwtracing/gtr= ace/gtrace-core.c index 6ff1b3087947..53a3679ba69f 100644 --- a/drivers/hwtracing/gtrace/gtrace-core.c +++ b/drivers/hwtracing/gtrace/gtrace-core.c @@ -626,6 +626,28 @@ int gtrace_path_stop(struct gtrace_path *path) } EXPORT_SYMBOL_GPL(gtrace_path_stop); =20 +int gtrace_path_copyto_auxbuf(struct gtrace_path *path, + struct gtrace_perf_auxbuf *buf, + size_t *bytes_copied, u64 *format) +{ + const struct gtrace_driver *gtdrv; + struct gtrace_component *comp; + struct gtrace_path_node *node; + + list_for_each_entry(node, &path->comp_list, head) { + comp =3D node->comp; + gtdrv =3D to_gtrace_driver(comp->dev.driver); + if (!gtdrv->copyto_auxbuf) + continue; + + *bytes_copied =3D gtdrv->copyto_auxbuf(comp, buf, format); + return 0; + } + + return -EOPNOTSUPP; +} +EXPORT_SYMBOL_GPL(gtrace_path_copyto_auxbuf); + struct gtrace_path *gtrace_create_path(struct gtrace_component *source, struct gtrace_component *sink, enum gtrace_component_mode mode) diff --git a/include/linux/gtrace.h b/include/linux/gtrace.h index 78e2ead3db8e..bc82814e2738 100644 --- a/include/linux/gtrace.h +++ b/include/linux/gtrace.h @@ -257,9 +257,30 @@ void gtrace_destroy_path(struct gtrace_path *path); int gtrace_path_start(struct gtrace_path *path); int gtrace_path_stop(struct gtrace_path *path); =20 +/** + * struct gtrace_perf_auxbuf - Representation of the perf AUX buffer. + * @length: Size of the AUX buffer. + * @nr_pages: Number of pages of the AUX buffer. + * @base: Start address of AUX buffer. + * @pos: Position in the AUX buffer to commit traced data. + */ +struct gtrace_perf_auxbuf { + size_t length; + int nr_pages; + void *base; + long pos; +}; + +int gtrace_path_copyto_auxbuf(struct gtrace_path *path, + struct gtrace_perf_auxbuf *buf, + size_t *bytes_copied, u64 *format); + /** * struct gtrace_driver - Representation of a trace driver. * @id_table: Table to match components handled by the driver. + * @copyto_auxbuf: Callback to copy data into perf AUX buffer. The driver + * reports the PMU specific trace format of the copied data + * via @format (see PERF_AUX_FLAG_PMU_FORMAT_TYPE_MASK). * @start: Callback to start tracing. * @stop: Callback to stop tracing. * @probe: Driver probe() function. @@ -270,6 +291,9 @@ int gtrace_path_stop(struct gtrace_path *path); */ struct gtrace_driver { const struct gtrace_component_id *id_table; + size_t (*copyto_auxbuf)(struct gtrace_component *comp, + struct gtrace_perf_auxbuf *buf, + u64 *format); int (*start)(struct gtrace_component *comp); int (*stop)(struct gtrace_component *comp); int (*probe)(struct gtrace_component *comp); --=20 2.43.0 From nobody Tue Sep 29 08:26:17 2026 Received: from mx0a-0031df01.pphosted.com (mx0a-0031df01.pphosted.com [205.220.168.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id DB9CD409623 for ; Mon, 10 Aug 2026 15:24:30 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=205.220.168.131 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375472; cv=none; b=AUvzDWSJmK+m9AOev82XtvxSPeh4NuDAGd7cFA623YpYq5WF8LnCgTuRzzO9HGNriMv8rVx6Je0dx3Ex5Ih16zDqlEN0nO/O+nz7Ag8XQnSFXw0nzQ7cvGvwz52v6P2u8FtInyFLIsiJI3sXn5q2+0bSet6nktfMrgjhRVdLkWs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375472; c=relaxed/simple; bh=0X7grRdtfkegL6PblKC0RKB6iVbpaSOb9mEgnVIZqWI=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Nuw5eCr48D0jPCp7q1lufAEeJ8SsZmeslbkXsj2bE2AY+8+E9bLuLGLA1JGhZRdU3IeFz7oHmivas65eU7nV8RD7RgHgmWAfor6Vl+P0bJHFmYLRyGkE0nAg9var0z0GMyx789310NST0r1qBM+mcRh2wEYK/X6wKpgIFCxbbVw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=oss.qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=JwBHuqx1; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b=KMzI+uxG; arc=none smtp.client-ip=205.220.168.131 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="JwBHuqx1"; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b="KMzI+uxG" Received: from pps.filterd (m0279863.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 67ACj72v1706815 for ; Mon, 10 Aug 2026 15:24:30 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qualcomm.com; h= cc:content-transfer-encoding:date:from:in-reply-to:message-id :mime-version:references:subject:to; s=qcppdkim1; bh=vmqn2TDyzfw u0fkZONzvlv8i/iDMucucBNwgndeXY1c=; b=JwBHuqx1ezeASHdBGbjA3CZVxEF HdGE8BTeAZKYsZbgiaYxiPL9ywBLbMknPbYF9pUEhQKENnGyZ5Y4HZu+HKwC9VLQ sRW0lvLLMeJRgzkoSSvI5WbRN1k8tv0wy+b96kug4l6EHSY5TVmVOhBU6zohAgNg GJSUhiiFIgZla0MrUxSj3U4LukviPwAVEu8tVzXO+HfpkqdNe6WhF807yzVxAgU9 JCtoTrRSBPprLBWZ3BIXfZB/GtxAMyqXVTFoOqFf9B/Q/pvIM/1OlvSqYUrsjTTP 5CLWcf9T0rAA+Lb/QAfnAXZop8AQWoS6a4mdnl5H1r312mcN+d85eIBgmyw== Received: from mail-pf1-f199.google.com (mail-pf1-f199.google.com [209.85.210.199]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4fybh59mng-1 (version=TLSv1.3 cipher=TLS_AES_128_GCM_SHA256 bits=128 verify=NOT) for ; Mon, 10 Aug 2026 15:24:30 +0000 (GMT) Received: by mail-pf1-f199.google.com with SMTP id d2e1a72fcca58-84e4ef486c7so1807833b3a.1 for ; Mon, 10 Aug 2026 08:24:29 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oss.qualcomm.com; s=google; t=1786375469; x=1786980269; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=vmqn2TDyzfwu0fkZONzvlv8i/iDMucucBNwgndeXY1c=; b=KMzI+uxGJjcv+ha7kVgaxZLeldX7A+pSPRBily0FU1mFpnzBv5BXpfmcOMJjOZ1L0O bj9Zk/eG31kJeKxErYGdSXm6oebJIwqhYMHWU6tZ6t20Lei2xMdY4xK4TmMCWDM3I5F9 ii++yYawpRC8APVnJF9zFrSKcGuR2Jqoui96aufoyxHaaGEC+8ZhULcpsEUj6Yzgt9Mc epH8T+DZgQZrxCySL54enFfV5Y3mXFEeo+BHrPmsuqKhi79KeXQ8ZVRFpFrnd5hI7zpn /YZlxVyL8XfkvScRfwJbMIjR1M9TWZaAug/URjiPyWlg02NJZeTK7fAKxQJ66Rwgd08O zooA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1786375469; x=1786980269; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=vmqn2TDyzfwu0fkZONzvlv8i/iDMucucBNwgndeXY1c=; b=L5zETQiBf6N0dfMrlEI8fDECam4leLrHwuWNZOC0HmJ3xyMEZLxG8tNmMYicj8MSAW 7zVWp9Yr3iZjmWdFBgBuEAFz0PIufU3A74HgoVYiw+KPrllSFSChRDdyYG8GizeZrDcg bBxEsG+dto+xNl1/V497ryWE5FtP6pAbt3INKMlG/RcaZbG8IcLyogAlBMqAuYO1BUpS uuqXuxYdTVRXzId8dX+6vAtcJNLHeUW6F8NPSPIj0LIwUYbeL/H3Jn9AW2gyAoBJeoWp vSkav7lHMb4kdFm67r9nTeqPA/L8Tq4d81foA6ZErF9qxZooZY1olFQ6SzbJU93YHTAR PfYA== X-Forwarded-Encrypted: i=1; AHgh+Rr+MdudaBhLXB/wE7PKv3+bNG/hq0EYaQPrTL4H2omRl3uHjmrW7XHrqZo7ZP2Bx86kINVO7xHk1KZP094=@vger.kernel.org X-Gm-Message-State: AOJu0Yx/oUPRXLCYob6CoTHT4MuNminzRnZPVc39v6Toull/3GEgnyTw SNfKTalCCXSEM5eT7k4l35rJV4zmM9Zee8LpLuwd9rVJLxfBqDS++KurPeM1/u0EsuT+bmpGO8T Qr9XNcI1mIxenFgzdzJT1sqxoSr+VxqK6m4/ifGuEjLJI3pFVztrkvhyczU/wiRMCtmI= X-Gm-Gg: AR+sD10VtazpxUoUWP8VUTNj5GFbNvbn4U+brH7PiJhS9+noM5W7qO2CH+NP4D9wdJv GbQJ+0sU+IRgmy/Hi6zv3mDkStrzp0IUO+5RItMrfoeUbQHB9kBR6c+h6RwVNqwmtWdNejv+Vr5 l1+bgfN0ha2a1zsmkozpkUI76onBKhZl3/V420pnrRKFmfkry1VqsL41W+Znf1slNpHKo0RV+ky eA3q4ygPTEGGsxWAgcLq7ATEmiTu/yLuQ3PeByryQzdDHW1AZN9p8hr7P6P88zfHI1O1Z7arWyx On9NnHVrpfxzXxskqvy/RBUFi5f4xg0WcTlu/EITfHnGZLP/csKuiQtO0M1Gs83tRMjdFXt6F47 zM4D8xFypwx/qXMi9SSgiV+EBrckL7T20UXWXxFnzlH8ssHC1NGvdOZzhRkNooZuOcdj7OMnmrI i6amW/cGnhOFk916GXe7Lzj8Vocw== X-Received: by 2002:a05:6a00:1a89:b0:848:52bf:4296 with SMTP id d2e1a72fcca58-84f6b9aae50mr19277158b3a.15.1786375469457; Mon, 10 Aug 2026 08:24:29 -0700 (PDT) X-Received: by 2002:a05:6a00:1a89:b0:848:52bf:4296 with SMTP id d2e1a72fcca58-84f6b9aae50mr19277094b3a.15.1786375468952; Mon, 10 Aug 2026 08:24:28 -0700 (PDT) Received: from hu-mchitale-blr.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com. [103.229.18.19]) by smtp.googlemail.com with ESMTPSA id 41be03b00d2f7-cbe8f1af985sm4282634a12.11.2026.08.10.08.24.22 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Aug 2026 08:24:28 -0700 (PDT) From: Mayuresh Chitale To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Mayuresh Chitale , Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Mayuresh Chitale , Anup Patel , Atish Patra , Andrew Jones , Sunil V L , linux-riscv@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v5 08/14] perf: Add gtrace AUX buffer trace format type Date: Mon, 10 Aug 2026 20:52:10 +0530 Message-ID: <20260810152223.3946743-9-mayuresh.chitale@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> References: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Authority-Analysis: v=2.4 cv=O4YJeh9W c=1 sm=1 tr=0 ts=6a79ed2e cx=c_pps a=WW5sKcV1LcKqjgzy2JUPuA==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=Sv0fKeRqtYgA:10 a=s4-Qcg_JpJYA:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=yOCtJkima9RkubShWh1s:22 a=EUspDBNiAAAA:8 a=6jy1HB2Bu3O3gCBx7RsA:9 a=OpyuDcXvxspvyRM73sMx:22 X-Proofpoint-ORIG-GUID: Q1nAd2mF_o7DKzw6wk_R1Eqr_KXCZkoj X-Proofpoint-Spam-Info: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX1nKhjWqnGgKk DceVXSLtFJpNXyLiaGy/8UpRWpDXpOsmPjbiO+V6pcgdCZkrBD6sWmkjZGLNWs9gQ93tySOCY9d 4GftBvHnTvqn6srDHkXtxWE0vdF9ayc= X-Proofpoint-GUID: Q1nAd2mF_o7DKzw6wk_R1Eqr_KXCZkoj X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX42jFApweAeyR kB4hBjafkbLrUdpM+YDvGwK1sdvH9kV0BLrDf0nKaaj+056wYEoliNpkzYahAWezXRPMXsLCKxl OuvtqcQ/YEb72W3VX2rMBzjWq8t5DxdvRmNjZuj7iXQNou4bAGmmJtieaQGHXg8F9Heq70de5bz 4qvMHfS96SkT1BM67pp+s6rslOD0FRUIrnsLg7bZ1dlLQZ4+mc3NQhRaAdNYdaRD5ZGEh4nJi3A 2Y1/y5Os8uU4X/DikKPD8O2e3PWGYf/wXkNXj8cIBbukh4XXLn+j8vSsZ7RYJnlwziaS55s0aNt HvhChc4a9IzQeJyL6PolR2Pabg3/qZ9pwOzzWfFNoaleY1U302d7lfExHnOxrDGpKFlLwc1UlRF bWsqhjJOHbIBkVs0zOEBfenUc0mRPqqQXEBLvF8l2Ir2vOd5U6tamgc0JA8McV1Y9Gcc661C5bN p6rkny+XP7q0LT5TCVQ== X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1176,Hydra:6.1.134,FMLib:17.12.100.49 definitions=2026-08-10_03,2026-08-07_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 spamscore=0 priorityscore=1501 adultscore=0 clxscore=1015 malwarescore=0 phishscore=0 bulkscore=0 lowpriorityscore=0 suspectscore=0 impostorscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2606150000 definitions=main-2608100132 Content-Type: text/plain; charset="utf-8" The gtrace PMU can host trace components of different architectures and trace protocols, so the recorded AUX data needs to carry its format as well. Define PERF_AUX_FLAG_GTRACE_FORMAT_ETRACE for the RISC-V E-trace format which the perf tool can use to decode the payload. Signed-off-by: Mayuresh Chitale --- include/uapi/linux/perf_event.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/include/uapi/linux/perf_event.h b/include/uapi/linux/perf_even= t.h index fd10aa8d697f..ca2d8614a780 100644 --- a/include/uapi/linux/perf_event.h +++ b/include/uapi/linux/perf_event.h @@ -1311,6 +1311,10 @@ enum perf_callchain_context { #define PERF_AUX_FLAG_CORESIGHT_FORMAT_CORESIGHT 0x0000 /* Default for bac= kward compatibility */ #define PERF_AUX_FLAG_CORESIGHT_FORMAT_RAW 0x0100 /* Raw format of the so= urce */ =20 +/* gtrace PMU AUX buffer formats */ +#define PERF_AUX_FLAG_GTRACE_FORMAT_UNKNOWN 0x0000 +#define PERF_AUX_FLAG_GTRACE_FORMAT_ETRACE 0x0100 /* RISC-V E-trace forma= t */ + #define PERF_FLAG_FD_NO_GROUP (1UL << 0) #define PERF_FLAG_FD_OUTPUT (1UL << 1) #define PERF_FLAG_PID_CGROUP (1UL << 2) /* pid=3Dcgroup ID, per-CPU mode= only */ --=20 2.43.0 From nobody Tue Sep 29 08:26:17 2026 Received: from mx0a-0031df01.pphosted.com (mx0a-0031df01.pphosted.com [205.220.168.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8E6A13F9278 for ; Mon, 10 Aug 2026 15:24:39 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=205.220.168.131 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375481; cv=none; b=TprJ2So5KVFBr1wZq4W0JSpfUguoPGTO0n2yEYKKfa2VByT3UOY9poQBPlauBR/hJv2nh1IGo3sYU6SiGEi50mVHYo3CIez7OiqneCYB58U+XuYBoHcL9XtBLEhC001ovmDdXwsvTCwaGxlgW7A8Kxw3sdjxFXeZo9F2y2KVS3g= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375481; c=relaxed/simple; bh=ikKKopLhztnYDbRF6631l+JmVWsrY4TGksETB85cIig=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=obx0K+4eaJDiwp7RCF011ay7oZCe8NRpEas17dZsMOT7VxgM8LMZjBj+W617OirCKUzGbuZ0jSGZUHYZXlYNbJN3BrJHP4tw8yyRrr2NZQB4dI4LRdmPJcRgbdR5mTil0+tdE/uV8cNw1YMxWcb6ezWK8Ya43kO8O9AtyVMpRL8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=oss.qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=VMyAuc5w; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b=KJtHxWFp; arc=none smtp.client-ip=205.220.168.131 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="VMyAuc5w"; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b="KJtHxWFp" Received: from pps.filterd (m0279862.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 67ACj5aF1343224 for ; Mon, 10 Aug 2026 15:24:38 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qualcomm.com; h= cc:content-transfer-encoding:date:from:in-reply-to:message-id :mime-version:references:subject:to; s=qcppdkim1; bh=lzDMmAD0xOQ mX/Xf0iW0AFAXwF9POaztIiwjZypmNYk=; b=VMyAuc5wwm96QWkCLv5JlfSE79t 8HWS4ZzQBgIz5e9H/otIkxnciHre6+uc+SwedssVp4g7fhVoULz/W2zfgbsm8qUv DQwp0pAjvXCGliU93Ma8fn86vEEn5VhrdEncdttmAS+mEF7qzPN1tfO2c+c2/q11 pWPsm50xcV19aG47cn73WgcQXZfTguEyfvj5p0+XAsucQOR3+V2igkjryOOBkbXF BnoLgKPYUxKDpK/hNTVmp62nMDjMDo9Na5AUg8ucvKa/EcCKI+pa4RJt/YOshdMl JL8G5m7AgtDnio7xbB6Y9Q8cKGw1ld8sBkMjDUS4YF3AUj42yCo33T0qDig== Received: from mail-pg1-f198.google.com (mail-pg1-f198.google.com [209.85.215.198]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4fy8v5a7by-1 (version=TLSv1.3 cipher=TLS_AES_128_GCM_SHA256 bits=128 verify=NOT) for ; Mon, 10 Aug 2026 15:24:37 +0000 (GMT) Received: by mail-pg1-f198.google.com with SMTP id 41be03b00d2f7-cbb467e56aaso2400039a12.1 for ; Mon, 10 Aug 2026 08:24:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oss.qualcomm.com; s=google; t=1786375477; x=1786980277; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=lzDMmAD0xOQmX/Xf0iW0AFAXwF9POaztIiwjZypmNYk=; b=KJtHxWFpwcrHyX3ugjzTV4eJu3jPQMRmMwG7ZvRNODIKKEmkxcFx8y8YJcwqeOJSpL OoPSQLK7XNnL2YFXYSink2sD5KoYoLnTCLDnoPXkKt6QSayJKS7U4SfFiqPZsRSI8TE+ V9J2rk3bwlX1a4K6Wb9D9NMDvv8HLDZ52gaXh3nga7jqinNBzI65lPX8sGsiIlg6ERzg AjuYgD3NxQnyBTx/PubAeyzGmJIOPdY+hmgqW+pDRGXjTKOk5iv+P1CWHj7Fz/jBQiyx aa/p3mg2NWPN+sfkg20Pj8enXfGueTjAoKyD1WMq13I525QHWg7g1PGIFt688QGe5DIF bCQg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1786375477; x=1786980277; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=lzDMmAD0xOQmX/Xf0iW0AFAXwF9POaztIiwjZypmNYk=; b=kRJRerkZOsu/Do4sdnJNOEnNkBFtWJ/kc2gRJybCds0vB55zWI/JwdPJ6FQODXQHXt VYEqymVqBUmCsLmWN0nCV+GnQbPHenJ0Wl4kbjA+gR5KU4H6KAo4eVhtBzgJBK+rc3ay lbrA6hGNetQ8OZGMOtCHpF48qp8fmJ6h+r7HXZ7EzF5om/x4X+VyXnjj4sqGkH58MEKK MsBiY1UmJ/pOV5uBYvaX2LlrJa5qItaW1u2wzFtOU9fy5fYxVg4AeBc2+lHD4W7FtAMX jRbU39JbvSModyaO65zgBRpbTeOhxA9F0o7GNWsmpnxzv5zz4EkDlRDxWtPxrFVVY3H1 4Dmg== X-Forwarded-Encrypted: i=1; AHgh+Rroz6TlL5zPc21mejiPtKofaa9I/cJpGu4xGjN2OV3PaSBUjrqc/KxNGO+25RbVfzPP+z0BE41VWAA1Rp0=@vger.kernel.org X-Gm-Message-State: AOJu0YyOqLr7K4iGAIuq4NHJE9QVRZ13vlNv6mM0UfrTzDxBjT0+BeeW nMxWvyXxgkUCyDE066gtyb7lnlAwEHhwhP6fs6yh4WVMSRLaB3zKoRfpfe0TUDBD9I1fTRXdZEm 2ZBQl7kdiKHbDj425jwIypJMoJLZ55Hc09KDlZvx6sqmH6fbLlaWoZLXWT6wvYd7AwFA= X-Gm-Gg: AR+sD11JBeg7tX2Dycl94ACcYYbqd6JZyaw2SE/nT6kSJUOX9iLKTR/FbXrTd5dW/Mx LRUt6MzCdAfF2nF4tg4DnraKsAfEN3hngufBbyA3XV63s+bl2aI53UQRfbqWiezeqNHv9E9rjug FHIma3f50IRC0RaeX+/F5LQYsdTN07VBgGp/6IAzfww1eg3uFq9D0x/BiuY/z0WsALDYywt0Bhr G06To0VpRvLSasSOY+jfjUkdX9vMYzMp0hFDBFEzVqRh9vdlzu1ljKGHUNpVX0VWl9wMDY511F6 oh9Fg1HkybZJmrrhiASG4ptQf3+6ItO3OwqcyJAAxnwM6D/8iuzF4RfDNb2YJpIHFmVFdiLj1DC vovYUP5vInLrSJGGl5lTVOCW2t0c1Cw/R9Y8FNpbgnQu6DjIKB52iP27+ws1jffzPqp2Kio0u2H HyxFl48225GnbWQVcAjomgzUKnjQ== X-Received: by 2002:a05:6a21:6e92:b0:3c6:61c6:8970 with SMTP id adf61e73a8af0-3cb85df2778mr58309971637.14.1786375476993; Mon, 10 Aug 2026 08:24:36 -0700 (PDT) X-Received: by 2002:a05:6a21:6e92:b0:3c6:61c6:8970 with SMTP id adf61e73a8af0-3cb85df2778mr58309911637.14.1786375476473; Mon, 10 Aug 2026 08:24:36 -0700 (PDT) Received: from hu-mchitale-blr.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com. [103.229.18.19]) by smtp.googlemail.com with ESMTPSA id 41be03b00d2f7-cbe8f1af985sm4282634a12.11.2026.08.10.08.24.29 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Aug 2026 08:24:36 -0700 (PDT) From: Mayuresh Chitale To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Mayuresh Chitale , Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Mayuresh Chitale , Anup Patel , Atish Patra , Andrew Jones , Sunil V L , linux-riscv@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, Anup Patel Subject: [PATCH v5 09/14] gtrace: Add RISC-V Trace ramsink driver Date: Mon, 10 Aug 2026 20:52:11 +0530 Message-ID: <20260810152223.3946743-10-mayuresh.chitale@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> References: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-Spam-Info: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX99P7+e7RrR0D 66IUD70M/7RleEH2jvKY+dGz3jS511k2H4gJSldZPtxAs48LmcFMRSlOhJ1qbaOUmeYIPXK5jM7 IXK+C5NMGDfhd7cuaMFFAYjnxO0Y1nQ= X-Authority-Analysis: v=2.4 cv=J6qaKgnS c=1 sm=1 tr=0 ts=6a79ed35 cx=c_pps a=Qgeoaf8Lrialg5Z894R3/Q==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=Sv0fKeRqtYgA:10 a=s4-Qcg_JpJYA:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=_K5XuSEh1TEqbUxoQ0s3:22 a=EUspDBNiAAAA:8 a=OYi3kTF5xvdVTFsD8bAA:9 a=x9snwWr2DeNwDh03kgHS:22 X-Proofpoint-GUID: xbWVv8jtSvLSVxyaK-hPBpPwMYUUVB1C X-Proofpoint-ORIG-GUID: xbWVv8jtSvLSVxyaK-hPBpPwMYUUVB1C X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfXzirKOYcypkHv RMTSKlg3pwRAOneXnUdVK0o3LT5vR+gbKMqn1gct8Pz9gnDHe6BCmDWQPKrlgHcAvqx9hkf1YFi wg6piNRWADsaz4eonGnmRUCC2CVaKUGNE0Ad+nV1yxf5s5IONJDInx3KsHxDHAv1akpRNPhRLdj 2nbFvcn63o0k/MxPdbSM6B1uldev0aILwWUc3+Wmif5fHoeYOon79dHOqWobZiB3QbPZkitlCx/ dUSA9tPAWYeXrjuY0ShG2/EofhgJZi05IRaNw+Fnv2ieN3SP+uTG3GY8JqsscrK6CU2sp/BJMRM NfwO/yXN15jl/vOCMOuKE3fps+J7MgcM9XFDVOhhzL7baWeMss070VCblWCsWvrEGMMVylgb4sL WtKNE0N64+0WNc1ESK6I+9rhKXFVCNS8XIuT622skaDw8e1EaKWhe41WxWggWDgDEV68Ysyf4rc /EpVOCkEyLOsl7ZvecQ== X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1176,Hydra:6.1.134,FMLib:17.12.100.49 definitions=2026-08-10_03,2026-08-07_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 suspectscore=0 phishscore=0 spamscore=0 lowpriorityscore=0 priorityscore=1501 impostorscore=0 clxscore=1015 adultscore=0 bulkscore=0 malwarescore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2606150000 definitions=main-2608100132 Content-Type: text/plain; charset="utf-8" Add initial implementation of RISC-V E-Trace ramsink driver. The ramsink is defined in the RISC-V Trace Control Interface specification. Co-developed-by: Anup Patel Signed-off-by: Anup Patel Signed-off-by: Mayuresh Chitale --- drivers/hwtracing/gtrace/Kconfig | 15 + drivers/hwtracing/gtrace/Makefile | 1 + drivers/hwtracing/gtrace/rvtrace-ramsink.c | 320 +++++++++++++++++++++ 3 files changed, 336 insertions(+) create mode 100644 drivers/hwtracing/gtrace/rvtrace-ramsink.c diff --git a/drivers/hwtracing/gtrace/Kconfig b/drivers/hwtracing/gtrace/Kc= onfig index e3a621b59913..de4a3b533591 100644 --- a/drivers/hwtracing/gtrace/Kconfig +++ b/drivers/hwtracing/gtrace/Kconfig @@ -41,3 +41,18 @@ config RVTRACE_ENCODER =20 To compile this driver as a module, choose M here: the module will be called rvtrace-encoder. + +config RVTRACE_RAMSINK + tristate "RISC-V Trace Ramsink driver" + depends on RVTRACE + select DMA_SHARED_BUFFER + default y + help + This driver provides support for the RISC-V trace ramsink component + which is defined by the RISC-V Trace Control Interface specification. + The ramsink is a trace sink which stores the trace data generated by + the upstream components into a system memory buffer. The buffer is + then copied to the perf AUX buffer when tracing using the perf tool. + + To compile this driver as a module, choose M here: the module + will be called rvtrace-ramsink. diff --git a/drivers/hwtracing/gtrace/Makefile b/drivers/hwtracing/gtrace/M= akefile index 10a74f852115..3e0c68d1b632 100644 --- a/drivers/hwtracing/gtrace/Makefile +++ b/drivers/hwtracing/gtrace/Makefile @@ -5,3 +5,4 @@ gtrace-y :=3D gtrace-core.o =20 obj-$(CONFIG_RVTRACE) +=3D rvtrace-platform.o obj-$(CONFIG_RVTRACE_ENCODER) +=3D rvtrace-encoder.o +obj-$(CONFIG_RVTRACE_RAMSINK) +=3D rvtrace-ramsink.o diff --git a/drivers/hwtracing/gtrace/rvtrace-ramsink.c b/drivers/hwtracing= /gtrace/rvtrace-ramsink.c new file mode 100644 index 000000000000..7ed25cf364a7 --- /dev/null +++ b/drivers/hwtracing/gtrace/rvtrace-ramsink.c @@ -0,0 +1,320 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2026 Qualcomm Technologies, Inc. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "rvtrace.h" + +#define RVTRACE_RAMSINK_STARTLOW_OFF 0x010 +#define RVTRACE_RAMSINK_STARTHIGH_OFF 0x014 +#define RVTRACE_RAMSINK_LIMITLOW_OFF 0x018 +#define RVTRACE_RAMSINK_LIMITHIGH_OFF 0x01c +#define RVTRACE_RAMSINK_WPLOW_OFF 0x020 +#define RVTRACE_RAMSINK_WPHIGH_OFF 0x024 +#define RVTRACE_RAMSINK_WPLOW_WRAP 0x1 +#define RVTRACE_RAMSINK_CTRL_MODE_SHIFT 0x4 +#define RVTRACE_RAMSINK_CTRL_STP_WRAP_SHIFT 0x8 + +enum rvtrace_ramsink_mode { + MODE_SRAM, + MODE_SMEM +}; + +struct rvtrace_ramsink_priv { + size_t size; + void *va; + dma_addr_t start; + dma_addr_t end; + enum rvtrace_ramsink_mode mode; + bool stop_on_wrap; + int mem_acc_width; + u64 prev_wp; +}; + +struct trace_buf { + void *base; + size_t cur; + size_t len; +}; + +static int rvtrace_ramsink_start(struct gtrace_component *comp) +{ + int ret; + + ret =3D gtrace_enable_component(comp); + if (ret) + dev_err(&comp->dev, "failed to start ramsink.\n"); + + return ret; +} + +static int rvtrace_ramsink_stop(struct gtrace_component *comp) +{ + int ret; + + ret =3D gtrace_disable_component(comp); + if (ret) { + dev_err(&comp->dev, "failed to stop ramsink.\n"); + return ret; + } + + return rvtrace_comp_poll_empty(comp); +} + +static void tbuf_to_pbuf_copy(struct trace_buf *src, struct trace_buf *dst= , size_t size) +{ + int bytes_dst, bytes_src, bytes; + void *dst_addr, *src_addr; + + /* If destination cannot hold entire source buffer then write only the la= test data. */ + if (dst->len < size) { + src->cur =3D (src->cur + size - dst->len) % src->len; + size =3D dst->len; + } + + while (size) { + src_addr =3D src->base + src->cur; + dst_addr =3D dst->base + dst->cur; + + /* Ensure that there are no OOB memory accesses */ + if (dst->len - dst->cur < size) + bytes_dst =3D dst->len - dst->cur; + else + bytes_dst =3D size; + + if (src->len - src->cur < size) + bytes_src =3D src->len - src->cur; + else + bytes_src =3D size; + bytes =3D bytes_dst < bytes_src ? bytes_dst : bytes_src; + memcpy(dst_addr, src_addr, bytes); + dst->cur =3D (dst->cur + bytes) % dst->len; + src->cur =3D (src->cur + bytes) % src->len; + size -=3D bytes; + } +} + +static size_t rvtrace_ramsink_copyto_auxbuf(struct gtrace_component *comp, + struct gtrace_perf_auxbuf *buf, + u64 *format) +{ + struct rvtrace_ramsink_priv *priv =3D dev_get_drvdata(&comp->dev); + struct trace_buf src, dst; + u32 wp_low, wp_high; + size_t bytes =3D 0; + bool wrap; + u64 wp; + + dst.base =3D buf->base; + dst.len =3D buf->length; + dst.cur =3D buf->pos; + src.base =3D priv->va; + src.len =3D priv->size; + wp_low =3D gtrace_read32(comp->pdata, RVTRACE_RAMSINK_WPLOW_OFF); + wp_high =3D gtrace_read32(comp->pdata, RVTRACE_RAMSINK_WPHIGH_OFF); + wp =3D (u64)(wp_high) << 32 | wp_low; + wrap =3D wp & RVTRACE_RAMSINK_WPLOW_WRAP; + wp &=3D ~RVTRACE_RAMSINK_WPLOW_WRAP; + if (wrap) { + gtrace_write32(comp->pdata, lower_32_bits(priv->start), + RVTRACE_RAMSINK_WPLOW_OFF); + gtrace_write32(comp->pdata, upper_32_bits(priv->start), + RVTRACE_RAMSINK_WPHIGH_OFF); + src.cur =3D wp - priv->start; + priv->prev_wp =3D priv->start; + /* + * There is no way to tell if trRamWp wrapped around more than once. As a + * result priv->prev_wp can't be used and the entire buffer must be copi= ed + * even though some data might be duplicated. + */ + bytes =3D priv->size; + } else { + src.cur =3D priv->prev_wp - priv->start; + bytes =3D wp - priv->prev_wp; + priv->prev_wp =3D wp; + } + + tbuf_to_pbuf_copy(&src, &dst, bytes); + dev_dbg(&comp->dev, "Copied %zu bytes\n", bytes); + *format =3D PERF_AUX_FLAG_GTRACE_FORMAT_ETRACE; + return bytes; +} + +static int rvtrace_ramsink_setup_buf(struct gtrace_component *comp, + struct rvtrace_ramsink_priv *priv) +{ + struct device *pdev =3D comp->pdata->dev; + u64 start_min, limit_max, end; + u32 low, high; + int ret; + + /* Probe min and max values for start and limit registers */ + gtrace_write32(comp->pdata, 0, RVTRACE_RAMSINK_STARTLOW_OFF); + gtrace_write32(comp->pdata, 0, RVTRACE_RAMSINK_STARTHIGH_OFF); + low =3D gtrace_read32(comp->pdata, RVTRACE_RAMSINK_STARTLOW_OFF); + high =3D gtrace_read32(comp->pdata, RVTRACE_RAMSINK_STARTHIGH_OFF); + start_min =3D (u64)(high) << 32 | low; + + gtrace_write32(comp->pdata, 0xffffffff, RVTRACE_RAMSINK_LIMITLOW_OFF); + gtrace_write32(comp->pdata, 0xffffffff, RVTRACE_RAMSINK_LIMITHIGH_OFF); + low =3D gtrace_read32(comp->pdata, RVTRACE_RAMSINK_LIMITLOW_OFF); + high =3D gtrace_read32(comp->pdata, RVTRACE_RAMSINK_LIMITHIGH_OFF); + limit_max =3D (u64)(high) << 32 | low; + + /* Set DMA mask based on the maximum allowed limit address */ + ret =3D dma_set_mask_and_coherent(pdev, DMA_BIT_MASK(fls64(limit_max))); + if (ret) + return ret; + + priv->va =3D dma_alloc_coherent(pdev, priv->size, &priv->start, GFP_KERNE= L); + if (!priv->va) + return -ENOMEM; + + priv->end =3D priv->start + priv->size; + priv->prev_wp =3D priv->start; + if (priv->end <=3D start_min || priv->start >=3D limit_max) { + dma_free_coherent(pdev, priv->size, priv->va, priv->start); + dev_err(&comp->dev, "DMA memory not addressable by device\n"); + return -EINVAL; + } + + /* Setup ram sink start addresses */ + if (priv->start < start_min) { + dev_warn(&comp->dev, "Ramsink start address updated from %pad to %pad\n", + &priv->start, &start_min); + priv->va +=3D start_min - priv->start; + priv->start =3D start_min; + } + + gtrace_write32(comp->pdata, lower_32_bits(priv->start), RVTRACE_RAMSINK_S= TARTLOW_OFF); + gtrace_write32(comp->pdata, upper_32_bits(priv->start), RVTRACE_RAMSINK_S= TARTHIGH_OFF); + gtrace_write32(comp->pdata, lower_32_bits(priv->start), RVTRACE_RAMSINK_W= PLOW_OFF); + gtrace_write32(comp->pdata, upper_32_bits(priv->start), RVTRACE_RAMSINK_W= PHIGH_OFF); + /* Setup ram sink limit addresses */ + if (priv->end > limit_max) { + dev_warn(&comp->dev, "Ramsink limit address updated from %pad to %pad\n", + &priv->end, &limit_max); + priv->end =3D limit_max; + priv->size =3D priv->end - priv->start; + } + + /* Limit address needs to be set to end - mem_access_width to avoid overf= low */ + end =3D priv->end - priv->mem_acc_width; + gtrace_write32(comp->pdata, lower_32_bits(end), RVTRACE_RAMSINK_LIMITLOW_= OFF); + gtrace_write32(comp->pdata, upper_32_bits(end), RVTRACE_RAMSINK_LIMITHIGH= _OFF); + low =3D gtrace_read32(comp->pdata, RVTRACE_RAMSINK_LIMITLOW_OFF); + high =3D gtrace_read32(comp->pdata, RVTRACE_RAMSINK_LIMITHIGH_OFF); + end =3D (u64)(high) << 32 | low; + if (end !=3D (priv->end - 4)) { + dev_warn(&comp->dev, "Ramsink limit address updated from %pad to %pad\n", + &priv->end, &end); + priv->end =3D end; + priv->size =3D priv->end - priv->start; + } + + return 0; +} + +static int rvtrace_ramsink_setup(struct gtrace_component *comp) +{ + struct rvtrace_ramsink_priv *priv; + u32 trram_ctrl; + int ret; + + priv =3D devm_kzalloc(&comp->dev, sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + /* Derive RAM sink memory size based on component implementation ID */ + switch (comp->pdata->impid) { + default: + priv->size =3D SZ_1M; + priv->mode =3D MODE_SMEM; + priv->stop_on_wrap =3D false; + priv->mem_acc_width =3D 4; + break; + } + + trram_ctrl =3D gtrace_read32(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET); + trram_ctrl |=3D priv->mode << RVTRACE_RAMSINK_CTRL_MODE_SHIFT; + gtrace_write32(comp->pdata, trram_ctrl, RVTRACE_COMPONENT_CTRL_OFFSET); + trram_ctrl =3D gtrace_read32(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET); + dev_dbg(&comp->dev, "mode: %s\n", (trram_ctrl >> RVTRACE_RAMSINK_CTRL_MOD= E_SHIFT) & 0x1 ? + "SMEM" : "SRAM"); + + trram_ctrl |=3D priv->stop_on_wrap << RVTRACE_RAMSINK_CTRL_STP_WRAP_SHIFT; + gtrace_write32(comp->pdata, trram_ctrl, RVTRACE_COMPONENT_CTRL_OFFSET); + + ret =3D rvtrace_ramsink_setup_buf(comp, priv); + if (!ret) + dev_set_drvdata(&comp->dev, priv); + + return ret; +} + +static void rvtrace_ramsink_cleanup(struct gtrace_component *comp) +{ + struct rvtrace_ramsink_priv *priv =3D dev_get_drvdata(&comp->dev); + + dma_free_coherent(comp->pdata->dev, priv->size, priv->va, priv->start); +} + +static int rvtrace_ramsink_probe(struct gtrace_component *comp) +{ + int ret; + + ret =3D rvtrace_ramsink_setup(comp); + if (ret) + return dev_err_probe(&comp->dev, ret, "failed to setup ramsink.\n"); + + return ret; +} + +static void rvtrace_ramsink_remove(struct gtrace_component *comp) +{ + rvtrace_ramsink_cleanup(comp); +} + +static const struct gtrace_component_id rvtrace_ramsink_ids[] =3D { + { .type =3D GTRACE_RVTRACE_RAMSINK, + .version =3D rvtrace_component_mkversion(1, 0), }, + {}, +}; + +static struct gtrace_driver rvtrace_ramsink_driver =3D { + .id_table =3D rvtrace_ramsink_ids, + .copyto_auxbuf =3D rvtrace_ramsink_copyto_auxbuf, + .stop =3D rvtrace_ramsink_stop, + .start =3D rvtrace_ramsink_start, + .probe =3D rvtrace_ramsink_probe, + .remove =3D rvtrace_ramsink_remove, + .driver =3D { + .name =3D "rvtrace-ramsink", + }, +}; + +static int __init rvtrace_ramsink_init(void) +{ + return gtrace_register_driver(&rvtrace_ramsink_driver); +} + +static void __exit rvtrace_ramsink_exit(void) +{ + gtrace_unregister_driver(&rvtrace_ramsink_driver); +} + +module_init(rvtrace_ramsink_init); +module_exit(rvtrace_ramsink_exit); + +/* Module information */ +MODULE_AUTHOR("Mayuresh Chitale"); +MODULE_DESCRIPTION("RISC-V E-Trace Ramsink Driver"); +MODULE_LICENSE("GPL"); --=20 2.43.0 From nobody Tue Sep 29 08:26:17 2026 Received: from mx0b-0031df01.pphosted.com (mx0b-0031df01.pphosted.com [205.220.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A271A3FDC05 for ; Mon, 10 Aug 2026 15:24:46 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=205.220.180.131 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375488; cv=none; b=oUTRVJhEVq1YiQGZUnjCPD0ImYC/68Y/dd419Km8JbqqwQGKFwU7dzVsonO4JkIYEJQvkdBaFR6V1L2NCY1vAV272DaZiARVCKE1jirpYFnshpeyjwQWd89XpPALEUXKFcfp+O2J12Arw4pFdKkMAVHvCKqLKT3XbQZ5d6+IIls= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375488; c=relaxed/simple; bh=MyG4/H4DcAIPpCJe6XPdeF4pbvoQzAOjtvN2yXg5erY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=rMDyHmQeOBh7Fq8ezoypxFWHfZeGwEwhE+sadgQeB1FJ+gJS/o1j/Gkdv29tkGLQZxTn+8fSW/VKJuMfRO19hay4Wv/izwkjMPrTBfrRRIVdJbL2et2Wi+46Rc0aYJCqvVUgrjdp6LEIrfNFVQ6FeFdQRTPKUcx/ZEZENjewX5E= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=oss.qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=C4J3hB6f; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b=aA052coN; arc=none smtp.client-ip=205.220.180.131 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="C4J3hB6f"; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b="aA052coN" Received: from pps.filterd (m0279869.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 67ACioh9397251 for ; Mon, 10 Aug 2026 15:24:45 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qualcomm.com; h= cc:content-transfer-encoding:date:from:in-reply-to:message-id :mime-version:references:subject:to; s=qcppdkim1; bh=LOklvPZbSkI l6v6AIVmRwrfMBoY1hOJLM+FnLZPE6WY=; b=C4J3hB6foIx/BjC/I+MQqSuhTZM 4nvCndqWcbK12lqXwwXM3fsCn8BfLoJwAclEnn6ts4mXIYWhwn/l/TzAAIStGyh4 4uofn3M479rKO25HL7FKtnDHoYnh2ef9T4Bz7wconPfUkZWJ2klyNkDWOngzwJMl Zyh/idKjzc/TAGsWBINOjUX4Tt5MvnleHK4CanNYwcNVGwSPLSueKK17KIIvOUtT 1UvwAn5OF8RfEPKLamJzc4yCVLY8GILc9PEFp9eUlLcbMapxdduAGHUy9b4ZXXzX HjDDKm0MuOBfxJwphy7YKNq5534hMcg0TKlDmbk4X9IHCEn3BM2/w2c7ayw== Received: from mail-pg1-f200.google.com (mail-pg1-f200.google.com [209.85.215.200]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4fycgesbm7-1 (version=TLSv1.3 cipher=TLS_AES_128_GCM_SHA256 bits=128 verify=NOT) for ; Mon, 10 Aug 2026 15:24:45 +0000 (GMT) Received: by mail-pg1-f200.google.com with SMTP id 41be03b00d2f7-cbb92868263so2482532a12.2 for ; Mon, 10 Aug 2026 08:24:45 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oss.qualcomm.com; s=google; t=1786375484; x=1786980284; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=LOklvPZbSkIl6v6AIVmRwrfMBoY1hOJLM+FnLZPE6WY=; b=aA052coN+Wnb5dvRXymCSmV3nF+qp+NCiKhcE128/vpB7zdDoA6BiR80gn8zQJrCCl CUHMUGIzzN/RwP7n4kultkpEOg9KH7jKiQnq9knwxRZeYHHwDaDKbI4rqFuWv9iYrWGw G3Hpv/jGRkJPXUV04bexNiiwHMuapHUatsFFBvAYeBOiVK1xo2p58rYt8Ugt6U2pHuux ykaCXqtE5NrvtptnuUpkbuEbRm7yQ8nqxxu0PvBltsSNXPDJEeAcj5BbU6GTYyph2gCl m5cS6r8QPOosrAVqeRsMmxFb6bnFL2X09aWj3OBWZwzBhsdeEHjrVft0VzJn9lHY82da ncpQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1786375484; x=1786980284; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=LOklvPZbSkIl6v6AIVmRwrfMBoY1hOJLM+FnLZPE6WY=; b=WFXM3isMx+XIIrK2nxJiAEcguYuEaNDLwubXIl2uh/ONp8WsVps7skAQk1KzZM4opf Oi2aHjikBLORUWPHvV6xDbeROdN7G4i5ugxl3lRCOD2G4UPmUuW01SXymI0JsBTuRveD J83lftfjm1bO4ca4kZKOgDjcKECGmdcokN5hL1MJvnK7l9LSmgWNgkfxA2hOv23WAlSK tQfqh8Z1yrZnkqOLpKAhBhv1ckCxmU/Kv43hDzLZD10r77PInutkqsKkbn5EwPZvWTky 29cK41vxpQ/HfUThRGUJwKaL0Hg30oN2K319Hd8+W674taNYHsGQrCaGnkQ7BP+kD1LV a4wg== X-Forwarded-Encrypted: i=1; AHgh+RpvCnjQRT/iTI0N3Vwf/iUVop3B3hwWQplYncEWBcx139qBYUAmyfiDwnvT+9FNsYMl9rmzqnJYihMRDdw=@vger.kernel.org X-Gm-Message-State: AOJu0YyT9Pmk6Vzvd07QlxYdmQXycMTIa4Fw+ovAx5u4rKKiVRoquzq1 HgoVjxPU1z6/Sj/Jydt0fG7mSOi5grRRoZ7/p/UuJgbE6Vodd1c9iSqiY9vwSylT/ni3kId0MaX Nq9jPiV8BHbHy7h+sld3Dje/6DppG2RMJDO1fTNNOHdnLJkMxMom3qXvV78lJ0rFTex8= X-Gm-Gg: AR+sD117MuFMdhr/2uMgS5xB0fMnMojzLoa+LV75MkKjKRI7mfoxGUQUFePiblhIUKu PSiajKtepWLWaPlxa1z43enVlaI42IYdvpL/01G3ZQUAVPJQqUgRjUh6xU3rj9iJNfpEEZbsYmj lxafq6MGVeWaiqtj5aD9WyQqCx1Bnc1A0PDhbO8VqKE29webIo/Kg8QXk8b4XYvQ3EFdhOwfgT+ fjBjiZCh56qm1BIzM1Tizku182MFyTyB7uuGXHYU7Zt/ZzA+ute95E++QpbOZOcgXDSbFccCayE +WD5z/FnUHsPy9gqOfZ1D90xkUMvwvsp77kXknLP+EE+iqwsiqsCmZ4V3ll3fRcCfvYIFKFRdPA /GUGpeE0172j+guECKfvlL/2HDECGodtw3/C2E4lyvKHzJ/bR26kVlrfJqltk1tA8KUdMjhjBi6 FY1yUW/KsLnb8EG+hE3xJMF/3FNQ== X-Received: by 2002:a05:6a00:2d8f:b0:848:48c6:480c with SMTP id d2e1a72fcca58-84f2e00e9ddmr45265715b3a.24.1786375484264; Mon, 10 Aug 2026 08:24:44 -0700 (PDT) X-Received: by 2002:a05:6a00:2d8f:b0:848:48c6:480c with SMTP id d2e1a72fcca58-84f2e00e9ddmr45265660b3a.24.1786375483712; Mon, 10 Aug 2026 08:24:43 -0700 (PDT) Received: from hu-mchitale-blr.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com. [103.229.18.19]) by smtp.googlemail.com with ESMTPSA id 41be03b00d2f7-cbe8f1af985sm4282634a12.11.2026.08.10.08.24.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Aug 2026 08:24:43 -0700 (PDT) From: Mayuresh Chitale To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Anup Patel , Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Mayuresh Chitale , Anup Patel , Atish Patra , Andrew Jones , Sunil V L , linux-riscv@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v5 10/14] riscv: Enable DMA_RESTRICTED_POOL in defconfig Date: Mon, 10 Aug 2026 20:52:12 +0530 Message-ID: <20260810152223.3946743-11-mayuresh.chitale@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> References: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-ORIG-GUID: KvKCKWWpVolOc8qZ1Sh6c4cZNc26d1yw X-Authority-Analysis: v=2.4 cv=R4cz39RX c=1 sm=1 tr=0 ts=6a79ed3d cx=c_pps a=oF/VQ+ItUULfLr/lQ2/icg==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=Sv0fKeRqtYgA:10 a=s4-Qcg_JpJYA:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=_glEPmIy2e8OvE2BGh3C:22 a=EUspDBNiAAAA:8 a=GbvFXuxacV0FzgsEJgAA:9 a=3WC7DwWrALyhR5TkjVHa:22 X-Proofpoint-GUID: KvKCKWWpVolOc8qZ1Sh6c4cZNc26d1yw X-Proofpoint-Spam-Info: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX72fG+h1Pkoc4 NZJ3mNPsiU/BCT3bEBxa4Sq30ayRsUN5hus4W7dSAlPzfw8gynCICEBZthILnEErKs3HCEVxFhD CAlR1nCsovi36AMgW2GcN/HbvWH5cVg= X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX6qrEB6qCQaWQ x+U8TEEvYvoWtk819kpx7tAFfdOd+Ue1QyAn1d3xH77kd9xAbOrvlEwX/74DuPbAUSsBtBHA52V HYgJ6jHvhkkrwpNKMAkryTg6x+hTjOBcjmg1bfr/SZawh6AWGWcd1DBDKWYCB9zDXzsOcnFjN6P 336RrqYidpreB3iHb3Hqi+XQ9utKioZWkQlLFM8E8572AI+ld5hEyQPQJfqaqUdENC4eIlkY/7X MAsbwefM702stqq7jPSx4wRtlWsBU/QsXbp8u/iny079TQb0ogxVuThBcqABZ9tc6RNfK6uN2iG akaoygHj23AFeMaFAkQegy7kqkQmvSEZ+KRnsJlk4e+nAwoR5kXcWtRSkmhLVtF/NcgjCj8P0O7 xxNXh2RcU0oVVMX+L5uzV3Oq03z87a1MW2qhj59KPD3mFbrUcFlFP7CkrqlhoYHJh6uwGLPaTDi XFnJBdm5I0c5rZf6fCA== X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1176,Hydra:6.1.134,FMLib:17.12.100.49 definitions=2026-08-10_03,2026-08-07_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 spamscore=0 adultscore=0 malwarescore=0 priorityscore=1501 bulkscore=0 suspectscore=0 clxscore=1015 lowpriorityscore=0 impostorscore=0 phishscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2606150000 definitions=main-2608100132 Content-Type: text/plain; charset="utf-8" From: Anup Patel The RISC-V ramsink trace component may have implementation specific restrictions such that the component can only write trace data in particular parts of DRAM. Enable DMA_RESTRICTED_POOL in the defconfig so that dma_alloc_*() and dma_free_*() APIs work for devices with DMA address restrictions. Signed-off-by: Anup Patel --- arch/riscv/configs/defconfig | 1 + 1 file changed, 1 insertion(+) diff --git a/arch/riscv/configs/defconfig b/arch/riscv/configs/defconfig index ed605b5e3162..57692fcdbb89 100644 --- a/arch/riscv/configs/defconfig +++ b/arch/riscv/configs/defconfig @@ -304,6 +304,7 @@ CONFIG_SECURITY_APPARMOR=3Dy CONFIG_DEFAULT_SECURITY_DAC=3Dy CONFIG_CRYPTO_USER_API_HASH=3Dy CONFIG_CRYPTO_DEV_VIRTIO=3Dy +CONFIG_DMA_RESTRICTED_POOL=3Dy CONFIG_PRINTK_TIME=3Dy CONFIG_DEBUG_KERNEL=3Dy CONFIG_DEBUG_FS=3Dy --=20 2.43.0 From nobody Tue Sep 29 08:26:17 2026 Received: from mx0a-0031df01.pphosted.com (mx0a-0031df01.pphosted.com [205.220.168.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id EF86F40FDAC for ; Mon, 10 Aug 2026 15:24:53 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=205.220.168.131 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375495; cv=none; b=Kpkuaz9LgPewB0YwlcE2Rzk+JJqRP4onJK6ceg8w53ULprMPiObHtBJZxdf5rx7yoYG2SBOXbC/Py2vof9/wvq99Wu5Jabw9VQlSD4kY6GmL3uev/cfLGgJN/Acxb5x2GsZWRxviKodEn/i5j4iuMUeB3FOuGh4UFXVyPDMHPmY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375495; c=relaxed/simple; bh=tgf+IVxiVZKhbGaRfiLzFf6N7y+3gz6edNDUkGgFhy8=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=OqMEFcZDJU51M0095xOURgQnCEAp8Mbr+vL/UppiQV/BTKpdAiO+ZwAQ5xN23S+Vufbq6WwNT8aPxf41yXIoHMIPZlSz1jEKWytrmjwLwPzQdbaaywhL02xgIaA4+P4R/IUD3JPXSVi9ItCboEG3cWfJSfI5kDiFeivKgd3FqzU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=oss.qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=R5qfyTJ0; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b=E1Lro6Pv; arc=none smtp.client-ip=205.220.168.131 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="R5qfyTJ0"; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b="E1Lro6Pv" Received: from pps.filterd (m0279862.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 67ACj5pK1343238 for ; Mon, 10 Aug 2026 15:24:53 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qualcomm.com; h= cc:content-transfer-encoding:date:from:in-reply-to:message-id :mime-version:references:subject:to; s=qcppdkim1; bh=WFsC6PGmfD/ xegtg7aOxmBQNqWxDfwAUvD3dRQnjBfE=; b=R5qfyTJ0DnVFzSA58wN2g589Z4c u3nw8u4VdT5jeVzLyME2ywod+n0GO+TLUUFIhAsNgmoT0TRPc7ed2zfnKiJRXjel w+F+dKk6MIMga5uo7OimogVNRuSAM2NqVL8rq5vsXOb+BlwhH1KGD2FDo6dBwtp6 n2M8yY1CufUO/wKCMS1UR5CDRDbBbmP10QYmlvdYe0cvjEXsGUPbyzTiEA+sjnt4 9vndn5hnsSt+UJwkkhgXg0tovW6oePQ2MAOUPpby+OV1PIA4KxpdBRbDdJG+pitY ZTi2jQ83BkKad1TRm3ULG9FSpvzizInuMozSkhIA1FIHPMLw91H0BgxH1LQ== Received: from mail-pf1-f198.google.com (mail-pf1-f198.google.com [209.85.210.198]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4fy8v5a7d7-1 (version=TLSv1.3 cipher=TLS_AES_128_GCM_SHA256 bits=128 verify=NOT) for ; Mon, 10 Aug 2026 15:24:53 +0000 (GMT) Received: by mail-pf1-f198.google.com with SMTP id d2e1a72fcca58-84c4cd31b51so7051b3a.0 for ; Mon, 10 Aug 2026 08:24:52 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oss.qualcomm.com; s=google; t=1786375492; x=1786980292; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=WFsC6PGmfD/xegtg7aOxmBQNqWxDfwAUvD3dRQnjBfE=; b=E1Lro6PvfGYyfIsINXIjpk1eSxlyHv2lSR/Assr6LxotfXb8iJhiez8QqY0AVnRdd3 x22v+EjrUYaK80wrW86PhNMjhYs3n9PIOrBfYPjmzhcDEbMZwKlEVwnhbSmRFkw4Y8IS pvwB4dSfftEfQf+U5lqqiG+EaIbgesZVq7Zdf5KK0mvjIEM6Kixm21vzEJlqrkjNlvu5 RJf2+GzhNqCaS0rNe9FfKhhKR+epg4uw/5PlCLD/iXjn7q1h1xOOdwuGwhk8YWyqdqOG ePIssMK0io5B+GGHPHyI0mzBafmXZ33eE3lzMthXgvesm/JZUh2K6ZN9tqR2VPzyRrac xXRA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1786375492; x=1786980292; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=WFsC6PGmfD/xegtg7aOxmBQNqWxDfwAUvD3dRQnjBfE=; b=VqaLskcY98/T5D0iVq/9TuHjl5BC20XO+0zwazIps9HV/8exNpvIUxBqQpOZnISr3M tx38xpwAkHlIkeAvHAQHB1+UUZuha5kOk4YIpUEqTqgQpYGfY24VxswL6bQXjntRfN5i GE08rlHLkUkAUZaO8oTuo11zzgys0D7GjAuyeJmCiRR9hq6iCu7DIF7lkeVGYwDHfYlc DyhS+RNIogTuCqrRRHB1L/vEqFbx03xXf8htRLFIpDMr299QhSxzE9fdgxzK5tN517tA eoKwNYMkNQVamZFFHuEw2+epYvNqUzqDxasy3wD5WZ31h+4zstO+eEsCFc8rhuYA0hXe SqPg== X-Forwarded-Encrypted: i=1; AHgh+RpIlXODi79jmNnpmZlbRudHkbzARb7L8K81EufjK/U72GfqKlda5kiPCbubwwNuWYN1pwo8A15X6ULTK+w=@vger.kernel.org X-Gm-Message-State: AOJu0YzoKKZYWDm84EObJPGHqg5ffuM0z7H+3n4oJrZ5dJAIoQEK/RtA 4kdl3K2z59/K/5Nq8Lg5jVYqhlSIP8b0Nz5Y2RmBv6TQqWXEYTaQnIGS+5AW7jvD0am0WrBZbk9 HHulbd35Q9w1lLdEcaQwiHS+q88zaCXtgM6d8fGCqenI+xZymQxGqNYqam27GuoSZ5OQ= X-Gm-Gg: AR+sD10M+WmrupvhnVA0CDyLruSfNUG03A4yJ3LHps4h/6z6uubjHlyzoyuwT7ZE/3t JnGM9prnL28y2YSMqA6IW66EDri/50827zzL5mwmnaCoe2+2z22WvHuigjLy66GaNSdR12Lq8EL DkrY6+VhVc4HYDxkKIOhLoLeEbJAxqguYTwQtAgxaum9//IAA1cX4A4lfnnnVEByJ2YlavWxlF9 qYrXXVzTMMMKumH5CkAY7xiyaN0RtaYiMWzwgQ0LMvBUrMDrlCTgPhkydRS+7QhEpl59sw4Hw3K HF4V0f4ye24eDNkCxNbDmP8C1UkndE1oeQRfNhNzELkyQVipZLjQTkztelP8zJ9PesqbClpgaxv GM4mpTgYHYUg2HyX/yQqlJ8SKgOuacg2Yr9/ztfIcsKVJAuOCixQyorW3SGHSx2izoZCGROiwTB zHtiUqm5j6kLw3zmnTLe0OjxIl5g== X-Received: by 2002:a05:6a21:7101:b0:3bf:ab54:8db8 with SMTP id adf61e73a8af0-3cbd3a40d5cmr21251130637.17.1786375492018; Mon, 10 Aug 2026 08:24:52 -0700 (PDT) X-Received: by 2002:a05:6a21:7101:b0:3bf:ab54:8db8 with SMTP id adf61e73a8af0-3cbd3a40d5cmr21251039637.17.1786375491354; Mon, 10 Aug 2026 08:24:51 -0700 (PDT) Received: from hu-mchitale-blr.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com. [103.229.18.19]) by smtp.googlemail.com with ESMTPSA id 41be03b00d2f7-cbe8f1af985sm4282634a12.11.2026.08.10.08.24.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Aug 2026 08:24:50 -0700 (PDT) From: Mayuresh Chitale To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Mayuresh Chitale , Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Mayuresh Chitale , Anup Patel , Atish Patra , Andrew Jones , Sunil V L , linux-riscv@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, Anup Patel Subject: [PATCH v5 11/14] gtrace: Add perf driver for tracing using perf tool Date: Mon, 10 Aug 2026 20:52:13 +0530 Message-ID: <20260810152223.3946743-12-mayuresh.chitale@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> References: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-Spam-Info: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX+k5cwe7IpdjD quPRRmt9RXTTxzX1Z8HIzscY3EXS/o5NMSKLMDjRN2PBulE0mgxf5vhgqrrIA6PMuS4EDXkgat7 EWWwePYixMQVekisIODvkyCvDgDPR4M= X-Authority-Analysis: v=2.4 cv=J6qaKgnS c=1 sm=1 tr=0 ts=6a79ed45 cx=c_pps a=m5Vt/hrsBiPMCU0y4gIsQw==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=Sv0fKeRqtYgA:10 a=s4-Qcg_JpJYA:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=_K5XuSEh1TEqbUxoQ0s3:22 a=EUspDBNiAAAA:8 a=_CJk7DrN_qkI4yTom0IA:9 a=IoOABgeZipijB_acs4fv:22 X-Proofpoint-GUID: bVJs09ZSGP8GuLXu4nHxLRZoMdskI6nd X-Proofpoint-ORIG-GUID: bVJs09ZSGP8GuLXu4nHxLRZoMdskI6nd X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX/BxZLMlxAZ+y jWDD9bNYBExqM6i1sxVr0h3CR947PHnn1wymkt+a+1usu7WVcBAmU62/ga8V0OjFKnk8eo8u74m hLAkd8AHGsv0OcoL9asDMOowEQd+a0p+cTIkh56hiqGI06HKdk1HyfIo/kmZ4cP7MG6Rq8hlIpG xwvR1opTyQccE2Rok3152s/1VXhW45YVkXgLtFx38fbzfjIMoAgPgAGll7bM+8+MKuVOB/DDQM3 ONUclZfmg/V9Y+NmAFwxU2BAI07fOMyX3jeNSyXcfLZw268isPX4m5NHxJ3A7WR1iaZ7ZW1uPdJ 3OYnE1pkWEZXXUagVWCez2su5wMFfdHORsLik+g2iD1XDMdwotPCuYZveSV0icBzQReMoViUGR8 RaOwO5ZSQZGwH/ggMC5hBSSeQDZKHT0ZHt+/cwHvZRJtV/c9gpvKmCcz9xPGG3yQYp6ud1Uvfmr 2jtTSKN4s7kJAUC2T6A== X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1176,Hydra:6.1.134,FMLib:17.12.100.49 definitions=2026-08-10_03,2026-08-07_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 suspectscore=0 phishscore=0 spamscore=0 lowpriorityscore=0 priorityscore=1501 impostorscore=0 clxscore=1015 adultscore=0 bulkscore=0 malwarescore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2606150000 definitions=main-2608100132 Content-Type: text/plain; charset="utf-8" Add perf driver for the gtrace similar to ARM Coresight and Hisilicon PTT drivers. The driver adds 'gtrace' event descriptor which can be used by the perf tool to record the trace data. The actual data format depends on type of encoder device and optionally the PMU specific trace format type. Co-developed-by: Anup Patel Signed-off-by: Anup Patel Signed-off-by: Mayuresh Chitale --- drivers/hwtracing/gtrace/Kconfig | 1 + drivers/hwtracing/gtrace/Makefile | 2 +- drivers/hwtracing/gtrace/gtrace-core.c | 15 +- drivers/hwtracing/gtrace/gtrace-perf.c | 347 +++++++++++++++++++++++++ include/linux/gtrace.h | 3 + 5 files changed, 366 insertions(+), 2 deletions(-) create mode 100644 drivers/hwtracing/gtrace/gtrace-perf.c diff --git a/drivers/hwtracing/gtrace/Kconfig b/drivers/hwtracing/gtrace/Kc= onfig index de4a3b533591..e5b62d65e2fd 100644 --- a/drivers/hwtracing/gtrace/Kconfig +++ b/drivers/hwtracing/gtrace/Kconfig @@ -3,6 +3,7 @@ menuconfig GTRACE tristate "Generic Hardware Trace Support" depends on OF + select PERF_EVENTS help This framework provides an architecture-neutral kernel interface for hardware trace drivers. It builds a topological view of the diff --git a/drivers/hwtracing/gtrace/Makefile b/drivers/hwtracing/gtrace/M= akefile index 3e0c68d1b632..aa044fdc787b 100644 --- a/drivers/hwtracing/gtrace/Makefile +++ b/drivers/hwtracing/gtrace/Makefile @@ -1,7 +1,7 @@ # SPDX-License-Identifier: GPL-2.0 =20 obj-$(CONFIG_GTRACE) +=3D gtrace.o -gtrace-y :=3D gtrace-core.o +gtrace-y :=3D gtrace-core.o gtrace-perf.o =20 obj-$(CONFIG_RVTRACE) +=3D rvtrace-platform.o obj-$(CONFIG_RVTRACE_ENCODER) +=3D rvtrace-encoder.o diff --git a/drivers/hwtracing/gtrace/gtrace-core.c b/drivers/hwtracing/gtr= ace/gtrace-core.c index 53a3679ba69f..102251f6a5a7 100644 --- a/drivers/hwtracing/gtrace/gtrace-core.c +++ b/drivers/hwtracing/gtrace/gtrace-core.c @@ -714,13 +714,26 @@ EXPORT_SYMBOL_GPL(__gtrace_register_driver); =20 static int __init gtrace_init(void) { + int ret; + gtrace_init_type_idx(); =20 - return bus_register(>race_bustype); + ret =3D bus_register(>race_bustype); + if (ret) + return ret; + + ret =3D gtrace_perf_init(); + if (ret) { + bus_unregister(>race_bustype); + return ret; + } + + return 0; } =20 static void __exit gtrace_exit(void) { + gtrace_perf_exit(); bus_unregister(>race_bustype); } =20 diff --git a/drivers/hwtracing/gtrace/gtrace-perf.c b/drivers/hwtracing/gtr= ace/gtrace-perf.c new file mode 100644 index 000000000000..ed9155bbbdb7 --- /dev/null +++ b/drivers/hwtracing/gtrace/gtrace-perf.c @@ -0,0 +1,347 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2026 Qualcomm Technologies, Inc. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define GTRACE_PMU_NAME "gtrace" +static struct pmu gtrace_pmu; +static DEFINE_SPINLOCK(perf_buf_lock); + +/** + * struct gtrace_event_data - generic hardware trace perf event data + * @work: Handle to free allocated memory outside IRQ context. + * @mask: Hold the CPU(s) this event was set for. + * @aux_hwid_done: Whether a CPU has emitted the TraceID packet or not. + * @path: An array of path, each slot for one CPU. + * @buf: Aux buffer / pages allocated by perf framework. + */ +struct gtrace_event_data { + struct work_struct work; + cpumask_t mask; + cpumask_t aux_hwid_done; + struct gtrace_path * __percpu *path; + struct gtrace_perf_auxbuf buf; +}; + +struct gtrace_ctxt { + struct perf_output_handle handle; + struct gtrace_event_data *event_data; +}; + +static DEFINE_PER_CPU(struct gtrace_ctxt, gtrace_ctxt); + +static void *alloc_event_data(int cpu) +{ + struct gtrace_event_data *event_data; + cpumask_t *mask; + + event_data =3D kzalloc_obj(*event_data); + if (!event_data) + return NULL; + + /* Update mask as per selected CPUs */ + mask =3D &event_data->mask; + if (cpu !=3D -1) + cpumask_set_cpu(cpu, mask); + else + cpumask_copy(mask, cpu_present_mask); + + event_data->path =3D alloc_percpu(struct gtrace_path *); + return event_data; +} + +static void gtrace_free_aux(void *data) +{ + struct gtrace_event_data *event_data =3D data; + + schedule_work(&event_data->work); +} + +static struct gtrace_path **gtrace_event_cpu_path_ptr(struct gtrace_event_= data *data, + int cpu) +{ + return per_cpu_ptr(data->path, cpu); +} + +static void free_event_data(struct work_struct *work) +{ + struct gtrace_event_data *event_data; + struct gtrace_path *path; + cpumask_t *mask; + int cpu; + + event_data =3D container_of(work, struct gtrace_event_data, work); + mask =3D &event_data->mask; + for_each_cpu(cpu, mask) { + path =3D *gtrace_event_cpu_path_ptr(event_data, cpu); + gtrace_destroy_path(path); + } + free_percpu(event_data->path); + kfree(event_data); +} + +static void *gtrace_setup_aux(struct perf_event *event, void **pages, + int nr_pages, bool overwrite) +{ + struct gtrace_event_data *event_data =3D NULL; + struct page **pagelist; + int cpu =3D event->cpu, i; + cpumask_t *mask; + + event_data =3D alloc_event_data(cpu); + if (!event_data) + return NULL; + + INIT_WORK(&event_data->work, free_event_data); + mask =3D &event_data->mask; + /* + * Create the path for each CPU in the mask. In case of any failure skip = the CPU + */ + for_each_cpu(cpu, mask) { + struct gtrace_component *src; + struct gtrace_path *path; + + src =3D gtrace_cpu_source(cpu); + if (!src) + continue; + + path =3D gtrace_create_path(src, NULL, GTRACE_COMPONENT_MODE_PERF); + if (!path) + continue; + + *gtrace_event_cpu_path_ptr(event_data, cpu) =3D path; + } + + /* If we don't have any CPUs ready for tracing, abort */ + cpu =3D cpumask_first(&event_data->mask); + if (cpu >=3D nr_cpu_ids) + goto err; + + pagelist =3D kcalloc(nr_pages, sizeof(*pagelist), GFP_KERNEL); + if (!pagelist) + goto err; + + for (i =3D 0; i < nr_pages; i++) + pagelist[i] =3D virt_to_page(pages[i]); + + event_data->buf.base =3D vmap(pagelist, nr_pages, VM_MAP, PAGE_KERNEL); + if (!event_data->buf.base) { + kfree(pagelist); + goto err; + } + + event_data->buf.nr_pages =3D nr_pages; + event_data->buf.length =3D nr_pages * PAGE_SIZE; + event_data->buf.pos =3D 0; + return event_data; +err: + gtrace_free_aux(event_data); + return NULL; +} + +static void gtrace_event_read(struct perf_event *event) +{ +} + +static void gtrace_event_destroy(struct perf_event *event) +{ +} + +static int gtrace_event_init(struct perf_event *event) +{ + if (event->attr.type !=3D gtrace_pmu.type) + return -EINVAL; + + event->destroy =3D gtrace_event_destroy; + return 0; +} + +static void gtrace_event_start(struct perf_event *event, int flags) +{ + struct gtrace_ctxt *ctxt =3D this_cpu_ptr(>race_ctxt); + struct perf_output_handle *handle =3D &ctxt->handle; + struct gtrace_event_data *event_data; + int cpu =3D smp_processor_id(); + struct gtrace_path *path; + + if (WARN_ON(ctxt->event_data)) + goto fail; + + /* + * Deal with the ring buffer API and get a handle on the + * session's information. + */ + event_data =3D perf_aux_output_begin(handle, event); + if (!event_data) + goto fail; + + if (!cpumask_test_cpu(cpu, &event_data->mask)) + goto out; + + event_data->buf.pos =3D handle->head % event_data->buf.length; + path =3D *gtrace_event_cpu_path_ptr(event_data, cpu); + if (!path) { + pr_err("Error. Path not found\n"); + return; + } + + if (gtrace_path_start(path)) { + pr_err("Error. Tracing not started\n"); + return; + } + + /* + * output cpu / trace ID in perf record, once for the lifetime + * of the event. + */ + if (!cpumask_test_cpu(cpu, &event_data->aux_hwid_done)) { + cpumask_set_cpu(cpu, &event_data->aux_hwid_done); + perf_report_aux_output_id(event, cpu); + } + +out: + /* Tell the perf core the event is alive */ + event->hw.state =3D 0; + ctxt->event_data =3D event_data; + return; +fail: + event->hw.state =3D PERF_HES_STOPPED; +} + +static void gtrace_event_stop(struct perf_event *event, int mode) +{ + struct gtrace_ctxt *ctxt =3D this_cpu_ptr(>race_ctxt); + struct perf_output_handle *handle =3D &ctxt->handle; + struct gtrace_event_data *event_data; + int ret, cpu =3D smp_processor_id(); + struct gtrace_path *path; + size_t size; + u64 format; + + if (event->hw.state =3D=3D PERF_HES_STOPPED) + return; + + if (handle->event && + WARN_ON(perf_get_aux(handle) !=3D ctxt->event_data)) + return; + + event_data =3D ctxt->event_data; + ctxt->event_data =3D NULL; + + if (WARN_ON(!event_data)) + return; + + if (handle->event && (mode & PERF_EF_UPDATE) && !cpumask_test_cpu(cpu, &e= vent_data->mask)) { + event->hw.state =3D PERF_HES_STOPPED; + perf_aux_output_end(handle, 0); + return; + } + + /* stop tracing */ + path =3D *gtrace_event_cpu_path_ptr(event_data, cpu); + if (!path) { + pr_err("Error. Path not found\n"); + return; + } + + if (gtrace_path_stop(path)) { + pr_err("Error. Tracing not stopped\n"); + return; + } + + event->hw.state =3D PERF_HES_STOPPED; + if (handle->event && (mode & PERF_EF_UPDATE)) { + if (WARN_ON_ONCE(handle->event !=3D event)) + return; + spin_lock(&perf_buf_lock); + ret =3D gtrace_path_copyto_auxbuf(path, &event_data->buf, &size, &format= ); + spin_unlock(&perf_buf_lock); + WARN_ON_ONCE(ret); + if (READ_ONCE(handle->event)) { + /* Tag the AUX data with the format reported by the sink. */ + perf_aux_output_flag(handle, format); + if (size > handle->size) { + size =3D handle->size; + perf_aux_output_flag(handle, PERF_AUX_FLAG_TRUNCATED); + } + perf_aux_output_end(handle, size); + } else + WARN_ON(size); + } +} + +static int gtrace_event_add(struct perf_event *event, int mode) +{ + struct hw_perf_event *hwc =3D &event->hw; + int ret =3D 0; + + if (mode & PERF_EF_START) { + gtrace_event_start(event, 0); + if (hwc->state & PERF_HES_STOPPED) + ret =3D -EINVAL; + } else { + hwc->state =3D PERF_HES_STOPPED; + } + + return ret; +} + +static void gtrace_event_del(struct perf_event *event, int mode) +{ + gtrace_event_stop(event, PERF_EF_UPDATE); +} + +PMU_FORMAT_ATTR(event, "config:0-0"); + +static struct attribute *gtrace_pmu_formats_attr[] =3D { + &format_attr_event.attr, + NULL, +}; + +static struct attribute_group gtrace_pmu_format_group =3D { + .name =3D "format", + .attrs =3D gtrace_pmu_formats_attr, +}; + +static const struct attribute_group *gtrace_pmu_attr_groups[] =3D { + >race_pmu_format_group, + NULL, +}; + +int __init gtrace_perf_init(void) +{ + gtrace_pmu.capabilities =3D (PERF_PMU_CAP_EXCLUSIVE | PERF_PMU_CAP_ITRACE= ); + gtrace_pmu.attr_groups =3D gtrace_pmu_attr_groups; + gtrace_pmu.task_ctx_nr =3D perf_sw_context; + gtrace_pmu.read =3D gtrace_event_read; + gtrace_pmu.event_init =3D gtrace_event_init; + gtrace_pmu.setup_aux =3D gtrace_setup_aux; + gtrace_pmu.free_aux =3D gtrace_free_aux; + gtrace_pmu.start =3D gtrace_event_start; + gtrace_pmu.stop =3D gtrace_event_stop; + gtrace_pmu.add =3D gtrace_event_add; + gtrace_pmu.del =3D gtrace_event_del; + gtrace_pmu.module =3D THIS_MODULE; + + return perf_pmu_register(>race_pmu, GTRACE_PMU_NAME, -1); +} + +void __exit gtrace_perf_exit(void) +{ + perf_pmu_unregister(>race_pmu); +} diff --git a/include/linux/gtrace.h b/include/linux/gtrace.h index bc82814e2738..439e2f091d4d 100644 --- a/include/linux/gtrace.h +++ b/include/linux/gtrace.h @@ -317,4 +317,7 @@ static inline void gtrace_unregister_driver(struct gtra= ce_driver *gtdrv) driver_unregister(>drv->driver); } =20 +int gtrace_perf_init(void); +void gtrace_perf_exit(void); + #endif /* __LINUX_GTRACE_H__ */ --=20 2.43.0 From nobody Tue Sep 29 08:26:17 2026 Received: from mx0a-0031df01.pphosted.com (mx0a-0031df01.pphosted.com [205.220.168.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id CE01D3F8223 for ; Mon, 10 Aug 2026 15:25:01 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=205.220.168.131 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375503; cv=none; b=WBoki4umkGiVnzZ54MDWm3bsRFJnC7vnTLiBvE9Fdq7cddBpnltTOZ0WQilJZzM2h99bKJQSgr7slmJesdkZshRyLDn+okFfvREFfmer9ByWYcTPWGOa/iZqHUHxtn9VjQU/xGiE++6wthVtYZOfw4x9u+WvOGB5ocS0ShsQFKY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375503; c=relaxed/simple; bh=In4x6785K8/vzSdIYiKbGi6O4zEsUhiyOAirPWAlgjk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=FIOI2mLKlj4GvKgrSVKcEOCSZH/ldrruD8OrajdCOC5eT2SDu08PliJXUbvE8iqg3lGdZRa6ZaZaRbLrz/gX+ayEORZtLgaJKaSGzb4r5nBlT/IT/wD+0jfJDBltHv4iSPNTfuKW2FphTEj6rugz4b4wD9f64675+c4cbBy1qqM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=oss.qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=VeFKsovc; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b=GQgjABSA; arc=none smtp.client-ip=205.220.168.131 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="VeFKsovc"; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b="GQgjABSA" Received: from pps.filterd (m0279862.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 67ACj5TH1343221 for ; Mon, 10 Aug 2026 15:25:01 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qualcomm.com; h= cc:content-transfer-encoding:date:from:in-reply-to:message-id :mime-version:references:subject:to; s=qcppdkim1; bh=Hk/olWcMYCC UGqV7YkEAh0ajnCbIBwvqXEI3sMl4tPk=; b=VeFKsovcq8oVyZZMdjRDlfKpsM4 Gp3kPQrCzcq7847iNVdgPb3Eq8jAkVHgLmv7a8gCrnL6UVY0QREsaX/3eVzHB9Yz lUN/a4ZKFqVkn8rHtRDYsZPCWbMS3o7HSjI8BcEQH+WLnCU2cQH+8AOO5SZIgn6q 9tOCwyDFZE6i3O3cS42bpwa5p7QoheDLl9O3Nn/e39YFS63sjiYDE+QjbVRnmLxP 443NYoTPXScGX9CWpygXxGeyZqqxOMYY/Co5X3BmK26vfl42s2+ffCw5qJiBgqUD TJaxDUQRfTi2GyDbVKNKKV/YTa8hQhfE+jk5/9mEFxIN9up0yH0MFK3N1Ig== Received: from mail-pg1-f197.google.com (mail-pg1-f197.google.com [209.85.215.197]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4fy8v5a7f5-1 (version=TLSv1.3 cipher=TLS_AES_128_GCM_SHA256 bits=128 verify=NOT) for ; Mon, 10 Aug 2026 15:25:00 +0000 (GMT) Received: by mail-pg1-f197.google.com with SMTP id 41be03b00d2f7-cb7d6ba548eso2547129a12.1 for ; Mon, 10 Aug 2026 08:25:00 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oss.qualcomm.com; s=google; t=1786375500; x=1786980300; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=Hk/olWcMYCCUGqV7YkEAh0ajnCbIBwvqXEI3sMl4tPk=; b=GQgjABSANY5GliZU1j2eHaYuj1F8e99UlR8L9L5Ala/htkG+MKAhCCc3TS0G4VWrqA hiZ5R34xQCeO/zs7viBJddbtGO5Zjrtiovfzne+wz2GCXOTyqP3OS9wI5Yg6vmNlyz2A mG7QNI/3v0G/VfbcXNaXxxFXOVnZe6mlPRPcAMwzY60ZVy+sJuTAtfAFfDZYIxM6TkTq Hz4CsmxdVshUl8+kbThsm3pAMb/aGxpnboaL/gtFSLdf6X0fcb4XQCs1qk59SCWJ8xRg peFPu/43WDeKQo8GB3eOPFTLiOVhetXrBHK5Op1rgo5gMocB767i+WjdW/p0ex/NgRmx 14vA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1786375500; x=1786980300; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=Hk/olWcMYCCUGqV7YkEAh0ajnCbIBwvqXEI3sMl4tPk=; b=IaQhh97MonkvntJ0ALktQKyj6/UbNvwmzieoCxFsAR1fZ+FCO+/RcPaHa0q7nTshNf w7M+9WHroOGl/6/TYODdo1VY1MtNrwFy/CL/Rfn9e0hstw7JbPX9cIo9fYUIh1sFxZn2 aBG5QFbDMJ0mawfmpvRKr/JdamXAYNpoY17Dok1H6WsWWsLx2HUC8JG0ZOA3KGhHrZnM QPR+pkjl2YBk9iFhMHEMrdNucTnSbAAaL0Bd1jlRppuhz/vbbiPLvROGtKPy2qUSOyNl sHHFeipI8JcT2ulkP67Ylqyy55CA2IxObDx3QJXzeEKw+okBLtrgrocoNLWJwRZp+izB cRiA== X-Forwarded-Encrypted: i=1; AHgh+Rr7YN4d2w5fuQ9PAefok92UOxoUqF7kVneSkRrbPGDYbZHc7bxi5eb/95IyJTiWw6Qog2Dtc1paTvHZDYc=@vger.kernel.org X-Gm-Message-State: AOJu0Ywsuggv6R/Y3zJqPENsLlV90wTGWFNYTaBtgzIOBf4Yo+8LERsi dudMk5nWJeQcMaS+cch/kOy4bFgsrjRfuRCD3RqKWnUMQfijAUIwsbgYUYfPo+HKVZHcHC+/ilo Qorl5baUCLGD53DGSgEXOizNno4k300nFVSXvtxZDIpGX3gSgrllzOVxFpSmkcKRCC3o= X-Gm-Gg: AR+sD13GZ1kw/FBzPoJFTGrfA2JnylkLo5auHW4YTARtRe3MM73tHYI9C8Ptv78geO0 GZCwnIx7bnSdk06ajdxcec2MawZyNNykioMseMv3OLkYWUT8Fh4LFg9ZlunJs1n1rMtNv2qKDhA K4k7ZR+RK2Yu3zrKqYsgXq5681DfTegFBLqZHx4caHK8UHxRfvSQiXEqQHp218I0hLr38hJhnnC 6UrVyz8dYhRTwUbsZf0Gz9ehtP7SclSjaw7PLqE2N7NhbJ6cchYfnCY8KD1akz3trtQC22HiyEB entVQAiKU6Zexo2vT9bHe+y9JRh2pcMAppNA44InExjx1VVZGEayh5Y+T3fkgLDVex3fvnF2JJ/ 8MNxwtnZ55uQEDEPiDHhKxKa5qYpnTdnnwTlpQbVvLw/831BDsC7d3rXXVHHlbnGe4821GIV7O2 lDAGkIoNhiTmPh2BR2+D5wDRPzjQ== X-Received: by 2002:a05:6a20:c5a7:b0:3c8:f98f:475b with SMTP id adf61e73a8af0-3cb85e6c950mr53762704637.19.1786375499779; Mon, 10 Aug 2026 08:24:59 -0700 (PDT) X-Received: by 2002:a05:6a20:c5a7:b0:3c8:f98f:475b with SMTP id adf61e73a8af0-3cb85e6c950mr53762639637.19.1786375499195; Mon, 10 Aug 2026 08:24:59 -0700 (PDT) Received: from hu-mchitale-blr.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com. [103.229.18.19]) by smtp.googlemail.com with ESMTPSA id 41be03b00d2f7-cbe8f1af985sm4282634a12.11.2026.08.10.08.24.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Aug 2026 08:24:58 -0700 (PDT) From: Mayuresh Chitale To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Mayuresh Chitale , Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Mayuresh Chitale , Anup Patel , Atish Patra , Andrew Jones , Sunil V L , linux-riscv@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, Anup Patel , Nutty Liu Subject: [PATCH v5 12/14] perf tools: Add RISC-V trace PMU record capabilities Date: Mon, 10 Aug 2026 20:52:14 +0530 Message-ID: <20260810152223.3946743-13-mayuresh.chitale@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> References: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-Spam-Info: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfXygrMrwonAA7J 9uJSVvg4k/D9LCDi/8oXqsZdQb8LdtnqjCh3nmkld2jOH8MS4rIhg+QwZ55+IWxztFDEEtppx/N rkzdVV+uF3KQcA0YJHWCqXc78VHPpiY= X-Authority-Analysis: v=2.4 cv=J6qaKgnS c=1 sm=1 tr=0 ts=6a79ed4c cx=c_pps a=rz3CxIlbcmazkYymdCej/Q==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=Sv0fKeRqtYgA:10 a=s4-Qcg_JpJYA:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=_K5XuSEh1TEqbUxoQ0s3:22 a=EUspDBNiAAAA:8 a=69EAbJreAAAA:8 a=QyXUC8HyAAAA:8 a=F5mInixxrWKVZ3nbcxgA:9 a=bFCP_H2QrGi7Okbo017w:22 X-Proofpoint-GUID: cV8KpXY1z9Hh1N8h3kMzwAZanRznoFR6 X-Proofpoint-ORIG-GUID: cV8KpXY1z9Hh1N8h3kMzwAZanRznoFR6 X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX5BpKNgLDUni4 J/vZwT5+S8dFP8mGhYGDYcgaMD1PTEwkZtSrfNQ4C9xxbqtHPeIpWngfXCHqcayXU/vikIm0KSD hikNmTQXaMLsW9Fz5c7H/B+cU4RFaXD5v7s7PuTz/kf+95LqFYaJI3QIEQC7LDr5FG0SvHXnu0V lukeq9cenHVk0dFx3IbFFHdDMrNgl/yNnqwE5frjn2Zh5vu1XrYTbyWS5W00NPuLIXSyxN4TkDm m9McrIu+aF2a+kXQaO0CcsztQaBDLLH4vcDrFau0nG+FDwFuE/scIQk8q8z1z9jeAnTqVwpY62U 17mNUgdK3QdOKqZxrlsSa6NIrkWXYJZLMfAQtbEIAizL4AMDls1BB6ACsz/h4GaewoT82dBMol4 Qw7fPD9j/7/t6m74cBNkGrRPpYb8STyry8Zzz+FJopymLyL8w3XR2gQhGNAnbXDKJccVLoyX4gd k5xWjzING8CzXV4Rc8Q== X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1176,Hydra:6.1.134,FMLib:17.12.100.49 definitions=2026-08-10_03,2026-08-07_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 suspectscore=0 phishscore=0 spamscore=0 lowpriorityscore=0 priorityscore=1501 impostorscore=0 clxscore=1015 adultscore=0 bulkscore=0 malwarescore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2606150000 definitions=main-2608100132 Content-Type: text/plain; charset="utf-8" Introduce the required auxiliary API functions allowing the perf core to interact with gtrace perf driver. On RISC-V systems the gtrace PMU uses the RISC-V E-Trace components and optionally an ATB Bridge component for connecting to ARM-side sinks, if it is present on the SoC. Co-developed-by: Anup Patel Signed-off-by: Anup Patel Signed-off-by: Mayuresh Chitale Reviewed-by: Nutty Liu Reviewed-by: Adrian Hunter --- tools/perf/arch/riscv/util/Build | 1 + tools/perf/arch/riscv/util/auxtrace.c | 217 ++++++++++++++++++++++++++ tools/perf/util/auxtrace.c | 1 + tools/perf/util/auxtrace.h | 1 + tools/perf/util/gtrace.h | 12 ++ 5 files changed, 232 insertions(+) create mode 100644 tools/perf/arch/riscv/util/auxtrace.c create mode 100644 tools/perf/util/gtrace.h diff --git a/tools/perf/arch/riscv/util/Build b/tools/perf/arch/riscv/util/= Build index 2328fb9a30a3..e07d5525ece6 100644 --- a/tools/perf/arch/riscv/util/Build +++ b/tools/perf/arch/riscv/util/Build @@ -1 +1,2 @@ perf-util-y +=3D header.o +perf-util-y +=3D auxtrace.o diff --git a/tools/perf/arch/riscv/util/auxtrace.c b/tools/perf/arch/riscv/= util/auxtrace.c new file mode 100644 index 000000000000..39c31be9f896 --- /dev/null +++ b/tools/perf/arch/riscv/util/auxtrace.c @@ -0,0 +1,217 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Risc-V E-Trace support + * Copyright (c) 2026 Qualcomm Technologies, Inc. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include "../../../util/auxtrace.h" +#include "../../../util/cpumap.h" +#include "../../../util/debug.h" +#include "../../../util/event.h" +#include "../../../util/evlist.h" +#include "../../../util/evsel.h" +#include "../../../util/pmu.h" +#include "../../../util/record.h" +#include "../../../util/session.h" + + +#define GTRACE_PMU_NAME "gtrace" +#define GTRACE_AUXTRACE_PRIV_SIZE sizeof(u64) +#define KiB(x) ((x) * 1024) +#define MiB(x) ((x) * 1024 * 1024) + +struct rvtrace_recording { + struct auxtrace_record itr; + struct perf_pmu *rvtrace_pmu; + struct evlist *evlist; +}; + +static size_t rvtrace_info_priv_size(struct auxtrace_record *itr __maybe_u= nused, + struct evlist *evlist __maybe_unused) +{ + return GTRACE_AUXTRACE_PRIV_SIZE; +} + +static int rvtrace_info_fill(struct auxtrace_record *itr, + struct perf_session *session __maybe_unused, + struct perf_record_auxtrace_info *auxtrace_info, size_t priv_size) +{ + struct rvtrace_recording *ptr =3D container_of(itr, struct rvtrace_record= ing, itr); + struct perf_pmu *rvtrace_pmu =3D ptr->rvtrace_pmu; + + if (priv_size !=3D GTRACE_AUXTRACE_PRIV_SIZE) + return -EINVAL; + + auxtrace_info->type =3D PERF_AUXTRACE_GTRACE; + auxtrace_info->priv[0] =3D rvtrace_pmu->type; + + return 0; +} + +static int rvtrace_set_auxtrace_mmap_page(struct record_opts *opts) +{ + bool privileged =3D perf_event_paranoid_check(-1); + + if (!opts->full_auxtrace) + return 0; + + if (opts->full_auxtrace && !opts->auxtrace_mmap_pages) { + if (privileged) { + opts->auxtrace_mmap_pages =3D MiB(16) / page_size; + } else { + opts->auxtrace_mmap_pages =3D KiB(128) / page_size; + if (opts->mmap_pages =3D=3D UINT_MAX) + opts->mmap_pages =3D KiB(256) / page_size; + } + } + + /* Validate auxtrace_mmap_pages */ + if (opts->auxtrace_mmap_pages) { + size_t sz =3D opts->auxtrace_mmap_pages * (size_t)page_size; + size_t min_sz =3D KiB(8); + + if (sz < min_sz || !is_power_of_2(sz)) { + pr_err("Invalid mmap size : must be at least %zuKiB and a power of 2\n", + min_sz / 1024); + return -EINVAL; + } + } + + return 0; +} + +static int rvtrace_recording_options(struct auxtrace_record *itr, struct e= vlist *evlist, + struct record_opts *opts) +{ + struct rvtrace_recording *ptr =3D container_of(itr, struct rvtrace_record= ing, itr); + struct perf_pmu *rvtrace_pmu =3D ptr->rvtrace_pmu; + struct evsel *evsel, *rvtrace_evsel =3D NULL; + struct evsel *tracking_evsel; + int err; + + ptr->evlist =3D evlist; + evlist__for_each_entry(evlist, evsel) { + if (evsel->core.attr.type =3D=3D rvtrace_pmu->type) { + if (rvtrace_evsel) { + pr_err("There may be only one " GTRACE_PMU_NAME " event\n"); + return -EINVAL; + } + evsel->core.attr.freq =3D 0; + evsel->core.attr.sample_period =3D 1; + evsel->needs_auxtrace_mmap =3D true; + rvtrace_evsel =3D evsel; + opts->full_auxtrace =3D true; + } + } + + err =3D rvtrace_set_auxtrace_mmap_page(opts); + if (err) + return err; + /* + * To obtain the auxtrace buffer file descriptor, the auxtrace event + * must come first. + */ + evlist__to_front(evlist, rvtrace_evsel); + evsel__set_sample_bit(rvtrace_evsel, TIME); + + /* Add dummy event to keep tracking */ + err =3D parse_event(evlist, "dummy:u"); + if (err) + return err; + + tracking_evsel =3D evlist__last(evlist); + evlist__set_tracking_event(evlist, tracking_evsel); + + tracking_evsel->core.attr.freq =3D 0; + tracking_evsel->core.attr.sample_period =3D 1; + evsel__set_sample_bit(tracking_evsel, TIME); + + return 0; +} + +static u64 rvtrace_reference(struct auxtrace_record *itr __maybe_unused) +{ + return 0; +} + +static void rvtrace_recording_free(struct auxtrace_record *itr) +{ + struct rvtrace_recording *ptr =3D container_of(itr, struct rvtrace_record= ing, itr); + + free(ptr); +} + +static struct auxtrace_record *rvtrace_recording_init(int *err, struct per= f_pmu *rvtrace_pmu) +{ + struct rvtrace_recording *ptr; + + if (!rvtrace_pmu) { + *err =3D -ENODEV; + return NULL; + } + + ptr =3D zalloc(sizeof(*ptr)); + if (!ptr) { + *err =3D -ENOMEM; + return NULL; + } + + ptr->rvtrace_pmu =3D rvtrace_pmu; + ptr->itr.recording_options =3D rvtrace_recording_options; + ptr->itr.info_priv_size =3D rvtrace_info_priv_size; + ptr->itr.info_fill =3D rvtrace_info_fill; + ptr->itr.free =3D rvtrace_recording_free; + ptr->itr.reference =3D rvtrace_reference; + ptr->itr.read_finish =3D auxtrace_record__read_finish; + ptr->itr.alignment =3D 0; + + *err =3D 0; + return &ptr->itr; +} + +static struct perf_pmu *find_pmu_for_event(struct perf_pmu **pmus, + int pmu_nr, struct evsel *evsel) +{ + int i; + + if (!pmus) + return NULL; + + for (i =3D 0; i < pmu_nr; i++) { + if (evsel->core.attr.type =3D=3D pmus[i]->type) + return pmus[i]; + } + + return NULL; +} + +struct auxtrace_record *auxtrace_record__init(struct evlist *evlist, int *= err) +{ + struct perf_pmu *rvtrace_pmu =3D NULL; + struct perf_pmu *found_pmu =3D NULL; + struct evsel *evsel; + + if (!evlist) + return NULL; + + rvtrace_pmu =3D perf_pmus__find(GTRACE_PMU_NAME); + evlist__for_each_entry(evlist, evsel) { + if (rvtrace_pmu && !found_pmu) + found_pmu =3D find_pmu_for_event(&rvtrace_pmu, 1, evsel); + } + + if (found_pmu) + return rvtrace_recording_init(err, rvtrace_pmu); + + *err =3D 0; + return NULL; +} diff --git a/tools/perf/util/auxtrace.c b/tools/perf/util/auxtrace.c index 4cd2caf54015..d7f27ca15b81 100644 --- a/tools/perf/util/auxtrace.c +++ b/tools/perf/util/auxtrace.c @@ -1427,6 +1427,7 @@ int perf_event__process_auxtrace_info(const struct pe= rf_tool *tool __maybe_unuse case PERF_AUXTRACE_VPA_DTL: err =3D powerpc_vpadtl_process_auxtrace_info(event, session); break; + case PERF_AUXTRACE_GTRACE: case PERF_AUXTRACE_UNKNOWN: default: return -EINVAL; diff --git a/tools/perf/util/auxtrace.h b/tools/perf/util/auxtrace.h index 6947f3f284c0..42b1481ec894 100644 --- a/tools/perf/util/auxtrace.h +++ b/tools/perf/util/auxtrace.h @@ -46,6 +46,7 @@ enum auxtrace_type { PERF_AUXTRACE_S390_CPUMSF, PERF_AUXTRACE_HISI_PTT, PERF_AUXTRACE_VPA_DTL, + PERF_AUXTRACE_GTRACE, }; =20 enum itrace_period_type { diff --git a/tools/perf/util/gtrace.h b/tools/perf/util/gtrace.h new file mode 100644 index 000000000000..4b87bdaf55c6 --- /dev/null +++ b/tools/perf/util/gtrace.h @@ -0,0 +1,12 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (c) 2026 Qualcomm Technologies, Inc. + */ + +#ifndef INCLUDE__UTIL_PERF_GTRACE_H__ +#define INCLUDE__UTIL_PERF_GTRACE_H__ + +#define GTRACE_AUXTRACE_PRIV_SIZE sizeof(u64) + +#endif + --=20 2.43.0 From nobody Tue Sep 29 08:26:17 2026 Received: from mx0b-0031df01.pphosted.com (mx0b-0031df01.pphosted.com [205.220.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3DE3A41D655 for ; Mon, 10 Aug 2026 15:25:10 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=205.220.180.131 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375511; cv=none; b=NxQ602uEGV4OvX/NI/Oqn8OxPeTwD6zDLXqxHtldPci9eNnNd9+53Oxm0WMPVbFAtjQ5AAIHhntDpWONvHwqhAU0udnoH7eKQUKuh+BACYqnP3kLXMrXDnCT4xicFa5Cp/GaEJidFTe55qovmAOBh5UJvzP0wK/4fU85goKYTYo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375511; c=relaxed/simple; bh=fOg5i2ihG8+tJLLCvkanJIPQZ/ECRJrI2j4yWoeAsj4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=ijHM2nuJSzdI2ja0nfMHKfnLnfV+HtQn0NWt9XFQPLmmthHo5p9kTr+UMmTHM2mnvTwm7FfaVt0Y9maHC/DzfxX/m4zjyqipT2p5k9/bSAdRFQV3o/ttt3r6B/hCrItqcPipNPE9YFVTyTGbapHOtyjh3EYPZPcT90EsGot3E6M= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=oss.qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=oJK2RHoc; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b=RxbWFMzl; arc=none smtp.client-ip=205.220.180.131 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="oJK2RHoc"; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b="RxbWFMzl" Received: from pps.filterd (m0279873.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 67ACj4V11671544 for ; Mon, 10 Aug 2026 15:25:09 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qualcomm.com; h= cc:content-transfer-encoding:date:from:in-reply-to:message-id :mime-version:references:subject:to; s=qcppdkim1; bh=QfjYrKxKbfX 2s3AbR0cFidaFV2bBYJPCsLbt9KgbLlk=; b=oJK2RHocf9Va6uS5vrKXeBBhXaw R4ziwHFl+UIN6W7ZhGN4q6xrVUPSUByQ4iMcttt/ob2LrATdh1vgkN/GV6MU+gMC aEMPAH8FsfXiwpJOO/Ev17oqkLy/kfn38Bina7uO5VnVSxIRtWeE2nLYbZjGbQha EVqJBgvHK1SPefmelxFlLWAoS7h1DMHfdHFBMNca8qZn6dXMFxJX369Q+zfeC46T GdXLngB4tr3YL7/rD9SpwpybV1LZNDDwCTXVpxvDcZCxyj7FQrNi2jUpVlYKGKl+ ZHgxWTKlHBjgHFz9G8GHPQdGYALZXeSMvojf8Br1+fs93QsUDA5zycMO0dw== Received: from mail-pf1-f197.google.com (mail-pf1-f197.google.com [209.85.210.197]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4fy8v2aa9a-1 (version=TLSv1.3 cipher=TLS_AES_128_GCM_SHA256 bits=128 verify=NOT) for ; Mon, 10 Aug 2026 15:25:08 +0000 (GMT) Received: by mail-pf1-f197.google.com with SMTP id d2e1a72fcca58-8484f26852dso2292350b3a.1 for ; Mon, 10 Aug 2026 08:25:08 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oss.qualcomm.com; s=google; t=1786375507; x=1786980307; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=QfjYrKxKbfX2s3AbR0cFidaFV2bBYJPCsLbt9KgbLlk=; b=RxbWFMzlSQ2YBmvlIqit1wfjTxPY8Po17wH7nm2ufoyVv4KCIGMwEEIoLxUAR5beXD KDAGxrETW/vgPHDUrlkjpYohGTnudpFlU7M92D66V7ND6S379ZHSn3r+FKXQMFm4FOmF uO+h/JAsCpukXPrF88S7thlqw7l84RqKwX8WJcOjA4iawjdVKN4RtAynkb/9qVF4I0bd cPUE5dNErpHDcrTphjK2uyXwQ/JOJgyFNxq75co9PAP9avusmVXZmmoHPto1BFao9O3D 3FVnEpPWzR33X/JQ2rv5mmj9TZ0AMjEQa9MCmvGiC3uSKvjE1PRmKWfwVFhAEYAwGRdZ x2tw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1786375507; x=1786980307; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=QfjYrKxKbfX2s3AbR0cFidaFV2bBYJPCsLbt9KgbLlk=; b=bW2vgPIk0k7HXnB9XnB6j6e5SCD4P7RqzkJOydjzA6PYj2rVXwdw1E6u/6ZTAJ7R5s OvSUJifq+xPEq38kXV/PMpX+wHwdWRBf3tXkXFtn3GtbQzMPrn9yiOPKUgCoMrTo+h+l ruejGKYOw5mXz0puuQiun9q4XEpYuxIquz6JFgAYNtJYYG9zjtg2J+c6qAkfe0xi6rq1 e1cnHsh4bIX9rOFQMve3ZZVbSoGujcFC9IDLkNvjPEDKkF+CNldKgvlpsiikmnStu7QT mipMe0lWF7/G1mw9ZU+9Nt47xpiDxev2jMN9xD11JeJqrAw1pLUqNKLca+2K9XVptcGM ijpA== X-Forwarded-Encrypted: i=1; AHgh+RovAq8cTUyvOl2JQbPLmIKmmD8jy06FSi139kmG4WdWASyuwp83/cL2Z2KZo0Gx3vIuxH1LjLit+N6nYOk=@vger.kernel.org X-Gm-Message-State: AOJu0YxsM8wU6Ml0gH67kC69gkAVI4QD4+gKrwRHQUOkGmuqYBOEg9A/ dUshJyV0VACCQGh/7ns4OxsSpg0aapTnHVQV9+2P/nLex9KNU3m3pvp8SUo1LTDtxs4OLeXlb+H JHTFPn5a1QUTMXqh4QEVv28VcMTr3kwI31oTzPgd2pQCnu4eORCDvAtG5K81bA8EZ790= X-Gm-Gg: AR+sD11kunHBohXdvx+QwZuhHfyVpp8nVxTqCQ1e6rjBaGO/KEBdghuHAapm5rEDegH W/M5nafCN3MPFB1Xh133C3Vtj2mPxd5v7QHz+/5yu07HzTUGx4jjhR+I0B+rnnRunJrtOhazWMY 0LN/d3WMt+15lQoedeqYVgm4VH4gPkhNqEgdfQ2O/M4YM8Y+bRFoBuiJcIOw4hEx6bCQVXigsQX hLi4YnUNmQy02VmFZTVHJFbJl/Qye4EtEumRUzHGrHms9jkxBZgq1PBXvPx9xR58a1doRe6cvXN XSHEc8dpaUb+IduVIEfAxB2dor0I0VqpLLJkXzLLkYPVAKGAqZP0tPBgfhZFcmtgz2DgMT/r/Dx XSWN7MWWhZclSbfI/PypbD5i57JP6TEX0FiiNDUV+/5BKZXEZf3bPkY1D6Hu3SaqwJysW6l8xR0 2oaxhFEBzcV/fZK9+JNcYMI5nEPw== X-Received: by 2002:a05:6a00:18a1:b0:84a:29a7:f3b1 with SMTP id d2e1a72fcca58-84f4fdbfe84mr31231013b3a.16.1786375507203; Mon, 10 Aug 2026 08:25:07 -0700 (PDT) X-Received: by 2002:a05:6a00:18a1:b0:84a:29a7:f3b1 with SMTP id d2e1a72fcca58-84f4fdbfe84mr31230942b3a.16.1786375506737; Mon, 10 Aug 2026 08:25:06 -0700 (PDT) Received: from hu-mchitale-blr.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com. [103.229.18.19]) by smtp.googlemail.com with ESMTPSA id 41be03b00d2f7-cbe8f1af985sm4282634a12.11.2026.08.10.08.24.59 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Aug 2026 08:25:06 -0700 (PDT) From: Mayuresh Chitale To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Mayuresh Chitale , Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Mayuresh Chitale , Anup Patel , Atish Patra , Andrew Jones , Sunil V L , linux-riscv@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, Anup Patel Subject: [PATCH v5 13/14] perf tools: Initial support for gtrace decoder Date: Mon, 10 Aug 2026 20:52:15 +0530 Message-ID: <20260810152223.3946743-14-mayuresh.chitale@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> References: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Authority-Analysis: v=2.4 cv=S9PpBosP c=1 sm=1 tr=0 ts=6a79ed54 cx=c_pps a=rEQLjTOiSrHUhVqRoksmgQ==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=Sv0fKeRqtYgA:10 a=s4-Qcg_JpJYA:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=rJkE3RaqiGZ5pbrm-msn:22 a=EUspDBNiAAAA:8 a=QyXUC8HyAAAA:8 a=pBE9Ga8SiHy0nNBnfKcA:9 a=2VI0MkxyNR6bbpdq8BZq:22 X-Proofpoint-ORIG-GUID: lJAdsS0lbyqMDJFtIcbIrm3dvHr_Ronw X-Proofpoint-GUID: lJAdsS0lbyqMDJFtIcbIrm3dvHr_Ronw X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX/kkhRmeD9CW+ 8aG4zcDAUelbsN2nTe5Umi5kZ0u160By7s9YtRwnV4tleA5uKEIKqMialSufpzQlRvHuJ6GuJzb EkqEK77hwYnCXWChH6sjcwnUyQqY4gJVSXbhUPEp6phpyzqU7U6hTjdSrd8tkvsHV3Iiqlzn3hj Q+PS3dpQcyzpzHP5wcKvSIlGD6ezlKhhdI9BGcUcpOgeV9QKCyW8lhH294DGhMiTASlx4A9FF0F bwc0PfbLmKsNIQrQRHaVEM//zdgzvIGJ3cnLxRfDRGtIfW5LXstqWM/41kUr1tNNbA88jCyvdGw sQdrC3PvGoO2LrmOqqf7Wr3SDNCAOsaX23y7eMYpbBpL4C6N81R97USD1dxZ9gmRmHr2u8pTlkv Dr3ZMEc/IWCbELq+z1GZxXzZ/NUCFU/BnKL+r64xvaBcY7LlpPxMBzlWZFIGpaazCuWtIC3M8WN 4zpAKTFlTW45ua9fkNQ== X-Proofpoint-Spam-Info: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfXyaECiYxZH/h6 G5tjEF9G6QZ6Glie6TN5KEELXsk902ccZMu7IldQMEShTtERQlGSoVnbb0Rr4VuLG7Nc8qAk5Lf 5QRRoK742vdKfV0XpBapo2s4tlGE1vI= X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1176,Hydra:6.1.134,FMLib:17.12.100.49 definitions=2026-08-10_03,2026-08-07_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 phishscore=0 bulkscore=0 adultscore=0 lowpriorityscore=0 malwarescore=0 priorityscore=1501 clxscore=1015 suspectscore=0 impostorscore=0 spamscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2606150000 definitions=main-2608100132 Content-Type: text/plain; charset="utf-8" Add bare bones support for gtrace decoder so that the data received from the hardware by the gtrace perf driver can be written to the perf record output file. Actual decoding of the trace payload is not yet implemented. Co-developed-by: Anup Patel Signed-off-by: Anup Patel Signed-off-by: Mayuresh Chitale Reviewed-by: Adrian Hunter --- tools/perf/util/Build | 1 + tools/perf/util/auxtrace.c | 3 ++ tools/perf/util/gtrace-decoder.c | 93 ++++++++++++++++++++++++++++++++ tools/perf/util/gtrace.h | 1 + 4 files changed, 98 insertions(+) create mode 100644 tools/perf/util/gtrace-decoder.c diff --git a/tools/perf/util/Build b/tools/perf/util/Build index 5e2265018826..7bd752b5ae6a 100644 --- a/tools/perf/util/Build +++ b/tools/perf/util/Build @@ -148,6 +148,7 @@ perf-util-y +=3D cs-etm.o perf-util-y +=3D cs-etm-decoder/ endif perf-util-y +=3D cs-etm-base.o +perf-util-y +=3D gtrace-decoder.o =20 perf-util-y +=3D parse-branch-options.o perf-util-y +=3D parse-regs-options.o diff --git a/tools/perf/util/auxtrace.c b/tools/perf/util/auxtrace.c index d7f27ca15b81..8eda626aede5 100644 --- a/tools/perf/util/auxtrace.c +++ b/tools/perf/util/auxtrace.c @@ -54,6 +54,7 @@ #include "arm-spe.h" #include "hisi-ptt.h" #include "s390-cpumsf.h" +#include "gtrace.h" #include "util/mmap.h" #include "powerpc-vpadtl.h" =20 @@ -1428,6 +1429,8 @@ int perf_event__process_auxtrace_info(const struct pe= rf_tool *tool __maybe_unuse err =3D powerpc_vpadtl_process_auxtrace_info(event, session); break; case PERF_AUXTRACE_GTRACE: + err =3D gtrace__process_auxtrace_info(event, session); + break; case PERF_AUXTRACE_UNKNOWN: default: return -EINVAL; diff --git a/tools/perf/util/gtrace-decoder.c b/tools/perf/util/gtrace-deco= der.c new file mode 100644 index 000000000000..4a1571431edb --- /dev/null +++ b/tools/perf/util/gtrace-decoder.c @@ -0,0 +1,93 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Generic hardware trace (gtrace) decoder + * Copyright (c) 2026 Qualcomm Technologies, Inc. + */ + +#include +#include +#include +#include "evlist.h" +#include "session.h" +#include "gtrace.h" + +struct gtrace_decoder { + struct auxtrace auxtrace; + u32 auxtrace_type; + struct perf_session *session; + struct machine *machine; + u32 pmu_type; +}; + +static int gtrace_process_event(struct perf_session *session __maybe_unuse= d, + union perf_event *event __maybe_unused, + struct perf_sample *sample __maybe_unused, + const struct perf_tool *tool __maybe_unused) +{ + return 0; +} + +static int gtrace_process_auxtrace_event(struct perf_session *session __ma= ybe_unused, + union perf_event *event __maybe_unused, + const struct perf_tool *tool __maybe_unused) +{ + return 0; +} + +static int gtrace_flush(struct perf_session *session __maybe_unused, + const struct perf_tool *tool __maybe_unused) +{ + return 0; +} + +static void gtrace_free_events(struct perf_session *session __maybe_unused) +{ +} + +static void gtrace_free(struct perf_session *session) +{ + struct gtrace_decoder *ptr =3D container_of(session->auxtrace, struct gtr= ace_decoder, + auxtrace); + + session->auxtrace =3D NULL; + free(ptr); +} + +static bool gtrace_evsel_is_auxtrace(struct perf_session *session, + struct evsel *evsel) +{ + struct gtrace_decoder *ptr =3D container_of(session->auxtrace, + struct gtrace_decoder, auxtrace); + + return evsel->core.attr.type =3D=3D ptr->pmu_type; +} + +int gtrace__process_auxtrace_info(union perf_event *event, + struct perf_session *session) +{ + struct perf_record_auxtrace_info *auxtrace_info =3D &event->auxtrace_info; + struct gtrace_decoder *ptr; + + if (auxtrace_info->header.size < GTRACE_AUXTRACE_PRIV_SIZE + + sizeof(struct perf_record_auxtrace_info)) + return -EINVAL; + + ptr =3D zalloc(sizeof(*ptr)); + if (!ptr) + return -ENOMEM; + + ptr->session =3D session; + ptr->machine =3D &session->machines.host; + ptr->auxtrace_type =3D auxtrace_info->type; + ptr->pmu_type =3D auxtrace_info->priv[0]; + + ptr->auxtrace.process_event =3D gtrace_process_event; + ptr->auxtrace.process_auxtrace_event =3D gtrace_process_auxtrace_event; + ptr->auxtrace.flush_events =3D gtrace_flush; + ptr->auxtrace.free_events =3D gtrace_free_events; + ptr->auxtrace.free =3D gtrace_free; + ptr->auxtrace.evsel_is_auxtrace =3D gtrace_evsel_is_auxtrace; + session->auxtrace =3D &ptr->auxtrace; + + return 0; +} diff --git a/tools/perf/util/gtrace.h b/tools/perf/util/gtrace.h index 4b87bdaf55c6..3531508b1dfb 100644 --- a/tools/perf/util/gtrace.h +++ b/tools/perf/util/gtrace.h @@ -8,5 +8,6 @@ =20 #define GTRACE_AUXTRACE_PRIV_SIZE sizeof(u64) =20 +int gtrace__process_auxtrace_info(union perf_event *event, struct perf_ses= sion *session); #endif =20 --=20 2.43.0 From nobody Tue Sep 29 08:26:17 2026 Received: from mx0a-0031df01.pphosted.com (mx0a-0031df01.pphosted.com [205.220.168.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 19D92429000 for ; Mon, 10 Aug 2026 15:25:16 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=205.220.168.131 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375517; cv=none; b=QX45DQ7CQe7G8FQpE9FB0qNNWfPj5esPN86r1K3e0O4EpkPIsk4w7Tv4oIoOXGZYauiYZuTdhl6JbtJcEY6u8JhUSzOWxEsZgYvaVRin26HU8+MVTIEEDnJWCNJheINB8EYyfxRIAx6ZEbQZHbzD5XYC6556xX9QXqQOpCZh9HA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786375517; c=relaxed/simple; bh=c4a8y/NG7USdLAezlweHsYVwlmujkZvRWqtUNfRkwQc=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=CsJISHn3SF2tC8XrROxxgyIIzFekASV/TuW8HTdfR7Yu0uqcVKfh++2E+i40+Fd5ZV2AiJrV7mObxDdAY6iCnDCT7KyEVJQM9AmsQfLVS8M0YOnSwGbszdeu/o8m/ueIKD0ubwS/OOEc94EMbVh6HniVpQN3Z7TkqPjEDRtsdfA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=oss.qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=hsXWBSZP; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b=SyflI6QY; arc=none smtp.client-ip=205.220.168.131 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="hsXWBSZP"; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b="SyflI6QY" Received: from pps.filterd (m0279866.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 67ACklBx1311180 for ; Mon, 10 Aug 2026 15:25:15 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qualcomm.com; h= cc:content-transfer-encoding:date:from:in-reply-to:message-id :mime-version:references:subject:to; s=qcppdkim1; bh=ZIMIvoLDAmz Gs9DS9cbp63zT/hFrfy2iRoEFdcbPmoY=; b=hsXWBSZPzmOfvUbNZ2knXrbQghi KaYk4x3ME3vAAzwxvjQiGEBt8q3lPzTjE7p1Wq4f+hI2Jn6DxT/94lc00j5U8/Ni iwoW9s4SPjn0A2c1wjtE9lOCB+idkdSfUY+rOfxU5jUhHT6etj3d7bJpjFI3fL8f o3QuYWi8Ys5E+Otn+5AHUCO9vhAvU4xyg514dvT4vIyKXC338Ov+Qy5gHxi97ckT VbiBtD7GR76bNzDlXj/ga3/aWnEWE+cXKoQJ+B+imm09ksbUnL52T+1qZd/YGfY/ Jyy/vDGZVBrUjIdhn5a+nqmaYZP74Xl3/zCiAuz8xUhFFfFe3/T5w2WLbqw== Received: from mail-pg1-f197.google.com (mail-pg1-f197.google.com [209.85.215.197]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4fyccqsby8-1 (version=TLSv1.3 cipher=TLS_AES_128_GCM_SHA256 bits=128 verify=NOT) for ; Mon, 10 Aug 2026 15:25:15 +0000 (GMT) Received: by mail-pg1-f197.google.com with SMTP id 41be03b00d2f7-cb5bdd8450dso1536443a12.0 for ; Mon, 10 Aug 2026 08:25:15 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oss.qualcomm.com; s=google; t=1786375515; x=1786980315; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=ZIMIvoLDAmzGs9DS9cbp63zT/hFrfy2iRoEFdcbPmoY=; b=SyflI6QY7gbK2FHSQgw4ImJop+qodTk/gHNI6TSTgQeM6mtwNwC7c44naLWlJb3LJV sd4u66tP0iXO/o8IsUUEuzilM5i5jYuWvNlk/Ni5x8Wu6oZpLLpDUJHL6dV0Z8Vso2rO h/nkh5+7wXyiGTwt67KahYEKPr+HUMGfg7s9v2swX525/l58DIOOiG19gUBQEwuG37JN nOlvHqup0BrlifP50NI7HVuFjaLLNrENPr7PmYX6ZIC3Ko+qDHjvbIQ6tRHcEHqAdArE Bf0m9xHf56uWORP+EwC1u25BCqgBDiCuWwe4wQ97TDk+O88BTTXee85zi4u6GaoeyTgj NkQA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1786375515; x=1786980315; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=ZIMIvoLDAmzGs9DS9cbp63zT/hFrfy2iRoEFdcbPmoY=; b=P3ueEykmvYqcTLD+eRhj7kj3tVUYugNpcVIoDTtVJ0cDXkpoosqWe3adNN39L4wOrG sd5JY5nlYSws5IXyq9jGQLObImHhYWoUhHxLcuWonQwHRsBsLNz8TG5WMuLjIsXHkaF6 MvvxdIVMyfAF9LSlMYhMCC4hlF0spsIKwbdQlrPlwfV6UQD8hPDzgmzb/sXG2wlxcRSB IOe2oPhgnXjO59s3Yl9ZXRkd/FZOiXUP36V9HOEGrR/cOFM8l42j+ujt6KiVAM+st/xn nQQdQ4GNN7S8izE0fX2yTaOzm9YRChVSR0/pdpsncfLr/AtGydIHbT9XLchiEvUhRoO8 J+jQ== X-Forwarded-Encrypted: i=1; AHgh+RrMD7hG2dSezB7MBf3ge0oPOJH/ylQqMkEvwXgRd13+LETyQo/+INsBxNPk4THyTFBOxhUx9pSTg7gmAms=@vger.kernel.org X-Gm-Message-State: AOJu0YzU5dNa7kZZ3kYRYtsPama3NkMIYzv5SLZrj47ARmq+1zTmhVbF m+Bwi3zmiWPTijjckESVIQGDNxdvsP+qvEGkkEAF1kEX3mqi/B8oTi6CBkeSgTwYHUNgXdwUF6/ FNg1LzwiiaUIC1kpWjHU6DW5F+dGK8ESEE73NHXxABRTThc4HgVUSnkw22WAC+OqBDGU= X-Gm-Gg: AR+sD13RWZpnobFq6uOItrEoJA+yjikBCtGehWRCNRKh5jxIY5SW5N9Ghp17n+nRB3h JuGa0nOQcCp9tMIPUTk6NMTyn+EoAEKbHlrw7DWHKqALBGWDwbTTSwyT1ZpNonihXdJEuxutkkA TOcQN0Dd+sfQiS3xlWCOQJhGrpKm+fBmTgvRmqkHwjh0B34w0zzbe4ciS/fCObj4tCm+TUSo9GE y9DmLMStSt75GvQ/HRnOhG0XeKJFmnbZbMKNErE3y6drK8oLt1Abggs9IQXlHLIwlqpbEBNitBm c3mrVyu3LgJCOGToco0UTq03QaO8x9j3HnZyG1EvbzT8HQTmvjDn7nTSgPS7VJ+L4RL+/jnhl7L RUYUg6k/fDq3CbIxbuNbwCEo1rQ2QPK5y3nGHr/m4PRUo+9rBVk1/a4XO0d2qpaNzhHcUgTUZKb jGLFUeZl+KgjG88AMjivmZ7DbQCQ== X-Received: by 2002:a05:6a20:6a0e:b0:3bf:9b61:f7ae with SMTP id adf61e73a8af0-3cbadb35cfbmr28824064637.14.1786375514606; Mon, 10 Aug 2026 08:25:14 -0700 (PDT) X-Received: by 2002:a05:6a20:6a0e:b0:3bf:9b61:f7ae with SMTP id adf61e73a8af0-3cbadb35cfbmr28823990637.14.1786375514030; Mon, 10 Aug 2026 08:25:14 -0700 (PDT) Received: from hu-mchitale-blr.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com. [103.229.18.19]) by smtp.googlemail.com with ESMTPSA id 41be03b00d2f7-cbe8f1af985sm4282634a12.11.2026.08.10.08.25.07 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Aug 2026 08:25:13 -0700 (PDT) From: Mayuresh Chitale To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Anup Patel , Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Mayuresh Chitale , Anup Patel , Atish Patra , Andrew Jones , Sunil V L , linux-riscv@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v5 14/14] MAINTAINERS: Add entry for RISC-V trace framework Date: Mon, 10 Aug 2026 20:52:16 +0530 Message-ID: <20260810152223.3946743-15-mayuresh.chitale@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> References: <20260810152223.3946743-1-mayuresh.chitale@oss.qualcomm.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Proofpoint-GUID: yzDCJ-hVoZfyrwI89IvNjJlDV20KEJ8Q X-Proofpoint-ORIG-GUID: yzDCJ-hVoZfyrwI89IvNjJlDV20KEJ8Q X-Authority-Analysis: v=2.4 cv=WNVPmHsR c=1 sm=1 tr=0 ts=6a79ed5b cx=c_pps a=rz3CxIlbcmazkYymdCej/Q==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=Sv0fKeRqtYgA:10 a=s4-Qcg_JpJYA:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=YMgV9FUhrdKAYTUUvYB2:22 a=EUspDBNiAAAA:8 a=pGLkceISAAAA:8 a=W-_n0kkjAAAA:8 a=JfrnYn6hAAAA:8 a=UgJECxHJAAAA:8 a=hzgbeqSfhi83Ps7mpaYA:9 a=bFCP_H2QrGi7Okbo017w:22 a=qeNa2pbTr82C0GpJEZFS:22 a=1CNFftbPRP8L7MoqJWF3:22 a=-El7cUbtino8hM1DCn8D:22 X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX4TjVkqYQHW86 gT4rE5hvq/ZNgki7bWVAfvljaqaxed3LVqQcKZlISB5+br528hB/6SViYKkiklKjNBwD1PrSX4z 1fhp0bZSbBii7LIWPJ60Mr5yMU8srXlFl5LdcFYhE1jJAksIfqbdGNzy7E6cfibT8N2GD7x9jay EjPPmWRcBw6m2O+WntY8AI0RzV5n4/TsEZ+pA1Sl8TsXJJObz2zYCWwYKJCRDmPc1fKg4gCHmV3 5oDERbV66LthnRJsTg4lm9yfDheRXoUsMeyRsGz18GyZWzWTujAzopqxcRaE58OrpTNvGzMGX0g o7B7/0MJqRSrKE5vin2e2Ep4s60K1q+lkNGBJ8/ysNIsK6atQaJxfj9CEzX+IsLnInjT8B3nHFW K1DWXWlV3IsaLcUauAx9I7a7eMLFpiunSRhZuZNQGwvrm0ktAW/sNqhOoLsvxnCJPRXe9q2MuyI GeZ4VDTZ31dxL+M3oYA== X-Proofpoint-Spam-Info: AW1haW4tMjYwODEwMDEzMiBTYWx0ZWRfX4mfWFmVQMtEr sJDFv4qBYtI/w/Wz58y0P/4l1nMWWilREGKHiCRFyHz5NuOHEcmDoREVh4uzE0UznxjPB0Km1va e2AKYtujELljL7n/jmPgQA5MiOH/lLo= X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1176,Hydra:6.1.134,FMLib:17.12.100.49 definitions=2026-08-10_03,2026-08-07_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 malwarescore=0 bulkscore=0 clxscore=1015 suspectscore=0 priorityscore=1501 impostorscore=0 phishscore=0 spamscore=0 adultscore=0 lowpriorityscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2606150000 definitions=main-2608100132 Content-Type: text/plain; charset="utf-8" From: Anup Patel Add Mayuresh and myself as maintainers for the gtrace framework and its RISC-V trace drivers. Signed-off-by: Anup Patel --- MAINTAINERS | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 4b592cf49746..904392530963 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -23359,6 +23359,17 @@ F: include/dt-bindings/power/thead,th1520-power.h F: include/dt-bindings/reset/thead,th1520-reset.h F: include/linux/firmware/thead/thead,th1520-aon.h =20 +GTRACE FRAMEWORK AND RISC-V TRACE DRIVERS +M: Mayuresh Chitale +M: Anup Patel +L: linux-riscv@lists.infradead.org +S: Maintained +F: Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml +F: drivers/hwtracing/gtrace/* +F: include/linux/gtrace* +F: tools/perf/arch/riscv/util/auxtrace.c +F: tools/perf/util/gtrace* + RNBD BLOCK DRIVERS M: Md. Haris Iqbal M: Jack Wang --=20 2.43.0