From nobody Wed Apr 8 17:53:44 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 D3D8A2D5926; Wed, 25 Feb 2026 06:25:34 +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=1772000736; cv=none; b=dMqfuWvBDE5C2jA2avSZ4T10c0WYjTa28PUT63hra4vlE6vcKnSa8h27UD/a9N0JT2noDpduExCrgD3PhprR7yk84QkxSRhcEWmBxHRCXr6o3ma7Ds0LnCYUk3EyVDnzlT3lNxxvJe5My7GJvkNCPTyFotVssUpSBcAxccf/Y7I= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772000736; c=relaxed/simple; bh=f44O/Uugp01hYZOvnvq9HQzQyqdukwHS5lfoOw7Ue1k=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Oz2naBRjc7UZyv1J+ezjDMoljsVx9FFLkXSXsChVjWSChIJtKP/2EIwSKVHNMFdldmRCjzyvpMwon80ajbzAJ85xHoCQOFxmnsIl8EMiOW1SbmjtcYZBWFl6qUCZBPz8ZABWUzu6ZBZwu0DeRnI9y5RyRsNDtobUbHP++6HtGTQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=OhT1ytiQ; 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=qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="OhT1ytiQ" 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 61P26g782334694; Wed, 25 Feb 2026 06:24:59 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=aMr4dNH/MUu z0ffOYJvBodOSH1/WkRI3RDB077bVJDU=; b=OhT1ytiQDKNOJQKTCPO3i/mnfim /WCgJ+o5ZZgtbbuF6B4QEramPSdTG5uvV0nrZwJTFYu0r5WH8NgsOD6/eSfBjTwr 7TkDT9vjfQsPRbUYlrY/tloc1JRk3+pVFLNHK0096hvZOKCSCNOn8pixrEtz3Wxn J4jWdbHjAu5+FyHlB9BSq7ns3xU8F3gyvCGHWUn70h/zvUXeAwSeVo3oaMf5G9+f wMzox6ozD5lv0Oa8iEDQRIjdv2VMjFwuvKj39yxEjg70KMGwkjn74N4KM2RlAJ6k KnMagwdjfai0M28kB9XKyz062vduxGxAclHuR7TMxJgeOzN+6oK9xdvg1rg== Received: from apblrppmta01.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com [103.229.18.19]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4chg37t696-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:58 +0000 (GMT) Received: from pps.filterd (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (8.18.1.2/8.18.1.2) with ESMTP id 61P6OtNb001287; Wed, 25 Feb 2026 06:24:55 GMT Received: from pps.reinject (localhost [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 4cf5sm83dy-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:55 +0000 Received: from APBLRPPMTA01.qualcomm.com (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 61P6OsFa001263; Wed, 25 Feb 2026 06:24:54 GMT Received: from hu-devc-blr-u24-a.qualcomm.com (hu-anuppate-blr.qualcomm.com [10.131.36.165]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 61P6OsSE001258 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:54 +0000 Received: by hu-devc-blr-u24-a.qualcomm.com (Postfix, from userid 486687) id B24BF22BE7; Wed, 25 Feb 2026 11:54:53 +0530 (+0530) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Liang Kan , 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 v3 01/12] dt-bindings: Add RISC-V trace component bindings Date: Wed, 25 Feb 2026 11:54:37 +0530 Message-ID: <20260225062448.4027948-2-anup.patel@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260225062448.4027948-1-anup.patel@oss.qualcomm.com> References: <20260225062448.4027948-1-anup.patel@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-QCInternal: smtphost X-QCInternal: smtphost X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Authority-Analysis: v=2.4 cv=br1BxUai c=1 sm=1 tr=0 ts=699e95bb cx=c_pps a=Ou0eQOY4+eZoSc0qltEV5Q==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=HzLeVaNsDn8A:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=YMgV9FUhrdKAYTUUvYB2:22 a=gEfo2CItAAAA:8 a=EUspDBNiAAAA:8 a=W-_n0kkjAAAA:8 a=N_VqnJttRWTASdLJg5MA:9 a=sptkURWiP4Gy88Gu7hUp:22 a=qeNa2pbTr82C0GpJEZFS:22 X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwMjI1MDA2MSBTYWx0ZWRfX6xYw2HvPGx9p DZlsNpuqeBoPYlAs0ZHKvOT6RW76Qg5J0hpPDVGgwz54IEv+eyyZyVnLgcMD9RwVUD4bPx9+qN9 Vjd3icFmgyGtlSOtBRODrdXUYHKTbTUbwsCYhvpN3inN6rwgVusBh35HMSc/L+b2LN9EdfMwwg4 g0VGItUPlXfYUi8IX4P6Br66gzsWO+xW36/2YGViP1DKs5fw6Y9Y7zlLe3knW1UFfjn65+G/A2X RPf01NTw1V/FQvDvJd4uEN4Z6RRckzCRkodBZOzsVK21nwbQE8GcNqBNHb0OhLq6Js0tYBd6V3E SUbJWwkRClXBlQQE0DLpoHYUUdBvMMiMztm4RVHPgo1VSmKHXyoHrrwyColfJWtqL4TqxU2eI3X 6FuvjdxF89vDGyeiH4Eqt2MYqZOWH8JvJwRaj+3CKQAkaTuzJdn5aX9sZr+9UhXe6pEYRG5DsxL 6ZpvRxq5fKu4k7hazYg== X-Proofpoint-ORIG-GUID: HNFiWTM9bVN2olg1mnCF-bE9p1C6En6D X-Proofpoint-GUID: HNFiWTM9bVN2olg1mnCF-bE9p1C6En6D X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1121,Hydra:6.1.51,FMLib:17.12.100.49 definitions=2026-02-24_03,2026-02-23_03,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 lowpriorityscore=0 priorityscore=1501 spamscore=0 clxscore=1011 impostorscore=0 adultscore=0 bulkscore=0 phishscore=0 malwarescore=0 suspectscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2602130000 definitions=main-2602250061 Content-Type: text/plain; charset="utf-8" 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 --- .../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 Wed Apr 8 17:53:44 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 4FD282F9DB5; Wed, 25 Feb 2026 06:25:37 +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=1772000739; cv=none; b=FFEXcgCTTMGqHLdEQddEoY9mvygQPmvylmRDrg4UFJkCe4SRImKQ5pGmr6C27975jKp8LfUeWwNK7K8D429U+DMLoWwoF2ZOTi6whGfKQ5HXCcCUuQCoUoDCZBQh8umGx9wpFsvI0WWs4uIUKyxdNLtnJ44kdpvQCicRDvYMQns= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772000739; c=relaxed/simple; bh=/l2/O1ufy4SaXiLZXd64/MwivlQiM8lBMkD9Vb0T0o0=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=iA/a5S68dbh7wvbW2ZDthO59Wm4cYvKo/+rTc5TPeqo/h1cem6EhSm/MHqhDUWqIF1C/K5hYMIiCbEgaxbx+gQ7K2DPszvg4Hauh05h5NQP1QsJx27U2n93f9b+cYoLWLfDqlAHV5IwC4Qg6uFGwm7fyBJp5VMcTNWgb06pe3W0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=OhL3ACoB; 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=qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="OhL3ACoB" 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 61ON50sY062035; Wed, 25 Feb 2026 06:24:59 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=h2ER+xWIXWt c0xmcMdMSU/xcROjsyLIu80ynBSa2y5k=; b=OhL3ACoBiIoyzX/CBv9vE8Zo/M5 tMhtSJkw2yKWrMztY13TA7rEwW+cJLj8c8IjDvETtjGidZUKgtqNkSuXRhueGEAA zTArQYQSi9a2A1UfCH39XC6c8ZIlbiaczCPG5Bm2DjJV4an718zkyf6lVIojmJ5V LVvG6tsVbk5QEEf1k27JF2PD6wRExSIK0b1rLFcZBoANsU22Zy2sLx3ZGWNdSsZn 5hTx6sYABR99g4kmFWJWV/CNAAIx62OfHTczx6zOZCeBosTjnREIvMJsCkJ5hRH1 3dFOABKhYDc4kgmyx/oR+SaKjZ99AIWnXgL8s7vPEaOEg4ACDV4wYggpMhQ== Received: from apblrppmta01.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com [103.229.18.19]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4cherjagd2-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:58 +0000 (GMT) Received: from pps.filterd (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (8.18.1.2/8.18.1.2) with ESMTP id 61P6OtOm001289; Wed, 25 Feb 2026 06:24:55 GMT Received: from pps.reinject (localhost [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 4cf5sm83du-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:55 +0000 Received: from APBLRPPMTA01.qualcomm.com (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 61P6OLn1001156; Wed, 25 Feb 2026 06:24:54 GMT Received: from hu-devc-blr-u24-a.qualcomm.com (hu-anuppate-blr.qualcomm.com [10.131.36.165]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 61P6OsFn001260 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:54 +0000 Received: by hu-devc-blr-u24-a.qualcomm.com (Postfix, from userid 486687) id B528723508; Wed, 25 Feb 2026 11:54:53 +0530 (+0530) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Liang Kan , 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 , Mayuresh Chitale Subject: [PATCH v3 02/12] rvtrace: Initial implementation of driver framework Date: Wed, 25 Feb 2026 11:54:38 +0530 Message-ID: <20260225062448.4027948-3-anup.patel@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260225062448.4027948-1-anup.patel@oss.qualcomm.com> References: <20260225062448.4027948-1-anup.patel@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-QCInternal: smtphost X-QCInternal: smtphost X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwMjI1MDA2MSBTYWx0ZWRfX0HxotdyFjQt9 4zla+E9eAOJrVfVR3IZfLmogtKh979ULzuRRch5IF8QPj+hOpt2DwWPLw7iuIDEODqQIUQO6jHS PqoTbYgOqdnJ4J8PCY0trz1RcDHmE0yyHYWJHDRboN42vLVoUr53VFKl7YWRKvPi78lwD8jKO1o XkL7spIUgM2c5YAOEguP600TgeKKdLYbDv7gi9kgT/BG25WkvaiKANhn2OXY/KeL8giPq/L3zCR YHkm879ELxbbgNK29V71bJWuxsiOb+P+jXqVW9Co5Zew+H4SR57Mf8FB4lXatlh2BJGGdmpOyOz Z/ds3qiGtgXJzE5sA6Eim5uSO4zOgnrpmC8qqaMQZhXIx/YJ5CcUaGdn8q+PShS2aAGHF+8F08y 2xAQSAEN1QO7CaoUxldSmbrH7iwcB+tTo0avptAAp6T9fDDqqz4iqXIZPqzZhEqekma8C4rWr8W NdNl1cgbtd+5afO4y6A== X-Proofpoint-GUID: 28qu5Gw1F-WYQ3JrKi9tdlrIaefEYNxM X-Proofpoint-ORIG-GUID: 28qu5Gw1F-WYQ3JrKi9tdlrIaefEYNxM X-Authority-Analysis: v=2.4 cv=NeDrFmD4 c=1 sm=1 tr=0 ts=699e95bb cx=c_pps a=Ou0eQOY4+eZoSc0qltEV5Q==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=HzLeVaNsDn8A:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=DJpcGTmdVt4CTyJn9g5Z:22 a=V1jnuoLLAAAA:20 a=EUspDBNiAAAA:8 a=YT8UZTGgE0tzOG1900gA:9 a=bA3UWDv6hWIuX7UZL3qL:22 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1121,Hydra:6.1.51,FMLib:17.12.100.49 definitions=2026-02-24_03,2026-02-23_03,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 impostorscore=0 bulkscore=0 adultscore=0 spamscore=0 priorityscore=1501 suspectscore=0 lowpriorityscore=0 phishscore=0 malwarescore=0 clxscore=1011 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2602130000 definitions=main-2602250061 Content-Type: text/plain; charset="utf-8" The RISC-V Trace Control Interface Specification [1] defines a standard way of implementing RISC-V trace related modular components irrespective to underlying trace format (E-trace or N-trace). These RISC-V trace components are organized in a graph-like topology where each RISC-V hart has its own RISC-V trace encoder component. Implement a basic driver framework for RISC-V trace where RISC-V trace components are instantiated by a common platform driver and a separate RISC-V trace driver for each type of RISC-V trace component. [1] https://github.com/riscv-non-isa/tg-nexus-trace/releases/download/1.0_R= atified/RISC-V-Trace-Control-Interface.pdf Co-developed-by: Mayuresh Chitale Signed-off-by: Mayuresh Chitale Signed-off-by: Anup Patel --- drivers/Makefile | 1 + drivers/hwtracing/Kconfig | 2 + drivers/hwtracing/rvtrace/Kconfig | 16 + drivers/hwtracing/rvtrace/Makefile | 4 + drivers/hwtracing/rvtrace/rvtrace-core.c | 490 +++++++++++++++++++ drivers/hwtracing/rvtrace/rvtrace-platform.c | 209 ++++++++ include/linux/rvtrace.h | 283 +++++++++++ 7 files changed, 1005 insertions(+) create mode 100644 drivers/hwtracing/rvtrace/Kconfig create mode 100644 drivers/hwtracing/rvtrace/Makefile create mode 100644 drivers/hwtracing/rvtrace/rvtrace-core.c create mode 100644 drivers/hwtracing/rvtrace/rvtrace-platform.c create mode 100644 include/linux/rvtrace.h diff --git a/drivers/Makefile b/drivers/Makefile index 53fbd2e0acdd..07cb97128d61 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -179,6 +179,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_RVTRACE) +=3D hwtracing/rvtrace/ 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..daeb38fe332d 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/rvtrace/Kconfig" + endmenu diff --git a/drivers/hwtracing/rvtrace/Kconfig b/drivers/hwtracing/rvtrace/= Kconfig new file mode 100644 index 000000000000..f8f6feea1953 --- /dev/null +++ b/drivers/hwtracing/rvtrace/Kconfig @@ -0,0 +1,16 @@ +# SPDX-License-Identifier: GPL-2.0-only + +menuconfig RVTRACE + tristate "RISC-V Trace Support" + depends on RISCV + depends on OF + default RISCV + help + This framework provides a kernel interface for the RISC-V trace + drivers (including both e-trace and n-trace). It's intended to + build a topological view of the RISC-V trace components and + configure the right series of components when trace is enabled + on a CPU. + + To compile this driver as a module, choose M here: the module + will be called rvtrace. diff --git a/drivers/hwtracing/rvtrace/Makefile b/drivers/hwtracing/rvtrace= /Makefile new file mode 100644 index 000000000000..988525a379cf --- /dev/null +++ b/drivers/hwtracing/rvtrace/Makefile @@ -0,0 +1,4 @@ +# SPDX-License-Identifier: GPL-2.0 + +obj-$(CONFIG_RVTRACE) +=3D rvtrace.o +rvtrace-y :=3D rvtrace-core.o rvtrace-platform.o diff --git a/drivers/hwtracing/rvtrace/rvtrace-core.c b/drivers/hwtracing/r= vtrace/rvtrace-core.c new file mode 100644 index 000000000000..d69c2236493a --- /dev/null +++ b/drivers/hwtracing/rvtrace/rvtrace-core.c @@ -0,0 +1,490 @@ +// 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(rvtrace_mutex); + +/* Per-CPU encoder instances */ +static DEFINE_PER_CPU(struct rvtrace_component *, rvtrace_cpu_encoder); + +/* Component type based id generator */ +struct rvtrace_type_idx { + /* Lock to protect the type ID generator */ + struct mutex lock; + struct idr idr; +}; + +/* Array of component type based id generator */ +static struct rvtrace_type_idx rvtrace_type_idx_array[RVTRACE_COMPONENT_TY= PE_MAX]; + +static int rvtrace_alloc_type_idx(struct rvtrace_component *comp) +{ + struct rvtrace_type_idx *rvidx =3D &rvtrace_type_idx_array[comp->id.type]; + int idx; + + mutex_lock(&rvidx->lock); + idx =3D idr_alloc(&rvidx->idr, comp, 0, 0, GFP_KERNEL); + mutex_unlock(&rvidx->lock); + if (idx < 0) + return idx; + + comp->type_idx =3D idx; + return 0; +} + +static void rvtrace_free_type_idx(struct rvtrace_component *comp) +{ + struct rvtrace_type_idx *rvidx =3D &rvtrace_type_idx_array[comp->id.type]; + + mutex_lock(&rvidx->lock); + idr_remove(&rvidx->idr, comp->type_idx); + mutex_unlock(&rvidx->lock); +} + +static void __init rvtrace_init_type_idx(void) +{ + struct rvtrace_type_idx *rvidx; + int i; + + for (i =3D 0; i < RVTRACE_COMPONENT_TYPE_MAX; i++) { + rvidx =3D &rvtrace_type_idx_array[i]; + mutex_init(&rvidx->lock); + idr_init(&rvidx->idr); + } +} + +const struct rvtrace_component_id *rvtrace_match_id(struct rvtrace_compone= nt *comp, + const struct rvtrace_component_id *ids) +{ + u32 comp_maj, comp_min, id_maj, id_min; + const struct rvtrace_component_id *id; + + for (id =3D ids; id->version && id->type; id++) { + if (comp->id.type !=3D id->type) + return NULL; + + id_maj =3D rvtrace_component_version_major(id->version); + id_min =3D rvtrace_component_version_minor(id->version); + comp_maj =3D rvtrace_component_version_major(comp->id.version); + comp_min =3D rvtrace_component_version_minor(comp->id.version); + if (comp_maj > id_maj) + continue; + + /* Refer to Ch. 5 'Versioning of components of the Trace Control spec. */ + if (comp_maj < id_maj) + dev_warn(&comp->dev, "Older component with major version %d\n", comp_ma= j); + if (comp_min =3D=3D 15) + dev_warn(&comp->dev, "Experimental component\n"); + else if (comp_min > id_min) + dev_warn(&comp->dev, "Newer component with minor version %d\n", comp_mi= n); + + return id; + } + + return NULL; +} +EXPORT_SYMBOL_GPL(rvtrace_match_id); + +static int rvtrace_match_device(struct device *dev, const struct device_dr= iver *drv) +{ + const struct rvtrace_driver *rtdrv =3D to_rvtrace_driver(drv); + struct rvtrace_component *comp =3D to_rvtrace_component(dev); + + return rvtrace_match_id(comp, rtdrv->id_table) ? 1 : 0; +} + +static int rvtrace_probe(struct device *dev) +{ + const struct rvtrace_driver *rtdrv =3D to_rvtrace_driver(dev->driver); + struct rvtrace_component *comp =3D to_rvtrace_component(dev); + int ret =3D -ENODEV; + + if (!rtdrv->probe) + return ret; + + ret =3D rtdrv->probe(comp); + if (!ret) + comp->ready =3D true; + + return ret; +} + +static void rvtrace_remove(struct device *dev) +{ + const struct rvtrace_driver *rtdrv =3D to_rvtrace_driver(dev->driver); + struct rvtrace_component *comp =3D to_rvtrace_component(dev); + + comp->ready =3D false; + if (rtdrv->remove) + rtdrv->remove(comp); +} + +static const struct bus_type rvtrace_bustype =3D { + .name =3D "rvtrace", + .match =3D rvtrace_match_device, + .probe =3D rvtrace_probe, + .remove =3D rvtrace_remove, +}; + +struct rvtrace_fwnode_match_data { + struct fwnode_handle *fwnode; + struct rvtrace_component *match; +}; + +static int rvtrace_match_fwnode(struct device *dev, void *data) +{ + struct rvtrace_component *comp =3D to_rvtrace_component(dev); + struct rvtrace_fwnode_match_data *d =3D data; + + if (device_match_fwnode(&comp->dev, d->fwnode)) { + d->match =3D comp; + return 1; + } + + return 0; +} + +struct rvtrace_component *rvtrace_find_by_fwnode(struct fwnode_handle *fwn= ode) +{ + struct rvtrace_fwnode_match_data d =3D { .fwnode =3D fwnode, .match =3D N= ULL }; + int ret; + + ret =3D bus_for_each_dev(&rvtrace_bustype, NULL, &d, rvtrace_match_fwnode= ); + if (ret < 0) + return ERR_PTR(ret); + + return d.match; +} +EXPORT_SYMBOL_GPL(rvtrace_find_by_fwnode); + +int rvtrace_poll_bit(struct rvtrace_platform_data *pdata, int offset, + int bit, int bitval, int timeout) +{ + u32 val; + + while (timeout--) { + val =3D rvtrace_read32(pdata, offset); + if (((val >> bit) & 0x1) =3D=3D bitval) + break; + udelay(1); + } + + return (timeout < 0) ? -ETIMEDOUT : 0; +} +EXPORT_SYMBOL_GPL(rvtrace_poll_bit); + +int rvtrace_enable_component(struct rvtrace_platform_data *pdata) +{ + u32 val; + + val =3D rvtrace_read32(pdata, RVTRACE_COMPONENT_CTRL_OFFSET); + val |=3D BIT(RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT); + rvtrace_write32(pdata, val, RVTRACE_COMPONENT_CTRL_OFFSET); + return rvtrace_poll_bit(pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT, 1, + pdata->control_poll_timeout_usecs); +} +EXPORT_SYMBOL_GPL(rvtrace_enable_component); + +int rvtrace_disable_component(struct rvtrace_platform_data *pdata) +{ + u32 val; + + val =3D rvtrace_read32(pdata, RVTRACE_COMPONENT_CTRL_OFFSET); + val &=3D ~BIT(RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT); + rvtrace_write32(pdata, val, RVTRACE_COMPONENT_CTRL_OFFSET); + return rvtrace_poll_bit(pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT, 0, + pdata->control_poll_timeout_usecs); +} +EXPORT_SYMBOL_GPL(rvtrace_disable_component); + +int rvtrace_reset_component(struct rvtrace_platform_data *pdata) +{ + int ret; + + rvtrace_write32(pdata, 0, RVTRACE_COMPONENT_CTRL_OFFSET); + ret =3D rvtrace_poll_bit(pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ACTIVE_SHIFT, 0, + pdata->control_poll_timeout_usecs); + if (ret) + return ret; + + rvtrace_write32(pdata, RVTRACE_COMPONENT_CTRL_ACTIVE_MASK, + RVTRACE_COMPONENT_CTRL_OFFSET); + return rvtrace_poll_bit(pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ACTIVE_SHIFT, 1, + pdata->control_poll_timeout_usecs); +} +EXPORT_SYMBOL_GPL(rvtrace_reset_component); + +struct rvtrace_component *rvtrace_cpu_source(unsigned int cpu) +{ + if (!cpu_present(cpu)) + return NULL; + + return per_cpu(rvtrace_cpu_encoder, cpu); +} +EXPORT_SYMBOL_GPL(rvtrace_cpu_source); + +static int rvtrace_cleanup_inconn(struct device *dev, void *data) +{ + struct rvtrace_component *comp =3D to_rvtrace_component(dev); + struct rvtrace_platform_data *pdata =3D comp->pdata; + struct rvtrace_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 rvtrace_cleanup_inconns_from_outconns(struct rvtrace_component= *comp) +{ + struct rvtrace_platform_data *pdata =3D comp->pdata; + struct rvtrace_connection *conn; + int i; + + lockdep_assert_held(&rvtrace_mutex); + + for (i =3D 0; i < pdata->nr_outconns; i++) { + conn =3D pdata->outconns[i]; + bus_for_each_dev(&rvtrace_bustype, NULL, conn, rvtrace_cleanup_inconn); + } +} + +static int rvtrace_setup_inconn(struct device *dev, void *data) +{ + struct rvtrace_component *comp =3D to_rvtrace_component(dev); + struct rvtrace_platform_data *pdata =3D comp->pdata; + struct rvtrace_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 rvtrace_setup_inconns_from_outconns(struct rvtrace_component *c= omp) +{ + struct rvtrace_platform_data *pdata =3D comp->pdata; + struct rvtrace_connection *conn; + int i, ret; + + lockdep_assert_held(&rvtrace_mutex); + + for (i =3D 0; i < pdata->nr_outconns; i++) { + conn =3D pdata->outconns[i]; + ret =3D bus_for_each_dev(&rvtrace_bustype, NULL, conn, rvtrace_setup_inc= onn); + if (ret < 0) { + rvtrace_cleanup_inconns_from_outconns(comp); + return ret; + } + } + + return 0; +} + +static void rvtrace_component_release(struct device *dev) +{ + struct rvtrace_component *comp =3D to_rvtrace_component(dev); + + fwnode_handle_put(comp->dev.fwnode); + rvtrace_free_type_idx(comp); + kfree(comp); +} + +struct rvtrace_component *rvtrace_register_component(enum rvtrace_componen= t_type type, + u32 version, + struct rvtrace_platform_data *pdata) +{ + struct rvtrace_connection *conn; + struct rvtrace_component *comp; + int i, ret =3D 0; + + 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; + } + if (type =3D=3D RVTRACE_COMPONENT_TYPE_ENCODER && pdata->bound_cpu < 0) { + 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.type =3D type; + comp->id.version =3D version; + ret =3D rvtrace_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 rvtrace_component_release; + comp->dev.bus =3D &rvtrace_bustype; + comp->dev.fwnode =3D fwnode_handle_get(dev_fwnode(pdata->dev)); + switch (comp->id.type) { + case RVTRACE_COMPONENT_TYPE_ENCODER: + dev_set_name(&comp->dev, "encoder-%d", comp->type_idx); + break; + case RVTRACE_COMPONENT_TYPE_FUNNEL: + dev_set_name(&comp->dev, "funnel-%d", comp->type_idx); + break; + case RVTRACE_COMPONENT_TYPE_RAMSINK: + dev_set_name(&comp->dev, "ramsink-%d", comp->type_idx); + break; + case RVTRACE_COMPONENT_TYPE_PIBSINK: + dev_set_name(&comp->dev, "pibsink-%d", comp->type_idx); + break; + case RVTRACE_COMPONENT_TYPE_ATBBRIDGE: + dev_set_name(&comp->dev, "atbbridge-%d", comp->type_idx); + break; + default: + dev_set_name(&comp->dev, "type%d-%d", comp->id.type, comp->type_idx); + break; + } + + mutex_lock(&rvtrace_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 rvtrace_setup_inconns_from_outconns(comp); + if (ret < 0) { + device_unregister(&comp->dev); + goto err_out_unlock; + } + + if (comp->id.type =3D=3D RVTRACE_COMPONENT_TYPE_ENCODER) { + rvtrace_get_component(comp); + per_cpu(rvtrace_cpu_encoder, comp->pdata->bound_cpu) =3D comp; + } + + mutex_unlock(&rvtrace_mutex); + + return comp; + +err_out_unlock: + mutex_unlock(&rvtrace_mutex); +err_out: + return ERR_PTR(ret); +} +EXPORT_SYMBOL_GPL(rvtrace_register_component); + +void rvtrace_unregister_component(struct rvtrace_component *comp) +{ + struct rvtrace_component *c; + + mutex_lock(&rvtrace_mutex); + + if (comp->id.type =3D=3D RVTRACE_COMPONENT_TYPE_ENCODER) { + c =3D per_cpu(rvtrace_cpu_encoder, comp->pdata->bound_cpu); + per_cpu(rvtrace_cpu_encoder, comp->pdata->bound_cpu) =3D NULL; + rvtrace_put_component(c); + } + + rvtrace_cleanup_inconns_from_outconns(comp); + device_unregister(&comp->dev); + + mutex_unlock(&rvtrace_mutex); +} +EXPORT_SYMBOL_GPL(rvtrace_unregister_component); + +int __rvtrace_register_driver(struct module *owner, struct rvtrace_driver = *rtdrv) +{ + rtdrv->driver.owner =3D owner; + rtdrv->driver.bus =3D &rvtrace_bustype; + + return driver_register(&rtdrv->driver); +} +EXPORT_SYMBOL_GPL(__rvtrace_register_driver); + +static int __init rvtrace_init(void) +{ + int ret; + + rvtrace_init_type_idx(); + + ret =3D bus_register(&rvtrace_bustype); + if (ret) + return ret; + + ret =3D platform_driver_register(&rvtrace_platform_driver); + if (ret) { + bus_unregister(&rvtrace_bustype); + return ret; + } + + return 0; +} + +static void __exit rvtrace_exit(void) +{ + platform_driver_unregister(&rvtrace_platform_driver); + bus_unregister(&rvtrace_bustype); +} + +module_init(rvtrace_init); +module_exit(rvtrace_exit); diff --git a/drivers/hwtracing/rvtrace/rvtrace-platform.c b/drivers/hwtraci= ng/rvtrace/rvtrace-platform.c new file mode 100644 index 000000000000..83e5a577bc52 --- /dev/null +++ b/drivers/hwtracing/rvtrace/rvtrace-platform.c @@ -0,0 +1,209 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2026 Qualcomm Technologies, Inc. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +static int rvtrace_of_parse_outconns(struct rvtrace_platform_data *pdata) +{ + struct device_node *parent, *ep_node, *rep_node, *rdev_node; + struct rvtrace_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 rvtrace_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 rvtrace_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 rvtrace_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 rvtrace_platform_data *pdata; + struct device *dev =3D &pdev->dev; + struct rvtrace_component *comp; + u32 impl, type, major, minor; + struct device_node *node; + struct resource *res; + 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; + + 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"); + + ret =3D rvtrace_reset_component(pdata); + if (ret) + return dev_err_probe(dev, ret, "failed to reset component\n"); + + impl =3D rvtrace_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; + + comp =3D rvtrace_register_component(type, rvtrace_component_mkversion(maj= or, minor), 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 rvtrace_component *comp =3D platform_get_drvdata(pdev); + struct rvtrace_platform_data *pdata =3D comp->pdata; + struct rvtrace_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); + } + + rvtrace_unregister_component(comp); +} + +static const struct of_device_id rvtrace_platform_match[] =3D { + { .compatible =3D "riscv,trace-component" }, + {} +}; + +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, +}; diff --git a/include/linux/rvtrace.h b/include/linux/rvtrace.h new file mode 100644 index 000000000000..d6be6e3cc10f --- /dev/null +++ b/include/linux/rvtrace.h @@ -0,0 +1,283 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2026 Qualcomm Technologies, Inc. + */ + +#ifndef __LINUX_RVTRACE_H__ +#define __LINUX_RVTRACE_H__ + +#include +#include +#include +#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 + +/* Possible 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 +}; + +/* Encoding/decoding macros for RISC-V trace component version */ +#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)) + +/* + * 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 +}; + +/** + * struct rvtrace_connection - Representation of a physical connection bet= ween + * two RISC-V trace components. + * @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 rvtrace_connection { + int src_port; + struct fwnode_handle *src_fwnode; + int dest_port; + struct fwnode_handle *dest_fwnode; + struct rvtrace_component *src_comp; + struct rvtrace_component *dest_comp; +}; + +/** + * struct rvtrace_platform_data - Platform-level data for a RISC-V trace c= omponent + * discovered from DT or ACPI. + * @dev: Parent device. + * @impid: Component implementation ID + * @io_mem: Flag showing whether component registers are memory mappe= d. + * @base: If io_mem =3D=3D true then base address of the memory map= ped registers. + * @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 "= offset". + * @bound_cpu: CPU to which the component is bound. This should be -1 if + * the component is not bound to any CPU. For encoder compon= ent + * type this must not be -1. + * @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 rvtrace_platform_data { + struct device *dev; + + enum rvtrace_component_impid impid; + + bool io_mem; + union { + void __iomem *base; + struct { + u32 (*read)(struct rvtrace_platform_data *pdata, + u32 offset, bool relaxed); + void (*write)(struct rvtrace_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 rvtrace_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 rvtrace_connection **outconns; +}; + +static inline u32 rvtrace_read32(struct rvtrace_platform_data *pdata, u32 = offset) +{ + if (likely(pdata->io_mem)) + return readl(pdata->base + offset); + + return pdata->read(pdata, offset, false); +} + +static inline u32 rvtrace_relaxed_read32(struct rvtrace_platform_data *pda= ta, u32 offset) +{ + if (likely(pdata->io_mem)) + return readl_relaxed(pdata->base + offset); + + return pdata->read(pdata, offset, true); +} + +static inline void rvtrace_write32(struct rvtrace_platform_data *pdata, u3= 2 val, u32 offset) +{ + if (likely(pdata->io_mem)) + writel(val, pdata->base + offset); + else + pdata->write(pdata, val, offset, false); +} + +static inline void rvtrace_relaxed_write32(struct rvtrace_platform_data *p= data, + 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 rvtrace_is_source(struct rvtrace_platform_data *pdata) +{ + return !pdata->nr_inconns ? true : false; +} + +static inline bool rvtrace_is_sink(struct rvtrace_platform_data *pdata) +{ + return !pdata->nr_outconns ? true : false; +} + +/** + * struct rvtrace_component_id - Details to identify or match a RISC-V tra= ce component + * @type: Type of the component + * @version: Version of the component + * @data: Data pointer for driver use + */ +struct rvtrace_component_id { + enum rvtrace_component_type type; + u32 version; + void *data; +}; + +/** + * struct rvtrace_component - Representation of a RISC-V 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 RISC-V trace driver was probed successfu= lly + */ +struct rvtrace_component { + struct rvtrace_platform_data *pdata; + struct rvtrace_component_id id; + u32 type_idx; + struct device dev; + bool ready; +}; + +#define to_rvtrace_component(__dev) container_of_const(__dev, struct rvtra= ce_component, dev) + +static inline void rvtrace_get_component(struct rvtrace_component *comp) +{ + get_device(&comp->dev); +} + +static inline void rvtrace_put_component(struct rvtrace_component *comp) +{ + put_device(&comp->dev); +} + +const struct rvtrace_component_id *rvtrace_match_id(struct rvtrace_compone= nt *comp, + const struct rvtrace_component_id *ids); +struct rvtrace_component *rvtrace_find_by_fwnode(struct fwnode_handle *fwn= ode); + +int rvtrace_poll_bit(struct rvtrace_platform_data *pdata, int offset, + int bit, int bitval, int timeout); +int rvtrace_enable_component(struct rvtrace_platform_data *pdata); +int rvtrace_disable_component(struct rvtrace_platform_data *pdata); +int rvtrace_reset_component(struct rvtrace_platform_data *pdata); + +struct rvtrace_component *rvtrace_cpu_source(unsigned int cpu); + +struct rvtrace_component *rvtrace_register_component(enum rvtrace_componen= t_type type, + u32 version, + struct rvtrace_platform_data *pdata); +void rvtrace_unregister_component(struct rvtrace_component *comp); + +/** + * struct rvtrace_driver - Representation of a RISC-V trace driver + * id_table: Table to match components handled by the driver + * probe: Driver probe() function + * remove: Driver remove() function + * driver: Device driver instance + */ +struct rvtrace_driver { + const struct rvtrace_component_id *id_table; + int (*probe)(struct rvtrace_component *comp); + void (*remove)(struct rvtrace_component *comp); + struct device_driver driver; +}; + +#define to_rvtrace_driver(__drv) \ + ((__drv) ? container_of_const((__drv), struct rvtrace_driver, driver) : N= ULL) + +extern struct platform_driver rvtrace_platform_driver; + +int __rvtrace_register_driver(struct module *owner, struct rvtrace_driver = *rtdrv); +#define rvtrace_register_driver(driver) __rvtrace_register_driver(THIS_MOD= ULE, driver) +static inline void rvtrace_unregister_driver(struct rvtrace_driver *rtdrv) +{ + if (rtdrv) + driver_unregister(&rtdrv->driver); +} + +static inline int rvtrace_comp_poll_empty(struct rvtrace_component *comp) +{ + return rvtrace_poll_bit(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_EMPTY_SHIFT, 1, + comp->pdata->control_poll_timeout_usecs); +} + +#endif --=20 2.43.0 From nobody Wed Apr 8 17:53:44 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 A13522F3614; Wed, 25 Feb 2026 06:25:55 +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=1772000762; cv=none; b=gM4kAV5+FvaW0RQdpz+L32efJ6gIArj8Kx9crQ2htCnZxccpcwAdMaZ5QT1xwXO7HLLjRrKWqg23QRDCM1CKtgyQpPZ0JZohHKm6lkImlsGxwzQJ78hMThwCQ9jSq3HFjTQ7OsABzH/Aki0NnAkwPYZtJ/VRLRNGBfw8anBkg6g= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772000762; c=relaxed/simple; bh=3lk0eeJEXb0fsUYE5hVJ2k25Rqjt0USGOiHNHCFXizM=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Frh61gfyNhHPmXjWswnCJEypFFCKPm4jV94SdbvE8XMWM6oo1EmAPgMH7dOBHNG94Df2el5hk1Iwib5EXm/fn8Cmbg8xXT3Plz1Gx2yiIe2Tqm0xCMQIlxLF1BBW1thYex3TTPjo+dXSibzn9vJAGcKOgj0aKSe1eo9fb9xt8DI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=JjKiaGNy; 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=qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="JjKiaGNy" 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 61ONp0UO134540; Wed, 25 Feb 2026 06:25:00 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=hxZVxXcr/V6 2gVHq9sxbPJrXaz87OM850jA/r80z02U=; b=JjKiaGNyiisea4BrHloREcHDlqS R0jEQlgzrz94tnoewanmfPd8mmynsktOOJeXlN9S/w8dooKrTF40cbGZ7GQhPgKF mrYmXGTNziOPBFrz6ITh+7rgrHJ1ZsRvlU8peLNC6g//UbCp24WZz0SsvvwePPA/ 3QoUMxttVtdixFxkgSbMFyESvRcR9+PMEotKLJUmOGBWpi0FNaBazxBDfYodqUpb J3SaEK7J7bKkk6TfBF5V5f3rCFHB7iKdIyVJgAhuEIqYL/KLj8rjcV+RgBqnUeFB bYSbeK/5ZAni8ZyrVsy5R34wVmMC17W34F6di17jvaPogJyAV0Qxo0EjLCQ== Received: from apblrppmta01.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com [103.229.18.19]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4chp158wv0-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:59 +0000 (GMT) Received: from pps.filterd (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (8.18.1.2/8.18.1.2) with ESMTP id 61P6OMbl001167; Wed, 25 Feb 2026 06:24:55 GMT Received: from pps.reinject (localhost [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 4cf5sm83dw-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:55 +0000 Received: from APBLRPPMTA01.qualcomm.com (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 61P6OsBl001264; Wed, 25 Feb 2026 06:24:54 GMT Received: from hu-devc-blr-u24-a.qualcomm.com (hu-anuppate-blr.qualcomm.com [10.131.36.165]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 61P6OsQv001262 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:54 +0000 Received: by hu-devc-blr-u24-a.qualcomm.com (Postfix, from userid 486687) id B90A3249BD; Wed, 25 Feb 2026 11:54:53 +0530 (+0530) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Liang Kan , 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 , Mayuresh Chitale Subject: [PATCH v3 03/12] rvtrace: Add functions to create/destroy a trace component path Date: Wed, 25 Feb 2026 11:54:39 +0530 Message-ID: <20260225062448.4027948-4-anup.patel@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260225062448.4027948-1-anup.patel@oss.qualcomm.com> References: <20260225062448.4027948-1-anup.patel@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-QCInternal: smtphost X-QCInternal: smtphost X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwMjI1MDA2MSBTYWx0ZWRfX5dMwES4a5jOL PzkDqE4B5TS7+bBv14TRaOC23/vH3iO8J5J33FV8QkrDIeN0UgsE0wqQnVl65j/BBGI+zkdyQGy ykETFAUG2JuOvtmzFk8S7vObXzxU/bWxH22rCmfNTpnOI6482F1ZZt2Cb5yZHiRNyb7EQmsVpLT cs/S/VYO3cxWDbF7qSVwKI+EmrcKanEQfsYP8gGZRzCFpnLA/A9VaB2DSHfx9RxrrrHnTgKX3QY ROQ7UZrK4A6Ky82caV6+55//z61ojEvqSnn1FyBQBP/YoymYV8JqSYehWwZjoUe/Z7ahVKtbl2H bUXa/pS8S4K+5CmhemaqwmRaQoTo4mBwiT9Ozndmk3wjp+PG6bu1FP1fxWmtHTYXMmwlygDZYyW wdk0KDOxdiKjjAwEWq/+PW2uj53z+1PSpw5OquIE8brrZa3x+xLMysm9vFS+6pUdxASCWi21AHe PxLR3KH+5NcBQ790fkw== X-Proofpoint-GUID: rg5-qdZ-lO1oULxUVaXdVYMxH9_xM5jF X-Proofpoint-ORIG-GUID: rg5-qdZ-lO1oULxUVaXdVYMxH9_xM5jF X-Authority-Analysis: v=2.4 cv=etXSD4pX c=1 sm=1 tr=0 ts=699e95bc cx=c_pps a=Ou0eQOY4+eZoSc0qltEV5Q==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=HzLeVaNsDn8A:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=yx91gb_oNiZeI1HMLzn7:22 a=EUspDBNiAAAA:8 a=UaIybRF2xpGp7VXWmyEA:9 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1121,Hydra:6.1.51,FMLib:17.12.100.49 definitions=2026-02-24_03,2026-02-23_03,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 clxscore=1015 lowpriorityscore=0 impostorscore=0 adultscore=0 malwarescore=0 suspectscore=0 bulkscore=0 phishscore=0 spamscore=0 priorityscore=1501 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2602130000 definitions=main-2602250061 Content-Type: text/plain; charset="utf-8" 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 RISC-V trace perf support. Co-developed-by: Mayuresh Chitale Signed-off-by: Mayuresh Chitale Signed-off-by: Anup Patel --- drivers/hwtracing/rvtrace/rvtrace-core.c | 223 +++++++++++++++++++++++ include/linux/rvtrace.h | 43 ++++- 2 files changed, 264 insertions(+), 2 deletions(-) diff --git a/drivers/hwtracing/rvtrace/rvtrace-core.c b/drivers/hwtracing/r= vtrace/rvtrace-core.c index d69c2236493a..5f40bad215e0 100644 --- a/drivers/hwtracing/rvtrace/rvtrace-core.c +++ b/drivers/hwtracing/rvtrace/rvtrace-core.c @@ -229,6 +229,53 @@ int rvtrace_reset_component(struct rvtrace_platform_da= ta *pdata) } EXPORT_SYMBOL_GPL(rvtrace_reset_component); =20 +static int __rvtrace_walk_output_components(struct rvtrace_component *comp, + bool *stop, void *priv, + int (*fn)(struct rvtrace_component *comp, bool *stop, + struct rvtrace_connection *stop_conn, + void *priv)) +{ + struct rvtrace_connection *conn, *stop_conn =3D NULL; + struct rvtrace_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 __rvtrace_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 rvtrace_walk_output_components(struct rvtrace_component *comp, void *p= riv, + int (*fn)(struct rvtrace_component *comp, bool *stop, + struct rvtrace_connection *stop_conn, + void *priv)) +{ + bool stop =3D false; + int ret; + + if (!comp || !fn) + return -EINVAL; + + mutex_lock(&rvtrace_mutex); + ret =3D __rvtrace_walk_output_components(comp, &stop, priv, fn); + mutex_unlock(&rvtrace_mutex); + + return ret; +} +EXPORT_SYMBOL_GPL(rvtrace_walk_output_components); + struct rvtrace_component *rvtrace_cpu_source(unsigned int cpu) { if (!cpu_present(cpu)) @@ -452,6 +499,182 @@ void rvtrace_unregister_component(struct rvtrace_comp= onent *comp) } EXPORT_SYMBOL_GPL(rvtrace_unregister_component); =20 +struct rvtrace_path_node { + struct list_head head; + struct rvtrace_component *comp; + struct rvtrace_connection *conn; +}; + +struct rvtrace_component *rvtrace_path_source(struct rvtrace_path *path) +{ + struct rvtrace_path_node *node; + + node =3D list_first_entry(&path->comp_list, struct rvtrace_path_node, hea= d); + return node->comp; +} +EXPORT_SYMBOL_GPL(rvtrace_path_source); + +struct rvtrace_component *rvtrace_path_sink(struct rvtrace_path *path) +{ + struct rvtrace_path_node *node; + + node =3D list_last_entry(&path->comp_list, struct rvtrace_path_node, head= ); + return node->comp; +} +EXPORT_SYMBOL_GPL(rvtrace_path_sink); + +static int rvtrace_assign_trace_id(struct rvtrace_path *path) +{ + const struct rvtrace_driver *rtdrv; + struct rvtrace_component *comp; + struct rvtrace_path_node *node; + int trace_id; + + list_for_each_entry(node, &path->comp_list, head) { + comp =3D node->comp; + rtdrv =3D to_rvtrace_driver(comp->dev.driver); + + if (!rtdrv->get_trace_id) + continue; + + trace_id =3D rtdrv->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 rvtrace_unassign_trace_id(struct rvtrace_path *path) +{ + const struct rvtrace_driver *rtdrv; + struct rvtrace_component *comp; + struct rvtrace_path_node *node; + + list_for_each_entry(node, &path->comp_list, head) { + comp =3D node->comp; + rtdrv =3D to_rvtrace_driver(comp->dev.driver); + + if (!rtdrv->put_trace_id) + continue; + + rtdrv->put_trace_id(comp, path->mode, path->trace_id); + } +} + +static bool rvtrace_path_ready(struct rvtrace_path *path) +{ + struct rvtrace_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 rvtrace_path *path; + struct rvtrace_component *sink; +}; + +static int build_path_walk_fn(struct rvtrace_component *comp, bool *stop, + struct rvtrace_connection *stop_conn, + void *priv) +{ + struct build_path_walk_priv *ppriv =3D priv; + struct rvtrace_path *path =3D ppriv->path; + struct rvtrace_path_node *node; + + if ((!ppriv->sink && rvtrace_is_sink(comp->pdata)) || + (ppriv->sink && ppriv->sink =3D=3D comp)) + *stop =3D true; + + if (*stop) { + node =3D kzalloc(sizeof(*node), GFP_KERNEL); + if (!path) + return -ENOMEM; + INIT_LIST_HEAD(&node->head); + rvtrace_get_component(comp); + node->comp =3D comp; + node->conn =3D stop_conn; + list_add(&node->head, &path->comp_list); + } + + return 0; +} + +static void rvtrace_release_path_nodes(struct rvtrace_path *path) +{ + struct rvtrace_path_node *node, *node1; + + list_for_each_entry_safe(node, node1, &path->comp_list, head) { + list_del(&node->head); + rvtrace_put_component(node->comp); + kfree(node); + } +} + +struct rvtrace_path *rvtrace_create_path(struct rvtrace_component *source, + struct rvtrace_component *sink, + enum rvtrace_component_mode mode) +{ + struct build_path_walk_priv priv; + struct rvtrace_path *path; + int ret =3D 0; + + if (!source || mode >=3D RVTRACE_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 RVTRACE_INVALID_TRACE_ID; + + priv.path =3D path; + priv.sink =3D sink; + ret =3D rvtrace_walk_output_components(source, &priv, build_path_walk_fn); + if (ret < 0) + goto err_release_path_nodes; + + if (!rvtrace_path_ready(path)) { + ret =3D -EOPNOTSUPP; + goto err_release_path_nodes; + } + + ret =3D rvtrace_assign_trace_id(path); + if (ret < 0) + goto err_release_path_nodes; + + return path; + +err_release_path_nodes: + rvtrace_release_path_nodes(path); + kfree(path); +err_out: + return ERR_PTR(ret); +} +EXPORT_SYMBOL_GPL(rvtrace_create_path); + +void rvtrace_destroy_path(struct rvtrace_path *path) +{ + rvtrace_unassign_trace_id(path); + rvtrace_release_path_nodes(path); + kfree(path); +} +EXPORT_SYMBOL_GPL(rvtrace_destroy_path); + int __rvtrace_register_driver(struct module *owner, struct rvtrace_driver = *rtdrv) { rtdrv->driver.owner =3D owner; diff --git a/include/linux/rvtrace.h b/include/linux/rvtrace.h index d6be6e3cc10f..00b63fa22da9 100644 --- a/include/linux/rvtrace.h +++ b/include/linux/rvtrace.h @@ -8,6 +8,8 @@ =20 #include #include +#include +#include #include #include #include @@ -72,6 +74,12 @@ enum rvtrace_component_impid { RVTRACE_COMPONENT_IMPID_MAX }; =20 +/* Supported usage modes for RISC-V trace components */ +enum rvtrace_component_mode { + RVTRACE_COMPONENT_MODE_PERF, + RVTRACE_COMPONENT_MODE_MAX +}; + /** * struct rvtrace_connection - Representation of a physical connection bet= ween * two RISC-V trace components. @@ -239,6 +247,10 @@ int rvtrace_enable_component(struct rvtrace_platform_d= ata *pdata); int rvtrace_disable_component(struct rvtrace_platform_data *pdata); int rvtrace_reset_component(struct rvtrace_platform_data *pdata); =20 +int rvtrace_walk_output_components(struct rvtrace_component *comp, void *p= riv, + int (*fn)(struct rvtrace_component *comp, bool *stop, + struct rvtrace_connection *stop_conn, + void *priv)); struct rvtrace_component *rvtrace_cpu_source(unsigned int cpu); =20 struct rvtrace_component *rvtrace_register_component(enum rvtrace_componen= t_type type, @@ -246,17 +258,44 @@ struct rvtrace_component *rvtrace_register_component(= enum rvtrace_component_type struct rvtrace_platform_data *pdata); void rvtrace_unregister_component(struct rvtrace_component *comp); =20 +/** + * struct rvtrace_path - Representation of a RISC-V trace path from source= to sink + * @comp_list: List of RISC-V trace components in the path + * @mode: Usage mode for RISC-V trace components + * @trace_id: ID of the trace source (typically hart id) + */ +struct rvtrace_path { + struct list_head comp_list; + enum rvtrace_component_mode mode; + u32 trace_id; +#define RVTRACE_INVALID_TRACE_ID 0 +}; + +struct rvtrace_component *rvtrace_path_source(struct rvtrace_path *path); +struct rvtrace_component *rvtrace_path_sink(struct rvtrace_path *path); +struct rvtrace_path *rvtrace_create_path(struct rvtrace_component *source, + struct rvtrace_component *sink, + enum rvtrace_component_mode mode); +void rvtrace_destroy_path(struct rvtrace_path *path); + /** * struct rvtrace_driver - Representation of a RISC-V trace driver * id_table: Table to match components handled by the driver - * probe: Driver probe() function - * remove: Driver remove() function + * 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 rvtrace_driver { const struct rvtrace_component_id *id_table; int (*probe)(struct rvtrace_component *comp); void (*remove)(struct rvtrace_component *comp); + int (*get_trace_id)(struct rvtrace_component *comp, + enum rvtrace_component_mode mode); + void (*put_trace_id)(struct rvtrace_component *comp, + enum rvtrace_component_mode mode, + u32 trace_id); struct device_driver driver; }; =20 --=20 2.43.0 From nobody Wed Apr 8 17:53:44 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 67AC8302767; Wed, 25 Feb 2026 06:25:46 +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=1772000751; cv=none; b=dYjgN1C6G3VgN2DTO/zfdWga8m6G0rGHhoeL3T6mkJyNEsraoaAS85FcG0gn7sxwZE8aMGBZxDSymFNwJHTmqWgTjbsZoHRMurLMuUQLhTXovYEhbXgL0BkF8CayHCcLt8EACVn3Q+q+v1ND3UHKS4Y/mUbmT+DOcDwdFBHhJK8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772000751; c=relaxed/simple; bh=TryLWMoFrvvrx/epc+FpZDXEzwyKvdqeja/m9q7taks=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=DS+WfQ9ZbH9KAKv1YtpdegR6IlUnExXQwaLFIMS6FpProvGXjLgQgLroPcwzA4MX41M0x4RHLqsyRILMdZCYYUXP6C5a5Dy8C5WBTe1qO39b3rAIjvBoa2kkdLqa3XYig9LD3wjq2nBLCwsc6kmKUKF+wLNxAqsC3kUI8tHiCj4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=VNbL5fvi; 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=qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="VNbL5fvi" Received: from pps.filterd (m0279865.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 61P1dRsE3660109; Wed, 25 Feb 2026 06:24:59 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=aEeCcigjEOI QiU3b6Nnn6bwgMriruVIr7smJgHT/vPs=; b=VNbL5fvicPi6fZhf9rG/YP97wDo d+SNiw5mimCqWSSildZVoYvAn0PyjEJGqLUwCu4/Il56s41HlSNt3KjtU5F1UZOv Wf2LbqVtaa0SvWrH3y78Wl5Dwzfl0t9kHCshkhjW8w3DBWMA74YVYvZV+HevIKbV Ykk9WeeOQ9MKtRoR3fhW8xdsc7zDgyeRBakwf7CfH3l1WlXZRJMoq2ZCLRkLNu5j mBTr/zU5YqW3LHddyRZwwrm424ALogEdR7ozZwL4Df8keJLCbdODdooyBnUcd9j5 hahnDhAcBbPT4hrDge5TrfC+IoPPcekprZNFnk7OqQCkPN5iJT+mlD0i5rw== Received: from apblrppmta01.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com [103.229.18.19]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4chg1sa62p-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:58 +0000 (GMT) Received: from pps.filterd (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (8.18.1.2/8.18.1.2) with ESMTP id 61P6OtpV001288; Wed, 25 Feb 2026 06:24:55 GMT Received: from pps.reinject (localhost [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 4cf5sm83dv-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:55 +0000 Received: from APBLRPPMTA01.qualcomm.com (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 61P6OsH5001265; Wed, 25 Feb 2026 06:24:54 GMT Received: from hu-devc-blr-u24-a.qualcomm.com (hu-anuppate-blr.qualcomm.com [10.131.36.165]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 61P6OsI5001259 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:54 +0000 Received: by hu-devc-blr-u24-a.qualcomm.com (Postfix, from userid 486687) id BE13E249DD; Wed, 25 Feb 2026 11:54:53 +0530 (+0530) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Liang Kan , 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 , Anup Patel Subject: [PATCH v3 04/12] rvtrace: Add functions to start/stop tracing on a component path Date: Wed, 25 Feb 2026 11:54:40 +0530 Message-ID: <20260225062448.4027948-5-anup.patel@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260225062448.4027948-1-anup.patel@oss.qualcomm.com> References: <20260225062448.4027948-1-anup.patel@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-QCInternal: smtphost X-QCInternal: smtphost X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Authority-Analysis: v=2.4 cv=ZKvaWH7b c=1 sm=1 tr=0 ts=699e95bb cx=c_pps a=Ou0eQOY4+eZoSc0qltEV5Q==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=HzLeVaNsDn8A:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=Um2Pa8k9VHT-vaBCBUpS:22 a=EUspDBNiAAAA:8 a=a8cUU4qgmBzOD3ajWOcA:9 X-Proofpoint-GUID: q2k8PoKbEc5gyhTKzuyPUKrN_fD0rYh9 X-Proofpoint-ORIG-GUID: q2k8PoKbEc5gyhTKzuyPUKrN_fD0rYh9 X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwMjI1MDA2MSBTYWx0ZWRfXyvbB8/BBCnsC 5k7UKyCRyJqW3mvggcpTlm4KGybrFE4uW0SYCI6kQM+ZyOJ4f7qiFB4YqxDZlqy1tIyJTSd4Nsl Zkxo0Z136s0BwBIg39lRQgfLCg7ioruFD/J+mmw2FTrkcwx2+2i4XA29oag9Xo4AbVIJYs5fUtp aSrTY0Yt600FM/Sc1lejvm3JWwHLBucrQSPYzHJD661tc0PriCzSrBk9uXr2pf2Q7ELaVUXoqBS ZW/m21j33hOWKn4+TbTIoYzwhfoY6JHg21zBx/99qnYhbIxXWl8SKBgvnK0M+0IEBah+9OKWfo2 3YJ74IM0G27VOCayXkV4VDKOatyLlUDzYAJDf1La2lq6yTUT8Sjn0gNgXyYe8gWT2UBZH1r2nBV gvkEGAfBnZP86OssLA5CjkKAGRtKcnNG2jNitw20RmkSzTrmbBJATzd1hgYCNX0Cs4OOQEoQ3NL CO+910xFrsCRTLsEBYg== X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1121,Hydra:6.1.51,FMLib:17.12.100.49 definitions=2026-02-24_03,2026-02-23_03,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 phishscore=0 lowpriorityscore=0 suspectscore=0 malwarescore=0 clxscore=1011 impostorscore=0 priorityscore=1501 adultscore=0 bulkscore=0 spamscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2602130000 definitions=main-2602250061 Content-Type: text/plain; charset="utf-8" From: Mayuresh Chitale The perf driver framework needs to be able to start / stop all components in a trace component path during its operation. Add rvtrace_path_start() and rvtrace_path_stop() functions for this purpose. Co-developed-by: Anup Patel Signed-off-by: Anup Patel Signed-off-by: Mayuresh Chitale --- drivers/hwtracing/rvtrace/rvtrace-core.c | 44 ++++++++++++++++++++++++ include/linux/rvtrace.h | 6 ++++ 2 files changed, 50 insertions(+) diff --git a/drivers/hwtracing/rvtrace/rvtrace-core.c b/drivers/hwtracing/r= vtrace/rvtrace-core.c index 5f40bad215e0..fa848935003a 100644 --- a/drivers/hwtracing/rvtrace/rvtrace-core.c +++ b/drivers/hwtracing/rvtrace/rvtrace-core.c @@ -620,6 +620,50 @@ static void rvtrace_release_path_nodes(struct rvtrace_= path *path) } } =20 +int rvtrace_path_start(struct rvtrace_path *path) +{ + const struct rvtrace_driver *rtdrv; + struct rvtrace_component *comp; + struct rvtrace_path_node *node; + int ret; + + list_for_each_entry_reverse(node, &path->comp_list, head) { + comp =3D node->comp; + rtdrv =3D to_rvtrace_driver(comp->dev.driver); + if (!rtdrv->start) + continue; + + ret =3D rtdrv->start(comp); + if (ret) + return ret; + } + + return 0; +} +EXPORT_SYMBOL_GPL(rvtrace_path_start); + +int rvtrace_path_stop(struct rvtrace_path *path) +{ + const struct rvtrace_driver *rtdrv; + struct rvtrace_component *comp; + struct rvtrace_path_node *node; + int ret; + + list_for_each_entry(node, &path->comp_list, head) { + comp =3D node->comp; + rtdrv =3D to_rvtrace_driver(comp->dev.driver); + if (!rtdrv->stop) + continue; + + ret =3D rtdrv->stop(comp); + if (ret) + return ret; + } + + return 0; +} +EXPORT_SYMBOL_GPL(rvtrace_path_stop); + struct rvtrace_path *rvtrace_create_path(struct rvtrace_component *source, struct rvtrace_component *sink, enum rvtrace_component_mode mode) diff --git a/include/linux/rvtrace.h b/include/linux/rvtrace.h index 00b63fa22da9..2a7d8afd27c8 100644 --- a/include/linux/rvtrace.h +++ b/include/linux/rvtrace.h @@ -277,10 +277,14 @@ struct rvtrace_path *rvtrace_create_path(struct rvtra= ce_component *source, struct rvtrace_component *sink, enum rvtrace_component_mode mode); void rvtrace_destroy_path(struct rvtrace_path *path); +int rvtrace_path_start(struct rvtrace_path *path); +int rvtrace_path_stop(struct rvtrace_path *path); =20 /** * struct rvtrace_driver - Representation of a RISC-V 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 @@ -289,6 +293,8 @@ void rvtrace_destroy_path(struct rvtrace_path *path); */ struct rvtrace_driver { const struct rvtrace_component_id *id_table; + int (*start)(struct rvtrace_component *comp); + int (*stop)(struct rvtrace_component *comp); int (*probe)(struct rvtrace_component *comp); void (*remove)(struct rvtrace_component *comp); int (*get_trace_id)(struct rvtrace_component *comp, --=20 2.43.0 From nobody Wed Apr 8 17:53:44 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 0AC832F12BA; Wed, 25 Feb 2026 06:25:41 +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=1772000743; cv=none; b=X1e0ucceeYdAPbX7ROxiyt7HyuzUadIoHCiS7p3GpSodptkFLpb++T0K41+3EsmT/2OHM0Se2Vk8fOJuDL+08wuPUtXkiErYE6lNMDukIEfU8A9yM6m4DLJ2tAGlvh1qHyDl/IPjEt/VbLhWGwOZADiWI8Pp8iF6t+ZV2EMuOZQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772000743; c=relaxed/simple; bh=4bl7/YjD5ptthtSBhvFFRBcottU9ktImwBEFtCPyz4I=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=TXyxKVl5nLbsiREFNYstiZpKwtSgxk5r0Gue6BqQsoFsPNp2/0FPZyBHwb+O4RlOYnb7Qfort1ugfkbHX66gBEp1XJErogvelaXAeNoYpornDrZ9u+BPS9Q3DvnGNGc6bnPY89Q1pCq0bUI4KJAmkpcK9HnjNyS2WZIhY7u/Z7A= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=XSSFpode; 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=qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="XSSFpode" 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 61ONZJHM3177236; Wed, 25 Feb 2026 06: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=ZXpV6H7vjYk qUaAQjiqyywI8Ceb5UFQ6rPmGH1z1J90=; b=XSSFpodev4Oq5CN8xKjdY/eak0H BQOZb1hK+geeGUZGtlPSvVX4em2/W5hqEVTcv0lh4WQwi8z9pfHTObF9SM+c1KuT muSkOFnKSovZsHTKGUGcw8cjxwsV63julFhlgRvOPP9wWFzUsSXxPsQ8DAA3PZVb scirxf33V9wsrbsanLStaY5NJ3BuYUNR27LK0BHQusu7TiMh7dla1Y6WpbztCP+b QCeV5JJzafo23VqXCLULlTggI5VTDcoKNI0AklCK2/gnFuzkQia4fg6N4mWbKJmO 1FJmeTJfUtqqyohKdkMJ9jH1N8htxjhrB5z/+JC/rZkSm5bfzgMfOdFL+bA== Received: from apblrppmta01.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com [103.229.18.19]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4chemntgth-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:25:01 +0000 (GMT) Received: from pps.filterd (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (8.18.1.2/8.18.1.2) with ESMTP id 61P6OtoD001344; Wed, 25 Feb 2026 06:24:57 GMT Received: from pps.reinject (localhost [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 4cf5sm83er-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:56 +0000 Received: from APBLRPPMTA01.qualcomm.com (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 61P6OLn3001156; Wed, 25 Feb 2026 06:24:55 GMT Received: from hu-devc-blr-u24-a.qualcomm.com (hu-anuppate-blr.qualcomm.com [10.131.36.165]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 61P6OtDl001308 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:55 +0000 Received: by hu-devc-blr-u24-a.qualcomm.com (Postfix, from userid 486687) id C303E249F5; Wed, 25 Feb 2026 11:54:53 +0530 (+0530) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Liang Kan , 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 , Anup Patel Subject: [PATCH v3 05/12] rvtrace: Add trace encoder driver Date: Wed, 25 Feb 2026 11:54:41 +0530 Message-ID: <20260225062448.4027948-6-anup.patel@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260225062448.4027948-1-anup.patel@oss.qualcomm.com> References: <20260225062448.4027948-1-anup.patel@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-QCInternal: smtphost X-QCInternal: smtphost X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwMjI1MDA2MSBTYWx0ZWRfX5a2GkCWuUVKd 5LkGn1Mcee22IteqNtVp2UA4ziggCmY5fC4j1T6Pbp1BoYTyZMTChRh4UgtNGrQFM8MYfTVBtev TidJUrh/EGKHMK92R0ynnKbrwOsksbtRb45Vw8sNkys8/UaKWog3UiZNlDAkR+U0QjVn8y7Lrrh KKW9xzgfZrKCrQCmRGDtgFPpoVgE4B6J19qXdXHf4iYvpMRAPZIyZdocP0mz/Dyy9yJmYc/u0bW xRZOZ+DhFtBXaIYTxO0JgpfLJOfE0s4zqySHN7hHsB496QTHet4lgzFGPatFyYsPh4iixgK9wOz 11DrJe3IGq9BAJ3gopE7MGPc3Ii2mN5Qmn8wXq8OHasBk6rTDUpiE5guNlj8btPqSwrgFo3+Gto 6qe+eNmpgPd88dF9zCY6AOiE+mEVsAo55sbztzACLA9oRgQRxvwUjINphq0FP0xnCubarSGrY+q 3RSiCssX7+7bUKxXCWQ== X-Proofpoint-ORIG-GUID: qwWsoajpRCxK8WLoGmSQMt92qiNF19nb X-Authority-Analysis: v=2.4 cv=Ro7I7SmK c=1 sm=1 tr=0 ts=699e95bd cx=c_pps a=Ou0eQOY4+eZoSc0qltEV5Q==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=HzLeVaNsDn8A:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=ZpdpYltYx_vBUK5n70dp:22 a=EUspDBNiAAAA:8 a=Snd26lYfUHIjvdY5T_gA:9 X-Proofpoint-GUID: qwWsoajpRCxK8WLoGmSQMt92qiNF19nb X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1121,Hydra:6.1.51,FMLib:17.12.100.49 definitions=2026-02-24_03,2026-02-23_03,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 malwarescore=0 clxscore=1015 spamscore=0 bulkscore=0 adultscore=0 impostorscore=0 phishscore=0 lowpriorityscore=0 priorityscore=1501 suspectscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2602130000 definitions=main-2602250061 Content-Type: text/plain; charset="utf-8" From: Mayuresh Chitale Add initial implementation of RISC-V 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/rvtrace/Kconfig | 7 ++ drivers/hwtracing/rvtrace/Makefile | 1 + drivers/hwtracing/rvtrace/rvtrace-encoder.c | 130 ++++++++++++++++++++ 3 files changed, 138 insertions(+) create mode 100644 drivers/hwtracing/rvtrace/rvtrace-encoder.c diff --git a/drivers/hwtracing/rvtrace/Kconfig b/drivers/hwtracing/rvtrace/= Kconfig index f8f6feea1953..ba35c05f3f54 100644 --- a/drivers/hwtracing/rvtrace/Kconfig +++ b/drivers/hwtracing/rvtrace/Kconfig @@ -14,3 +14,10 @@ menuconfig 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 RISC-V Trace Encoder component. diff --git a/drivers/hwtracing/rvtrace/Makefile b/drivers/hwtracing/rvtrace= /Makefile index 988525a379cf..f320693a1fc5 100644 --- a/drivers/hwtracing/rvtrace/Makefile +++ b/drivers/hwtracing/rvtrace/Makefile @@ -2,3 +2,4 @@ =20 obj-$(CONFIG_RVTRACE) +=3D rvtrace.o rvtrace-y :=3D rvtrace-core.o rvtrace-platform.o +obj-$(CONFIG_RVTRACE_ENCODER) +=3D rvtrace-encoder.o diff --git a/drivers/hwtracing/rvtrace/rvtrace-encoder.c b/drivers/hwtracin= g/rvtrace/rvtrace-encoder.c new file mode 100644 index 000000000000..d189819aecf7 --- /dev/null +++ b/drivers/hwtracing/rvtrace/rvtrace-encoder.c @@ -0,0 +1,130 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2026 Qualcomm Technologies, Inc. + */ + +#include +#include +#include + +#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 rvtrace_component *comp) +{ + int ret; + u32 val; + + val =3D rvtrace_read32(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET); + val |=3D BIT(RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT); + rvtrace_write32(comp->pdata, val, RVTRACE_COMPONENT_CTRL_OFFSET); + ret =3D rvtrace_poll_bit(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT, 1, + comp->pdata->control_poll_timeout_usecs); + if (ret) { + dev_err(&comp->dev, "failed to enable encoder.\n"); + return ret; + } + + /* set mode */ + val =3D rvtrace_read32(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET); + val |=3D (RVTRACE_COMPONENT_CTRL_INSTMODE_OPIT << RVTRACE_COMPONENT_CTRL_= INSTMODE_SHIFT); + rvtrace_write32(comp->pdata, val, RVTRACE_COMPONENT_CTRL_OFFSET); + + val =3D rvtrace_read32(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET); + val |=3D BIT(RVTRACE_COMPONENT_CTRL_ITRACE_SHIFT); + rvtrace_write32(comp->pdata, val, RVTRACE_COMPONENT_CTRL_OFFSET); + ret =3D rvtrace_poll_bit(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ITRACE_SHIFT, 1, + comp->pdata->control_poll_timeout_usecs); + if (ret) + dev_err(&comp->dev, "failed to enable tracing.\n"); + + return ret; +} + +static int rvtrace_encoder_stop(struct rvtrace_component *comp) +{ + int ret; + u32 val; + + val =3D rvtrace_read32(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET); + val &=3D ~BIT(RVTRACE_COMPONENT_CTRL_ITRACE_SHIFT); + rvtrace_write32(comp->pdata, val, RVTRACE_COMPONENT_CTRL_OFFSET); + ret =3D rvtrace_poll_bit(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ITRACE_SHIFT, 0, + comp->pdata->control_poll_timeout_usecs); + if (ret) { + dev_err(&comp->dev, "failed to stop tracing.\n"); + return ret; + } + + val =3D rvtrace_read32(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET); + val &=3D ~BIT(RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT); + rvtrace_write32(comp->pdata, val, RVTRACE_COMPONENT_CTRL_OFFSET); + ret =3D rvtrace_poll_bit(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT, 0, + comp->pdata->control_poll_timeout_usecs); + if (ret) { + dev_err(&comp->dev, "failed to disable encoder.\n"); + return ret; + } + + return rvtrace_comp_poll_empty(comp); +} + +static int rvtrace_encoder_probe(struct rvtrace_component *comp) +{ + int ret; + + ret =3D rvtrace_enable_component(comp->pdata); + if (ret) + return dev_err_probe(&comp->dev, ret, "failed to enable encoder.\n"); + + return 0; +} + +static void rvtrace_encoder_remove(struct rvtrace_component *comp) +{ + int ret; + + ret =3D rvtrace_disable_component(comp->pdata); + if (ret) + dev_err(&comp->dev, "failed to disable encoder.\n"); +} + +static struct rvtrace_component_id rvtrace_encoder_ids[] =3D { + { .type =3D RVTRACE_COMPONENT_TYPE_ENCODER, + .version =3D rvtrace_component_mkversion(1, 0), }, + {}, +}; + +static struct rvtrace_driver rvtrace_encoder_driver =3D { + .id_table =3D rvtrace_encoder_ids, + .start =3D rvtrace_encoder_start, + .stop =3D rvtrace_encoder_stop, + .probe =3D rvtrace_encoder_probe, + .remove =3D rvtrace_encoder_remove, + .driver =3D { + .name =3D "rvtrace-encoder", + }, +}; + +static int __init rvtrace_encoder_init(void) +{ + return rvtrace_register_driver(&rvtrace_encoder_driver); +} + +static void __exit rvtrace_encoder_exit(void) +{ + rvtrace_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 Wed Apr 8 17:53:44 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 450CB2F3614; Wed, 25 Feb 2026 06:25:36 +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=1772000738; cv=none; b=PVmx/Uk7tY1b4WI8XVU9pR6KrAaIu37SCIDAnu8P9TluZ+bYZ86gfzA889dga24k2EtnkFXgXyW9lkrhCT0WBvj3zCgxOPVTS3TYSGzGIWlmsiwcyzoBHmZ29O3qdIngXO2ACxuuP+s+cutXUzCVKJgcrrrjV10Se2XOwpdbNAI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772000738; c=relaxed/simple; bh=qMbJlO9V+EqdfsZstLmamkZwUaN4TCa/6mtzDI+qsG4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Mq7r4c1CQiMzWADFmrzVChVx6l2NbYv5JCW2SgL1qaF295K8MlaDh+NO28xKiq+2VigLdWnXobv+Vjl5ZztwNOAbkWYtEQ8k7mce5a7Qrrir06g9oqiv2RQcQLKnQzJlKbu518WpL6b6imiMYOw4XaTGC0tejTeHT6PprrU94Fc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=a2gaLLjN; 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=qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="a2gaLLjN" Received: from pps.filterd (m0279867.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 61P17vs44148421; Wed, 25 Feb 2026 06:25:00 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=Z8UeAqz8mv/ 0uZywowuExjjkK4BGRfFcOVNS/N+S34A=; b=a2gaLLjNL9t/Q9JSqaPnlGMge4H nmHMi/91EMX9b5jgBnOZuQss9t+bdakgj/D4dKGkEyiTJtrafujUQWQZoORrRavp x0fHzyO7stB2SKEyzn4FEARAgUPKX6Nk5mKHOid4Fj7a9DvhwWt8Q/1syUW7OmHD SUhwfq7CmfBU26ig7rxXoakA0PoA9I2/jWTRqV3GBGzMRfRPnTFkGaHsolD3W2E1 tijc0wkNsxnv728k2IOfqdyiAitmNcSLH0169vhFr9wzHBr/547NPI2bm3JY5zBh nlx3zmZ3xqJfBtx4Dn2J/pRhcOW2bRhfP/XBhuMCVZ9oVrj3NuWifdAm8Eg== Received: from apblrppmta01.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com [103.229.18.19]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4chq57rqe7-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:59 +0000 (GMT) Received: from pps.filterd (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (8.18.1.2/8.18.1.2) with ESMTP id 61P6Oto9001344; Wed, 25 Feb 2026 06:24:56 GMT Received: from pps.reinject (localhost [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 4cf5sm83es-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:56 +0000 Received: from APBLRPPMTA01.qualcomm.com (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 61P6OsFc001263; Wed, 25 Feb 2026 06:24:55 GMT Received: from hu-devc-blr-u24-a.qualcomm.com (hu-anuppate-blr.qualcomm.com [10.131.36.165]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 61P6Ot08001309 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:55 +0000 Received: by hu-devc-blr-u24-a.qualcomm.com (Postfix, from userid 486687) id C7E3F24A1E; Wed, 25 Feb 2026 11:54:53 +0530 (+0530) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Liang Kan , 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 , Mayuresh Chitale Subject: [PATCH v3 06/12] rvtrace: Add function to copy into perf AUX buffer Date: Wed, 25 Feb 2026 11:54:42 +0530 Message-ID: <20260225062448.4027948-7-anup.patel@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260225062448.4027948-1-anup.patel@oss.qualcomm.com> References: <20260225062448.4027948-1-anup.patel@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-QCInternal: smtphost X-QCInternal: smtphost X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Authority-Analysis: v=2.4 cv=faOgCkQF c=1 sm=1 tr=0 ts=699e95bb cx=c_pps a=Ou0eQOY4+eZoSc0qltEV5Q==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=HzLeVaNsDn8A:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=eoimf2acIAo5FJnRuUoq:22 a=EUspDBNiAAAA:8 a=J47OFj0AjNl56Ar9NcoA:9 X-Proofpoint-ORIG-GUID: RLbr5tueSDzNRbQGpuNNCgtd_tKGkNoI X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwMjI1MDA2MSBTYWx0ZWRfXw+g5cmOMFDoa 3VlbmAe/BXn42ntf/wo8Kq36RNAlJhCF+eAesbG3NZ4ZS/V/ipyCETbOBViEWRCunQ2dHR3N04B VFk9UwX/dGykY3KvDyTHxj136I3+EeojhEGRtWBPsYVQ2JfjhoGY6ytwBfKG5JCoangNYSRFLkV zdqkWrXjysIjsESEgUobu4N3vLUEnXLFbvtKeAwXG+RMn28g4sFJmMS/DSEH6MEVQl+ndL7t+TE VMG2t/83rsADmUo+Lr8HUOpSkXSmELS2l3fmcBQvgjMLoeBfOqeMHPJdAvARKgsukVgSNAxUb9O HcDg7RJ3FCfrLhq0MAK7G0mm8QlLqg51gxZOpo+e/8bdJVPQBKxU+MWshqtcSKVOwEhuoJ3hC3F OborUHrs2Z+QeWa5HFKZcQpwd73/Q1KT3l9FwuM+PSuhW281cDF1XhoXY/rbRuKff6tn6Se4lcp rpWnKTj3NRrRksgZf9g== X-Proofpoint-GUID: RLbr5tueSDzNRbQGpuNNCgtd_tKGkNoI X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1121,Hydra:6.1.51,FMLib:17.12.100.49 definitions=2026-02-24_03,2026-02-23_03,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 adultscore=0 clxscore=1015 impostorscore=0 suspectscore=0 phishscore=0 lowpriorityscore=0 malwarescore=0 spamscore=0 bulkscore=0 priorityscore=1501 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2602130000 definitions=main-2602250061 Content-Type: text/plain; charset="utf-8" The RISC-V trace ramsink will need a mechanism to copy trace data into the perf AUX buffer. Add rvtrace_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/rvtrace/rvtrace-core.c | 22 ++++++++++++++++++++++ include/linux/rvtrace.h | 21 +++++++++++++++++++++ 2 files changed, 43 insertions(+) diff --git a/drivers/hwtracing/rvtrace/rvtrace-core.c b/drivers/hwtracing/r= vtrace/rvtrace-core.c index fa848935003a..1a1484c1eca4 100644 --- a/drivers/hwtracing/rvtrace/rvtrace-core.c +++ b/drivers/hwtracing/rvtrace/rvtrace-core.c @@ -664,6 +664,28 @@ int rvtrace_path_stop(struct rvtrace_path *path) } EXPORT_SYMBOL_GPL(rvtrace_path_stop); =20 +int rvtrace_path_copyto_auxbuf(struct rvtrace_path *path, + struct rvtrace_perf_auxbuf *buf, + size_t *bytes_copied) +{ + const struct rvtrace_driver *rtdrv; + struct rvtrace_component *comp; + struct rvtrace_path_node *node; + + list_for_each_entry(node, &path->comp_list, head) { + comp =3D node->comp; + rtdrv =3D to_rvtrace_driver(comp->dev.driver); + if (!rtdrv->copyto_auxbuf) + continue; + + *bytes_copied =3D rtdrv->copyto_auxbuf(comp, buf); + return 0; + } + + return -EOPNOTSUPP; +} +EXPORT_SYMBOL_GPL(rvtrace_path_copyto_auxbuf); + struct rvtrace_path *rvtrace_create_path(struct rvtrace_component *source, struct rvtrace_component *sink, enum rvtrace_component_mode mode) diff --git a/include/linux/rvtrace.h b/include/linux/rvtrace.h index 2a7d8afd27c8..36663c7b3e30 100644 --- a/include/linux/rvtrace.h +++ b/include/linux/rvtrace.h @@ -280,9 +280,28 @@ void rvtrace_destroy_path(struct rvtrace_path *path); int rvtrace_path_start(struct rvtrace_path *path); int rvtrace_path_stop(struct rvtrace_path *path); =20 +/** + * struct rvtrace_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 rvtrace_perf_auxbuf { + size_t length; + int nr_pages; + void *base; + long pos; +}; + +int rvtrace_path_copyto_auxbuf(struct rvtrace_path *path, + struct rvtrace_perf_auxbuf *buf, + size_t *bytes_copied); + /** * struct rvtrace_driver - Representation of a RISC-V trace driver * id_table: Table to match components handled by the driver + * copyto_auxbuf:Callback to copy data into perf AUX buffer * start: Callback to start tracing * stop: Callback to stop tracing * probe: Driver probe() function @@ -293,6 +312,8 @@ int rvtrace_path_stop(struct rvtrace_path *path); */ struct rvtrace_driver { const struct rvtrace_component_id *id_table; + size_t (*copyto_auxbuf)(struct rvtrace_component *comp, + struct rvtrace_perf_auxbuf *buf); int (*start)(struct rvtrace_component *comp); int (*stop)(struct rvtrace_component *comp); int (*probe)(struct rvtrace_component *comp); --=20 2.43.0 From nobody Wed Apr 8 17:53:44 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 5076A28850E; Wed, 25 Feb 2026 06:25:34 +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=1772000735; cv=none; b=H97qOHV1qU8w5MffmGFzahL07fLurAWNbF3l4zHMa27DTgZ5IlaTwai0XJwis1k4b2XO+poEGuEClaV+FvdujwNXAeAWtprlCuAhu5zPP2tx/sHwLYDon7bgXGOUkzn6WofoYW6HcI76Y9oPpRKAbu4AjtanEiJ9kGlgGy6hNM8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772000735; c=relaxed/simple; bh=+s3oMQF73eZEWRe64+ZOck8HOyl7/tW+I0hYmOEzCMM=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=PgxroOTf5ofFStVcImMM0GWtabuLRgOWh3tMa01V+QiW/HLwMEINsi2OB55OI2cQq9T3ExM2E755ZeQQUJ+4+7VmDF9BPyPpXnOO2gAcVgieu6Iv7UxPc79GcK8cgO39qk6UOTvarMKvRsaCbI0EYrsfH8yB14sX/4ug7PP6o44= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=gzSS1XvA; 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=qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="gzSS1XvA" 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 61P2GAFP2334651; Wed, 25 Feb 2026 06: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=5nyYLEnoxMT Fo2XO2kGWyJb4IpOqryd07weB76W/NDI=; b=gzSS1XvAPQsAOgDpUStwsuhTN5t 1IJnvYR5xDw6hwUsyFVg7LroRLyMgYqBms2w4ZFQbFZC7KuBLXc+hJuwA9lh6+4c N2w//yPc3BCQRU9Dx3SndBubudaZFDsc34ATuNZanUyqsHhRc3Shys690HTS3gqm 5avT2PS17Z/aIF6YqKGm+haL0/oXFsSPICv9duyCFPCIB0mJVrjHejDeyxuffYc9 Ri3oUli10g/i9joodMOFv03/MR2TbUodOe50wj5yenbKr8Qf1IT52xN+u+fCTuRH YHyf9b0GAl/HqPT64RMSDz/powHAqmOjVhH8WP7Dd40z4i0kkrGMV1Ohw9g== Received: from apblrppmta01.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com [103.229.18.19]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4chg37t699-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:25:00 +0000 (GMT) Received: from pps.filterd (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (8.18.1.2/8.18.1.2) with ESMTP id 61P6OtoE001344; Wed, 25 Feb 2026 06:24:57 GMT Received: from pps.reinject (localhost [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 4cf5sm83et-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:57 +0000 Received: from APBLRPPMTA01.qualcomm.com (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 61P6OsUm001266; Wed, 25 Feb 2026 06:24:55 GMT Received: from hu-devc-blr-u24-a.qualcomm.com (hu-anuppate-blr.qualcomm.com [10.131.36.165]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 61P6Ot9F001302 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:55 +0000 Received: by hu-devc-blr-u24-a.qualcomm.com (Postfix, from userid 486687) id CC8FF24A39; Wed, 25 Feb 2026 11:54:53 +0530 (+0530) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Liang Kan , 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 , Anup Patel Subject: [PATCH v3 07/12] rvtrace: Add trace ramsink driver Date: Wed, 25 Feb 2026 11:54:43 +0530 Message-ID: <20260225062448.4027948-8-anup.patel@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260225062448.4027948-1-anup.patel@oss.qualcomm.com> References: <20260225062448.4027948-1-anup.patel@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-QCInternal: smtphost X-QCInternal: smtphost X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Authority-Analysis: v=2.4 cv=br1BxUai c=1 sm=1 tr=0 ts=699e95bd cx=c_pps a=Ou0eQOY4+eZoSc0qltEV5Q==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=HzLeVaNsDn8A:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=YMgV9FUhrdKAYTUUvYB2:22 a=EUspDBNiAAAA:8 a=i6N2WwkFxVyM5ZFWfxQA:9 X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwMjI1MDA2MSBTYWx0ZWRfX+Ae3I+oDHUg5 uB0dQubr6L6/1Pr2hfNTMMZLxZu2Wr4I723DCdhRslum5S1KxUi+B+/fbPzqEGf8HQsmoK4hCiD gF6kZWrnx+2Dunyr1XYnZ6tadfqvQdOQWvlBy6/p99snxx3FwrPMGnZAXsaBDv0xlopMVKzd+M6 C8t/QMCsWhZCrdGNGDGdtFcE0zSYHxxGHWAMBDDe3lI2C3t0hmMLibyfELp3QCi8XOOC2y4niQI hDhjyC71UX5fCG+HD1xmeRJJaAhSH4EZW0GstwlAO15e71FIPuYqU+2YhXqd6fbjGgU1383r6Dx ab+4rxC5aNel221iy7d2JCbwdH8aVgbO0Gl/Gai5s/QHY0XX51takNAi7FHSP+eakO5GFPijuXU ImCQc4YHjEyjVNEHYE0mQ5NmsWb16QXh0vNYrGdfMt1KgMlKxuKQWyQxyxl0ITT7+7AMWY/IyYt ofbaAcpkbcm4X97QB8w== X-Proofpoint-ORIG-GUID: kmD7cS1nHcoE2QDTi-brg_VHMTjq6yYO X-Proofpoint-GUID: kmD7cS1nHcoE2QDTi-brg_VHMTjq6yYO X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1121,Hydra:6.1.51,FMLib:17.12.100.49 definitions=2026-02-24_03,2026-02-23_03,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 lowpriorityscore=0 priorityscore=1501 spamscore=0 clxscore=1015 impostorscore=0 adultscore=0 bulkscore=0 phishscore=0 malwarescore=0 suspectscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2602130000 definitions=main-2602250061 Content-Type: text/plain; charset="utf-8" From: Mayuresh Chitale Add initial implementation of RISC-V 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/rvtrace/Kconfig | 9 + drivers/hwtracing/rvtrace/Makefile | 1 + drivers/hwtracing/rvtrace/rvtrace-ramsink.c | 322 ++++++++++++++++++++ 3 files changed, 332 insertions(+) create mode 100644 drivers/hwtracing/rvtrace/rvtrace-ramsink.c diff --git a/drivers/hwtracing/rvtrace/Kconfig b/drivers/hwtracing/rvtrace/= Kconfig index ba35c05f3f54..0577f9acb858 100644 --- a/drivers/hwtracing/rvtrace/Kconfig +++ b/drivers/hwtracing/rvtrace/Kconfig @@ -21,3 +21,12 @@ config RVTRACE_ENCODER default y help This driver provides support for RISC-V Trace Encoder component. + +config RVTRACE_RAMSINK + tristate "RISC-V Trace Ramsink driver" + depends on RVTRACE + select DMA_SHARED_BUFFER + default y + help + This driver provides support for Risc-V E-Trace Ramsink + component. diff --git a/drivers/hwtracing/rvtrace/Makefile b/drivers/hwtracing/rvtrace= /Makefile index f320693a1fc5..122e575da9fb 100644 --- a/drivers/hwtracing/rvtrace/Makefile +++ b/drivers/hwtracing/rvtrace/Makefile @@ -3,3 +3,4 @@ obj-$(CONFIG_RVTRACE) +=3D rvtrace.o rvtrace-y :=3D rvtrace-core.o rvtrace-platform.o obj-$(CONFIG_RVTRACE_ENCODER) +=3D rvtrace-encoder.o +obj-$(CONFIG_RVTRACE_RAMSINK) +=3D rvtrace-ramsink.o diff --git a/drivers/hwtracing/rvtrace/rvtrace-ramsink.c b/drivers/hwtracin= g/rvtrace/rvtrace-ramsink.c new file mode 100644 index 000000000000..5393423c8f28 --- /dev/null +++ b/drivers/hwtracing/rvtrace/rvtrace-ramsink.c @@ -0,0 +1,322 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2026 Qualcomm Technologies, Inc. + */ + +#include +#include +#include +#include +#include +#include +#include + +#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; +}; + +struct trace_buf { + void *base; + long cur; + size_t len; +}; + +static int rvtrace_ramsink_start(struct rvtrace_component *comp) +{ + int ret; + u32 val; + + val =3D rvtrace_read32(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET); + val |=3D BIT(RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT); + rvtrace_write32(comp->pdata, val, RVTRACE_COMPONENT_CTRL_OFFSET); + ret =3D rvtrace_poll_bit(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT, 1, + comp->pdata->control_poll_timeout_usecs); + if (ret) + dev_err(&comp->dev, "failed to start ramsink.\n"); + + return ret; +} + +static int rvtrace_ramsink_stop(struct rvtrace_component *comp) +{ + int ret; + u32 val; + + val =3D rvtrace_read32(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET); + val &=3D ~BIT(RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT); + rvtrace_write32(comp->pdata, val, RVTRACE_COMPONENT_CTRL_OFFSET); + ret =3D rvtrace_poll_bit(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT, 0, + comp->pdata->control_poll_timeout_usecs); + 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; + + 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 rvtrace_component *comp, + struct rvtrace_perf_auxbuf *buf) +{ + struct rvtrace_ramsink_priv *priv =3D dev_get_drvdata(&comp->dev); + size_t size_wp_end =3D 0, size_start_wp =3D 0; + struct trace_buf src, dst; + u32 wp_low, wp_high, trram_ctrl; + u64 buf_cur_head; + + 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 rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_WPLOW_OFF); + wp_high =3D rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_WPHIGH_OFF); + buf_cur_head =3D (u64)(wp_high) << 32 | wp_low; + trram_ctrl =3D rvtrace_read32(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET); + if (buf_cur_head & 0x1) { + buf_cur_head &=3D ~RVTRACE_RAMSINK_WPLOW_WRAP; + rvtrace_write32(comp->pdata, lower_32_bits(priv->start), + RVTRACE_RAMSINK_WPLOW_OFF); + rvtrace_write32(comp->pdata, upper_32_bits(priv->start), + RVTRACE_RAMSINK_WPHIGH_OFF); + src.cur =3D buf_cur_head - priv->start; + size_wp_end =3D priv->end - buf_cur_head; + tbuf_to_pbuf_copy(&src, &dst, size_wp_end); + } + + src.cur =3D 0; + size_start_wp =3D buf_cur_head - priv->start; + tbuf_to_pbuf_copy(&src, &dst, size_start_wp); + dev_dbg(&comp->dev, "Copied %zu bytes\n", size_wp_end + size_start_wp); + return (size_wp_end + size_start_wp); +} + +static int rvtrace_ramsink_setup_buf(struct rvtrace_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 */ + rvtrace_write32(comp->pdata, 0, RVTRACE_RAMSINK_STARTLOW_OFF); + rvtrace_write32(comp->pdata, 0, RVTRACE_RAMSINK_STARTHIGH_OFF); + low =3D rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_STARTLOW_OFF); + high =3D rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_STARTHIGH_OFF); + start_min =3D (u64)(high) << 32 | low; + + rvtrace_write32(comp->pdata, 0xffffffff, RVTRACE_RAMSINK_LIMITLOW_OFF); + rvtrace_write32(comp->pdata, 0xffffffff, RVTRACE_RAMSINK_LIMITHIGH_OFF); + low =3D rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_LIMITLOW_OFF); + high =3D rvtrace_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; + 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; + } + + rvtrace_write32(comp->pdata, lower_32_bits(priv->start), RVTRACE_RAMSINK_= STARTLOW_OFF); + rvtrace_write32(comp->pdata, upper_32_bits(priv->start), RVTRACE_RAMSINK_= STARTHIGH_OFF); + rvtrace_write32(comp->pdata, lower_32_bits(priv->start), RVTRACE_RAMSINK_= WPLOW_OFF); + rvtrace_write32(comp->pdata, upper_32_bits(priv->start), RVTRACE_RAMSINK_= WPHIGH_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; + rvtrace_write32(comp->pdata, lower_32_bits(end), RVTRACE_RAMSINK_LIMITLOW= _OFF); + rvtrace_write32(comp->pdata, upper_32_bits(end), RVTRACE_RAMSINK_LIMITHIG= H_OFF); + low =3D rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_LIMITLOW_OFF); + high =3D rvtrace_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 rvtrace_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 rvtrace_read32(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET); + trram_ctrl |=3D priv->mode << RVTRACE_RAMSINK_CTRL_MODE_SHIFT; + rvtrace_write32(comp->pdata, trram_ctrl, RVTRACE_COMPONENT_CTRL_OFFSET); + trram_ctrl =3D rvtrace_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; + rvtrace_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 rvtrace_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 rvtrace_component *comp) +{ + int ret; + + ret =3D rvtrace_ramsink_setup(comp); + if (ret) + return dev_err_probe(&comp->dev, ret, "failed to setup ramsink.\n"); + + ret =3D rvtrace_enable_component(comp->pdata); + if (ret) + return dev_err_probe(&comp->dev, ret, "failed to enable ramsink.\n"); + + return ret; +} + +static void rvtrace_ramsink_remove(struct rvtrace_component *comp) +{ + int ret; + + ret =3D rvtrace_disable_component(comp->pdata); + if (ret) + dev_err(&comp->dev, "failed to disable ramsink.\n"); + + rvtrace_ramsink_cleanup(comp); +} + +static struct rvtrace_component_id rvtrace_ramsink_ids[] =3D { + { .type =3D RVTRACE_COMPONENT_TYPE_RAMSINK, + .version =3D rvtrace_component_mkversion(1, 0), }, + {}, +}; + +static struct rvtrace_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 rvtrace_register_driver(&rvtrace_ramsink_driver); +} + +static void __exit rvtrace_ramsink_exit(void) +{ + rvtrace_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 Trace Ramsink Driver"); +MODULE_LICENSE("GPL"); --=20 2.43.0 From nobody Wed Apr 8 17:53:44 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 575092F6188; Wed, 25 Feb 2026 06:25:36 +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=1772000737; cv=none; b=nbjbtOr5Zua3zYwdyGM87r3hIb/rFJB3Byp5T0iRqZ8bO9TNajxool/d2xl9qHw0sGAyPqurow47yIMW4Mdk5OyOtJqu0j1wWekhP4wwajYPgAtL5hdR4bUdan210mJa7aUpyamgz+ZZjI+fQ5aAgDcYem0uy0QYOlqkOF6m294= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772000737; c=relaxed/simple; bh=GT1i4dMh86PNfifvawXsQLp+rGtpu+XtyTdCoigIjFk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=R2kU7oFNcENP/csVY6hsD+zqEWczh6dFH1v2PTCqCq+jhl540WvvhsmOaA1aOlY7jxUznj7IWsEp9XN5R0E70B3xtJsU8Ne0/P1itmkn/35+DRiGaT6u6L8tUgc1jjMc4AyLX4/8QhTdqjKBL7Iw3FcSG4oFaS4k+NuuCMjw7+g= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=WNPTIe2V; 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=qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="WNPTIe2V" Received: from pps.filterd (m0279867.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 61P17qa24148179; Wed, 25 Feb 2026 06:25:00 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=odMtPkzlfTT 23R0rkbHdXvpqJqTpjG5bJsVPmnOO+EU=; b=WNPTIe2VakuIiZ7Ca/JCqa7KqaE N8+TdwtkUUv9YjnxmCrhBkm0SawHLQNLhctBSmnq7S4jv0umGoYfWsh3KIpEdeYP V7TFbR/4LU5qjdp3nfX3jmjm0Z9vCt7ybXF/IsmZ0CaHDv6mdIocxiB1E5n/AW82 mQzdXFt84MLBwDy6I0dKTIDhJyXMRqnwUt5z7R7nwLmjS+UFyidqzYmLj67cJTXj vr4vE9CUi/nFTCCR8FfZvjaF1LjKi3cq4h9ULHB1KWjpqdb94LYNGXDO/n0exIgd 5yOAEV4DGMBJsK6JX3dB8oI/sqWPYkmtid5srIHJd3qDELDELVzu9Q3WUlw== Received: from apblrppmta01.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com [103.229.18.19]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4chq57rqe9-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:25:00 +0000 (GMT) Received: from pps.filterd (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (8.18.1.2/8.18.1.2) with ESMTP id 61P6OtoC001344; Wed, 25 Feb 2026 06:24:56 GMT Received: from pps.reinject (localhost [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 4cf5sm83eq-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:56 +0000 Received: from APBLRPPMTA01.qualcomm.com (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 61P6OtxQ001313; Wed, 25 Feb 2026 06:24:55 GMT Received: from hu-devc-blr-u24-a.qualcomm.com (hu-anuppate-blr.qualcomm.com [10.131.36.165]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 61P6OtDu001307 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:55 +0000 Received: by hu-devc-blr-u24-a.qualcomm.com (Postfix, from userid 486687) id D13EB24A5F; Wed, 25 Feb 2026 11:54:53 +0530 (+0530) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Liang Kan , 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 v3 08/12] riscv: Enable DMA_RESTRICTED_POOL in defconfig Date: Wed, 25 Feb 2026 11:54:44 +0530 Message-ID: <20260225062448.4027948-9-anup.patel@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260225062448.4027948-1-anup.patel@oss.qualcomm.com> References: <20260225062448.4027948-1-anup.patel@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-QCInternal: smtphost X-QCInternal: smtphost X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Authority-Analysis: v=2.4 cv=faOgCkQF c=1 sm=1 tr=0 ts=699e95bc cx=c_pps a=Ou0eQOY4+eZoSc0qltEV5Q==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=HzLeVaNsDn8A:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=eoimf2acIAo5FJnRuUoq:22 a=EUspDBNiAAAA:8 a=bXOGUNLACKbNXswU7uMA:9 X-Proofpoint-ORIG-GUID: 3tGXTfSrc3P9aUWztP9tiCD0aylK_o9s X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwMjI1MDA2MSBTYWx0ZWRfXy6sH1VODJVAr 95P7SxfGdzx7uyI6PB3fUW34hbv6GZhPQZ5EgK5QSGpfdWM3Q0Nhmu+h2CAWUQOjrBCbSyqxzjs prrY71VrMWQa75+1EZYQt7U5P7lpe3BYf4X4at+YhLRx322SyvBAsinQwTBebF0auQZR8d2g3KN 0XvAVdrZ27WE+535ypiWjelFvIJ+dcHpYYip5k7/GtiYKV95bM33lZk8CPkekxnKEelTGgU6FLZ DXxvVc6bdCrqJ954i3bqUWL/zGKS4d9ztFvXylE8qRNTlHbw0FV/uEAAKrt8sDxmxaoS461pv4n Spw5XtN+t4M0QQFnUUkk4rSMAlVU+44vVvzg9pvQVUxYzjSfZuHd2x6SzIUarHGFg4pa3En8uST MbUOwjRtwi/9PPxYhxq6n626w4l4JbEJXrbkwVxuyhEyYTy/wbmkGqc1oBiwYxuecckLy8KEtqA bNzpOT9V9TANdEwqFUw== X-Proofpoint-GUID: 3tGXTfSrc3P9aUWztP9tiCD0aylK_o9s X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1121,Hydra:6.1.51,FMLib:17.12.100.49 definitions=2026-02-24_03,2026-02-23_03,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 adultscore=0 clxscore=1015 impostorscore=0 suspectscore=0 phishscore=0 lowpriorityscore=0 malwarescore=0 spamscore=0 bulkscore=0 priorityscore=1501 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2602130000 definitions=main-2602250061 Content-Type: text/plain; charset="utf-8" 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 b7cee9775f8d..42a1391480c6 100644 --- a/arch/riscv/configs/defconfig +++ b/arch/riscv/configs/defconfig @@ -308,6 +308,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 Wed Apr 8 17:53:44 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 CC2183002B9; Wed, 25 Feb 2026 06:25:50 +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=1772000757; cv=none; b=u0QL6gW2ydAk1Oqr2lSB8ELOt8nLYp4iZxS9GvmmQe+im6g7FiefXMm3nH+55QJQuVxgiOI2ubx5H+lyxSCHbkAoXbMtjst9FmKLWh+0L6JN7sahRCliswBsT0+pdLw8oaDpo1o9QNZ4RJcGSWZPiaSRu6EBySor9Pvs8WBI4aI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772000757; c=relaxed/simple; bh=2xUWeNT1tSNCLeMbBs7n+QBD+1Su5L0EiPQYJw/OkDw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=ELhw9WRkze3C+yk1Cqtk7+zbPnw/RGP87UcU3oD7LFlSgmgtIRPpTp+azeutY8I+waW90rEkpzsjWShjohcBX5nW5y5GdyBYQNmCvN6q1vq1cBnDUC+FEF5EWG9OhBbYg2RLaRdIxMv15BnGC8GVAAI3l4YIuwcTc/oqiS7QrEM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=IH8LzGqU; 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=qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="IH8LzGqU" 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 61P2TPlk583293; Wed, 25 Feb 2026 06:25:00 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=4V8xwFf6TIw IWFZcVTEKulyPWH+m1hcR5fEkS8N/mO8=; b=IH8LzGqUFX6jXio7ZBhGbDpM5U3 taTUYLLdW0nvmlaRwCoZe5psMI++yQJHO6AKUOBEvKEgqNKwGcBETcPl6h4jhZet IwbFiFYtCr4mzqkNLUaM39ptKg9uSO4RznztUKf1Tsn6qnAxOPWmPDtqk5JnI2nB RK8CHk0iz12WqH5vVs/wBr7nxZJEXhJxmcKDzYXxCpG+MSDkG6nw5mq3GCxbOyJW AGiXv9edPUdrc7G6I9SqncEbm/xV4ugS72aGrxDXVYUY1UOxbB0sQrxUTSUlYCnS 79J5XYneOB3A1dKXrh4dNar0oRj2y/ZReGgMzvXArZbZJsL9p0KyX+84NJw== Received: from apblrppmta01.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com [103.229.18.19]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4chg2gt5b7-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:25:00 +0000 (GMT) Received: from pps.filterd (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (8.18.1.2/8.18.1.2) with ESMTP id 61P6OMs6001164; Wed, 25 Feb 2026 06:24:56 GMT Received: from pps.reinject (localhost [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 4cf5sm83f0-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:56 +0000 Received: from APBLRPPMTA01.qualcomm.com (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 61P6OuWg001356; Wed, 25 Feb 2026 06:24:56 GMT Received: from hu-devc-blr-u24-a.qualcomm.com (hu-anuppate-blr.qualcomm.com [10.131.36.165]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 61P6OtZL001305 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:56 +0000 Received: by hu-devc-blr-u24-a.qualcomm.com (Postfix, from userid 486687) id D633224B4A; Wed, 25 Feb 2026 11:54:53 +0530 (+0530) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Liang Kan , 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 , Anup Patel Subject: [PATCH v3 09/12] rvtrace: Add perf driver for tracing using perf tool Date: Wed, 25 Feb 2026 11:54:45 +0530 Message-ID: <20260225062448.4027948-10-anup.patel@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260225062448.4027948-1-anup.patel@oss.qualcomm.com> References: <20260225062448.4027948-1-anup.patel@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-QCInternal: smtphost X-QCInternal: smtphost X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-ORIG-GUID: iELcoQ1p8Uc2AVZNPWV_kZDEEQqEibRj X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwMjI1MDA2MSBTYWx0ZWRfX3T4gF/WaWhRi ohEAs3PvgkeMIqBlkf2x5OyN0cI2PoOVVNClviSFIHPDykRFUsLqjLEreYWM5iOkZIRdplj0AjH GNpsSUTcK9DhALtA8lXgFpRrK8KAwxy0obgufqZGgi21n3h1rZLYAsOosSA3jMRYloQwL0GEvym jUGFLU+QLdu6L11Vd6I87CQtUpHJghaymR/rrpPvgZjv79ibAvfYDznMsiqlFpTXnQgm3DRPJEm utkCX83SamryZgjb2IyaZHYY1EJy3C7mZiCzbFfaImzTDXsjXINNrBuQW6GtaCkYS6Fzj1GrSNQ Y7P7ynxAljHkosx/DqVTTR0ktI1rUntacIuhKC/7qyew7ce+EvBn9apVQkJra8if6v7dDl7RABD brKSxvoZTa/GnWJbdACxth2isHN1PngZTqy+LWmbzscATd1IfY9P/bwLjEBkGlXIo3d7yXSZHSo bTVMJV1u7ZuxkqzjlaA== X-Authority-Analysis: v=2.4 cv=ftHRpV4f c=1 sm=1 tr=0 ts=699e95bc cx=c_pps a=Ou0eQOY4+eZoSc0qltEV5Q==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=HzLeVaNsDn8A:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=_glEPmIy2e8OvE2BGh3C:22 a=EUspDBNiAAAA:8 a=HURrUvzjhtnrdgnosHYA:9 X-Proofpoint-GUID: iELcoQ1p8Uc2AVZNPWV_kZDEEQqEibRj X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1121,Hydra:6.1.51,FMLib:17.12.100.49 definitions=2026-02-24_03,2026-02-23_03,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 priorityscore=1501 malwarescore=0 suspectscore=0 clxscore=1015 spamscore=0 impostorscore=0 lowpriorityscore=0 phishscore=0 bulkscore=0 adultscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2602130000 definitions=main-2602250061 Content-Type: text/plain; charset="utf-8" From: Mayuresh Chitale Add perf driver for RISC-V tracing similar to ARM Coresight and Hisilicon PTT drivers. The driver adds 'rvtrace' event descriptor which can be used by the perf tool to record the RISC-V trace data. Co-developed-by: Anup Patel Signed-off-by: Anup Patel Signed-off-by: Mayuresh Chitale --- drivers/hwtracing/rvtrace/Kconfig | 1 + drivers/hwtracing/rvtrace/Makefile | 2 +- drivers/hwtracing/rvtrace/rvtrace-core.c | 8 + drivers/hwtracing/rvtrace/rvtrace-perf.c | 341 +++++++++++++++++++++++ include/linux/rvtrace.h | 3 + 5 files changed, 354 insertions(+), 1 deletion(-) create mode 100644 drivers/hwtracing/rvtrace/rvtrace-perf.c diff --git a/drivers/hwtracing/rvtrace/Kconfig b/drivers/hwtracing/rvtrace/= Kconfig index 0577f9acb858..ba11acf1117d 100644 --- a/drivers/hwtracing/rvtrace/Kconfig +++ b/drivers/hwtracing/rvtrace/Kconfig @@ -4,6 +4,7 @@ menuconfig RVTRACE tristate "RISC-V Trace Support" depends on RISCV depends on OF + select PERF_EVENTS default RISCV help This framework provides a kernel interface for the RISC-V trace diff --git a/drivers/hwtracing/rvtrace/Makefile b/drivers/hwtracing/rvtrace= /Makefile index 122e575da9fb..07403f4d94e3 100644 --- a/drivers/hwtracing/rvtrace/Makefile +++ b/drivers/hwtracing/rvtrace/Makefile @@ -1,6 +1,6 @@ # SPDX-License-Identifier: GPL-2.0 =20 obj-$(CONFIG_RVTRACE) +=3D rvtrace.o -rvtrace-y :=3D rvtrace-core.o rvtrace-platform.o +rvtrace-y :=3D rvtrace-core.o rvtrace-platform.o rvtrace-perf.o obj-$(CONFIG_RVTRACE_ENCODER) +=3D rvtrace-encoder.o obj-$(CONFIG_RVTRACE_RAMSINK) +=3D rvtrace-ramsink.o diff --git a/drivers/hwtracing/rvtrace/rvtrace-core.c b/drivers/hwtracing/r= vtrace/rvtrace-core.c index 1a1484c1eca4..159d3df0aa41 100644 --- a/drivers/hwtracing/rvtrace/rvtrace-core.c +++ b/drivers/hwtracing/rvtrace/rvtrace-core.c @@ -766,11 +766,19 @@ static int __init rvtrace_init(void) return ret; } =20 + ret =3D rvtrace_perf_init(); + if (ret) { + platform_driver_unregister(&rvtrace_platform_driver); + bus_unregister(&rvtrace_bustype); + return ret; + } + return 0; } =20 static void __exit rvtrace_exit(void) { + rvtrace_perf_exit(); platform_driver_unregister(&rvtrace_platform_driver); bus_unregister(&rvtrace_bustype); } diff --git a/drivers/hwtracing/rvtrace/rvtrace-perf.c b/drivers/hwtracing/r= vtrace/rvtrace-perf.c new file mode 100644 index 000000000000..dca83589c419 --- /dev/null +++ b/drivers/hwtracing/rvtrace/rvtrace-perf.c @@ -0,0 +1,341 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2026 Qualcomm Technologies, Inc. + * Author: Mayuresh Chitale + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define RVTRACE_PMU_NAME "rvtrace" +static struct pmu rvtrace_pmu; +static DEFINE_SPINLOCK(perf_buf_lock); + +/** + * struct rvtrace_event_data - RISC-V trace specific 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 rvtrace_event_data { + struct work_struct work; + cpumask_t mask; + cpumask_t aux_hwid_done; + struct rvtrace_path * __percpu *path; + struct rvtrace_perf_auxbuf buf; +}; + +struct rvtrace_ctxt { + struct perf_output_handle handle; + struct rvtrace_event_data *event_data; +}; + +static DEFINE_PER_CPU(struct rvtrace_ctxt, rvtrace_ctxt); + +static void *alloc_event_data(int cpu) +{ + struct rvtrace_event_data *event_data; + cpumask_t *mask; + + event_data =3D kzalloc(sizeof(*event_data), GFP_KERNEL); + 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 rvtrace_path *); + return event_data; +} + +static void rvtrace_free_aux(void *data) +{ + struct rvtrace_event_data *event_data =3D data; + + schedule_work(&event_data->work); +} + +static struct rvtrace_path **rvtrace_event_cpu_path_ptr(struct rvtrace_eve= nt_data *data, + int cpu) +{ + return per_cpu_ptr(data->path, cpu); +} + +static void free_event_data(struct work_struct *work) +{ + struct rvtrace_event_data *event_data; + struct rvtrace_path *path; + cpumask_t *mask; + int cpu; + + event_data =3D container_of(work, struct rvtrace_event_data, work); + mask =3D &event_data->mask; + for_each_cpu(cpu, mask) { + path =3D *rvtrace_event_cpu_path_ptr(event_data, cpu); + rvtrace_destroy_path(path); + } + free_percpu(event_data->path); + kfree(event_data); +} + +static void *rvtrace_setup_aux(struct perf_event *event, void **pages, + int nr_pages, bool overwrite) +{ + struct rvtrace_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 rvtrace_component *src; + struct rvtrace_path *path; + + src =3D rvtrace_cpu_source(cpu); + if (!src) + continue; + + path =3D rvtrace_create_path(src, NULL, RVTRACE_COMPONENT_MODE_PERF); + if (!path) + continue; + + *rvtrace_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: + rvtrace_free_aux(event_data); + return NULL; +} + +static void rvtrace_event_read(struct perf_event *event) +{ +} + +static void rvtrace_event_destroy(struct perf_event *event) +{ +} + +static int rvtrace_event_init(struct perf_event *event) +{ + if (event->attr.type !=3D rvtrace_pmu.type) + return -EINVAL; + + event->destroy =3D rvtrace_event_destroy; + return 0; +} + +static void rvtrace_event_start(struct perf_event *event, int flags) +{ + struct rvtrace_ctxt *ctxt =3D this_cpu_ptr(&rvtrace_ctxt); + struct perf_output_handle *handle =3D &ctxt->handle; + struct rvtrace_event_data *event_data; + int cpu =3D smp_processor_id(); + struct rvtrace_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 *rvtrace_event_cpu_path_ptr(event_data, cpu); + if (!path) { + pr_err("Error. Path not found\n"); + return; + } + + if (rvtrace_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 rvtrace_event_stop(struct perf_event *event, int mode) +{ + struct rvtrace_ctxt *ctxt =3D this_cpu_ptr(&rvtrace_ctxt); + struct perf_output_handle *handle =3D &ctxt->handle; + struct rvtrace_event_data *event_data; + int ret, cpu =3D smp_processor_id(); + struct rvtrace_path *path; + size_t size; + + 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 *rvtrace_event_cpu_path_ptr(event_data, cpu); + if (!path) { + pr_err("Error. Path not found\n"); + return; + } + + if (rvtrace_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 rvtrace_path_copyto_auxbuf(path, &event_data->buf, &size); + spin_unlock(&perf_buf_lock); + WARN_ON_ONCE(ret); + if (READ_ONCE(handle->event)) + perf_aux_output_end(handle, size); + else + WARN_ON(size); + } +} + +static int rvtrace_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) { + rvtrace_event_start(event, 0); + if (hwc->state & PERF_HES_STOPPED) + ret =3D -EINVAL; + } else { + hwc->state =3D PERF_HES_STOPPED; + } + + return ret; +} + +static void rvtrace_event_del(struct perf_event *event, int mode) +{ + rvtrace_event_stop(event, PERF_EF_UPDATE); +} + +PMU_FORMAT_ATTR(event, "config:0-0"); + +static struct attribute *rvtrace_pmu_formats_attr[] =3D { + &format_attr_event.attr, + NULL, +}; + +static struct attribute_group rvtrace_pmu_format_group =3D { + .name =3D "format", + .attrs =3D rvtrace_pmu_formats_attr, +}; + +static const struct attribute_group *rvtrace_pmu_attr_groups[] =3D { + &rvtrace_pmu_format_group, + NULL, +}; + +int __init rvtrace_perf_init(void) +{ + rvtrace_pmu.capabilities =3D (PERF_PMU_CAP_EXCLUSIVE | PERF_PMU_CAP_ITRAC= E); + rvtrace_pmu.attr_groups =3D rvtrace_pmu_attr_groups; + rvtrace_pmu.task_ctx_nr =3D perf_sw_context; + rvtrace_pmu.read =3D rvtrace_event_read; + rvtrace_pmu.event_init =3D rvtrace_event_init; + rvtrace_pmu.setup_aux =3D rvtrace_setup_aux; + rvtrace_pmu.free_aux =3D rvtrace_free_aux; + rvtrace_pmu.start =3D rvtrace_event_start; + rvtrace_pmu.stop =3D rvtrace_event_stop; + rvtrace_pmu.add =3D rvtrace_event_add; + rvtrace_pmu.del =3D rvtrace_event_del; + rvtrace_pmu.module =3D THIS_MODULE; + + return perf_pmu_register(&rvtrace_pmu, RVTRACE_PMU_NAME, -1); +} + +void __exit rvtrace_perf_exit(void) +{ + perf_pmu_unregister(&rvtrace_pmu); +} diff --git a/include/linux/rvtrace.h b/include/linux/rvtrace.h index 36663c7b3e30..0cb3bd474c2b 100644 --- a/include/linux/rvtrace.h +++ b/include/linux/rvtrace.h @@ -346,4 +346,7 @@ static inline int rvtrace_comp_poll_empty(struct rvtrac= e_component *comp) comp->pdata->control_poll_timeout_usecs); } =20 +int rvtrace_perf_init(void); +void rvtrace_perf_exit(void); + #endif --=20 2.43.0 From nobody Wed Apr 8 17:53:44 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 469972F6922; Wed, 25 Feb 2026 06:25:43 +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=1772000744; cv=none; b=PRwhIEVvXjVVFOAyL4sh2OgeL1Xe2ZqkGjYHhgI4imjOWaYNRd7UpqZP/R4NVzu8yuhm1LFFSGXON5+CPvCsYeXh3tbYC6oGF0xnO/wTMRZNnBBTAHa8q0obuOwtVVzmuLNvJfadbdYpTbIK+Fbjtl1J8c7WT+BUucjSYpBMRG4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772000744; c=relaxed/simple; bh=+DL1DclBlXFeMArXfCaUevQHEMgSDsY+8x6YxAFkm14=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=VbT30mBBCgJOM04arTPKJPCm+PxleKttshyUvs4GNo1nv57kEBqoHny8RbRCsZ3QI53L6vOCbYifyOHZLfxES+1b2UzWyovOC52bw0VYoDVyCCMaZ+hjVNuTr6LQCxazdWcBMlkhWegvYXNrK91N7IrlvU+RP2gNPmITNCZWNbs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=a3UZ1eyO; 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=qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="a3UZ1eyO" 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 61OLaCwH2432418; Wed, 25 Feb 2026 06: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=paPXV6QvgMm syxf0ALUvgRJENAz5jaR9fVu6RhkIUR8=; b=a3UZ1eyOgxRH3XwrEFbIZxKSzYw OxXwrqqHAURnE12qXqG1C1qR8uOckjumyz17L0oF9YH8isDC6LTAIW2BUGcyFXoG UvZkOCp7TSz7QhdfAU8OgAu16S/Xdzommcfw8kdpTHsXBo62In5g5VjYR3sRJ3Au HQlHTpBOLgnmYsir2ZJi8TkN5vv7cALdZE0YognhxEChk/cxrR+QijqgArKKsFJV 1zWCMV0RwSgyFvPLEjqiYnHNSzgbt+zFKt4t00TI4NGOauANlxpUFsILpOv52DjU LvGWwpHFUHHDQhaj85cuxIYaEibHJutJN1/hHLAW7MSgEjx31fJjssPqnzw== Received: from apblrppmta01.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com [103.229.18.19]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4chekjajv2-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:25:00 +0000 (GMT) Received: from pps.filterd (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (8.18.1.2/8.18.1.2) with ESMTP id 61P6OtoB001344; Wed, 25 Feb 2026 06:24:56 GMT Received: from pps.reinject (localhost [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 4cf5sm83eu-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:56 +0000 Received: from APBLRPPMTA01.qualcomm.com (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 61P6OtgG001314; Wed, 25 Feb 2026 06:24:55 GMT Received: from hu-devc-blr-u24-a.qualcomm.com (hu-anuppate-blr.qualcomm.com [10.131.36.165]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 61P6OtGF001304 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:55 +0000 Received: by hu-devc-blr-u24-a.qualcomm.com (Postfix, from userid 486687) id DBE7A24B76; Wed, 25 Feb 2026 11:54:53 +0530 (+0530) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Liang Kan , 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 , Anup Patel , Nutty Liu Subject: [PATCH v3 10/12] perf tools: Add RISC-V trace PMU record capabilities Date: Wed, 25 Feb 2026 11:54:46 +0530 Message-ID: <20260225062448.4027948-11-anup.patel@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260225062448.4027948-1-anup.patel@oss.qualcomm.com> References: <20260225062448.4027948-1-anup.patel@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-QCInternal: smtphost X-QCInternal: smtphost X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Authority-Analysis: v=2.4 cv=RNe+3oi+ c=1 sm=1 tr=0 ts=699e95bc cx=c_pps a=Ou0eQOY4+eZoSc0qltEV5Q==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=HzLeVaNsDn8A:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=rJkE3RaqiGZ5pbrm-msn:22 a=EUspDBNiAAAA:8 a=69EAbJreAAAA:8 a=kkaCVUy_t53esOPYLmQA:9 X-Proofpoint-ORIG-GUID: AaNR_0HlXantu2wAn2mDH_lOpq3AXZUI X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwMjI1MDA2MSBTYWx0ZWRfX3jRX0iKg+9XI ruWV8steDOVgIpVzAxlzrWk2tEA8Ct3tbeq6wlMzopMolPe8NO8I2ltmJqa7yL3SKVvPf2pn0EC 1EK6B/B5qs9TpMvUrTdqSDfrDgDkOunvMKmDvceId2tFPvX/agZ4A6KUJB8H0DkWPSaPGBgdOzb zBWk9GYtcJMGn6PrCIzT+k+hn1q/UiCodbCmP8CmXgaIqW9n5GOySesGsZXnuzR46+DjXhZfr2d 7HakI7WrqHt7AejYBdACMUcK15ETBrMwo5bNh/3W+4gVFDXKBp7XhJ2yFAz8K9EMyuyZZ0aiSOb /eEPKnbjmuN8wqs0GI4L3WaFKaFEZtdGpEQEoilnR8xAzj7TFme47wUqZQLKXBWp2tGgnoCYLBP IaO/yuWOwP13+wM9aPnpgQPfT/aPvbADOmki5e5/2/Y7gPyc511OwQKBPpvoPBuSu91nkSlALou n+tGmR6qdUVA0EYWSJQ== X-Proofpoint-GUID: AaNR_0HlXantu2wAn2mDH_lOpq3AXZUI X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1121,Hydra:6.1.51,FMLib:17.12.100.49 definitions=2026-02-24_03,2026-02-23_03,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 bulkscore=0 lowpriorityscore=0 adultscore=0 priorityscore=1501 phishscore=0 clxscore=1015 spamscore=0 impostorscore=0 suspectscore=0 malwarescore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2602130000 definitions=main-2602250061 Content-Type: text/plain; charset="utf-8" From: Mayuresh Chitale Introduce the required auxiliary API functions allowing the perf core to interact with RISC-V trace perf driver. Co-developed-by: Anup Patel Signed-off-by: Anup Patel Signed-off-by: Mayuresh Chitale Reviewed-by: Nutty Liu --- tools/perf/arch/riscv/util/Build | 1 + tools/perf/arch/riscv/util/auxtrace.c | 219 ++++++++++++++++++++++++++ tools/perf/util/auxtrace.c | 1 + tools/perf/util/auxtrace.h | 1 + tools/perf/util/rvtrace.h | 18 +++ 5 files changed, 240 insertions(+) create mode 100644 tools/perf/arch/riscv/util/auxtrace.c create mode 100644 tools/perf/util/rvtrace.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..5293ece2147d --- /dev/null +++ b/tools/perf/arch/riscv/util/auxtrace.c @@ -0,0 +1,219 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Risc-V E-Trace support + */ + +#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/rvtrace.h" +#include "../../../util/pmu.h" +#include "../../../util/record.h" +#include "../../../util/session.h" +#include "../../../util/tsc.h" + +#define RVTRACE_PMU_NAME "rvtrace" +#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 RVTRACE_AUXTRACE_PRIV_SIZE; +} + +static int rvtrace_info_fill(struct auxtrace_record *itr, struct perf_sess= ion *session, + 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 RVTRACE_AUXTRACE_PRIV_SIZE) + return -EINVAL; + + if (!session->evlist->core.nr_mmaps) + return -EINVAL; + + auxtrace_info->type =3D PERF_AUXTRACE_RISCV_TRACE; + 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 " RVTRACE_PMU_NAME "x 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 rdtsc(); +} + +static void rvtrace_recording_free(struct auxtrace_record *itr) +{ + struct rvtrace_recording *ptr =3D + container_of(itr, struct rvtrace_recording, 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(RVTRACE_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 a224687ffbc1..944a43d48739 100644 --- a/tools/perf/util/auxtrace.c +++ b/tools/perf/util/auxtrace.c @@ -1411,6 +1411,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_RISCV_TRACE: case PERF_AUXTRACE_UNKNOWN: default: return -EINVAL; diff --git a/tools/perf/util/auxtrace.h b/tools/perf/util/auxtrace.h index 6947f3f284c0..4f4714c1b53f 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_RISCV_TRACE, }; =20 enum itrace_period_type { diff --git a/tools/perf/util/rvtrace.h b/tools/perf/util/rvtrace.h new file mode 100644 index 000000000000..24b32947fb4c --- /dev/null +++ b/tools/perf/util/rvtrace.h @@ -0,0 +1,18 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (c) 2026 Qualcomm Technologies, Inc. + * Author: Mayuresh Chitale + */ + +#ifndef INCLUDE__UTIL_PERF_RVTRACE_H__ +#define INCLUDE__UTIL_PERF_RVTRACE_H__ + +#include "debug.h" +#include "auxtrace.h" +#include "util/event.h" +#include "util/session.h" +#include + +#define RVTRACE_AUXTRACE_PRIV_SIZE sizeof(u64) + +#endif --=20 2.43.0 From nobody Wed Apr 8 17:53:44 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 D3B3E2FF65B; Wed, 25 Feb 2026 06:25:46 +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=1772000754; cv=none; b=gJlmjpI5JI80SjfTB42EV3ZZmPAfxXEyxO9t5knpEjz1v7k9Y5wXyLmmpYVLHUJJnblp61fSF3wom4oxmJ8HqWud/tZb9wd90VTw+IjrOhyYvXWzPAFD9umi7xI+zBVW+iHB+YqRZ3ZnrRY2nI7sNqHWXayYrxjHlnLyfqCDdPU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772000754; c=relaxed/simple; bh=3fjiR1OLUKEW3wYA7hZz7rAGXNWjm2SfZk7UVWmb9xw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=ge5dWoUd2QxZ+3hLwC5ulZqltmGfzscWoa+w8NmqaP/s0eYH1IXLeBPO20/l2eFr5YauyOzQv5Sq8fCh1TNv/TQf8KIhhaa1dkuUnD/rAkZSVI3VrJlX6vPbOvAZJcsNBrfjwdDQXSss6gsNyfSzim1sHAGs1lobNf9vaFGDkwQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=Nx0qnNNW; 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=qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="Nx0qnNNW" 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 61P2J7h72334677; Wed, 25 Feb 2026 06:25:00 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=whc2xuE7mjG PrFhJLcfcyz207KCnXeQQirLtWYIG99E=; b=Nx0qnNNWFuRK0bpKS+dfDOWU2HC V6ZotrThg+WI5zYZu4Ab0bpvLVveA+qjlGKg+CfWOr8dT+9LRdemry8a6r8xlF86 8sFSlsqcLGpq6RMKUtOQuYP6gXqzfrKcU8kfe/oUVP+DNHW85pKKmlYdrbF3FqGe 0qW5sMQbSfI8Cn2B5CF0UTVr2/ASMxffm8W6tKbC4qWJ/NijVF98/s7Wo0YLC1pG /jPOpS+8VcFBxB+pJNUUwKY1iv2BY0kiSITxgqA+TxxqESuWpzqClnZx5qS6UB4q 3cW0H9RGu7mqho1c/tOpD2llmitSUsLiOq+KOjuS8gDzAuGVs6qqJHh3Bxg== Received: from apblrppmta01.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com [103.229.18.19]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4chg37t698-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:59 +0000 (GMT) Received: from pps.filterd (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (8.18.1.2/8.18.1.2) with ESMTP id 61P6OtoA001344; Wed, 25 Feb 2026 06:24:56 GMT Received: from pps.reinject (localhost [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 4cf5sm83ev-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:56 +0000 Received: from APBLRPPMTA01.qualcomm.com (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 61P6OtgR001315; Wed, 25 Feb 2026 06:24:55 GMT Received: from hu-devc-blr-u24-a.qualcomm.com (hu-anuppate-blr.qualcomm.com [10.131.36.165]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 61P6Ot0r001303 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:55 +0000 Received: by hu-devc-blr-u24-a.qualcomm.com (Postfix, from userid 486687) id E06862574B; Wed, 25 Feb 2026 11:54:53 +0530 (+0530) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Liang Kan , 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 , Anup Patel Subject: [PATCH v3 11/12] perf tools: Initial support for RISC-V trace decoder Date: Wed, 25 Feb 2026 11:54:47 +0530 Message-ID: <20260225062448.4027948-12-anup.patel@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260225062448.4027948-1-anup.patel@oss.qualcomm.com> References: <20260225062448.4027948-1-anup.patel@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-QCInternal: smtphost X-QCInternal: smtphost X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Authority-Analysis: v=2.4 cv=br1BxUai c=1 sm=1 tr=0 ts=699e95bb cx=c_pps a=Ou0eQOY4+eZoSc0qltEV5Q==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=HzLeVaNsDn8A:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=YMgV9FUhrdKAYTUUvYB2:22 a=EUspDBNiAAAA:8 a=b95MOGMN5JXeKaQ3w7sA:9 X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwMjI1MDA2MSBTYWx0ZWRfXytCZ2TOdUZVW igJwoMAZWB+od35QbVOZ5RKjPWCDjhMg7n9mKrhDEAYPdmTB93EwGl7db8vdp4KaibkHX0CTfEa esYwvjb7hvddYZfNFVMiyA5DGqsgl/ofA4dZyVR7sggecPKiYfc15PamUOriOK4VAxSlVF+71dq +qxR0CYCKxE1OxY1osq67gEK6RXQn5eWAFA97XTQfW5ptjVZOIePKlmNtUaZ1gRB9ngKFmZIuHA RSXXL2rvQL3qzrmXPrxK8JU/5lrJ6T346FP3H5J1PgebWo5hci2W4mvSm5PoIJq/+/MRK3iNO7b KWmH5342JOnPXVT5nQ11ElXPra1oSPFPtUxmeD+oWbpWdwxTzjuS8vJvgAA/vEfwEUz99YwyucN IzV3BLU9NhhAst1S/tF6z4izy7bJ58QZwY7KdVPDJgAfwhuw/xY89ujkccs2scM5+sd3D5duVX9 Fhcju0ZMQK+N7Fos8Vw== X-Proofpoint-ORIG-GUID: S24LmRNr1STx8rNAqM9fQIHSskUYYuPN X-Proofpoint-GUID: S24LmRNr1STx8rNAqM9fQIHSskUYYuPN X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1121,Hydra:6.1.51,FMLib:17.12.100.49 definitions=2026-02-24_03,2026-02-23_03,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 lowpriorityscore=0 priorityscore=1501 spamscore=0 clxscore=1015 impostorscore=0 adultscore=0 bulkscore=0 phishscore=0 malwarescore=0 suspectscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2602130000 definitions=main-2602250061 Content-Type: text/plain; charset="utf-8" From: Mayuresh Chitale Add bare bones support for RISC-V trace decoder so that the data received from the hardware by the RISC-V trace perf driver can be written to the perf record output file. Co-developed-by: Anup Patel Signed-off-by: Anup Patel Signed-off-by: Mayuresh Chitale --- tools/perf/util/Build | 1 + tools/perf/util/auxtrace.c | 3 + tools/perf/util/rvtrace-decoder.c | 91 +++++++++++++++++++++++++++++++ tools/perf/util/rvtrace.h | 1 + 4 files changed, 96 insertions(+) create mode 100644 tools/perf/util/rvtrace-decoder.c diff --git a/tools/perf/util/Build b/tools/perf/util/Build index bcccad7487a9..4cb5a6c61bf7 100644 --- a/tools/perf/util/Build +++ b/tools/perf/util/Build @@ -147,6 +147,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 rvtrace-decoder.o =20 perf-util-y +=3D parse-branch-options.o perf-util-y +=3D dump-insn.o diff --git a/tools/perf/util/auxtrace.c b/tools/perf/util/auxtrace.c index 944a43d48739..c6bd6642ce05 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 "rvtrace.h" #include "util/mmap.h" #include "powerpc-vpadtl.h" =20 @@ -1412,6 +1413,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_RISCV_TRACE: + err =3D rvtrace__process_auxtrace_info(event, session); + break; case PERF_AUXTRACE_UNKNOWN: default: return -EINVAL; diff --git a/tools/perf/util/rvtrace-decoder.c b/tools/perf/util/rvtrace-de= coder.c new file mode 100644 index 000000000000..58db5ca62c1a --- /dev/null +++ b/tools/perf/util/rvtrace-decoder.c @@ -0,0 +1,91 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * RISC-V trace Decoder + */ + +#include +#include +#include "evlist.h" +#include +#include "rvtrace.h" + +struct rvtrace_decoder { + struct auxtrace auxtrace; + u32 auxtrace_type; + struct perf_session *session; + struct machine *machine; + u32 pmu_type; +}; + +static int rvtrace_process_event(struct perf_session *session __maybe_unus= ed, + union perf_event *event __maybe_unused, + struct perf_sample *sample __maybe_unused, + const struct perf_tool *tool __maybe_unused) +{ + return 0; +} + +static int rvtrace_process_auxtrace_event(struct perf_session *session __m= aybe_unused, + union perf_event *event __maybe_unused, + const struct perf_tool *tool __maybe_unused) +{ + return 0; +} + +static int rvtrace_flush(struct perf_session *session __maybe_unused, + const struct perf_tool *tool __maybe_unused) +{ + return 0; +} + +static void rvtrace_free_events(struct perf_session *session __maybe_unuse= d) +{ +} + +static void rvtrace_free(struct perf_session *session) +{ + struct rvtrace_decoder *ptr =3D container_of(session->auxtrace, struct rv= trace_decoder, + auxtrace); + + session->auxtrace =3D NULL; + free(ptr); +} + +static bool rvtrace_evsel_is_auxtrace(struct perf_session *session, + struct evsel *evsel) +{ + struct rvtrace_decoder *ptr =3D container_of(session->auxtrace, + struct rvtrace_decoder, auxtrace); + + return evsel->core.attr.type =3D=3D ptr->pmu_type; +} + +int rvtrace__process_auxtrace_info(union perf_event *event, + struct perf_session *session) +{ + struct perf_record_auxtrace_info *auxtrace_info =3D &event->auxtrace_info; + struct rvtrace_decoder *ptr; + + if (auxtrace_info->header.size < RVTRACE_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 rvtrace_process_event; + ptr->auxtrace.process_auxtrace_event =3D rvtrace_process_auxtrace_event; + ptr->auxtrace.flush_events =3D rvtrace_flush; + ptr->auxtrace.free_events =3D rvtrace_free_events; + ptr->auxtrace.free =3D rvtrace_free; + ptr->auxtrace.evsel_is_auxtrace =3D rvtrace_evsel_is_auxtrace; + session->auxtrace =3D &ptr->auxtrace; + + return 0; +} diff --git a/tools/perf/util/rvtrace.h b/tools/perf/util/rvtrace.h index 24b32947fb4c..8e3eb4d681a7 100644 --- a/tools/perf/util/rvtrace.h +++ b/tools/perf/util/rvtrace.h @@ -15,4 +15,5 @@ =20 #define RVTRACE_AUXTRACE_PRIV_SIZE sizeof(u64) =20 +int rvtrace__process_auxtrace_info(union perf_event *event, struct perf_se= ssion *session); #endif --=20 2.43.0 From nobody Wed Apr 8 17:53:44 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 CEB642F5311; Wed, 25 Feb 2026 06:25:42 +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=1772000744; cv=none; b=C51EFEA921JEbGRUKkVAIIWiU9hZ5USlRKhw0RCy2XnCNLaEyL9+2mSYTp6CxiqMWTP9pm2mLEF+ZF8rcSL84I1eGcjCTOkF7pNz4ymVdRIGrnZJ2DTyM+ro7ko6f27UqnilNny6ocMpjX+N3zLzmaU0jLOVtiWNeGAYPGaNve8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772000744; c=relaxed/simple; bh=Gtykh5ZSwDaNrlTzRYx6f1x15R7gRqdDOB2CASdDpcQ=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=W7WpW3/NI/p6eDMb6UpCYTYrh1ZuHGNfdEeOFsgkL68lCbE+zwkrZxVw1ou69PPaz+RYVZYFY4xZ8VplNdodoUOW3vfKlfrq7gTMBsPblFsJZ7DXw4srT0mT4ehMN3aKAYRey94fB854AvnmfMZH6wM5cbribtXr6+pQ1oer6Ak= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=eKt1rfUO; 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=qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="eKt1rfUO" 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 61P2oGob583301; Wed, 25 Feb 2026 06:24:59 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=XefO2ouM5MH XWJr7FxS1gZopdg+zoq0NBIC65oXtUyw=; b=eKt1rfUOot9wmpXrtfz4ET7G2j5 B/GwvF21PVceUmHKZVBa5DRnJPJoFa0fqzNLkFk5/DpsezKy59nX/x9Xs05mFOjC 3urzmOMv18ZJGg3eBM2MucyMPiXx9FhY8CBRdOsujPV3ANrtboS405jkdgRhCtfd +9H+rf64WEgoZ82a1YfojPC9yLqVTZbvpfXTqPJTX+jH+ejW21Xi//cZubnyptkx ZYlWc5m5TnO+52ky1NtkJI2A1q7rpeIG1KsSvZyhkHAh9yTH5QmwJjyxhRRXdP8O GkbvPAM4aUxW5tRDXm8VABJtQlUGoeZ49Dii30nlzSE8CkaN6U/XC0TmZZg== Received: from apblrppmta01.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com [103.229.18.19]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4chg2gt5b6-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:59 +0000 (GMT) Received: from pps.filterd (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (8.18.1.2/8.18.1.2) with ESMTP id 61P6OtfV001345; Wed, 25 Feb 2026 06:24:56 GMT Received: from pps.reinject (localhost [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 4cf5sm83ep-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:56 +0000 Received: from APBLRPPMTA01.qualcomm.com (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 61P6OsBn001264; Wed, 25 Feb 2026 06:24:55 GMT Received: from hu-devc-blr-u24-a.qualcomm.com (hu-anuppate-blr.qualcomm.com [10.131.36.165]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 61P6OtEv001306 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:55 +0000 Received: by hu-devc-blr-u24-a.qualcomm.com (Postfix, from userid 486687) id E4D2B2574F; Wed, 25 Feb 2026 11:54:53 +0530 (+0530) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Liang Kan , 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 v3 12/12] MAINTAINERS: Add entry for RISC-V trace framework Date: Wed, 25 Feb 2026 11:54:48 +0530 Message-ID: <20260225062448.4027948-13-anup.patel@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260225062448.4027948-1-anup.patel@oss.qualcomm.com> References: <20260225062448.4027948-1-anup.patel@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-QCInternal: smtphost X-QCInternal: smtphost X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-ORIG-GUID: XPFDJYLRDY1f8pKHjlFVN2kgDclj8hPp X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwMjI1MDA2MSBTYWx0ZWRfX84QiWPGe3pWY eZT2pROAcvycfucYgPzT+qCPUD9ZmSbTkVLoRzkuA5+Aw+tid//QFLUM3ArugIe1ReJqnC9eRrq Ao08BRNZZ6QMCZCxZKkfX+T5kT28FjWVDVPBk9IuNVR3w/AHcVutVqZkznG1tWL0CN7LdzCORrA GrCaUWe48VBnWmPl3j61ir11+oRG9JHBZvVOQ4qngq42lJzn2xbFRLMXTCxR9cyG+cOhJUGtcGm E/pKxjWle6bFAqlhn1mwgfw7ekL6/jX8WKvsctSEsh8qkq0vruhtoTFr06mDpl/qwJbdcObLVZQ EwoCGWItXbYPI6rvxUy7oHygW/0FgodvMOhpdT20jTZurA3w0Vbt0xTinhtSDyTrObty77B35tD iMCxSlavzs32Cuf9oJBRlWN17m+n6oWmkomuurNpXnUV7+0ZASPjV+CdwAUGS74q8V1bt6XE/MJ 5Z427cWJ8Qzlnk/4FSA== X-Authority-Analysis: v=2.4 cv=ftHRpV4f c=1 sm=1 tr=0 ts=699e95bb cx=c_pps a=Ou0eQOY4+eZoSc0qltEV5Q==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=HzLeVaNsDn8A:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=_glEPmIy2e8OvE2BGh3C:22 a=EUspDBNiAAAA:8 a=pGLkceISAAAA:8 a=W-_n0kkjAAAA:8 a=JfrnYn6hAAAA:8 a=UgJECxHJAAAA:8 a=cfWhVP6ADMLbqTyXlKgA:9 a=qeNa2pbTr82C0GpJEZFS:22 a=1CNFftbPRP8L7MoqJWF3:22 a=-El7cUbtino8hM1DCn8D:22 X-Proofpoint-GUID: XPFDJYLRDY1f8pKHjlFVN2kgDclj8hPp X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1121,Hydra:6.1.51,FMLib:17.12.100.49 definitions=2026-02-24_03,2026-02-23_03,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 priorityscore=1501 malwarescore=0 suspectscore=0 clxscore=1015 spamscore=0 impostorscore=0 lowpriorityscore=0 phishscore=0 bulkscore=0 adultscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2602130000 definitions=main-2602250061 Content-Type: text/plain; charset="utf-8" Add Mayuresh and myself as maintainers for RISC-V trace framework and drivers. Signed-off-by: Anup Patel --- MAINTAINERS | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index ac63782a75d5..01fa7144552e 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -22858,6 +22858,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 +RISC-V TRACE FRAMEWORK AND 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/rvtrace/* +F: include/linux/rvtrace* +F: tools/perf/arch/riscv/util/auxtrace.c +F: tools/perf/util/rvtrace* + RNBD BLOCK DRIVERS M: Md. Haris Iqbal M: Jack Wang --=20 2.43.0