From nobody Wed Dec 17 16:09:41 2025 Received: from mail-pl1-f175.google.com (mail-pl1-f175.google.com [209.85.214.175]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 86F222797AF for ; Thu, 2 Oct 2025 06:08:29 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.175 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385312; cv=none; b=GIfNz0GJ0KBNB4Px1238GmLY2npSvOFCjOot0zFBxwPyi1jus1VH5E+eiEiWnQfa0aTbL+G5S+wbGXJ3v+KtVhr44Gkn8rj5byjktBEX2cN54vkY9QemDYMBPDdnn92/5lUiOwnLhUoSU9RLumzE0Hksr6fakNfSBeIOqIvA6dc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385312; c=relaxed/simple; bh=u/9mpbUc0JqX9+dr2hZMumKkTxhPP1IyUUeTXXdGAN4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=uvQ5AI4hTlWVqC0YZGUnsAVDh+rbBhhX3KKMVhc0MNRR1lahI5dSdxYXKiRbJYcx8E2J6rYponFeAKtd+REzGm00b6gxIrq0LU32bqIHjY2fMeueYoeeZk56/Ce6ZOXXhhU8YoB/ok2bbA7PilAymu8QU3/rm9XhStfYGKMbHyI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com; spf=pass smtp.mailfrom=ventanamicro.com; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b=mN8AzA+/; arc=none smtp.client-ip=209.85.214.175 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b="mN8AzA+/" Received: by mail-pl1-f175.google.com with SMTP id d9443c01a7336-26c209802c0so5904025ad.0 for ; Wed, 01 Oct 2025 23:08:29 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ventanamicro.com; s=google; t=1759385309; x=1759990109; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=hj2c615CrUy8YOmyqKQouk0cNfHyOtyWOMbH+KweoEQ=; b=mN8AzA+/7xiMUJWI0uwIFN3xv9RF2VwGH1gXh0PvRV4yavyelwBLjOzwcDv5g+KkPV d44VLdxdqkHNH9Mmr+2efp/0/pu/P6blWGZobzg4a4USAA3JXnxxbza+9i4+eoNizjFT RwrO4RsJ34GpGdFZ5lpYvBTztF9oh8jbh/H952AnJz7W1LJiQRSsNBptki/JeFFGqTHF qVPFQ/JtKq7MuVdOaeM3lThhMnHO3XzF6yBongcfCNK2KaS26FbnDn/1K1VruGtYsrp6 BTbBBFGDxiVCnXs/mvxsLdl/TkknQ5kr5xx26Vdd2mK+bdTE5AUZZfOnfIiWKBmSCQ46 tBAg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1759385309; x=1759990109; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=hj2c615CrUy8YOmyqKQouk0cNfHyOtyWOMbH+KweoEQ=; b=GQcHrIwPJz1ZMjsGBuZrDZg65AjVGu082+LjtW3JupkgVtl6IdgmA7Md4eg+vFyxdf 3GAiqnOxDf1H9UWoTO+iwtBx5KohlfdBkkQACjmFd6O4PqFhnCumGDHCJMpEko1mxfaS CnDVJSin5QS2GhOMGfe1gVEWj5sXDBhs/XKcOW5jR8qOcapop6042Fc9P/cxegmXLG4M 8B6fT0Q5D2639BKRiPq+qJxmHWAq68ILndrOWr8HkVWa2w+W1K4cEpQuGAleawkU6ZPd WWbfSwaaO+ALLJkubBuKfeS95LntXrLyOfYiPgZIdNhs/anZ4ETqHkJRCuOqRHjiTOC0 pCmA== X-Forwarded-Encrypted: i=1; AJvYcCVI7LuugUmm2IBSkNZ/oU6+XFPvoY6R1uNmNryRdx6nHtT25WrsqtxKSpSX88akMBZX3UKEflGEGG7SV50=@vger.kernel.org X-Gm-Message-State: AOJu0Yx4eSzZBFmK7sPTSMHVb1pbkzwx4hMAgrb30GhR+C3u1xHb41gK MYYIz19O8XTvidrq88sWuPfIt7rdv/5tukUq7VIQ/d0pA6mk+piXrtj0VROcupYTVQw= X-Gm-Gg: ASbGncvuuOXkUjNBl1LmdiXKPWsiFCqApIRZcM46vjjdNL7CCxk/qCRpdbMr0MgMxAl AeTSj/2KEfsFLs1DTsDP9e80uK75iN0TIApwKfKXnHSkyD9la+77AKQaK8tFkNwJ2amVVz1Bl72 kzE3T3rYF3i3/MBZpJqiPjFpudZeq9Cj26zwmpNiQYCTYtkSilzS6GeHkR7KfgjzULOuWT9NXeY J9bhbRr9B9zlmHAh2rUSK/dcP4BZvu6FCAZfLoJ6TLHZvPm9Oa3Cnkw1ZqE9XRtgS+Y7TKrv3uG +rNVKnNV0fAefRgjohbAKL/6ujdLGYYmom83BZY32USAQAEGKNyEg2qhMURIWkObsrFV28OkvpF 3dyDyJjAcrTKWQ9R8yiGBJxzpr+mhMXGPvggMn7VTQQnP9kGuNnbMBgTr//hmhWTcoWfrg3RdWu JSpCeS2fJ2Bc9BkQ== X-Google-Smtp-Source: AGHT+IGyT87xXKU7t+8dsmisG5C9KDNLA6TvuaXRJOG8u8du93ihWhzMU5v4etOkFz1S4HPaXHTjzg== X-Received: by 2002:a17:903:1b46:b0:275:27ab:f6c8 with SMTP id d9443c01a7336-28e7f2922bcmr64570775ad.20.1759385309029; Wed, 01 Oct 2025 23:08:29 -0700 (PDT) Received: from localhost.localdomain ([122.171.19.158]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b6099f594afsm1205029a12.37.2025.10.01.23.08.22 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 01 Oct 2025 23:08:28 -0700 (PDT) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Paul Walmsley , Palmer Dabbelt , 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 01/11] dt-bindings: Add RISC-V trace component bindings Date: Thu, 2 Oct 2025 11:37:22 +0530 Message-ID: <20251002060732.100213-2-apatel@ventanamicro.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251002060732.100213-1-apatel@ventanamicro.com> References: <20251002060732.100213-1-apatel@ventanamicro.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 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 | 110 ++++++++++++++++++ 1 file changed, 110 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..78a70fe04dfe --- /dev/null +++ b/Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml @@ -0,0 +1,110 @@ +# 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. + +properties: + compatible: + items: + - enum: + - qemu,trace-component + - const: riscv,trace-component + + reg: + maxItems: 1 + + cpu: + description: + phandle to the cpu to which the RISC-V trace component is bound. + $ref: /schemas/types.yaml#/definitions/phandle + + 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 + +unevaluatedProperties: false + +examples: + - | + // Example 1 (Per-hart encoder and ramsink components): + + encoder@c000000 { + compatible =3D "qemu,trace-component", "riscv,trace-component"; + reg =3D <0xc000000 0x1000>; + cpu =3D <&CPU0>; + out-ports { + port { + CPU0_ENCODER_OUTPUT: endpoint { + remote-endpoint =3D <&CPU0_RAMSINK_INPUT>; + }; + }; + }; + }; + + ramsink@c001000 { + compatible =3D "qemu,trace-component", "riscv,trace-component"; + reg =3D <0xc001000 0x1000>; + cpu =3D <&CPU0>; + in-ports { + port { + CPU0_RAMSINK_INPUT: endpoint { + }; + }; + }; + }; + + encoder@c002000 { + compatible =3D "qemu,trace-component", "riscv,trace-component"; + reg =3D <0xc002000 0x1000>; + cpu =3D <&CPU1>; + out-ports { + port { + CPU1_ENCODER_OUTPUT: endpoint { + remote-endpoint =3D <&CPU1_RAMSINK_INPUT>; + }; + }; + }; + }; + + ramsink@c003000 { + compatible =3D "qemu,trace-component", "riscv,trace-component"; + reg =3D <0xc003000 0x1000>; + cpu =3D <&CPU1>; + in-ports { + port { + CPU1_RAMSINK_INPUT: endpoint { + }; + }; + }; + }; + +... --=20 2.43.0 From nobody Wed Dec 17 16:09:41 2025 Received: from mail-pf1-f172.google.com (mail-pf1-f172.google.com [209.85.210.172]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id E9A9728727F for ; Thu, 2 Oct 2025 06:08:36 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.172 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385319; cv=none; b=MVWiTKB99uNawMCFdMNtAdXj26w1iiNWjJLtPo1fv4vKflRzX/3C+Q4lBtMhuV5nMMXcHkaFWiFr0d2WzbmtB7Lnnr+KuHaLiX71A3PfNkZDc8LDrUJSP7QkFDtohv4vBBKgK5Hi7HB5v7lhHm0BrBbi8077d/SWEoqRJmdGPck= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385319; c=relaxed/simple; bh=ybQyvvm6i1y4Wa8Op9xhy2eIkespA8Nb9GMqF6JaXRg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=jU14UJrG6bTQsAb0aXQvJJzahJsgy7wFYD6fJpli59pAjMr/iH20hgnMZmjxFgmUC19rMoLioAgEy2lAQ/PM8q4MvD0BpEFI5SN4/TaqUjYGj9o8aNmb1ItO6b+gVvxDWJdJ9OQnr7HdP7lvFn/Okqb6TkyEELgfMH/uLQJ201o= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com; spf=pass smtp.mailfrom=ventanamicro.com; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b=eSdkix+o; arc=none smtp.client-ip=209.85.210.172 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b="eSdkix+o" Received: by mail-pf1-f172.google.com with SMTP id d2e1a72fcca58-781206cce18so617910b3a.0 for ; Wed, 01 Oct 2025 23:08:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ventanamicro.com; s=google; t=1759385316; x=1759990116; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=R8j8k0Vez178jFtEYMAyyi4KPe42MRS7/ciUbfnTnyc=; b=eSdkix+oGd1dz35wI2NtuYXR7t+xVA+hCziu0kf9OyQhYS0WcwBWNiweM9kN+ED/Oh MNnN/DcP6T+PfL7lsf3Kt+O7c5MAl7RbQ9NXJR0wWU2WvEnWDxeqCAOyZYJyOTpB+EuE OjH+mlZhu44Q2exETQlX7DruFpmZ3q7XhUcc9qA4Zn2Aezk8f4XzxVdvSY37fBxhl12Q DW2hYkCmqXqKRpugpTtrqs6uzKVC3blQVVQC1BtubdT4pgx6z7lasAq7ojGQPmlcdW7E Bkh0lawCKGqv/qMp+VFY2F3jqNmcKu7EDIKPhnogLmDlJqKmcYBoXzVHjL1Kx9uQwqz6 OOFQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1759385316; x=1759990116; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=R8j8k0Vez178jFtEYMAyyi4KPe42MRS7/ciUbfnTnyc=; b=q9vr/Xltdv1m19Uik2kucgzc/P3PCifiUw5SyjkmfeG07c63V3hNrvb3FdGlcPFvdp wehhbKLTZ6MS1/roYuKDxdmVYzlJYlRdAzbROTVLpLMbBaw+3odB3xACHCMfX6F52j2g knzwbdTJpfqSPqXcZyEYIWIzjxVMzPM7oz1jRN29nB2TtlqtRPM+tlpULGdwzkA4yzeG cNqu8M5iSCtV3Lzn2kc7xTrd0dzqVU6YqDDyn2QybcCrd8jJ2rNPieQx6EkIjZ7UmHt8 5rPDUlAx6AmEwpOQuJRuxnKeog617NGjCUbsXE+LHKsFb5gOdMzHyFdBpHUJWmy1gv0l LKgA== X-Forwarded-Encrypted: i=1; AJvYcCVVWgSC/IxgP+ewled3vxxlB6gBiFozF4TbyA1iR4TSFpFk0uiKDcFz+L9i2LoKaKbTAkIfxyN9GmS8+Kc=@vger.kernel.org X-Gm-Message-State: AOJu0YyQMSk30XHrsB0+mTRSF1bSrfQwYdLsMJTODiAwOhnHgJJOvNuV 2om6OBQ+I1rnVp9SBWFrcBfDikJnz514LIa3m315eVyAM4V71IvFr72opeSTHPV3D20= X-Gm-Gg: ASbGncvubLu+c8alqhBcKUV6fqVG2xJ7lz5BhDUol47AzjIub/WfGPCXUQWlQR28rAw ZYXUl8NBNDdebs0GNzdMyswBUMJgXSDYDl+serQSPAHN47FwLIQw/rqJiONNGQXaRSQSXMAr6Ht 24VxqMtHzIZirVBU+BTNtwB0B5+MwITS1lIHwZnFj0qe/rohRrd8gasAxQmrdT/rOvWFQ+nVutL vu957IbHfDmjNMi8pvf9QPFogurDCGiNprw/kn/2FHo4Y71tMJogZLSMy0d1tjdEvtQmQqyFvPi LwDqLwaNxm0ADseMCD8jxQWeYlRYSyrvZ/zCJeG1ueNmVxuhyQgWZ9RwEFSLO8R95R+3ajN3bPb LeUMJ+rnoUdjc8MzUO6zo8DU5IvtP0qImm9h6kMNFDbMyVpkzwefbZqqEOb08P/Q8rkCqtTbFP8 2bUvQ= X-Google-Smtp-Source: AGHT+IHs1pxgNcFj/av/XwgniPcZJfFd5oWIbk+o5Q7JRBBQbc0wPq6C26fCiOdOg6tGrPl4fClVtQ== X-Received: by 2002:a05:6a20:9f93:b0:25b:b4d0:1090 with SMTP id adf61e73a8af0-32a24dc78aamr3598056637.17.1759385315902; Wed, 01 Oct 2025 23:08:35 -0700 (PDT) Received: from localhost.localdomain ([122.171.19.158]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b6099f594afsm1205029a12.37.2025.10.01.23.08.29 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 01 Oct 2025 23:08:35 -0700 (PDT) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Paul Walmsley , Palmer Dabbelt , 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 02/11] rvtrace: Initial implementation of driver framework Date: Thu, 2 Oct 2025 11:37:23 +0530 Message-ID: <20251002060732.100213-3-apatel@ventanamicro.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251002060732.100213-1-apatel@ventanamicro.com> References: <20251002060732.100213-1-apatel@ventanamicro.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 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 | 484 +++++++++++++++++++ drivers/hwtracing/rvtrace/rvtrace-platform.c | 174 +++++++ include/linux/rvtrace.h | 272 +++++++++++ 7 files changed, 953 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 b5749cf67044..466a55580f60 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -178,6 +178,7 @@ obj-$(CONFIG_CORESIGHT) +=3D hwtracing/coresight/ obj-y +=3D hwtracing/intel_th/ obj-$(CONFIG_STM) +=3D hwtracing/stm/ obj-$(CONFIG_HISI_PTT) +=3D hwtracing/ptt/ +obj-$(CONFIG_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..52ea931745fc --- /dev/null +++ b/drivers/hwtracing/rvtrace/rvtrace-core.c @@ -0,0 +1,484 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2025 Ventana Micro Systems 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) +{ + const struct rvtrace_component_id *id; + + for (id =3D ids; id->version && id->type; id++) { + if (comp->id.type =3D=3D id->type && + comp->id.version =3D=3D id->version) + 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); +} + +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) +{ + int i =3D 10; + u32 val; + + while (i--) { + val =3D rvtrace_read32(pdata, offset); + if (((val >> bit) & 0x1) =3D=3D bitval) + break; + udelay(timeout); + } + + return (i < 0) ? -ETIMEDOUT : 0; +} +EXPORT_SYMBOL_GPL(rvtrace_poll_bit); + +int rvtrace_enable_component(struct rvtrace_component *comp) +{ + 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); + return rvtrace_poll_bit(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT, 1, + comp->pdata->control_poll_timeout_usecs); +} +EXPORT_SYMBOL_GPL(rvtrace_enable_component); + +int rvtrace_disable_component(struct rvtrace_component *comp) +{ + 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); + return rvtrace_poll_bit(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT, 0, + comp->pdata->control_poll_timeout_usecs); +} +EXPORT_SYMBOL_GPL(rvtrace_disable_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); +} + +static int rvtrace_component_reset(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); +} + +struct rvtrace_component *rvtrace_register_component(struct rvtrace_platfo= rm_data *pdata) +{ + struct rvtrace_connection *conn; + struct rvtrace_component *comp; + u32 impl, type, major, minor; + 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; + } + } + + ret =3D rvtrace_component_reset(pdata); + if (ret) + goto err_out; + + 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; + + 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 rvtrace_component_mkversion(major, minor); + 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..a110ff1f2f08 --- /dev/null +++ b/drivers/hwtracing/rvtrace/rvtrace-platform.c @@ -0,0 +1,174 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2025 Ventana Micro Systems 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); + 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); + conn->dest_comp =3D rvtrace_find_by_fwnode(conn->dest_fwnode); + if (!conn->dest_comp) { + ret =3D -EPROBE_DEFER; + of_node_put(ep_node); + } + + pdata->outconns[i] =3D conn; + i++; + } + +done: + 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; + 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), "cpu", 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"); + + comp =3D rvtrace_register_component(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); + + 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..04eb03e62601 --- /dev/null +++ b/include/linux/rvtrace.h @@ -0,0 +1,272 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2025 Ventana Micro Systems 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 + +/* 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_component *comp); +int rvtrace_disable_component(struct rvtrace_component *comp); + +struct rvtrace_component *rvtrace_cpu_source(unsigned int cpu); + +struct rvtrace_component *rvtrace_register_component(struct rvtrace_platfo= rm_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); +} + +#endif --=20 2.43.0 From nobody Wed Dec 17 16:09:41 2025 Received: from mail-pf1-f172.google.com (mail-pf1-f172.google.com [209.85.210.172]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 85D6628507C for ; Thu, 2 Oct 2025 06:08:43 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.172 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385325; cv=none; b=tMVRg00BNSRs7Cuym4O1YqLYvrXJ1Zp4nzHZoBkjGWQOGwUY3HvpX/vX7qUlfCcYYSYXHdaKYdX/sfoxDtegw3cvR52kNc2ixcUnEr5yVDd1jfCSwdGhMTimA8fTstObfyFEhm1V/6f0gSxsff7WndXgtIJC5fXo5OioUo7d3Ak= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385325; c=relaxed/simple; bh=IghswXhFNIp7efTk/BphgUDtNxmQwDcFVTHaXFgsxjg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=o4YZgRebQaUt8rt3+op5Y/K7IIIGoG/uSathuTwLUJH0HhLNJd6GHKDn379J48K1Voi83/aQH+rjXQ34GopuSTIMtQXj/q6t4EdjNA6iWJ8LBLWuhGRWK3EyxZBoaNhCHjptyx+lB8v/IHo1HGd0aUP1j6hXzK7OVW/cpDQf5tU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com; spf=pass smtp.mailfrom=ventanamicro.com; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b=mdinp/KY; arc=none smtp.client-ip=209.85.210.172 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b="mdinp/KY" Received: by mail-pf1-f172.google.com with SMTP id d2e1a72fcca58-782a77b5ec7so677811b3a.1 for ; Wed, 01 Oct 2025 23:08:43 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ventanamicro.com; s=google; t=1759385323; x=1759990123; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=JDMrSo5zE78/yp6K2Yzv6nvOvNQV4+z5IjijgGyjqfE=; b=mdinp/KYOqdNKGd+3wpVTON9hWGWNVaAvWRXObcomDwURi/AwzqRGOWisoSi76BCx7 9iSIWDzBxnyE2zlq1v25myicdZfV5eiEPJI2p6d/sVbOfd8lhdGySo1z6X0o2hMg6GXx eo65dvUxG9pciHmtiG1Tkb8cq8y/ZgKZPDvutBliobSGi+8rG+3x4f0zJzUZawAmadZc 4cqtvCL2Wi9bUi9HOpF0tWGxAsXqT5qakinvHy/6MlE3RNA3kVliZUeOOcyO5jW4ook8 wtz21var82vZn5Tcl+xY4vJs5rTiQ111k+JdsSOStSewYpFhT6UY9UwEkw0cjaG6+uU4 GzUQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1759385323; x=1759990123; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=JDMrSo5zE78/yp6K2Yzv6nvOvNQV4+z5IjijgGyjqfE=; b=nFG6rzlf42bAPgP+rkH1zPoYU5gR3WnukVwCmYPWa40QrUPtbbkgP3JDNEDAnWEhs+ qpJ4PSeJ4V/a7Z/xnGbxw0jK8WnQ0YjUF/fs9ExEeUic5uvjVmVexdK9BE/eCXsT+jkl W72lRSdn5++3tA9nI85BO+LF1P2qkP2lU26ffrxIss+lRy32a/EpWDMsOvZMB6XI7E74 zynjm4r7mDq0QgUOUR3g/vo/OWmqcHIj8UAvgjVvnbP9Ibg78x95gPQAjyhp+ixyIhWh T9eksjWVHHZgIxT3MXucqanza22XqM/moxXBatJdW7FUKlqJjISqsMr4ZL48Hquzv9Qb GrdA== X-Forwarded-Encrypted: i=1; AJvYcCUFYMmTEK9HmOoqgWus+RefDs6+tcuwgmB9QuZtDF72GVZz2/QCTKyFAXSSQTcQ5nmYFoaBUeWXmUL47oc=@vger.kernel.org X-Gm-Message-State: AOJu0Yzl7AS2IuWHsjncx8zNqUFZ6LjvrKyZs0LH6MrD6Q2pX3q3a9ZL aLtjWepK6fOIR9tW7tnA2Bi/Uyg32bZOmTBZx9qoggdpuryvUnK5dQnDTwPoUSgQQCA= X-Gm-Gg: ASbGnctoACrn4lUJFV/3CYHWR+gdp2y6CCqvimQOlOW0Si4IwXkU5GIudo5Z07SbFtA cTSe+TZM0444xYxKP5tPIxqu+xS+mjEfRLwNb88s3q6lHkqGMy6d52TFqJV0+1LHigUER8pY9ZI lPnWq8KIdmjyD0igoRU89wMvXqjlNutGslP72lLLld6dZKTllPiL49Rwuf/fZZvqsEigW2uqG/R x/3SiENp+ZGnzqodmVpQ7Sbc+ohmj6+hhDhT1+ijIgN9ZvbuXNmPsq3pEmNLdevBtW5FHb26DzZ SKBHwTTnhKVSMVRJ8DsGbD7atM3o5zHAB9jPqa4mW9cG7t7Rp05pXV6Xp2pnosAgmcVYbI2+/bG VTzipGzznPf1zJbM0xqq4gNaYUjVd7uA7eMdhkOeOz2dnc5XkoOkP8UCfIQOR4R8thC8EjIwCyJ NpnRA= X-Google-Smtp-Source: AGHT+IHgKU6jM0c+W5oVcxlG6nEX1xAKWoIfttRFMeLhxyiP4XNtqKsWmTuThx5iRTl4h4Gz11OdUw== X-Received: by 2002:a05:6a20:9f9b:b0:2ec:f29:1011 with SMTP id adf61e73a8af0-321db7561a9mr8065872637.20.1759385322705; Wed, 01 Oct 2025 23:08:42 -0700 (PDT) Received: from localhost.localdomain ([122.171.19.158]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b6099f594afsm1205029a12.37.2025.10.01.23.08.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 01 Oct 2025 23:08:42 -0700 (PDT) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Paul Walmsley , Palmer Dabbelt , 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 03/11] rvtrace: Add functions to create/destroy a trace component path Date: Thu, 2 Oct 2025 11:37:24 +0530 Message-ID: <20251002060732.100213-4-apatel@ventanamicro.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251002060732.100213-1-apatel@ventanamicro.com> References: <20251002060732.100213-1-apatel@ventanamicro.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 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 52ea931745fc..7013d50ca569 100644 --- a/drivers/hwtracing/rvtrace/rvtrace-core.c +++ b/drivers/hwtracing/rvtrace/rvtrace-core.c @@ -194,6 +194,53 @@ int rvtrace_disable_component(struct rvtrace_component= *comp) } EXPORT_SYMBOL_GPL(rvtrace_disable_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)) @@ -446,6 +493,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 04eb03e62601..f2174f463a69 100644 --- a/include/linux/rvtrace.h +++ b/include/linux/rvtrace.h @@ -8,6 +8,8 @@ =20 #include #include +#include +#include #include #include #include @@ -71,6 +73,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. @@ -237,22 +245,53 @@ int rvtrace_poll_bit(struct rvtrace_platform_data *pd= ata, int offset, int rvtrace_enable_component(struct rvtrace_component *comp); int rvtrace_disable_component(struct rvtrace_component *comp); =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(struct rvtrace_platfo= rm_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 Dec 17 16:09:41 2025 Received: from mail-pf1-f176.google.com (mail-pf1-f176.google.com [209.85.210.176]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 5167E2877DE for ; Thu, 2 Oct 2025 06:08:50 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.176 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385332; cv=none; b=ZePZuYbJ1R3dHjEJ417PfNZPBiIUdH9RqxW6MgIHTqRs+4Tz6lr9h9Mbs3YJvd1pToKy4DGlXgzbXe6Ei+aBrP7X4aUwNELuaR6+DjjM6dCv0EFz2s7yjbHcb0VQnU8LTBRoJk9WNwy6AkJ/95kwD4Cqw7zTQWy/WmkGWWaJ6vc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385332; c=relaxed/simple; bh=+xq60ZeSAVV1ocmjyOiB1hqUauhWVy1UVAEnUaHfa1o=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Cxzo25lKgJCCnrEB+cGT8K1EWYh+TVgBP1xNe7gv8nWs+De8SuYs3k9sJ0Sq13epFh24rVzU54A1cE+P6EVu9ZI5bAmcUM95DRc8ADE02pwAu6F/udDlhhVj8U8ObiTg8HcCCvisJ4sY2KkqPPOUpLV8nEqlC0Bmhodrm8GPSgY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com; spf=pass smtp.mailfrom=ventanamicro.com; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b=dfSyplzA; arc=none smtp.client-ip=209.85.210.176 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b="dfSyplzA" Received: by mail-pf1-f176.google.com with SMTP id d2e1a72fcca58-78125ed4052so874397b3a.0 for ; Wed, 01 Oct 2025 23:08:50 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ventanamicro.com; s=google; t=1759385329; x=1759990129; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=1JHjFWe4nSJBuXJLW+4dSgn35y5ppiBpVluUI0Wnqq8=; b=dfSyplzArAgDDnWXl0t/mvTcBjYRLmErc9ZyXY1iMdI8qrSMZ/057fk6ktwrkqoTWm A+vl8mXxHvKa6YKw83ZuG80AmjseBxd7OguZGZLqyLEDhjpPJLd3syc+xX/MCiJw31Ft TC1nK1of8MKzk3wIEEDYbPDIopp6t3BMLitq/tQlVddltB2QzjAVpft1uPeYDQVioCD0 pmoEoqQVVuvKh94YZJirFcNZynm9VtjyA5JRLhyeWXvK07e/HOHkaslW3ivCziO3KVxK yiuwE7OLFqT+Uo0f+giPK50bNQyhFHMoJQwvFRuA/paCOWHxf4f9GS/ael9BNhj4V6yI KLiA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1759385329; x=1759990129; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=1JHjFWe4nSJBuXJLW+4dSgn35y5ppiBpVluUI0Wnqq8=; b=mNqr1InYBIfmBWtOQXDWOuO+p/O9Y/oOXsyMmx0HEGRMnKGhC6TZKzuvGuGZnI0DxL eaNbwUi12+psT1sBBo0/tt2c0U0XX60+paMGl+YQ0aNZb4oIDp6UHozYche2VSbJiYTk rLjr9JnhzwXTMn/Z8cUL5323KXO8RMpf4ArYO4wUDcvQMiIsIJPP63XjQDNEFSRUcsQA juqYCzN2MQpCifLlBHprvAgNuAmHo444tKGNguZUP9L5QU1ynM5DCWLAMvkNJI3vebgr 0S1zWFMyNTxZT4bjcRYI12/oHjCCeWOMCxZ/3dpTm/VMbZZjS6X6ywV5VoM8gCcIScP2 DWVw== X-Forwarded-Encrypted: i=1; AJvYcCUQXKpL1faoYcQ2r3n8WcjFF6X05ArbSDin9XMTFJmPgjXoNEWoTlcacyk9C7Ulf9fZBjzj5KyXvTNUUfM=@vger.kernel.org X-Gm-Message-State: AOJu0YxvcIrmUekZ6zaJ1QD1GP6gzIQ5v/CV72C1f+3Nk3i1rGopflV1 mG2VZ2ULU0ep0nBcfOz77qhNLgGMSmpFcdSI733fWz9XkjV3P3SsjE9KS3x1PGkI3eQ= X-Gm-Gg: ASbGncujqskEGqOKYnrUPpW5Kow+3+0H0hNYDFWHYLo6I/Q6JbWXYUP5FzKe/s/C5hq 4eMhO3rSx+IJojeL2MnnOtWRErj7IV7X7Y0WA1C5DhbVUfag/hDCmCxIyNK7K/ZzHtc8fFifQnT TI5yup8tBXJCfY6vcgvRZi5IGhQQnMX/nbZY3Uk9j6J1cDnxs7fSBUMPxnR9wgjc5eQEDWBXv0f miSiZcsUvyp42rWfiJ1tloWlRXn4V8CsF/nnkJfrFdmXBHVvCNjsIHNSP6EWSc5fi4E1UoRYtWm xcdYgFFaQSYBf54VGO6YFq8dfjnrJinhB70V+w7n428Rof2rJQXmN6zSEdWfNqmaECEHynxz5eQ YwLldB2UkE8qdos8EK3nxhfKeQBUTA3oGonw+JE+S72YUCuOnNq4RrQhyiNLVrdx7gWj6RVwpkq VXCJ/IY6whpf6n3Q== X-Google-Smtp-Source: AGHT+IEVQ8syUgiiA1nKnyUpyfhQ8Ilp5w1llqzl73BCypyrqi5ezsbXFBblcxqXVmPTbmDs4OeyLQ== X-Received: by 2002:a05:6a21:683:b0:251:e4b4:7a44 with SMTP id adf61e73a8af0-321df6c2562mr8435299637.41.1759385329448; Wed, 01 Oct 2025 23:08:49 -0700 (PDT) Received: from localhost.localdomain ([122.171.19.158]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b6099f594afsm1205029a12.37.2025.10.01.23.08.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 01 Oct 2025 23:08:49 -0700 (PDT) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Paul Walmsley , Palmer Dabbelt , 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 04/11] rvtrace: Add functions to start/stop tracing on a component path Date: Thu, 2 Oct 2025 11:37:25 +0530 Message-ID: <20251002060732.100213-5-apatel@ventanamicro.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251002060732.100213-1-apatel@ventanamicro.com> References: <20251002060732.100213-1-apatel@ventanamicro.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 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 7013d50ca569..109be40d4b24 100644 --- a/drivers/hwtracing/rvtrace/rvtrace-core.c +++ b/drivers/hwtracing/rvtrace/rvtrace-core.c @@ -614,6 +614,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(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 f2174f463a69..e7bd335d388f 100644 --- a/include/linux/rvtrace.h +++ b/include/linux/rvtrace.h @@ -273,10 +273,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 @@ -285,6 +289,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 Dec 17 16:09:41 2025 Received: from mail-pf1-f180.google.com (mail-pf1-f180.google.com [209.85.210.180]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 54AB528725E for ; Thu, 2 Oct 2025 06:08:57 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.180 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385338; cv=none; b=svWgYz8Uuc/dvpuT3oIs1bbsPajIkynRnm2PbtxBQ6y5+UfVq+mCx2k5OAIO+u9n+DdfnLYk6nEVz2XK8MDyjXzZOnkU2JOG1eNK0bWF6dY8qVDskTfTg03NId461q7dyneGHI5GAI/ZF+drPi82ef+oTRoteihAMmZ1K2vBNpg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385338; c=relaxed/simple; bh=lOHsyvTJOJiG0tf9/Mmf+m467IOd18DoT/rpd92xBfA=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=XnYAZ8Zs3ztuSrhBkyfuElQU6XMfSmeV7CJZgXY+B/9epn7KAodiQTrRxOib+crfRc0+nSSSaCkopvINXg678y7tsB8KLc8VCa/y44lzoc2tZzrrxdI1ZjD3VZMw3IrRQZsxsVc5NqJ5SebQJTz2bWSzd1uGQCzVg2T0QQvLXQY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com; spf=pass smtp.mailfrom=ventanamicro.com; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b=hgKFpkiG; arc=none smtp.client-ip=209.85.210.180 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b="hgKFpkiG" Received: by mail-pf1-f180.google.com with SMTP id d2e1a72fcca58-781206cce18so618103b3a.0 for ; Wed, 01 Oct 2025 23:08:57 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ventanamicro.com; s=google; t=1759385336; x=1759990136; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=UpifXrkDvDh1xYGpNX5UKxh32Xx9f0TyTyPM+srBPqY=; b=hgKFpkiGxO6yLWiNZjBKobzgsMUAHbQJt6HKIau7q/DEY1GNtfoHHyWGcbwtR3dSAF qeW56NmbyMYToy7EY/KWZzjNBaS0X/yw3cX+UFO7BMYTr45+qh4ygiXIpogSJKSHMZP0 WDaXYHuvwup77gVDsmOyT7my+MMiiLpY+0hkDkhz7Bs9iv94BlV7lEPyFxgp/Yfx6YrU lyi6aMK3M4x56Q1cgONiaP2BUsPwZOc18ogiR4ymekjlq44iOjmOkWSry4RfKl/shN6G AmL/VNGXWope/c/H4+TkVuhB/RESvB31az9L/dJCEqRHSW8MfXGyIFrterPRQvZDUif3 zO/g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1759385336; x=1759990136; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=UpifXrkDvDh1xYGpNX5UKxh32Xx9f0TyTyPM+srBPqY=; b=TwSFRj9NdZQdRP6KJ/a8U93P9JonrFlkHi7dCskVQAR0m8Uw6SFIT4OAR29ufMzMPA 5veD7By7zIfm1hlFbxwkvOmAnjXbEJwpSbEDHZ4KX7WpZQWgnepfq2000QPk3uddWg1v ZAMK4MsCAXjXqY+W5yR0MoyIBkbCar/CaFMe6wuKQFYf1Sz8eMHDKKLyhkSJlOKa869A JVOymzj5SP5Lj/3fQqGSnPcFSRCBkFQHCx3hWYdB1DpHW/DyHEj4LzRvQVcxHuO4Pz/n a28bYiT4/IQGZ1foEUDRNzhA2GvQ5IkKBKPG0IwC3S1m5HmIU2WacluGrOgptgd2xYXa D9Xw== X-Forwarded-Encrypted: i=1; AJvYcCU0MyiJS1R649AnJHQIFb7e8DZ4hf4XWDX4BhfsXWtDuLlbSm51QW+euwlyBJpC9MxyAQSM1OvvA9xEaeg=@vger.kernel.org X-Gm-Message-State: AOJu0YwDi5/5+r2xwZ/fmRrMu5x89hrSe1b+zaCeLrrzn9cAF6OESxth v1SpB/PCxRG9y0+ssU3QeSQSFlokolsKHzHZzoRf74QyB1rWO5I9TgRjssVaGAwenPQ= X-Gm-Gg: ASbGncvIm+j2CDG+E/KVuw9vvqZzVafp4/KYhoxpeIbCzizyaEvanPNJKKy5BcmG4/b cXKQ4AkqrYkb5Ev1iVDJLU8QONDjcSmxpHRuhJv72CX9gBALINbqznBo17rQQYYrZzJxctxeRER BVefwIVUzpBr+mZrJGzSgWXzJPusgWg+rgIouwzOMbU4K1bhqXSVdgYbYE6Eok7xnvjDQ5Lvb/w F2wO3hetiK+/Xl3OiIANavBupSYoxD6aWXbwzLOYcN3djs1O3kb8wRKw2BQITtK8Nt1/SOPKNvU aPLtfgtGQ12D10Ld2GLgM0mW2UScDHLCsjM66TPxasMTH744u4Tn1XnA7cZLeejY8F1BdFJuvLt LwJUEACw6qqpg2orFGVgwqV21NVMEIddsJZB16iBgEY5/jPzFFqTMtWwV5tI1fEO1jCrwvKlYhZ 4n/lov110rAULvtw== X-Google-Smtp-Source: AGHT+IGsK5zmN/1TMI8l5ShAU1WG5heF+BcYOUnln5ovyw9K+EhBee4z4X9UbHLvM+t1E8NyUqH7Qw== X-Received: by 2002:a05:6a21:6da8:b0:2be:8ead:1bec with SMTP id adf61e73a8af0-32a261f1677mr2900159637.24.1759385336405; Wed, 01 Oct 2025 23:08:56 -0700 (PDT) Received: from localhost.localdomain ([122.171.19.158]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b6099f594afsm1205029a12.37.2025.10.01.23.08.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 01 Oct 2025 23:08:55 -0700 (PDT) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Paul Walmsley , Palmer Dabbelt , 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 05/11] rvtrace: Add trace encoder driver Date: Thu, 2 Oct 2025 11:37:26 +0530 Message-ID: <20251002060732.100213-6-apatel@ventanamicro.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251002060732.100213-1-apatel@ventanamicro.com> References: <20251002060732.100213-1-apatel@ventanamicro.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 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 | 107 ++++++++++++++++++++ 3 files changed, 115 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..45d1c5b12c51 --- /dev/null +++ b/drivers/hwtracing/rvtrace/rvtrace-encoder.c @@ -0,0 +1,107 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2025 Ventana Micro Systems Inc. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#define RVTRACE_COMPONENT_CTRL_ITRACE_MASK 0x1 +#define RVTRACE_COMPONENT_CTRL_ITRACE_SHIFT 2 +#define RVTRACE_COMPONENT_CTRL_INSTMODE_MASK 0x7 +#define RVTRACE_COMPONENT_CTRL_INSTMODE_SHIFT 4 + +static int rvtrace_encoder_start(struct rvtrace_component *comp) +{ + 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); + return rvtrace_poll_bit(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ITRACE_SHIFT, 1, + comp->pdata->control_poll_timeout_usecs); +} + +static int rvtrace_encoder_stop(struct rvtrace_component *comp) +{ + 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); + return rvtrace_poll_bit(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET, + RVTRACE_COMPONENT_CTRL_ITRACE_SHIFT, 0, + comp->pdata->control_poll_timeout_usecs); +} + +static void rvtrace_encoder_setmode(struct rvtrace_component *comp, u32 mo= de) +{ + u32 val; + + val =3D rvtrace_read32(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET); + val |=3D (mode << RVTRACE_COMPONENT_CTRL_INSTMODE_SHIFT); + rvtrace_write32(comp->pdata, val, RVTRACE_COMPONENT_CTRL_OFFSET); +} + +static int rvtrace_encoder_probe(struct rvtrace_component *comp) +{ + int ret; + + rvtrace_encoder_setmode(comp, 0x6); + ret =3D rvtrace_enable_component(comp); + 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); + 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 Dec 17 16:09:41 2025 Received: from mail-pj1-f50.google.com (mail-pj1-f50.google.com [209.85.216.50]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id EA41328C03B for ; Thu, 2 Oct 2025 06:09:03 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.50 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385345; cv=none; b=I8pvMNi4p32GynPjNDzkFTseqS8LmYlO5mjRY4wqaIK0emAomCFoMnHQR+oYpg44kBcCl87P2fMl6nvIWO/faHEOfYY54YNOOK5hAAyLRwtIWfUA5NpuxPrDaIS4jZNnUqdnyhqRIo30LizKkKckHx+SGJvGFRZh1lXnKQbeVc8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385345; c=relaxed/simple; bh=tfWE837rSy6IepZ2Tv7OhO61tMfo7jk1UPoqBIN/PaY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=HOuXW3CtccNQLDmQkGixYl3/PUTvhVGSCkRz1PNI5liwX09czfKfgFGoJ9TZ5r/C+jbAz15pGoG5tiwjtxFk7BokYPe5QxDBiX5drN9SzOGOjnirmXiDPTm9EmvQJ5q3affUth7BaEQvvEMq3N3UjAsKIPhDMuaJrx3mwX9rJ48= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com; spf=pass smtp.mailfrom=ventanamicro.com; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b=n8YOdS0B; arc=none smtp.client-ip=209.85.216.50 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b="n8YOdS0B" Received: by mail-pj1-f50.google.com with SMTP id 98e67ed59e1d1-3307de086d8so663479a91.2 for ; Wed, 01 Oct 2025 23:09:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ventanamicro.com; s=google; t=1759385343; x=1759990143; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=8ElwK4fIoolTelCOzIEenmHWdT3EJLmrIEE1cSAO83o=; b=n8YOdS0B6KVyCkmJesTn72ytBpthQXnvlLhdfHe6Jo99/FZZuFx01kDLY2PDTPGy6Z LirSSFVBwk1iveysAJrp5Fkh0aKxc9/xN2wFUvfBnUDTpC50v63q50uXvGCCXgYMqfUS Ccr7lzHvU3y95oZH1A6739/2xQqyEyi0/ga7OUk97XZORPKXTlnohbqUOhhckWDNPo+9 ddCNm2kAZ+NWf01UKvHEvq7gX8xxjiCboI7gymhhdTt6WA/geoGZsvRWHI9blsMscGsy JP/UIOdd6MsrI1opUpkSR7xExYhHgjtCHOmiI2wvJNvtTfqw2gD1T/+wmayTQ52sygV/ gmkw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1759385343; x=1759990143; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=8ElwK4fIoolTelCOzIEenmHWdT3EJLmrIEE1cSAO83o=; b=XjKtJadZf3IScvWbW/KEhgwkWWdwl5HQQPHk8cbTfRt0Mq+fEkdq2b6fezbGryEC9B btQZ16lb0tSsQDTgIWPzKbcUXmxdckqwva4rrExAtq/BJbImW05goexgkPZN1JNWCv7p ixR82ICne8EeDUUb98tnPVdr66H/LdZu6lNCcfCqsxV5+P+016qCBsStn7kY6amqH2bJ gtqOSiSFsUHHaVvw36eDSOI3t4mnYyVmbVZLmFMt5gKWgWCeQ91iHTumAd6gA4hXWSOT NugObHMaXKbfWH2tcMCoXflGqpNCZkunaTAFYA53w7noHMhyIYnXJAUgkDTRaEE7ySm1 knYw== X-Forwarded-Encrypted: i=1; AJvYcCWFRIGzGFUWGOOq0D0gJ6OvA9SK/tNbsuHl5peWxDuODXntzxHbpGdB/yA/8Da7FWQ/GFQgkEdGk9e5fyk=@vger.kernel.org X-Gm-Message-State: AOJu0YzV1ldCFC9HvcFuwh+fmAkSA68YxCuRne4igN7QPyWoTCHOOAYL P5H2Omjb9MmvP/wuyrCklKG0z3Or35kgiZWz2qQIHvmrs7qO/BZxgzWd+C5/ZL12suU= X-Gm-Gg: ASbGncvrnrFote31aOfyfLOGwiz86g1BRl3Ns0uPV+i+1qxGZZkWMH1TGwDB2OTaLkK J9PhSqrG50f6xJLgZXh2yq/Fbcp8xuqvS9qcLON4LAJ8n1OtpZaJuGocM2vXc+pDRYQOeEHPv6q i6+VP/4EDyL3maoAb1bJ9dYsFXN0dURQ652JZZegHYntQbSe8/XkiinjP7AxZhRBQcRA7hnHobC iRKeWN2ZOtn7dKdhXDihODCdBQAnj9S5sSKmFD06Wf4KnnU00mDT3QBL0n4/ADzHFLJyl8xCunE Lh/WiNZ6Jk+OK6ypp36jQ+pG2au6VwFQ536THEMm0ZaGX9flH2xRJHhVYRkJS+CplRJaI6d0Evp i7T75B7wZE8ItJOywEE3fuC2Z7JNGZMfAfdmQVZGTklZU5BX43zhXOY+AcTnykSrVX1hVBQ/mYR q0ZQs= X-Google-Smtp-Source: AGHT+IH/FR32C0/V3WVvZjUC/0GDNM4I0fMXKVVovBTpA8gpuMX7GO08LEuXV0qjTChgIGlM9e6nAw== X-Received: by 2002:a17:90b:3a91:b0:32e:dd8c:dd18 with SMTP id 98e67ed59e1d1-339a6f07273mr7437233a91.17.1759385343125; Wed, 01 Oct 2025 23:09:03 -0700 (PDT) Received: from localhost.localdomain ([122.171.19.158]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b6099f594afsm1205029a12.37.2025.10.01.23.08.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 01 Oct 2025 23:09:02 -0700 (PDT) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Paul Walmsley , Palmer Dabbelt , 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 06/11] rvtrace: Add function to copy into perf AUX buffer Date: Thu, 2 Oct 2025 11:37:27 +0530 Message-ID: <20251002060732.100213-7-apatel@ventanamicro.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251002060732.100213-1-apatel@ventanamicro.com> References: <20251002060732.100213-1-apatel@ventanamicro.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 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 109be40d4b24..e874899c8b43 100644 --- a/drivers/hwtracing/rvtrace/rvtrace-core.c +++ b/drivers/hwtracing/rvtrace/rvtrace-core.c @@ -658,6 +658,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 e7bd335d388f..17d2fd9234c2 100644 --- a/include/linux/rvtrace.h +++ b/include/linux/rvtrace.h @@ -276,9 +276,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 @@ -289,6 +308,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 Dec 17 16:09:41 2025 Received: from mail-pj1-f45.google.com (mail-pj1-f45.google.com [209.85.216.45]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B2AD7288C34 for ; Thu, 2 Oct 2025 06:09:10 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.45 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385352; cv=none; b=MfAs6FwE265GMEBpD7lOBclvw57guqdLNiHTNJGtiDhPALxehU1PlCadXDTV/ld8KCD6AUhQa7MzqTlPbH4rRG3IgsuMntLwvdnyfhyi7320GhVod65A/o89HuSFvJ695gNU4w0602lMCx686lx21l+Z8lCL9rkbHf6W8IGz34g= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385352; c=relaxed/simple; bh=XEFA8zyiDZVVbLjKoilUQi+l/dTbcVsvCwesMof/7ow=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=t9sROcqIVJevQPPDXh1b0fEsn+tpqCJ9B5QWf/IB96LcE2K/Kl0d3DfVmXqM+FUagSwrQTb3dYbz89jJodqVboLj1uUUp+PwFDgptC1YuzKXgorfA63ca0ZVmIF/OrYwAm45PaCujZDeAS7SxpRoXuLEIq3KXqRQkkUD7Ar78UQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com; spf=pass smtp.mailfrom=ventanamicro.com; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b=d5Yuli6B; arc=none smtp.client-ip=209.85.216.45 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b="d5Yuli6B" Received: by mail-pj1-f45.google.com with SMTP id 98e67ed59e1d1-32df5cae0b1so974280a91.2 for ; Wed, 01 Oct 2025 23:09:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ventanamicro.com; s=google; t=1759385350; x=1759990150; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=9ftqbP+UQqSEu2f4CDXI8ip1QBHLXUd+nnX5oELppTk=; b=d5Yuli6BxUk6olra3rf21GWsTEeVvxc8xVqhMpsV0lFhes+Fvi7zbG9TeHngG4zqG+ X4PJOmZHbq5BxLaX/pl02NJb5XKjxDTAM6aIwt7BPKXiW8P/GY5qJDgYigTJOVbC+2dP Yr8/DNpRu7OQMohrYd0cNfnDVMo/9Epb4qXb3kVACtZ4hz6acJIZsJLoAATF4+GvF8KH vyd4iye1yy6lTUoJk44JlFO0YRbKVYCGvcCxxrqQLVusXsllUpe05yxpPSI2Z7hqYt8q tJx58panx1+ca9/5CiJMpO33BXpwk6a9KbJJs/JYRddaBiTaBYNpo2V7lPBdy/YZL+ol R48g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1759385350; x=1759990150; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=9ftqbP+UQqSEu2f4CDXI8ip1QBHLXUd+nnX5oELppTk=; b=SGkl0dF6XUG9PnIzBua7Z9cD7nM8fAmjnAHW5+LUv4w6/VYDXE+dzmP+CdYEbxqhEW ibivKakzf9c5EqyHqPhwFQSnK40Yz5vq0HXO6NAQodmEIlqYOErP5z2UlltfRRIIkSlq OaxhCMs/xJfRQLRtumnJRa7aei4G3KTCd96AyLo+ROaZketrCs68EGHbgFMl919uozM9 +hzuScULW7JsmhGUhMSJXbwlFmST/xhUmJBqFkiEkKj7GlZ3iuIleyKlTdZjTC8D3ljR 4TiUlL0jPGA4glcahUGYg71GTaIcuhiShZd5+6dn2+156V8LOrHzbMtnlH2g9Kn4845n VO5Q== X-Forwarded-Encrypted: i=1; AJvYcCVux2wCrz7CpLIOggTEQ24RIQccWH88PoD7bAgwfgJny6kFndClmifBXcX7WKGyDkN3hyE6LnMOghUsCG8=@vger.kernel.org X-Gm-Message-State: AOJu0Yw6naPcpKqNGE8JM9LRh0RTp4AjxSOkFhQTo+nBTs9DgVejOvQU Wg8pLA9m8Os2drFhmcTWnGpXH/eki2Oq8fctAY5AI+yQ77GZhzIk1zvI8aZRr46D7EE= X-Gm-Gg: ASbGncv40oGj4B1dA0ZnhE2GFGWvcgmupl55K/DiA1Cxirroh/n0m5QP4sCSkxgOSBE +Q0Cvj18UyqGFim+3JpTQhkYDDTn/CizXjZcAZ0XDdL+pGInDXi7saAh8PnEeDXGrr2A4rM8e1C /YIH3Scw47mYvVJMMMG66G96wPWSzNwNXJrOXFnB1VvRz34QPRYea6Lfl+7WfoRWkaCj1HH2oqg 0cbbpYf82bVpYz0aBP0x/vqH2m1wfVpbvXxbhvSQyc7YfRuKybHRMWP7Z//yaRl6MJRlX2QVH0b Tc4id6eOISz2jrrcAYDj2Z7JeP1Iw+DQG4mMX9YsDIp2BrHgacjlhVcgFKT46x8kmoNzLDqKSdB nBLzzjWgPRB1j7RyVvQUQ6EX1C1miU/2FmPvG27iPFBzH2ikyxo6g4+fPWzrJ2dltFfvco+tXPE NdDCY= X-Google-Smtp-Source: AGHT+IEFL89FRAz70PFiXxdbB3Wjgy9mSV6Pk0dwPsKpmwVWnajTDyjSSOaPk9cpQlVIA3PETGEPeQ== X-Received: by 2002:a17:90b:4a87:b0:32b:623d:ee91 with SMTP id 98e67ed59e1d1-339a6f36e19mr6863672a91.27.1759385349850; Wed, 01 Oct 2025 23:09:09 -0700 (PDT) Received: from localhost.localdomain ([122.171.19.158]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b6099f594afsm1205029a12.37.2025.10.01.23.09.03 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 01 Oct 2025 23:09:09 -0700 (PDT) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Paul Walmsley , Palmer Dabbelt , 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 07/11] rvtrace: Add trace ramsink driver Date: Thu, 2 Oct 2025 11:37:28 +0530 Message-ID: <20251002060732.100213-8-apatel@ventanamicro.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251002060732.100213-1-apatel@ventanamicro.com> References: <20251002060732.100213-1-apatel@ventanamicro.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 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 | 8 + drivers/hwtracing/rvtrace/Makefile | 1 + drivers/hwtracing/rvtrace/rvtrace-ramsink.c | 198 ++++++++++++++++++++ 3 files changed, 207 insertions(+) create mode 100644 drivers/hwtracing/rvtrace/rvtrace-ramsink.c diff --git a/drivers/hwtracing/rvtrace/Kconfig b/drivers/hwtracing/rvtrace/= Kconfig index ba35c05f3f54..aef7e9989165 100644 --- a/drivers/hwtracing/rvtrace/Kconfig +++ b/drivers/hwtracing/rvtrace/Kconfig @@ -21,3 +21,11 @@ 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 + 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..7bd0cf1e4dfd --- /dev/null +++ b/drivers/hwtracing/rvtrace/rvtrace-ramsink.c @@ -0,0 +1,198 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2025 Ventana Micro Systems Inc. + */ + +#include +#include +#include +#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_RPLOW_OFF 0x028 +#define RVTRACE_RAMSINK_RPHIGH_OFF 0x02c + +struct rvtrace_ramsink_priv { + size_t size; + void *va; + dma_addr_t start; + dma_addr_t end; + /* WP from prev iteration */ + dma_addr_t prev_head; +}; + +struct trace_buf { + void *base; + size_t size; + int cur, len; +}; + +static void tbuf_to_pbuf_copy(struct trace_buf *src, struct trace_buf *dst) +{ + int bytes_dst, bytes_src, bytes; + void *dst_addr, *src_addr; + + while (src->size) { + src_addr =3D src->base + src->cur; + dst_addr =3D dst->base + dst->cur; + + if (dst->len - dst->cur < src->size) + bytes_dst =3D dst->len - dst->cur; + else + bytes_dst =3D src->size; + if (src->len - src->cur < src->size) + bytes_src =3D src->len - src->cur; + else + bytes_src =3D src->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; + src->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); + struct trace_buf src, dst; + u32 wp_low, wp_high; + u64 buf_cur_head; + size_t 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; + + if (buf_cur_head =3D=3D priv->prev_head) + return 0; + + dst.base =3D buf->base; + dst.len =3D buf->length; + dst.cur =3D buf->pos; + dst.size =3D 0; + + src.base =3D priv->va; + src.len =3D priv->end - priv->start; + if (buf_cur_head > priv->prev_head) { + src.size =3D buf_cur_head - priv->prev_head; + } else { + src.size =3D priv->end - priv->prev_head; + src.size +=3D buf_cur_head - priv->start; + } + + src.cur =3D buf_cur_head - priv->start; + size =3D src.size; + tbuf_to_pbuf_copy(&src, &dst); + buf->pos =3D dst.cur; + priv->prev_head =3D buf_cur_head; + + return size; +} + +static int rvtrace_ramsink_setup(struct rvtrace_component *comp) +{ + struct rvtrace_ramsink_priv *priv; + + priv =3D devm_kzalloc(&comp->dev, sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + dev_set_drvdata(&comp->dev, priv); + + priv->size =3D SZ_4M; + priv->va =3D dma_alloc_coherent(&comp->dev, priv->size, &priv->start, GFP= _KERNEL); + if (!priv->va) + return -ENOMEM; + priv->end =3D priv->start + priv->size; + priv->prev_head =3D priv->start; + + /* Setup ram sink addresses */ + 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); + /* Limit address needs to be set to end - 4 so that HW doesn't cause an o= verflow. */ + rvtrace_write32(comp->pdata, lower_32_bits(priv->end - 0x4), RVTRACE_RAMS= INK_LIMITLOW_OFF); + rvtrace_write32(comp->pdata, upper_32_bits(priv->end), RVTRACE_RAMSINK_LI= MITHIGH_OFF); + + return 0; +} + +static void rvtrace_ramsink_cleanup(struct rvtrace_component *comp) +{ + struct rvtrace_ramsink_priv *priv =3D dev_get_drvdata(&comp->dev); + + dma_free_coherent(&comp->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); + 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); + 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, + .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 Dec 17 16:09:41 2025 Received: from mail-pf1-f181.google.com (mail-pf1-f181.google.com [209.85.210.181]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 858742D0C7E for ; Thu, 2 Oct 2025 06:09:17 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.181 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385359; cv=none; b=YIAPeI0HQE3aavHvNcMiNsGFn1Rvu32UodDhYuOAyH6R4sjRBrH3k1Qs2/7bvRa8AvuK0ReH6nKJou6QuR5Y8YwiB0y7VNiJ5GtlDZjM8VUM0e8L6POyMdRIezL1qJGjieFRu/2yO/oDU3VvyWb94hE319aBt77/O6EEEeJ8kUQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385359; c=relaxed/simple; bh=slfHC8PAv5VIT8u+nD/h/2IirRKXgHzJULs1SA2PJNE=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Fhy8fGkF7bppYXNWwzogSZ6ZkSfO6gjSoLG86K1UWGWmVRfBfUMVQRvvfjPmDUrVSlGbJqysbbMopVfght6DbHJZxuRbpjtW6Gn4N3dSKRTwQtCi3HWs2DSJCsGkCPjuZRz9HfLZ+dfNbA7YyN/Ep8dyBBjuxsw6qxkPjbHDENA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com; spf=pass smtp.mailfrom=ventanamicro.com; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b=DxaxHb4z; arc=none smtp.client-ip=209.85.210.181 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b="DxaxHb4z" Received: by mail-pf1-f181.google.com with SMTP id d2e1a72fcca58-7835321bc98so775688b3a.2 for ; Wed, 01 Oct 2025 23:09:17 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ventanamicro.com; s=google; t=1759385357; x=1759990157; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=BUQPfkbJ3dZW7yGpAIpAlgM0v37IerodzZgj+qIzfvU=; b=DxaxHb4zY7HJV5iCD5NAtLnBV10HvC4Vi8pKyxGiUYLU3z0ePsxMrKBMXXZrPYtjQJ IZMV8vHvIOha6VB4iy9YhwX0v8sk6a+0pzHIy7UUWNEos7CclMOJGuq7Wt1DlbHMunnS AFF53q2rqEXlojAoRwBM6wPMSGezJ3iZ3VzVnZv4PXw7t6EcOLgalurQ+DPIEpy0Tnsu AEGZpDiCbbYUTZLaPprPC1t311UmSv1lQvyJaQ9EDoQhsKf+eNKyQv9UGcppzJ35Mn31 D6ho7Vy1yKLPM9d9nOXRumjak3M5zKCRC8x2VyGnWCU+coYN01+g6BSJKH3q8qqCkGBR M+4A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1759385357; x=1759990157; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=BUQPfkbJ3dZW7yGpAIpAlgM0v37IerodzZgj+qIzfvU=; b=hwnP5Ggfx6Yt6fVZN5MAaA0TIbdZH+BA4EItTltXrE1a3H6SWkVR82EHXPX1pbqwnd F3Yb0z6BEjpQ78wrcsl84kCerOk9haNGYmNhGpTNaoLQd2xpsL8Eo4eVm/bDUniYbdhk 89vrPSKTpnCFs4UDi2vYDtvq7xSygUnrBpRn9BoHMT0Ie0EAnrgszt7PdrSbASq1RteF hOJ9WyH7iz/JoBSIynxZxbO9N51wrwipZHuZoS4RDEQSno3Vm/Yd4qh8L2qiTERzHOSc l1Km4rarlGPnA2F1hSfPjH2xvGr4/kt+EXwKKWnbXI20gsNr95E0btaxEfH8OfrwALyj WOzg== X-Forwarded-Encrypted: i=1; AJvYcCUtN8rlSbVHeaD9gOiDEP69ErdqPbyVUXEI/FyvsGIJCYQSDHBy5Bv/f6SBrEqMKFS6NG2PRsVI6m+K1mc=@vger.kernel.org X-Gm-Message-State: AOJu0YznBnMU2zQD0XL6Sy03vXK1rB+8py0nia/1Eq38ksNr1UO/W6Hm QBLjruD3Nzdy5igBYJuRPdDZRxGa8P/T/eX3QXODRtNi0AHyOhnGv3FepX4NeS9nzzc= X-Gm-Gg: ASbGncvLMasH8M/fhB54Ztf0TLey+9PjydEtXb/es9wZjWkbrxH391ClGPk3olXTM1I 2yRotdcVKnXR3KpCVRAju3sODoKlHtvoQzzMUUWqfI9q+romDDkmBbQu+qbOwMSzL5rdmmWf0GT SIUGVndApM+o7dgTK2fKMmfV8mGYdtmJtO5qTJWqCVONVfVccZpIvbNOa+ZVBIqaQNUgT7DHdYm 0Waa7IH9ctzsgjqWtQs5AqdfBaf/jnv9xNa8zK1etx6sZNzWirbZjh89fwHyvsSCIegX0ZOwIFb Lc6B+ExzdnvsYs9s7UOw1E/K0vLNCO4Wlnu/cHtVx9mMKDXZjeht2EeoSbuqF8Bm/HYHheh6ai+ L8BllWJQ6piusB80OUHG/F8ZawwDy0XG1jsDDhrQQjrPSAyByDflXYrrNg0LHn9JhiFlf4obU7S 7WQcs= X-Google-Smtp-Source: AGHT+IFJYhph88TXwzRm6wpDFKmxs7iIGvjnIRXrwoaN/aRyPB6wF1pi6B0teuXwXD5OsXwiw3KiPw== X-Received: by 2002:a05:6a21:b8a:b0:2ea:41f1:d53a with SMTP id adf61e73a8af0-321e72b876emr7793339637.41.1759385356653; Wed, 01 Oct 2025 23:09:16 -0700 (PDT) Received: from localhost.localdomain ([122.171.19.158]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b6099f594afsm1205029a12.37.2025.10.01.23.09.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 01 Oct 2025 23:09:16 -0700 (PDT) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Paul Walmsley , Palmer Dabbelt , 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 08/11] rvtrace: Add perf driver for tracing using perf tool Date: Thu, 2 Oct 2025 11:37:29 +0530 Message-ID: <20251002060732.100213-9-apatel@ventanamicro.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251002060732.100213-1-apatel@ventanamicro.com> References: <20251002060732.100213-1-apatel@ventanamicro.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 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 | 343 +++++++++++++++++++++++ include/linux/rvtrace.h | 3 + 5 files changed, 356 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 aef7e9989165..76379c63c5c3 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 e874899c8b43..5d4e92f22ccd 100644 --- a/drivers/hwtracing/rvtrace/rvtrace-core.c +++ b/drivers/hwtracing/rvtrace/rvtrace-core.c @@ -760,11 +760,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..2d3039f8b681 --- /dev/null +++ b/drivers/hwtracing/rvtrace/rvtrace-perf.c @@ -0,0 +1,343 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright(C) 2025 Ventanamicro Limited. All rights reserved. + * Author: Mayuresh Chitale + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define RVTRACE_PMU_NAME "rvtrace" +#define RVTRACE_BUF_LEN (4 * 1024 * 1024) + +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 17d2fd9234c2..0a454707633b 100644 --- a/include/linux/rvtrace.h +++ b/include/linux/rvtrace.h @@ -335,4 +335,7 @@ static inline void rvtrace_unregister_driver(struct rvt= race_driver *rtdrv) driver_unregister(&rtdrv->driver); } =20 +int rvtrace_perf_init(void); +void rvtrace_perf_exit(void); + #endif --=20 2.43.0 From nobody Wed Dec 17 16:09:41 2025 Received: from mail-pj1-f51.google.com (mail-pj1-f51.google.com [209.85.216.51]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 61A50299A87 for ; Thu, 2 Oct 2025 06:09:24 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.51 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385366; cv=none; b=Q+Z1aI8pbXe/3uRTxXZ2MkFeApGHDpJJavArU0spQIzKJmlOCIYrzoPMozw72t9GhAw4x3Dq6TpwtVSngoXoLs3FHAm7KBHb8LNh7m0uUN+xmv7auZZB2zS/5FL726ZQhW+vPW98TTZcz/X6hbw/K4jziu6b6Z8nrixkHUkFujU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385366; c=relaxed/simple; bh=xbV+rCfsZKYy3dRObZGeFxQK+7W/WDJNNtkZSU1JOQ4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=SEs0vKQGB/NswmMJn8KbkG5I4+ZK6OtvMFXIgqZlyNnhmalPDQIZT6EBVM90W2A/QtQjkdlix4BUjy4sAWMkpx7KP0o8PaZ+1tc20xAGYiKORw8qLhvLCMuOuYKNKnc/VYzupx4pTO9zfQCBce3QGu3QHR+FMUNbrSHjyTi8b7k= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com; spf=pass smtp.mailfrom=ventanamicro.com; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b=RYr7P7Yi; arc=none smtp.client-ip=209.85.216.51 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b="RYr7P7Yi" Received: by mail-pj1-f51.google.com with SMTP id 98e67ed59e1d1-3307de086d8so663702a91.2 for ; Wed, 01 Oct 2025 23:09:24 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ventanamicro.com; s=google; t=1759385364; x=1759990164; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=GmROAtU6SgDhctC5OYUrxi6P8MiR5wW5dx2HxDTamiw=; b=RYr7P7YiFlMCSCASYInPkcN4OqdBfTXTowz4XG8zLzLqiEZVvc1jzs3uMHXPXaO5ua KSU3dqQwEmAq3aIgSYF5zq7oCuHdtaHR7qNO4cRGqi5sfICJaNh+YOolAYcY4Y9W+hza CM2fJFpOP8ucf1mvCVMoSVKp1DfnixAeiwc2cC1lD56D9WjZ+dfkxvG5bIH506sPAcUD jlG/tsdNTPBMgundltOgyMcGKJtyHhXNXyq9phuVNd1QmkY3T/nZ4+EikVKQQToQ1kwX MtcCgYrz25lBKoDKti8PADBcbBV6jtITuXbjSWV0eG9EBwGu/CxTgB3w0ceDXodf0KLG mxZA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1759385364; x=1759990164; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=GmROAtU6SgDhctC5OYUrxi6P8MiR5wW5dx2HxDTamiw=; b=Qqo7TnjQ1V40ndsrvPCWdX8AN7Mf32VzOjLX8Df+6PPLsQ19P9Xeoifcl8ixuWLeXH zm+4SkZPhncEp+x2vXojJPlKGkikLxDFfJKY7RLRVjg77ObSSeucWVWxt8MHtC9b7Q1F VuIeVkkzW0bNgkUR4/NxQ1kqBexpjPXJmc8CQWmxCUp0t2MY5KfqbNnhtLhNRiD0s1k4 aft3zG40/4PDK94UuEaY9UUZ+4UUp+1XFisWL5xJsqP8zn0Q+hSalBg6WaW51l0SvpXw s3wQPEMCQVMNcyweBH04cSzI7a2MtYsv6N4aVMppWbtGAW6j31f9rMtMUNhiXUKT6cZX RXRQ== X-Forwarded-Encrypted: i=1; AJvYcCV2+KtqnKuySs4JW5eJZj8ds97AnwGXPBg37AD7ymY7d//8w/bfQ4hwO+xgDKmviMCacIacRdGbBsDixpk=@vger.kernel.org X-Gm-Message-State: AOJu0YxdAY7TNOel7GisLXk6Fc/Y3UjnAP2MvwklEYDRpDb0D/eD9vQc udlE5La3cHZXYAYH/HgHUL6faPZf/sdjkQmAS7CeAzEdTA+j5H3q0/0Tp8oct+PZ9bw= X-Gm-Gg: ASbGncsdPlrTmc6PYP4jCSFgZspseM28C6xasKGYmgD6NKRRkQoiEgq2ANGHSi20mFw xfO3siXX6unSWE3NscHGwMkiwUvT36kGpszbhDSbaQc0WFIf++OEZncIuBr0Y3lA4OXlHHd830M bRa1+39AK2vYodfEHR5NC+4yw/M0IvmEOE7aEKqkTJzGlpSrbYiYB2jkKDz82wgpeMaivfQk66S n3ny+vjDd7XpoYwrZxv1PMPRQWHI2QQSk3NtH7goGJXpyXAM1zElV0uriKgBLT0pKUduV+DmS6q lgoxLQPByKe/2+/3rUbN3BVKIG+E51Pf9NL0ZWbLrUTX2dA4AeZkdzl5jPCPKrgVjGY9TWRIzLX IgJcUKjIfxb04JUnkqnT9dp7KQkIep9+vOJ2SXJLG6Po2hr5yyiow/ZvQ4vdVD3eifKkaEi0grF qMlgA= X-Google-Smtp-Source: AGHT+IFIvD/TGVwCuMeABFCgpn8+lbAS6QxuDhvf7qSI2NatW7LF3gsrGSse9+7/agcJceCONR03+Q== X-Received: by 2002:a17:90b:3a91:b0:32e:dd8c:dd18 with SMTP id 98e67ed59e1d1-339a6f07273mr7438539a91.17.1759385363417; Wed, 01 Oct 2025 23:09:23 -0700 (PDT) Received: from localhost.localdomain ([122.171.19.158]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b6099f594afsm1205029a12.37.2025.10.01.23.09.17 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 01 Oct 2025 23:09:22 -0700 (PDT) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Paul Walmsley , Palmer Dabbelt , 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 09/11] perf tools: Add RISC-V trace PMU record capabilities Date: Thu, 2 Oct 2025 11:37:30 +0530 Message-ID: <20251002060732.100213-10-apatel@ventanamicro.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251002060732.100213-1-apatel@ventanamicro.com> References: <20251002060732.100213-1-apatel@ventanamicro.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 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 --- tools/perf/arch/riscv/util/Build | 1 + tools/perf/arch/riscv/util/auxtrace.c | 218 ++++++++++++++++++++++++++ tools/perf/util/auxtrace.c | 1 + tools/perf/util/auxtrace.h | 1 + tools/perf/util/rvtrace.h | 18 +++ 5 files changed, 239 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 58a672246024..2ba1fb98a0ad 100644 --- a/tools/perf/arch/riscv/util/Build +++ b/tools/perf/arch/riscv/util/Build @@ -3,3 +3,4 @@ perf-util-y +=3D header.o =20 perf-util-$(CONFIG_LIBTRACEEVENT) +=3D kvm-stat.o perf-util-$(CONFIG_LIBDW_DWARF_UNWIND) +=3D unwind-libdw.o +perf-util-$(CONFIG_AUXTRACE) +=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..adc86bd38998 --- /dev/null +++ b/tools/perf/arch/riscv/util/auxtrace.c @@ -0,0 +1,218 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Risc-V E-Trace support + */ + +#include +#include +#include +#include +#include +#include + +#include // page_size +#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_etm =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_etm) + found_etm =3D find_pmu_for_event(&rvtrace_pmu, 1, evsel); + } + + if (found_etm) + 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 ebd32f1b8f12..735f6c360064 100644 --- a/tools/perf/util/auxtrace.c +++ b/tools/perf/util/auxtrace.c @@ -1393,6 +1393,7 @@ int perf_event__process_auxtrace_info(struct perf_ses= sion *session, case PERF_AUXTRACE_HISI_PTT: err =3D hisi_ptt_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 f001cbb68f8e..5b7ce4a99709 100644 --- a/tools/perf/util/auxtrace.h +++ b/tools/perf/util/auxtrace.h @@ -50,6 +50,7 @@ enum auxtrace_type { PERF_AUXTRACE_ARM_SPE, PERF_AUXTRACE_S390_CPUMSF, PERF_AUXTRACE_HISI_PTT, + 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..93c041db8660 --- /dev/null +++ b/tools/perf/util/rvtrace.h @@ -0,0 +1,18 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright(C) 2015 Linaro Limited. All rights reserved. + * Author: Mathieu Poirier + */ + +#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 Dec 17 16:09:41 2025 Received: from mail-pf1-f170.google.com (mail-pf1-f170.google.com [209.85.210.170]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2DFB22D2390 for ; Thu, 2 Oct 2025 06:09:31 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.170 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385372; cv=none; b=Sby/cES3ZmOk84svnhkCFJkXHPUxn5YxfyDKsL/ESJ8da9UAHUjZxiAZV+7DxPEmeNP/UI33NzjoXE5ttYrdh8pWlq/jQFPklYfzHA2/VzCsynFaMIS8xKsSftmHiVMfxVe2zSd3JfRVPRL3bz/GJjmi8PmYLqI59HGt7sO9P6k= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385372; c=relaxed/simple; bh=A8yV6HZYjL3Q3FaHQaHm8hNAwETN0T+E21KzDymdeVs=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=n10XiaDj/Ni6LYJRPgSiBmMVeZfq9NQF+uQg71Cr3SQMf2V7pgZX0U5ugvJNOWAbdHhM+aU+F0I0WQ638poaGqEqp1ZUChQl8JN+8TKrIsIwNjYyeqtUPDXlQF4LcMarS1josGBUh7rtBwAm69e+a87IdxuLvX4tEL8Ta5U0u10= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com; spf=pass smtp.mailfrom=ventanamicro.com; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b=k/3CAjt+; arc=none smtp.client-ip=209.85.210.170 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b="k/3CAjt+" Received: by mail-pf1-f170.google.com with SMTP id d2e1a72fcca58-78118e163e5so1647283b3a.0 for ; Wed, 01 Oct 2025 23:09:31 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ventanamicro.com; s=google; t=1759385370; x=1759990170; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=8zmmvMMm35WfJWJCu/rbPWUzK6j6v7Igidp5p7E+6WY=; b=k/3CAjt+Jo16pYkpnbpvBxVzcvIbnZwFycGZMB1N+g/J9ZV1yDLUcL98Am+PW4ClrE BpvAxWkCC5g16yzXuVxWMTNY428F5EnXxV92Jda3gkLBr/296zvbYMBK8lyYRhGGxw2d PXY0OqQMdmmt8EfRo4/fRfpJOfXBs5ZsNobwtQckF+Qp1YFmB3uwb+rNudQzzS+cw0gC K1DaS7u5VuJ5j4hjsNTF4vWtCuQ5Qjb82S81Xz1vd/e2Q6FcC1MEFkw8w3IFkrOIti3g hCMiDUAN7Dvc4ZKqqyj98qMLHgF6aoHYFCzDPnrcSB5ZbdYJxnjLkPummDou+LtECDz3 cEmA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1759385370; x=1759990170; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=8zmmvMMm35WfJWJCu/rbPWUzK6j6v7Igidp5p7E+6WY=; b=Wl8TusZEFzhfyk/V4zBmPGnJG2sMPJL/b4CJ+hLB49T9AhLNFamISeWACIAExfeRTo VbZa9Y2JsYoo2GZ8fYST1n+H5QXqf5lOvEASvW31lFKj7Kcmt6JFfBK+5tEEjr9YkG05 fUgQdopqNy5moW6jB9tgwnB15w+k+gETErzPCCHu9Gx5DwhlOEHa07E8AKl66jHOkBHm 9xlJtRbJmoCCIqoDwEB6cykfsC0Te2CIheWz1cIjdIc4ltqk2PZoElKxNPJimiBmzrQD OE92ls1n2XrXBgXjj//WexX7JQ8Nr6Vqzh2UnEnllB+usnlFVBNjJSY6XCyPMYHT8W1B hLeQ== X-Forwarded-Encrypted: i=1; AJvYcCU7AasgrZO6Pasv/GrPB+n1uVSbZ2zbYuLkRF95z+8vDLsGlQD4D0va6Gk7i1BOzIb1j9uaAbg2dtJ5wIg=@vger.kernel.org X-Gm-Message-State: AOJu0Yx4IspfgnY8hlIYjdZlYeZZB2X77iIucdA1YWFZPEBmrVZ/dXXU 01MWlNNqBb4Yq8MhdP1Qyp1gsrX5nZ7Je1NGHXkLmBHIzE9mg+2qOPfxze6xcvPj9fg= X-Gm-Gg: ASbGncsusUXp0bfJc99SJF/1lXD7CE2qIYo5oP5zcI/JzmnCqAqVGr73y4bpXFv3AoZ 60BBXA3zDzYt4NY52cXxe2yylr2KtQ6byzSlAMWpG3rdsRcCHL7fon4HIa4jN2Xan/UAA4YnY7R M7eLjVio5R9fIAvcY/pRAc37WEALOIzKEWoKgKVtx0p/dxxyQJvi1DuGQL/DDt8c0EbN0taixA2 nj0jp2y+EdnbV3MfSe7TRYzcW43aAX+n93ZOuhhJplIfNv/1r6zNWczbW9RHRgmiwxM+FTH2FMs 8+y2dWTOWY0Y6XVSkiZC+pSthvcBQUnciVFlv9vtu+DXvjfpGQKOOP0OOW0JzY76D7iF+RT8fdo 9ViTztRPCnrdfXgDTd+tfa32ZqCvWFcQoSY1yq9Hc1sdOyDFskEZcAS1EbtP60bCEZIsGYesK1i tsZaI= X-Google-Smtp-Source: AGHT+IF+YSzJ58uViX8Nc9sdQwacWiEzaK5CydbflVdamOordFViOPRH4V5+hIAsR14420tWtxw0Bw== X-Received: by 2002:a05:6a21:3943:b0:243:78a:82c4 with SMTP id adf61e73a8af0-32a261f188amr2830964637.25.1759385370384; Wed, 01 Oct 2025 23:09:30 -0700 (PDT) Received: from localhost.localdomain ([122.171.19.158]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b6099f594afsm1205029a12.37.2025.10.01.23.09.23 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 01 Oct 2025 23:09:29 -0700 (PDT) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Paul Walmsley , Palmer Dabbelt , 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 10/11] perf tools: Initial support for RISC-V trace decoder Date: Thu, 2 Oct 2025 11:37:31 +0530 Message-ID: <20251002060732.100213-11-apatel@ventanamicro.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251002060732.100213-1-apatel@ventanamicro.com> References: <20251002060732.100213-1-apatel@ventanamicro.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 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 | 2 + 4 files changed, 97 insertions(+) create mode 100644 tools/perf/util/rvtrace-decoder.c diff --git a/tools/perf/util/Build b/tools/perf/util/Build index 4959e7a990e4..2305638283c4 100644 --- a/tools/perf/util/Build +++ b/tools/perf/util/Build @@ -142,6 +142,7 @@ perf-util-$(CONFIG_AUXTRACE) +=3D cs-etm.o perf-util-$(CONFIG_AUXTRACE) +=3D cs-etm-decoder/ endif perf-util-$(CONFIG_AUXTRACE) +=3D cs-etm-base.o +perf-util-$(CONFIG_AUXTRACE) +=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 735f6c360064..5ccb5f3d9af8 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" =20 #include @@ -1394,6 +1395,8 @@ int perf_event__process_auxtrace_info(struct perf_ses= sion *session, err =3D hisi_ptt_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 93c041db8660..fdf2e5866c85 100644 --- a/tools/perf/util/rvtrace.h +++ b/tools/perf/util/rvtrace.h @@ -15,4 +15,6 @@ =20 #define RVTRACE_AUXTRACE_PRIV_SIZE sizeof(u64) =20 +int rvtrace__process_auxtrace_info(union perf_event *event, struct perf_se= ssion *session); +struct auxtrace_record *rvtrace_record_init(int *err); #endif --=20 2.43.0 From nobody Wed Dec 17 16:09:41 2025 Received: from mail-pj1-f42.google.com (mail-pj1-f42.google.com [209.85.216.42]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 0C23B2882BD for ; Thu, 2 Oct 2025 06:09:37 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.42 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385379; cv=none; b=XP+OWBsjP7+HC8rJry4TBdcsczyp74HT16XiNvPJpp64sh1NfCbqJxhxRoub3hR7sJAsz9M5vBEBdbJvVQ6h4q0g8c9+8DR3HuMvbosq38tJHVwzYalz8PHcwYoOftUHkZVOhYiLXLlulfsQcyprB6CQn/rIzn5MqhulBe1LRTQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759385379; c=relaxed/simple; bh=j2jjXbUEye2nfKb3sw3aIgKPRAfLAp+24kdzx86f4sc=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=f6b7TiDgVDIncGxi8f7OHKIrrVaVGMVrc2U6pLngORcm+t2+kGOALCjKW25M8/6gJkcyrtpCkrrl6gN+sSAVTz0ptCR5aoAO+hdmys0o5c64uu8mEk8XZuq/vf0BbJ+Xm3z0M+3JZDDcm1kb+DPdHZqKJD8OUTlfjKOOeAEd4Ng= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com; spf=pass smtp.mailfrom=ventanamicro.com; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b=hcikybLL; arc=none smtp.client-ip=209.85.216.42 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b="hcikybLL" Received: by mail-pj1-f42.google.com with SMTP id 98e67ed59e1d1-3327f8ed081so877676a91.1 for ; Wed, 01 Oct 2025 23:09:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ventanamicro.com; s=google; t=1759385377; x=1759990177; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=MF1UBNl0YQdxkCR2Wq/BcrNYDGhukTT3j7EdaD4pBPY=; b=hcikybLLA/XrC7oQzbMplex6fDdyU1a4XXZ7jQJRx1uxX3hFXxTtUzlZ7xVDhR3sgo AWvUKGbpjW8mNUwQPaY9vzDfJKxKdTl4UrYBV1KIEZ3oB6n7SXxJttxWonhTdwIFGOhv G+4AZftItpiBRGUheuWhY5Yo6DSw02eDAY3D4uVma+0+tgzVvmrH6+4NC5QZPdzVmgCC fXbvrQAKly2YUrjmH61PeU5YzCsmswRzPsEpPHE7VLuP7Ae0ow4siB5DB2EsgRaVy2u8 lZhTVhMGNDPFMT7IAjUAD3j1g2XcgSGcnyBPlqHxJ0b5pL7IVO05jZT+7iAEzxsw5XC1 f0zA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1759385377; x=1759990177; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=MF1UBNl0YQdxkCR2Wq/BcrNYDGhukTT3j7EdaD4pBPY=; b=eQ22HVo7ZRk8ZCKmlWQZO1VVAe14tNLBfRjwfTz/O3Y5fEH5I/l9mjnE9/i/afZMen mfR7AcWpoVxtWa4YbZ/mJ9T/SZ+4lPKIHFgOSOvUlv/DdBEPA4pS94b4EbFvt0EXbv9j JoqKUxiX4fy3qlq+oCQITyuVLEuhez/KNXz7Yix8PUuUkDJ3cWGPvWics8XQF4GxTvAq 3qLV53J/fPhU1CpYH2//i+vwZw/5pA9iaoXvZ6H0y2c2WzWr0ZOMh/VN99N9taDHnnTp YeBpiWORLRVdkR/Q1eMddu2rzKykZ2ONvTQBXgQMpIDCdqsYmefM8e03CvQII2YjcBrb VcbQ== X-Forwarded-Encrypted: i=1; AJvYcCWBZ625BYji7ur/O168TF3a8WxITuN+r3rq3CGRD1ZjK1Zsu+frpsU0TFbkiWW28+vEAhdA4oRFuyiZkRs=@vger.kernel.org X-Gm-Message-State: AOJu0Yx+J6bFGmlbbjW1XEdPcD4cFx8QTN+pX/+/UIy5bbRtvP/e3t2B +inZBXAk4hpQsLc1LJXGEghZ5h7xRx5KWdOp1Wec6/ryWuNNGv6SLPz0/oB5VQAPWSI= X-Gm-Gg: ASbGncshWGbYrhheucSg82NYZUSiSWdwUcJu334r7Tp1ci4cj+Cn2JsIxuiR30DJ7wu TP9KClWzVQltpikPt5HvucwzbbskDjtiKN10F5LfRwVEup6EvNA7Y9/fkQwX71xS/thNMA+8Ten JL3a4UibSnOPsfH2a/Ey/EAtwKbfXVkeTPQPOO4eh44ydPaEOIlqpqNijvxyViZnwT7sT/MKEKh AJ2RcSdfuk0nhiZLxaRDGos8equ6R6G0R1KW8jFIolWfC/cFsI2Dd+8nrOZPFhVjacawNtewsM4 kIt89s8YCabQwbWC2Ijd9syMaOd7WsKxy6YEvD/tgHBIxHrjVBDaidzIISdHCiHmICgLJ9jUquk amqK8s8ClxInbVDi6S0aJ+YqQ6EqSO2ruB1eePER5PtRhz8R4xp6oET5gHKT6XPnkGWgm7hI6fD cBR/Q= X-Google-Smtp-Source: AGHT+IHhhHbJ8hJGnY+jVzo5XBMGx1xaIAa5m44vk4uxyjS42YcaIHBNHmkiTntGZfiB3yhY5MXCRg== X-Received: by 2002:a17:90b:1e08:b0:32e:70f5:6988 with SMTP id 98e67ed59e1d1-339a6f84cd2mr5872201a91.32.1759385377284; Wed, 01 Oct 2025 23:09:37 -0700 (PDT) Received: from localhost.localdomain ([122.171.19.158]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b6099f594afsm1205029a12.37.2025.10.01.23.09.30 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 01 Oct 2025 23:09:36 -0700 (PDT) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Paul Walmsley , Palmer Dabbelt , 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 11/11] MAINTAINERS: Add entry for RISC-V trace framework and drivers Date: Thu, 2 Oct 2025 11:37:32 +0530 Message-ID: <20251002060732.100213-12-apatel@ventanamicro.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251002060732.100213-1-apatel@ventanamicro.com> References: <20251002060732.100213-1-apatel@ventanamicro.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 Content-Type: text/plain; charset="utf-8" Add Mayuresh and myself as maintainers for RISC-V trace framework and drive= rs. Signed-off-by: Anup Patel --- MAINTAINERS | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 969df0192fc1..898b51d3dd8a 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -21800,6 +21800,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