Linux RISC-V trace framework and drivers

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 <[email protected]>

---
 .../bindings/riscv/riscv,trace-component.yaml | 112 ++++++++++++++++++
 1 file changed, 112 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml

Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml new file +18 -0

new file mode 100644
index 000000000000..7979af3d4174
@@ -0,0 +1,112 @@
+# 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 <[email protected]>
+
+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 inputs

Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml new file +16 -0

+
+  reg:
+    maxItems: 1
+
+  cpus:
+    maxItems: 1
+    description:
+      phandle to the cpu to which the RISC-V trace component is bound.
+
+  in-ports:
+    $ref: /schemas/graph.yaml#/properties/ports
+    patternProperties:
+      '^port(@[0-7])?$':
+        description: Input connections from RISC-V trace component
+        $ref: /schemas/graph.yaml#/properties/port
+

Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml new file +47 -0

+      out-ports {
+        port {
+          CPU0_ENCODER_OUTPUT: endpoint {
+            remote-endpoint = <&CPU0_RAMSINK_INPUT>;
+          };
+        };
+      };
+    };
+
+    ramsink@c001000 {
+      compatible = "qemu,trace-component", "riscv,trace-component";
+      reg = <0xc001000 0x1000>;
+      cpus = <&CPU0>;
+      in-ports {
+        port {
+          CPU0_RAMSINK_INPUT: endpoint {
+          };
+        };
+      };
+    };
+
+    encoder@c002000 {
+      compatible = "qemu,trace-component", "riscv,trace-component";
+      reg = <0xc002000 0x1000>;
+      cpus = <&CPU1>;
+      out-ports {
+        port {
+          CPU1_ENCODER_OUTPUT: endpoint {
+            remote-endpoint = <&CPU1_RAMSINK_INPUT>;
+          };
+        };
+      };
+    };
+
+    ramsink@c003000 {
+      compatible = "qemu,trace-component", "riscv,trace-component";
+      reg = <0xc003000 0x1000>;
+      cpus = <&CPU1>;
+      in-ports {
+        port {
+          CPU1_RAMSINK_INPUT: endpoint {
+          };
+        };
+      };
+    };
+
+...

Signature · 1 line

2.43.0

Quoted 41 lines · Anup Patel

Add device tree bindings for the memory mapped RISC-V trace components which support both the RISC-V efficient trace (E-trace) protocol and the RISC-V Nexus-based trace (N-trace) protocol.

The RISC-V trace components are defined by the RISC-V trace control interface specification.

Signed-off-by Anup Patel <[email protected]>

---
 .../bindings/riscv/riscv,trace-component.yaml | 112 ++++++++++++++++++
 1 file changed, 112 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml

Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml new file +22 -0

new file mode 100644
index 000000000000..7979af3d4174
@@ -0,0 +1,112 @@
+# 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 <[email protected]>
+
+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 inputs
+  from multiple components. The type and version of a RISC-V trace component
+  can be discovered from it's IMPL memory mapped register hence component
+  specific compatible strings are not needed.
+

Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml line 28

Quoted 6 lines

Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml new file +6 -0

+properties:
+  compatible:
+    items:
+      - enum:
+          - qemu,trace-component
+      - const: riscv,trace-component

'component' seems a bit redundant.

Quoted 17 lines

Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml new file +16 -0

+
+  reg:
+    maxItems: 1
+
+  cpus:
+    maxItems: 1
+    description:
+      phandle to the cpu to which the RISC-V trace component is bound.
+
+  in-ports:
+    $ref: /schemas/graph.yaml#/properties/ports
+    patternProperties:
+      '^port(@[0-7])?$':
+        description: Input connections from RISC-V trace component
+        $ref: /schemas/graph.yaml#/properties/port
+

Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml line 54

Quoted 10 lines

Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml new file +10 -0

+  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

Is no in or out ports valid? If not, you need:

anyOf:
- required: [ in-ports ]
- required: [ out-ports ]

Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml line 62

Quoted 9 lines

Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml new file +8 -0

+
+unevaluatedProperties: false
+
+examples:
+  - |
+    // Example 1 (Per-hart encoder and ramsink components):
+
+    encoder@c000000 {

trace@...?

Node names should be generic and a given compatible should only have 1 possible node name. (Yes, we failed to do this on Arm coresight stuff.)

Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml line 65

Quoted 3 lines

Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml new file +3 -0

+      compatible = "qemu,trace-component", "riscv,trace-component";
+      reg = <0xc000000 0x1000>;
+      cpus = <&CPU0>;

blank line between properties and child nodes.

Quoted 43 lines

Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml new file +42 -0

+      out-ports {
+        port {
+          CPU0_ENCODER_OUTPUT: endpoint {
+            remote-endpoint = <&CPU0_RAMSINK_INPUT>;
+          };
+        };
+      };
+    };
+
+    ramsink@c001000 {
+      compatible = "qemu,trace-component", "riscv,trace-component";
+      reg = <0xc001000 0x1000>;
+      cpus = <&CPU0>;
+      in-ports {
+        port {
+          CPU0_RAMSINK_INPUT: endpoint {
+          };
+        };
+      };
+    };
+
+    encoder@c002000 {
+      compatible = "qemu,trace-component", "riscv,trace-component";
+      reg = <0xc002000 0x1000>;
+      cpus = <&CPU1>;
+      out-ports {
+        port {
+          CPU1_ENCODER_OUTPUT: endpoint {
+            remote-endpoint = <&CPU1_RAMSINK_INPUT>;
+          };
+        };
+      };
+    };
+
+    ramsink@c003000 {
+      compatible = "qemu,trace-component", "riscv,trace-component";
+      reg = <0xc003000 0x1000>;
+      cpus = <&CPU1>;
+      in-ports {
+        port {
+          CPU1_RAMSINK_INPUT: endpoint {
+          };

Quoted 8 lines

Documentation/devicetree/bindings/riscv/riscv,trace-component.yaml new file +5 -1

+        };
+      };
+    };
+
+...
--

2.43.0

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_Ratified/RISC-V-Trace-Control-Interface.pdf

Co-developed-by Mayuresh Chitale <[email protected]>

Signed-off-by Mayuresh Chitale <[email protected]>

Signed-off-by Anup Patel <[email protected]>

---
  drivers/Makefile                             |   1 +
  drivers/hwtracing/Kconfig                    |   2 +
  drivers/hwtracing/rvtrace/Kconfig            |  16 +
  drivers/hwtracing/rvtrace/Makefile           |   4 +
  drivers/hwtracing/rvtrace/rvtrace-core.c     | 501 +++++++++++++++++++
  drivers/hwtracing/rvtrace/rvtrace-platform.c | 192 +++++++
  include/linux/rvtrace.h                      | 280 +++++++++++
  7 files changed, 996 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

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_Ratified/RISC-V-Trace-Control-Interface.pdf

Co-developed-by Mayuresh Chitale <[email protected]>

Signed-off-by Mayuresh Chitale <[email protected]>

Signed-off-by Anup Patel <[email protected]>

---
  drivers/Makefile                             |   1 +
  drivers/hwtracing/Kconfig                    |   2 +
  drivers/hwtracing/rvtrace/Kconfig            |  16 +
  drivers/hwtracing/rvtrace/Makefile           |   4 +
  drivers/hwtracing/rvtrace/rvtrace-core.c     | 501 +++++++++++++++++++
  drivers/hwtracing/rvtrace/rvtrace-platform.c | 192 +++++++
  include/linux/rvtrace.h                      | 280 +++++++++++
  7 files changed, 996 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

drivers/Makefile +1 -0

index 8e1ffa4358d5..3c0c3bd40a89 100644
@@ -178,6 +178,7 @@ obj-$(CONFIG_CORESIGHT)		+= hwtracing/coresight/
  obj-y				+= hwtracing/intel_th/
  obj-$(CONFIG_STM)		+= hwtracing/stm/
  obj-$(CONFIG_HISI_PTT)		+= hwtracing/ptt/
+obj-$(CONFIG_RVTRACE)		+= hwtracing/rvtrace/
  obj-y				+= android/
  obj-$(CONFIG_NVMEM)		+= nvmem/
  obj-$(CONFIG_FPGA)		+= fpga/

drivers/hwtracing/Kconfig +2 -0

index 911ee977103c..daeb38fe332d 100644
@@ -7,4 +7,6 @@ source "drivers/hwtracing/intel_th/Kconfig"
 
  source "drivers/hwtracing/ptt/Kconfig"
 
+source "drivers/hwtracing/rvtrace/Kconfig"
+
  endmenu

drivers/hwtracing/rvtrace/Kconfig new file +16 -0

new file mode 100644
index 000000000000..f8f6feea1953
@@ -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.

drivers/hwtracing/rvtrace/Makefile new file +4 -0

new file mode 100644
index 000000000000..988525a379cf
@@ -0,0 +1,4 @@
+# SPDX-License-Identifier: GPL-2.0
+
+obj-$(CONFIG_RVTRACE) += rvtrace.o
+rvtrace-y := rvtrace-core.o rvtrace-platform.o

drivers/hwtracing/rvtrace/rvtrace-core.c new file +172 -0

new file mode 100644
index 000000000000..32fda1647b39
@@ -0,0 +1,501 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2025 Ventana Micro Systems Inc.
+ */
+
+#include <linux/cpumask.h>
+#include <linux/delay.h>
+#include <linux/export.h>
+#include <linux/idr.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/percpu.h>
+#include <linux/rvtrace.h>
+
+/* 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_TYPE_MAX];
+
+static int rvtrace_alloc_type_idx(struct rvtrace_component *comp)
+{
+	struct rvtrace_type_idx *rvidx = &rvtrace_type_idx_array[comp->id.type];
+	int idx;
+
+	mutex_lock(&rvidx->lock);
+	idx = idr_alloc(&rvidx->idr, comp, 0, 0, GFP_KERNEL);
+	mutex_unlock(&rvidx->lock);
+	if (idx < 0)
+		return idx;
+
+	comp->type_idx = idx;
+	return 0;
+}
+
+static void rvtrace_free_type_idx(struct rvtrace_component *comp)
+{
+	struct rvtrace_type_idx *rvidx = &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 = 0; i < RVTRACE_COMPONENT_TYPE_MAX; i++) {
+		rvidx = &rvtrace_type_idx_array[i];
+		mutex_init(&rvidx->lock);
+		idr_init(&rvidx->idr);
+	}
+}
+
+const struct rvtrace_component_id *rvtrace_match_id(struct rvtrace_component *comp,
+						    const struct rvtrace_component_id *ids)
+{
+	u32 comp_maj, comp_min, id_maj, id_min;
+	const struct rvtrace_component_id *id;
+
+	for (id = ids; id->version && id->type; id++) {
+		if (comp->id.type != id->type)
+			return NULL;
+
+		id_maj = rvtrace_component_version_major(id->version);
+		id_min = rvtrace_component_version_minor(id->version);
+		comp_maj = rvtrace_component_version_major(comp->id.version);
+		comp_min = rvtrace_component_version_minor(comp->id.version);
+		if (comp_maj > id_maj)
+			continue;
+
+		/* Refer to Ch. 5 'Versioning of components of the Trace Control spec. */
+		if (comp_maj < id_maj)
+			dev_warn(&comp->dev, "Older component with major version %d\n", comp_maj);
+		if (comp_min == 15)
+			dev_warn(&comp->dev, "Experimental component\n");
+		else if (comp_min > id_min)
+			dev_warn(&comp->dev, "Newer component with minor version %d\n", comp_min);
+
+		return id;
+	}
+
+	return NULL;
+}
+EXPORT_SYMBOL_GPL(rvtrace_match_id);
+
+static int rvtrace_match_device(struct device *dev, const struct device_driver *drv)
+{
+	const struct rvtrace_driver *rtdrv = to_rvtrace_driver(drv);
+	struct rvtrace_component *comp = 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 = to_rvtrace_driver(dev->driver);
+	struct rvtrace_component *comp = to_rvtrace_component(dev);
+	int ret = -ENODEV;
+
+	if (!rtdrv->probe)
+		return ret;
+
+	ret = rtdrv->probe(comp);
+	if (!ret)
+		comp->ready = true;
+
+	return ret;
+}
+
+static void rvtrace_remove(struct device *dev)
+{
+	const struct rvtrace_driver *rtdrv = to_rvtrace_driver(dev->driver);
+	struct rvtrace_component *comp = to_rvtrace_component(dev);
+
+	comp->ready = false;
+	if (rtdrv->remove)
+		rtdrv->remove(comp);
+}
+
+const struct bus_type rvtrace_bustype = {
+	.name	= "rvtrace",
+	.match	= rvtrace_match_device,
+	.probe	= rvtrace_probe,
+	.remove	= 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 = to_rvtrace_component(dev);
+	struct rvtrace_fwnode_match_data *d = data;
+
+	if (device_match_fwnode(&comp->dev, d->fwnode)) {
+		d->match = comp;
+		return 1;
+	}
+
+	return 0;
+}
+
+struct rvtrace_component *rvtrace_find_by_fwnode(struct fwnode_handle *fwnode)
+{
+	struct rvtrace_fwnode_match_data d = { .fwnode = fwnode, .match = NULL };
+	int ret;
+
+	ret = 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)

drivers/hwtracing/rvtrace/rvtrace-core.c new file +5 -0

+
+	return (i < 0) ? -ETIMEDOUT : 0;
+}
+EXPORT_SYMBOL_GPL(rvtrace_poll_bit);
+

drivers/hwtracing/rvtrace/rvtrace-core.c new file +140 -0

+}
+EXPORT_SYMBOL_GPL(rvtrace_enable_component);
+
+int rvtrace_disable_component(struct rvtrace_component *comp)
+{
+	u32 val;
+
+	val = rvtrace_read32(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET);
+	val &= ~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 = to_rvtrace_component(dev);
+	struct rvtrace_platform_data *pdata = comp->pdata;
+	struct rvtrace_connection *conn = data;
+	int i;
+
+	if (device_match_fwnode(&comp->dev, conn->dest_fwnode)) {
+		for (i = 0; i < pdata->nr_inconns; i++) {
+			if (pdata->inconns[i] != conn)
+				continue;
+			pdata->inconns[i] = NULL;
+			return 1;
+		}
+	}
+
+	return 0;
+}
+
+static void rvtrace_cleanup_inconns_from_outconns(struct rvtrace_component *comp)
+{
+	struct rvtrace_platform_data *pdata = comp->pdata;
+	struct rvtrace_connection *conn;
+	int i;
+
+	lockdep_assert_held(&rvtrace_mutex);
+
+	for (i = 0; i < pdata->nr_outconns; i++) {
+		conn = 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 = to_rvtrace_component(dev);
+	struct rvtrace_platform_data *pdata = comp->pdata;
+	struct rvtrace_connection *conn = data;
+	int i;
+
+	if (device_match_fwnode(&comp->dev, conn->dest_fwnode)) {
+		for (i = 0; i < pdata->nr_inconns; i++) {
+			if (pdata->inconns[i])
+				continue;
+			pdata->inconns[i] = conn;
+			return 1;
+		}
+	}
+
+	return 0;
+}
+
+static int rvtrace_setup_inconns_from_outconns(struct rvtrace_component *comp)
+{
+	struct rvtrace_platform_data *pdata = comp->pdata;
+	struct rvtrace_connection *conn;
+	int i, ret;
+
+	lockdep_assert_held(&rvtrace_mutex);
+
+	for (i = 0; i < pdata->nr_outconns; i++) {
+		conn = pdata->outconns[i];
+		ret = bus_for_each_dev(&rvtrace_bustype, NULL, conn, rvtrace_setup_inconn);
+		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 = 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 = 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_platform_data *pdata)
+{
+	struct rvtrace_connection *conn;
+	struct rvtrace_component *comp;
+	u32 impl, type, major, minor;
+	int i, ret = 0;
+
+	if (!pdata || !pdata->dev) {
+		ret = -EINVAL;
+		goto err_out;
+	}
+
+	for (i = 0; i < pdata->nr_inconns; i++) {
+		if (pdata->inconns[i]) {
+			ret = -EINVAL;
+			goto err_out;

drivers/hwtracing/rvtrace/rvtrace-core.c new file +154 -0

+		}
+	}
+
+	ret = rvtrace_component_reset(pdata);
+	if (ret)
+		goto err_out;
+
+	impl = rvtrace_read32(pdata, RVTRACE_COMPONENT_IMPL_OFFSET);
+	type = (impl >> RVTRACE_COMPONENT_IMPL_TYPE_SHIFT) &
+		RVTRACE_COMPONENT_IMPL_TYPE_MASK;
+	major = (impl >> RVTRACE_COMPONENT_IMPL_VERMAJOR_SHIFT) &
+		RVTRACE_COMPONENT_IMPL_VERMAJOR_MASK;
+	minor = (impl >> RVTRACE_COMPONENT_IMPL_VERMINOR_SHIFT) &
+		RVTRACE_COMPONENT_IMPL_VERMINOR_MASK;
+
+	if (pdata->bound_cpu >= 0 && !cpu_present(pdata->bound_cpu)) {
+		ret = -EINVAL;
+		goto err_out;
+	}
+	if (type == RVTRACE_COMPONENT_TYPE_ENCODER && pdata->bound_cpu < 0) {
+		ret = -EINVAL;
+		goto err_out;
+	}
+
+	comp = kzalloc(sizeof(*comp), GFP_KERNEL);
+	if (!comp) {
+		ret = -ENOMEM;
+		goto err_out;
+	}
+	comp->pdata = pdata;
+	comp->id.type = type;
+	comp->id.version = rvtrace_component_mkversion(major, minor);
+	ret = rvtrace_alloc_type_idx(comp);
+	if (ret) {
+		kfree(comp);
+		goto err_out;
+	}
+
+	comp->dev.parent = pdata->dev;
+	comp->dev.coherent_dma_mask = pdata->dev->coherent_dma_mask;
+	comp->dev.release = rvtrace_component_release;
+	comp->dev.bus = &rvtrace_bustype;
+	comp->dev.fwnode = 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 = device_register(&comp->dev);
+	if (ret) {
+		put_device(&comp->dev);
+		goto err_out_unlock;
+	}
+
+	for (i = 0; i < pdata->nr_outconns; i++) {
+		conn = pdata->outconns[i];
+		conn->src_comp = comp;
+	}
+
+	ret = rvtrace_setup_inconns_from_outconns(comp);
+	if (ret < 0) {
+		device_unregister(&comp->dev);
+		goto err_out_unlock;
+	}
+
+	if (comp->id.type == RVTRACE_COMPONENT_TYPE_ENCODER) {
+		rvtrace_get_component(comp);
+		per_cpu(rvtrace_cpu_encoder, comp->pdata->bound_cpu) = 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 == RVTRACE_COMPONENT_TYPE_ENCODER) {
+		c = per_cpu(rvtrace_cpu_encoder, comp->pdata->bound_cpu);
+		per_cpu(rvtrace_cpu_encoder, comp->pdata->bound_cpu) = 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 = owner;
+	rtdrv->driver.bus = &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 = bus_register(&rvtrace_bustype);
+	if (ret)
+		return ret;
+
+	ret = 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);

drivers/hwtracing/rvtrace/rvtrace-platform.c new file +38 -0

new file mode 100644
index 000000000000..6eb362880e5c
@@ -0,0 +1,192 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2025 Ventana Micro Systems Inc.
+ */
+
+#include <linux/device.h>
+#include <linux/io.h>
+#include <linux/of.h>
+#include <linux/of_graph.h>
+#include <linux/platform_device.h>
+#include <linux/property.h>
+#include <linux/rvtrace.h>
+#include <linux/types.h>
+
+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 = 0, i = 0;
+
+	parent = of_get_child_by_name(dev_of_node(pdata->dev), "out-ports");
+	if (!parent)
+		return 0;
+
+	pdata->nr_outconns = of_graph_get_endpoint_count(parent);
+	pdata->outconns = devm_kcalloc(pdata->dev, pdata->nr_outconns,
+				       sizeof(*pdata->outconns), GFP_KERNEL);
+	if (!pdata->outconns) {
+		ret = -ENOMEM;
+		goto done;
+	}
+
+	for_each_endpoint_of_node(parent, ep_node) {
+		conn = devm_kzalloc(pdata->dev, sizeof(*conn), GFP_KERNEL);
+		if (!conn) {
+			of_node_put(ep_node);
+			ret = -ENOMEM;

drivers/hwtracing/rvtrace/rvtrace-platform.c new file +138 -0

+
+		ret = of_graph_parse_endpoint(rep_node, &rep);
+		if (ret) {
+			of_node_put(ep_node);
+			break;
+		}
+
+		conn->src_port = ep.port;
+		conn->src_fwnode = dev_fwnode(pdata->dev);
+		/* The 'src_comp' is set by rvtrace_register_component() */
+		conn->src_comp = NULL;
+		conn->dest_port = rep.port;
+		conn->dest_fwnode = of_fwnode_handle(rdev_node);
+		fwnode_handle_get(conn->dest_fwnode);
+		conn->dest_comp = rvtrace_find_by_fwnode(conn->dest_fwnode);
+		if (!conn->dest_comp) {
+			ret = -EPROBE_DEFER;
+			of_node_put(ep_node);
+			break;
+		}
+
+		pdata->outconns[i] = conn;
+		i++;
+	}
+
+done:
+	if (ret) {
+		for (i = 0; i < pdata->nr_outconns; i++) {
+			conn = pdata->outconns[i];
+			if (conn && conn->dest_fwnode)
+				fwnode_handle_put(conn->dest_fwnode);
+		}
+	}
+	of_node_put(parent);
+	return ret;
+}
+
+static int rvtrace_of_parse_inconns(struct rvtrace_platform_data *pdata)
+{
+	struct device_node *parent;
+	int ret = 0;
+
+	parent = of_get_child_by_name(dev_of_node(pdata->dev), "in-ports");
+	if (!parent)
+		return 0;
+
+	pdata->nr_inconns = of_graph_get_endpoint_count(parent);
+	pdata->inconns = devm_kcalloc(pdata->dev, pdata->nr_inconns,
+				      sizeof(*pdata->inconns), GFP_KERNEL);
+	if (!pdata->inconns)
+		ret = -ENOMEM;
+
+	of_node_put(parent);
+	return ret;
+}
+
+static int rvtrace_platform_probe(struct platform_device *pdev)
+{
+	struct rvtrace_platform_data *pdata;
+	struct device *dev = &pdev->dev;
+	struct rvtrace_component *comp;
+	struct device_node *node;
+	struct resource *res;
+	int ret;
+
+	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
+	if (!pdata)
+		return -ENOMEM;
+	pdata->dev = dev;
+	pdata->impid = RVTRACE_COMPONENT_IMPID_UNKNOWN;
+
+	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	if (!res)
+		return -EINVAL;
+
+	pdata->io_mem = true;
+	pdata->base = 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 = -1;
+	node = of_parse_phandle(dev_of_node(dev), "cpus", 0);
+	if (node) {
+		ret = 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 = ret;
+	}
+
+	/* Default control poll timeout */
+	pdata->control_poll_timeout_usecs = 10;
+
+	ret = rvtrace_of_parse_outconns(pdata);
+	if (ret)
+		return dev_err_probe(dev, ret, "failed to parse output connections\n");
+
+	ret = rvtrace_of_parse_inconns(pdata);
+	if (ret)
+		return dev_err_probe(dev, ret, "failed to parse input connections\n");
+
+	comp = 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 = platform_get_drvdata(pdev);
+	struct rvtrace_platform_data *pdata = comp->pdata;
+	struct rvtrace_connection *conn;
+	int i;
+
+	for (i = 0; i < pdata->nr_outconns; i++) {
+		conn = pdata->outconns[i];
+		if (conn && conn->dest_fwnode)
+			fwnode_handle_put(conn->dest_fwnode);
+	}
+
+	rvtrace_unregister_component(comp);
+}
+
+static const struct of_device_id rvtrace_platform_match[] = {
+	{ .compatible = "riscv,trace-component" },
+	{}
+};
+
+struct platform_driver rvtrace_platform_driver = {
+	.driver = {
+		.name		= "rvtrace",
+		.of_match_table	= rvtrace_platform_match,
+	},
+	.probe = rvtrace_platform_probe,
+	.remove = rvtrace_platform_remove,
+};

include/linux/rvtrace.h new file +280 -0

new file mode 100644
index 000000000000..e8e055ad6583
@@ -0,0 +1,280 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (c) 2025 Ventana Micro Systems Inc.
+ */
+
+#ifndef __LINUX_RVTRACE_H__
+#define __LINUX_RVTRACE_H__
+
+#include <linux/device.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/property.h>
+#include <linux/types.h>
+
+/* Control register common across all RISC-V trace components */
+#define RVTRACE_COMPONENT_CTRL_OFFSET		0x000
+#define RVTRACE_COMPONENT_CTRL_ACTIVE_MASK	0x1
+#define RVTRACE_COMPONENT_CTRL_ACTIVE_SHIFT	0
+#define RVTRACE_COMPONENT_CTRL_ENABLE_MASK	0x1
+#define RVTRACE_COMPONENT_CTRL_ENABLE_SHIFT	1
+#define RVTRACE_COMPONENT_CTRL_EMPTY_SHIFT	3
+
+/* Implementation register common across all RISC-V trace components */
+#define RVTRACE_COMPONENT_IMPL_OFFSET		0x004
+#define RVTRACE_COMPONENT_IMPL_VERMAJOR_MASK	0xf
+#define RVTRACE_COMPONENT_IMPL_VERMAJOR_SHIFT	0
+#define RVTRACE_COMPONENT_IMPL_VERMINOR_MASK	0xf
+#define RVTRACE_COMPONENT_IMPL_VERMINOR_SHIFT	4
+#define RVTRACE_COMPONENT_IMPL_TYPE_MASK	0xf
+#define RVTRACE_COMPONENT_IMPL_TYPE_SHIFT	8
+
+/* Possible component types defined by the RISC-V Trace Control Interface */
+enum rvtrace_component_type {
+	RVTRACE_COMPONENT_TYPE_RESV0,
+	RVTRACE_COMPONENT_TYPE_ENCODER, /* 0x1 */
+	RVTRACE_COMPONENT_TYPE_RESV2,
+	RVTRACE_COMPONENT_TYPE_RESV3,
+	RVTRACE_COMPONENT_TYPE_RESV4,
+	RVTRACE_COMPONENT_TYPE_RESV5,
+	RVTRACE_COMPONENT_TYPE_RESV6,
+	RVTRACE_COMPONENT_TYPE_RESV7,
+	RVTRACE_COMPONENT_TYPE_FUNNEL, /* 0x8 */
+	RVTRACE_COMPONENT_TYPE_RAMSINK, /* 0x9 */
+	RVTRACE_COMPONENT_TYPE_PIBSINK, /* 0xA */
+	RVTRACE_COMPONENT_TYPE_RESV11,
+	RVTRACE_COMPONENT_TYPE_RESV12,
+	RVTRACE_COMPONENT_TYPE_RESV13,
+	RVTRACE_COMPONENT_TYPE_ATBBRIDGE, /* 0xE */
+	RVTRACE_COMPONENT_TYPE_RESV15,
+	RVTRACE_COMPONENT_TYPE_MAX
+};
+
+/* Encoding/decoding macros for RISC-V trace component version */
+#define rvtrace_component_version_major(__version)	\
+	(((__version) >> 16) & 0xffff)
+#define rvtrace_component_version_minor(__version)	\
+	((__version) & 0xffff)
+#define rvtrace_component_mkversion(__major, __minor)	\
+	((((__major) & 0xffff) << 16) |	((__minor) & 0xffff))
+
+/*
+ * Possible component implementation IDs discovered from DT or ACPI
+ * shared across the RISC-V trace drivers to infer trace parameters,
+ * quirks, and work-arounds. These component implementation IDs are
+ * internal to Linux and must not be exposed to user-space.
+ *
+ * The component implementation ID should be named as follows:
+ *    RVTRACE_COMPONENT_IMPID_<vendor>_<part>
+ */
+enum rvtrace_component_impid {
+	RVTRACE_COMPONENT_IMPID_UNKNOWN,
+	RVTRACE_COMPONENT_IMPID_MAX
+};
+
+/**
+ * struct rvtrace_connection - Representation of a physical connection between
+ * 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 component
+ * discovered from DT or ACPI.
+ * @dev:         Parent device.
+ * @impid:       Component implementation ID
+ * @io_mem:      Flag showing whether component registers are memory mapped.
+ * @base:        If io_mem == true then base address of the memory mapped registers.
+ * @read:        If io_mem == false then read register from the given "offset".
+ * @write:       If io_mem == 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 component
+ *               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 *pdata, 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, u32 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 *pdata,
+					   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 trace 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 successfully
+ */
+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 rvtrace_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_component *comp,
+						    const struct rvtrace_component_id *ids);
+struct rvtrace_component *rvtrace_find_by_fwnode(struct fwnode_handle *fwnode);
+
+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_platform_data *pdata);
+void rvtrace_unregister_component(struct rvtrace_component *comp);
+
+/**
+ * struct rvtrace_driver - Representation of a RISC-V trace driver
+ * id_table: Table to match components handled by the driver
+ * probe:    Driver probe() function
+ * remove:   Driver remove() function
+ * driver:   Device driver instance
+ */
+struct rvtrace_driver {
+	const struct rvtrace_component_id *id_table;
+	int			(*probe)(struct rvtrace_component *comp);
+	void			(*remove)(struct rvtrace_component *comp);
+	struct device_driver	driver;
+};
+
+#define to_rvtrace_driver(__drv)   \
+	((__drv) ? container_of_const((__drv), struct rvtrace_driver, driver) : NULL)
+
+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_MODULE, driver)
+static inline void rvtrace_unregister_driver(struct rvtrace_driver *rtdrv)
+{
+	if (rtdrv)
+		driver_unregister(&rtdrv->driver);
+}
+
+static inline int rvtrace_comp_is_empty(struct rvtrace_component *comp)
+{
+	return rvtrace_poll_bit(comp->pdata, RVTRACE_COMPONENT_CTRL_OFFSET,
+				RVTRACE_COMPONENT_CTRL_EMPTY_SHIFT, 1,
+				comp->pdata->control_poll_timeout_usecs);
+}
+
+#endif

From: Mayuresh Chitale <[email protected]>

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 <[email protected]>

Signed-off-by Anup Patel <[email protected]>

Signed-off-by Mayuresh Chitale <[email protected]>

---
  drivers/hwtracing/rvtrace/Kconfig           |   9 +
  drivers/hwtracing/rvtrace/Makefile          |   1 +
  drivers/hwtracing/rvtrace/rvtrace-ramsink.c | 262 ++++++++++++++++++++
  3 files changed, 272 insertions(+)

create mode 100644 drivers/hwtracing/rvtrace/rvtrace-ramsink.c

drivers/hwtracing/rvtrace/Kconfig +9 -0

index ba35c05f3f54..0577f9acb858 100644
@@ -21,3 +21,12 @@ config RVTRACE_ENCODER
  	default y
  	help
  	  This driver provides support for RISC-V Trace Encoder component.
+
+config RVTRACE_RAMSINK
+	tristate "RISC-V Trace Ramsink driver"
+	depends on RVTRACE
+	select DMA_SHARED_BUFFER
+	default y
+	help
+	  This driver provides support for Risc-V E-Trace Ramsink
+	  component.

drivers/hwtracing/rvtrace/Makefile +1 -0

index f320693a1fc5..122e575da9fb 100644
@@ -3,3 +3,4 @@
  obj-$(CONFIG_RVTRACE) += rvtrace.o
  rvtrace-y := rvtrace-core.o rvtrace-platform.o
  obj-$(CONFIG_RVTRACE_ENCODER) += rvtrace-encoder.o
+obj-$(CONFIG_RVTRACE_RAMSINK) += rvtrace-ramsink.o

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +9 -0

new file mode 100644
index 000000000000..676344c9387c
@@ -0,0 +1,262 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2025 Ventana Micro Systems Inc.
+ */
+
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/property.h>
+#include <linux/dma-mapping.h>

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +15 -0

+#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;

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +30 -0

+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 = src->base + src->cur;
+		dst_addr = dst->base + dst->cur;
+
+		if (dst->len - dst->cur < src->size)
+			bytes_dst = dst->len - dst->cur;
+		else
+			bytes_dst = src->size;
+		if (src->len - src->cur < src->size)
+			bytes_src = src->len - src->cur;
+		else
+			bytes_src = src->size;
+		bytes = bytes_dst < bytes_src ? bytes_dst : bytes_src;
+		memcpy(dst_addr, src_addr, bytes);
+		dst->cur = (dst->cur + bytes) % dst->len;
+		src->cur = (src->cur + bytes) % src->len;
+		src->size -= bytes;
+	}
+}
+
+static size_t rvtrace_ramsink_copyto_auxbuf(struct rvtrace_component *comp,
+					    struct rvtrace_perf_auxbuf *buf)
+{
+	struct rvtrace_ramsink_priv *priv = dev_get_drvdata(&comp->dev);
+	struct trace_buf src, dst;

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +33 -0

+
+	dst.base = buf->base;
+	dst.len = buf->length;
+	dst.cur = buf->pos;
+
+	src.base = priv->va;
+	src.len = priv->end - priv->start;
+	if (buf_cur_head > priv->prev_head) {
+		src.size = buf_cur_head - priv->prev_head;
+	} else {
+		src.size = priv->end - priv->prev_head;
+		src.size += buf_cur_head - priv->start;
+	}
+
+	src.cur = buf_cur_head - priv->start;
+	size = src.size;
+	tbuf_to_pbuf_copy(&src, &dst);
+	buf->pos = dst.cur;
+	priv->prev_head = buf_cur_head;
+
+	return size;
+}
+
+static int rvtrace_ramsink_setup_buf(struct rvtrace_component *comp)
+{
+	struct rvtrace_ramsink_priv *priv = dev_get_drvdata(&comp->dev);
+	u64 start_min, limit_max, end;
+	u32 low, high;
+
+	/* Probe min and max values for start and limit registers */
+	rvtrace_write32(comp->pdata, 0, RVTRACE_RAMSINK_STARTLOW_OFF);
+	rvtrace_write32(comp->pdata, 0, RVTRACE_RAMSINK_STARTHIGH_OFF);
+	low = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_STARTLOW_OFF);

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +12 -0

+		dev_warn(&comp->dev, "Ramsink start address updated from %llx to %llx\n",
+			 priv->start, start_min);
+		priv->va += start_min - priv->start;
+		priv->start = start_min;
+	}
+
+	priv->prev_head = priv->start;
+	priv->end = priv->start + priv->size;
+	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);

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +37 -0

+
+static int rvtrace_ramsink_setup(struct rvtrace_component *comp)
+{
+	struct device *pdev = comp->pdata->dev;
+	struct rvtrace_ramsink_priv *priv;
+
+	priv = devm_kzalloc(&comp->dev, sizeof(*priv), GFP_KERNEL);
+	if (!priv)
+		return -ENOMEM;
+
+	dev_set_drvdata(&comp->dev, priv);
+
+	/* Derive RAM sink memory size based on component implementation ID */
+	switch (comp->pdata->impid) {
+	default:
+		priv->size = SZ_1M;
+		break;
+	}
+
+	priv->va = dma_alloc_coherent(pdev, priv->size, &priv->start, GFP_KERNEL);
+	if (!priv->va)
+		return -ENOMEM;
+
+	return rvtrace_ramsink_setup_buf(comp);
+}
+
+static void rvtrace_ramsink_cleanup(struct rvtrace_component *comp)
+{
+	struct rvtrace_ramsink_priv *priv = 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;
+

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +11 -0

+
+static void rvtrace_ramsink_remove(struct rvtrace_component *comp)
+{
+	int ret;
+
+	ret = rvtrace_disable_component(comp);
+	if (ret)
+		dev_err(&comp->dev, "failed to disable ramsink.\n");
+
+	rvtrace_ramsink_cleanup(comp);
+}

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +15 -0

+	.stop = rvtrace_ramsink_stop,
+	.probe = rvtrace_ramsink_probe,
+	.remove = rvtrace_ramsink_remove,
+	.driver = {
+		.name = "rvtrace-ramsink",
+	},
+};
+
+static int __init rvtrace_ramsink_init(void)
+{
+	return rvtrace_register_driver(&rvtrace_ramsink_driver);
+}
+
+static void __exit rvtrace_ramsink_exit(void)
+{

Hi Anup,

My comments below:

Quoted 56 lines · Anup Patel

From: Mayuresh Chitale <[email protected]>

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 <[email protected]>

Signed-off-by Anup Patel <[email protected]>

Signed-off-by Mayuresh Chitale <[email protected]>

---
  drivers/hwtracing/rvtrace/Kconfig           |   9 +
  drivers/hwtracing/rvtrace/Makefile          |   1 +
  drivers/hwtracing/rvtrace/rvtrace-ramsink.c | 262 ++++++++++++++++++++
  3 files changed, 272 insertions(+)

create mode 100644 drivers/hwtracing/rvtrace/rvtrace-ramsink.c

drivers/hwtracing/rvtrace/Kconfig +9 -0

index ba35c05f3f54..0577f9acb858 100644
@@ -21,3 +21,12 @@ config RVTRACE_ENCODER
      default y
      help
        This driver provides support for RISC-V Trace Encoder component.
+
+config RVTRACE_RAMSINK
+     tristate "RISC-V Trace Ramsink driver"
+     depends on RVTRACE
+     select DMA_SHARED_BUFFER
+     default y
+     help
+       This driver provides support for Risc-V E-Trace Ramsink
+       component.

drivers/hwtracing/rvtrace/Makefile +1 -0

index f320693a1fc5..122e575da9fb 100644
@@ -3,3 +3,4 @@
  obj-$(CONFIG_RVTRACE) += rvtrace.o
  rvtrace-y := rvtrace-core.o rvtrace-platform.o
  obj-$(CONFIG_RVTRACE_ENCODER) += rvtrace-encoder.o
+obj-$(CONFIG_RVTRACE_RAMSINK) += rvtrace-ramsink.o

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +9 -0

new file mode 100644
index 000000000000..676344c9387c
@@ -0,0 +1,262 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2025 Ventana Micro Systems Inc.
+ */
+
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/property.h>
+#include <linux/dma-mapping.h>

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 19

Quoted 10 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +10 -0

+#include <linux/rvtrace.h>
+#include <linux/types.h>
+#include <linux/sizes.h>
+
+#define RVTRACE_RAMSINK_STARTLOW_OFF         0x010
+#define RVTRACE_RAMSINK_STARTHIGH_OFF                0x014
+#define RVTRACE_RAMSINK_LIMITLOW_OFF         0x018
+#define RVTRACE_RAMSINK_LIMITHIGH_OFF                0x01c
+#define RVTRACE_RAMSINK_WPLOW_OFF            0x020
+#define   RVTRACE_RAMSINK_WPLOW_WRAP         0x1

nit: wrong spacing

Quoted 22 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +22 -0

+#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;
+     long cur;
+     size_t len;
+};
+
+static int rvtrace_ramsink_stop(struct rvtrace_component *comp)
+{

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 44

Quoted 3 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +3 -0

+     return rvtrace_comp_is_empty(comp);
+}
+

We should first set trRamEnable to 0, poll it, then poll trRamEmpty. It's essentially the same as encoder, so perhaps move it to core.c. Here we're just checking whether it's empty, which is wrong. We're also doing similar things in encoder.c Should fix that as well.

Quoted 38 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +37 -0

+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 = src->base + src->cur;
+             dst_addr = dst->base + dst->cur;
+
+             if (dst->len - dst->cur < src->size)
+                     bytes_dst = dst->len - dst->cur;
+             else
+                     bytes_dst = src->size;
+             if (src->len - src->cur < src->size)
+                     bytes_src = src->len - src->cur;
+             else
+                     bytes_src = src->size;
+             bytes = bytes_dst < bytes_src ? bytes_dst : bytes_src;
+             memcpy(dst_addr, src_addr, bytes);
+             dst->cur = (dst->cur + bytes) % dst->len;
+             src->cur = (src->cur + bytes) % src->len;
+             src->size -= bytes;
+     }
+}
+
+static size_t rvtrace_ramsink_copyto_auxbuf(struct rvtrace_component *comp,
+                                         struct rvtrace_perf_auxbuf *buf)
+{
+     struct rvtrace_ramsink_priv *priv = dev_get_drvdata(&comp->dev);
+     struct trace_buf src, dst;
+     u32 wp_low, wp_high;
+     u64 buf_cur_head;
+     size_t size;
+
+     wp_low = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_WPLOW_OFF);
+     wp_high = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_WPHIGH_OFF);
+     buf_cur_head = (u64)(wp_high) << 32 | (wp_low & ~RVTRACE_RAMSINK_WPLOW_WRAP);

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 84

Quoted 3 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +3 -0

+
+     if (buf_cur_head == priv->prev_head)
+             return 0;

cur_head == prev_head could mean that we've wrapped around and stopped at the exact position. Thus, we need to check for the wrapped around bit. If set, then this case can be merged into buf_cur_head <= priv->prev_head below.

For cur_head > prev_head case, we also need to check for wrap-around. If wrapped-around, we actually filled the entire buffer, not just cur - prev We also should consider the possibility that the buffer has been wrapped around multiple times. In all cases, maintaining a prev_head seems to complicate things, so why don't we just reset the WP to priv->start each time we start the ramsink component and get rid of prev_head? This way, we'll always have cur >= start, and depending on wrapped bit, we either get the whole buffer, or cur - start.

Quoted 39 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +37 -0

+
+     dst.base = buf->base;
+     dst.len = buf->length;
+     dst.cur = buf->pos;
+
+     src.base = priv->va;
+     src.len = priv->end - priv->start;
+     if (buf_cur_head > priv->prev_head) {
+             src.size = buf_cur_head - priv->prev_head;
+     } else {
+             src.size = priv->end - priv->prev_head;
+             src.size += buf_cur_head - priv->start;
+     }
+
+     src.cur = buf_cur_head - priv->start;
+     size = src.size;
+     tbuf_to_pbuf_copy(&src, &dst);
+     buf->pos = dst.cur;
+     priv->prev_head = buf_cur_head;
+
+     return size;
+}
+
+static int rvtrace_ramsink_setup_buf(struct rvtrace_component *comp)
+{
+     struct rvtrace_ramsink_priv *priv = dev_get_drvdata(&comp->dev);
+     u64 start_min, limit_max, end;
+     u32 low, high;
+
+     /* Probe min and max values for start and limit registers */
+     rvtrace_write32(comp->pdata, 0, RVTRACE_RAMSINK_STARTLOW_OFF);
+     rvtrace_write32(comp->pdata, 0, RVTRACE_RAMSINK_STARTHIGH_OFF);
+     low = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_STARTLOW_OFF);
+     high = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_STARTHIGH_OFF);
+     start_min = (u64)(high) << 32 | low;
+
+     rvtrace_write32(comp->pdata, 0xffffffff, RVTRACE_RAMSINK_LIMITLOW_OFF);

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 127

Quoted 6 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +6 -0

+     rvtrace_write32(comp->pdata, 0xffffffff, RVTRACE_RAMSINK_LIMITHIGH_OFF);
+     low = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_LIMITLOW_OFF);
+     high = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_LIMITHIGH_OFF);
+     limit_max = (u64)(high) << 32 | low;
+
+     if (priv->end < start_min) {

Where was priv->end initialized before this check?

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 133

Quoted 7 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +6 -0

+             dev_err(&comp->dev, "DMA memory not addressable by device\n");
+             return -EINVAL;
+     }
+
+     /* Setup ram sink start addresses */
+     if (priv->start < start_min) {

No checks for start_min >= priv->end?

Quoted 18 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +18 -0

+             dev_warn(&comp->dev, "Ramsink start address updated from %llx to %llx\n",
+                      priv->start, start_min);
+             priv->va += start_min - priv->start;
+             priv->start = start_min;
+     }
+
+     priv->prev_head = priv->start;
+     priv->end = priv->start + priv->size;
+     rvtrace_write32(comp->pdata, lower_32_bits(priv->start), RVTRACE_RAMSINK_STARTLOW_OFF);
+     rvtrace_write32(comp->pdata, upper_32_bits(priv->start), RVTRACE_RAMSINK_STARTHIGH_OFF);
+     rvtrace_write32(comp->pdata, lower_32_bits(priv->start), RVTRACE_RAMSINK_WPLOW_OFF);
+     rvtrace_write32(comp->pdata, upper_32_bits(priv->start), RVTRACE_RAMSINK_WPHIGH_OFF);
+     /* Setup ram sink limit addresses */
+     if (priv->end > limit_max) {
+             dev_warn(&comp->dev, "Ramsink limit address updated from %llx to %llx\n", priv->end,
+                      limit_max);
+             priv->end = limit_max;
+             priv->size = priv->end - priv->start;

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 155

Quoted 4 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +4 -0

+     }
+
+     /* Limit address needs to be set to end - 4 to avoid overflow */
+     end = priv->end - 4;

Should not hard-code 4, instead, do write32(0xfffffff, RamLimit), then ffs(RamLimit) to probe for the the write width, aka, "A" value in Table
47. Typical Trace RAM Sink Configuration in the Spec.

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 165

Quoted 11 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +10 -0

+     rvtrace_write32(comp->pdata, lower_32_bits(end), RVTRACE_RAMSINK_LIMITLOW_OFF);
+     rvtrace_write32(comp->pdata, upper_32_bits(end), RVTRACE_RAMSINK_LIMITHIGH_OFF);
+     low = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_LIMITLOW_OFF);
+     high = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_LIMITHIGH_OFF);
+     end = (u64)(high) << 32 | low;
+     if (end != (priv->end - 4)) {
+             dev_warn(&comp->dev, "Ramsink limit address updated from %llx to %llx\n", priv->end,
+                      end);
+             priv->end = end;
+             priv->size = priv->end - priv->start;

Actually the RamLimit read is not the real limit. It's Limit - "A" (the write width).

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 97

Quoted 4 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +4 -0

+     }
+
+     return 0;
+}

I think overall we should simplify this setup_buf function. For RamStart alone, there're alignment + min_addr requirement, which is very unlikely that the lowest valid address happens to be within the range that dma- allocated in the caller (when you need to adjust priv->start). Thus, to do it properly, we first need to detect the min_addr + alignment *before*

dma-alloc, and pass such requirements into dma-alloc, then depending on what dma-alloc returns, detect the "M" value by interrogating RamLimit. I'm not sure if dma-alloc can be passed a hint address that whatever returned must be higher, and whether it can enforce random alignment, so may be we can just program RamStart/Limit based on what dma-alloc gives and error out if value is not retained. We do however need to probe for write width ("A" value). It's usually 4 or 8, but it does vary per-impl, and remember, the total buffer size is still 1MB, not 1MB - 4 or -8.

Quoted 43 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +42 -0

+
+static int rvtrace_ramsink_setup(struct rvtrace_component *comp)
+{
+     struct device *pdev = comp->pdata->dev;
+     struct rvtrace_ramsink_priv *priv;
+
+     priv = devm_kzalloc(&comp->dev, sizeof(*priv), GFP_KERNEL);
+     if (!priv)
+             return -ENOMEM;
+
+     dev_set_drvdata(&comp->dev, priv);
+
+     /* Derive RAM sink memory size based on component implementation ID */
+     switch (comp->pdata->impid) {
+     default:
+             priv->size = SZ_1M;
+             break;
+     }
+
+     priv->va = dma_alloc_coherent(pdev, priv->size, &priv->start, GFP_KERNEL);
+     if (!priv->va)
+             return -ENOMEM;
+
+     return rvtrace_ramsink_setup_buf(comp);
+}
+
+static void rvtrace_ramsink_cleanup(struct rvtrace_component *comp)
+{
+     struct rvtrace_ramsink_priv *priv = 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 = rvtrace_ramsink_setup(comp);
+     if (ret)
+             return dev_err_probe(&comp->dev, ret, "failed to setup ramsink.\n");
+
+     ret = rvtrace_enable_component(comp);

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 216

Quoted 5 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +5 -0

+     if (ret)
+             return dev_err_probe(&comp->dev, ret, "failed to enable ramsink.\n");
+
+     return ret;
+}

In probe, we should detect and set it to SMEM mode. The default is SRAM mode.

Quoted 17 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +16 -0

+
+static void rvtrace_ramsink_remove(struct rvtrace_component *comp)
+{
+     int ret;
+
+     ret = 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[] = {
+     { .type = RVTRACE_COMPONENT_TYPE_RAMSINK,
+       .version = rvtrace_component_mkversion(1, 0), },
+     {},

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 237

Quoted 5 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +5 -0

+};
+
+static struct rvtrace_driver rvtrace_ramsink_driver = {
+     .id_table = rvtrace_ramsink_ids,
+     .copyto_auxbuf = rvtrace_ramsink_copyto_auxbuf,

Should have a .start function like the encoder (setting trRamEnable), and reset the WP to priv->start, as suggested above.

Quoted 16 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +15 -0

+     .stop = rvtrace_ramsink_stop,
+     .probe = rvtrace_ramsink_probe,
+     .remove = rvtrace_ramsink_remove,
+     .driver = {
+             .name = "rvtrace-ramsink",
+     },
+};
+
+static int __init rvtrace_ramsink_init(void)
+{
+     return rvtrace_register_driver(&rvtrace_ramsink_driver);
+}
+
+static void __exit rvtrace_ramsink_exit(void)
+{

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 262

Quoted 10 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +10 -0

+     rvtrace_unregister_driver(&rvtrace_ramsink_driver);
+}
+
+module_init(rvtrace_ramsink_init);
+module_exit(rvtrace_ramsink_exit);
+
+/* Module information */
+MODULE_AUTHOR("Mayuresh Chitale <[email protected]>");
+MODULE_DESCRIPTION("RISC-V Trace Ramsink Driver");
+MODULE_LICENSE("GPL");

Bo

Hi Bo,

Quoted 97 lines · Bo Gan

Hi Anup,

My comments below:

Quoted 56 lines · Anup Patel

From: Mayuresh Chitale <[email protected]>

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 <[email protected]>

Signed-off-by Anup Patel <[email protected]>

Signed-off-by Mayuresh Chitale <[email protected]>

---
   drivers/hwtracing/rvtrace/Kconfig           |   9 +
   drivers/hwtracing/rvtrace/Makefile          |   1 +
   drivers/hwtracing/rvtrace/rvtrace-ramsink.c | 262 ++++++++++++++++++++
   3 files changed, 272 insertions(+)

create mode 100644 drivers/hwtracing/rvtrace/rvtrace-ramsink.c

drivers/hwtracing/rvtrace/Kconfig +9 -0

index ba35c05f3f54..0577f9acb858 100644
@@ -21,3 +21,12 @@ config RVTRACE_ENCODER
       default y
       help
         This driver provides support for RISC-V Trace Encoder component.
+
+config RVTRACE_RAMSINK
+     tristate "RISC-V Trace Ramsink driver"
+     depends on RVTRACE
+     select DMA_SHARED_BUFFER
+     default y
+     help
+       This driver provides support for Risc-V E-Trace Ramsink
+       component.

drivers/hwtracing/rvtrace/Makefile +1 -0

index f320693a1fc5..122e575da9fb 100644
@@ -3,3 +3,4 @@
   obj-$(CONFIG_RVTRACE) += rvtrace.o
   rvtrace-y := rvtrace-core.o rvtrace-platform.o
   obj-$(CONFIG_RVTRACE_ENCODER) += rvtrace-encoder.o
+obj-$(CONFIG_RVTRACE_RAMSINK) += rvtrace-ramsink.o

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +9 -0

new file mode 100644
index 000000000000..676344c9387c
@@ -0,0 +1,262 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2025 Ventana Micro Systems Inc.
+ */
+
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/property.h>
+#include <linux/dma-mapping.h>

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 19

Quoted 10 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +10 -0

+#include <linux/rvtrace.h>
+#include <linux/types.h>
+#include <linux/sizes.h>
+
+#define RVTRACE_RAMSINK_STARTLOW_OFF         0x010
+#define RVTRACE_RAMSINK_STARTHIGH_OFF                0x014
+#define RVTRACE_RAMSINK_LIMITLOW_OFF         0x018
+#define RVTRACE_RAMSINK_LIMITHIGH_OFF                0x01c
+#define RVTRACE_RAMSINK_WPLOW_OFF            0x020
+#define   RVTRACE_RAMSINK_WPLOW_WRAP         0x1

nit: wrong spacing

Quoted 22 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +22 -0

+#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;
+     long cur;
+     size_t len;
+};
+
+static int rvtrace_ramsink_stop(struct rvtrace_component *comp)
+{

Quoted 8 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 44

Quoted 3 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +3 -0

+     return rvtrace_comp_is_empty(comp);
+}
+

We should first set trRamEnable to 0, poll it, then poll trRamEmpty. It's essentially the same as encoder, so perhaps move it to core.c. Here we're just checking whether it's empty, which is wrong. We're also doing similar things in encoder.c Should fix that as well.

This code is called to just stop all components in a path which means:
- for encoders the driver clears the trTeInstTracing bit and then polls for empty bit to be cleared
- for ramsinks the driver just polls for the empty bit to be cleared More on this below.

Quoted 38 lines

Quoted 38 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +37 -0

+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 = src->base + src->cur;
+             dst_addr = dst->base + dst->cur;
+
+             if (dst->len - dst->cur < src->size)
+                     bytes_dst = dst->len - dst->cur;
+             else
+                     bytes_dst = src->size;
+             if (src->len - src->cur < src->size)
+                     bytes_src = src->len - src->cur;
+             else
+                     bytes_src = src->size;
+             bytes = bytes_dst < bytes_src ? bytes_dst : bytes_src;
+             memcpy(dst_addr, src_addr, bytes);
+             dst->cur = (dst->cur + bytes) % dst->len;
+             src->cur = (src->cur + bytes) % src->len;
+             src->size -= bytes;
+     }
+}
+
+static size_t rvtrace_ramsink_copyto_auxbuf(struct rvtrace_component *comp,
+                                         struct rvtrace_perf_auxbuf *buf)
+{
+     struct rvtrace_ramsink_priv *priv = dev_get_drvdata(&comp->dev);
+     struct trace_buf src, dst;
+     u32 wp_low, wp_high;
+     u64 buf_cur_head;
+     size_t size;
+
+     wp_low = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_WPLOW_OFF);
+     wp_high = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_WPHIGH_OFF);
+     buf_cur_head = (u64)(wp_high) << 32 | (wp_low & ~RVTRACE_RAMSINK_WPLOW_WRAP);

Quoted 8 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 84

Quoted 3 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +3 -0

+
+     if (buf_cur_head == priv->prev_head)
+             return 0;

cur_head == prev_head could mean that we've wrapped around and stopped at the exact position. Thus, we need to check for the wrapped around bit. If set, then this case can be merged into buf_cur_head <= priv->prev_head below.

cur_head is the current value in the wp registers whereas prev_head is the value in wp registers from the previous iteration which is saved explicitly by software. So prev_head can't change dynamically.

Quoted 9 lines

For cur_head > prev_head case, we also need to check for wrap-around. If wrapped-around, we actually filled the entire buffer, not just cur - prev We also should consider the possibility that the buffer has been wrapped around multiple times. In all cases, maintaining a prev_head seems to complicate things, so why don't we just reset the WP to priv->start each time we start the ramsink component and get rid of prev_head? This way, we'll always have cur >= start, and depending on wrapped bit, we either get the whole buffer, or cur - start.

Currently the software never clears trRamWrap bit because as per the spec:
- It is only set to 0 if trRamWPLow is written
- After trace is enabled and active , the trace tool should NOT write any of trRamStart/Limit/WP?? registers.

Let me test this change to disable all the components (instead of just stopping trace) every time we want to copy data to perf buffer. This should let us use the trRamWrap bit as expected. Multiple wraparounds can't be avoided unless StopOnWrap was set. I will update the ramsink driver to set StopOnWrap based on the implementation id.

Quoted 39 lines

Quoted 39 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +37 -0

+
+     dst.base = buf->base;
+     dst.len = buf->length;
+     dst.cur = buf->pos;
+
+     src.base = priv->va;
+     src.len = priv->end - priv->start;
+     if (buf_cur_head > priv->prev_head) {
+             src.size = buf_cur_head - priv->prev_head;
+     } else {
+             src.size = priv->end - priv->prev_head;
+             src.size += buf_cur_head - priv->start;
+     }
+
+     src.cur = buf_cur_head - priv->start;
+     size = src.size;
+     tbuf_to_pbuf_copy(&src, &dst);
+     buf->pos = dst.cur;
+     priv->prev_head = buf_cur_head;
+
+     return size;
+}
+
+static int rvtrace_ramsink_setup_buf(struct rvtrace_component *comp)
+{
+     struct rvtrace_ramsink_priv *priv = dev_get_drvdata(&comp->dev);
+     u64 start_min, limit_max, end;
+     u32 low, high;
+
+     /* Probe min and max values for start and limit registers */
+     rvtrace_write32(comp->pdata, 0, RVTRACE_RAMSINK_STARTLOW_OFF);
+     rvtrace_write32(comp->pdata, 0, RVTRACE_RAMSINK_STARTHIGH_OFF);
+     low = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_STARTLOW_OFF);
+     high = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_STARTHIGH_OFF);
+     start_min = (u64)(high) << 32 | low;
+
+     rvtrace_write32(comp->pdata, 0xffffffff, RVTRACE_RAMSINK_LIMITLOW_OFF);

Quoted 8 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 127

Quoted 6 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +6 -0

+     rvtrace_write32(comp->pdata, 0xffffffff, RVTRACE_RAMSINK_LIMITHIGH_OFF);
+     low = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_LIMITLOW_OFF);
+     high = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_LIMITHIGH_OFF);
+     limit_max = (u64)(high) << 32 | low;
+
+     if (priv->end < start_min) {

Where was priv->end initialized before this check?

I will move it before the check.

Quoted 28 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 133

Quoted 7 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +6 -0

+             dev_err(&comp->dev, "DMA memory not addressable by device\n");
+             return -EINVAL;
+     }
+
+     /* Setup ram sink start addresses */
+     if (priv->start < start_min) {

No checks for start_min >= priv->end?

Quoted 18 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +18 -0

+             dev_warn(&comp->dev, "Ramsink start address updated from %llx to %llx\n",
+                      priv->start, start_min);
+             priv->va += start_min - priv->start;
+             priv->start = start_min;
+     }
+
+     priv->prev_head = priv->start;
+     priv->end = priv->start + priv->size;
+     rvtrace_write32(comp->pdata, lower_32_bits(priv->start), RVTRACE_RAMSINK_STARTLOW_OFF);
+     rvtrace_write32(comp->pdata, upper_32_bits(priv->start), RVTRACE_RAMSINK_STARTHIGH_OFF);
+     rvtrace_write32(comp->pdata, lower_32_bits(priv->start), RVTRACE_RAMSINK_WPLOW_OFF);
+     rvtrace_write32(comp->pdata, upper_32_bits(priv->start), RVTRACE_RAMSINK_WPHIGH_OFF);
+     /* Setup ram sink limit addresses */
+     if (priv->end > limit_max) {
+             dev_warn(&comp->dev, "Ramsink limit address updated from %llx to %llx\n", priv->end,
+                      limit_max);
+             priv->end = limit_max;
+             priv->size = priv->end - priv->start;

Quoted 8 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 155

Quoted 4 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +4 -0

+     }
+
+     /* Limit address needs to be set to end - 4 to avoid overflow */
+     end = priv->end - 4;

Should not hard-code 4, instead, do write32(0xfffffff, RamLimit), then ffs(RamLimit) to probe for the the write width, aka, "A" value in Table
47. Typical Trace RAM Sink Configuration in the Spec.

I dont think 'A' can be probed that way because as per section 7.1:
"Not every value may be settable in trRamStart/Limit registers. Value written may be trimmed (for example aligned on a particular 2^N boundary)". So writing 0xffffffff to limit register will reveal the boundary alignment but not 'A'. I think 'A' needs to be specified by an implementation with default as 4. I will change it accordingly.

Quoted 25 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 165

Quoted 11 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +10 -0

+     rvtrace_write32(comp->pdata, lower_32_bits(end), RVTRACE_RAMSINK_LIMITLOW_OFF);
+     rvtrace_write32(comp->pdata, upper_32_bits(end), RVTRACE_RAMSINK_LIMITHIGH_OFF);
+     low = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_LIMITLOW_OFF);
+     high = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_LIMITHIGH_OFF);
+     end = (u64)(high) << 32 | low;
+     if (end != (priv->end - 4)) {
+             dev_warn(&comp->dev, "Ramsink limit address updated from %llx to %llx\n", priv->end,
+                      end);
+             priv->end = end;
+             priv->size = priv->end - priv->start;

Actually the RamLimit read is not the real limit. It's Limit - "A" (the write width).

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 97

Quoted 4 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +4 -0

+     }
+
+     return 0;
+}

I think overall we should simplify this setup_buf function. For RamStart alone, there're alignment + min_addr requirement, which is very unlikely that the lowest valid address happens to be within the range that dma- allocated in the caller (when you need to adjust priv->start). Thus, to do it properly, we first need to detect the min_addr + alignment *before*

Quoted 8 lines

dma-alloc, and pass such requirements into dma-alloc, then depending on what dma-alloc returns, detect the "M" value by interrogating RamLimit. I'm not sure if dma-alloc can be passed a hint address that whatever returned must be higher, and whether it can enforce random alignment, so may be we can just program RamStart/Limit based on what dma-alloc gives and error out if value is not retained. We do however need to probe for write width ("A" value). It's usually 4 or 8, but it does vary per-impl, and remember, the total buffer size is still 1MB, not 1MB - 4 or -8.

I think the issue is that the physical memory region returned by dma_alloc* might not be addressable by the hw and so the start / end addresses are already trimmed in the code accordingly but I agree this can be handled differently. For e.g
- probe max RamLimit value .
- set the dma_mask to the probed value
- dma_alloc*
- further address checks

Quoted 43 lines

Quoted 43 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +42 -0

+
+static int rvtrace_ramsink_setup(struct rvtrace_component *comp)
+{
+     struct device *pdev = comp->pdata->dev;
+     struct rvtrace_ramsink_priv *priv;
+
+     priv = devm_kzalloc(&comp->dev, sizeof(*priv), GFP_KERNEL);
+     if (!priv)
+             return -ENOMEM;
+
+     dev_set_drvdata(&comp->dev, priv);
+
+     /* Derive RAM sink memory size based on component implementation ID */
+     switch (comp->pdata->impid) {
+     default:
+             priv->size = SZ_1M;
+             break;
+     }
+
+     priv->va = dma_alloc_coherent(pdev, priv->size, &priv->start, GFP_KERNEL);
+     if (!priv->va)
+             return -ENOMEM;
+
+     return rvtrace_ramsink_setup_buf(comp);
+}
+
+static void rvtrace_ramsink_cleanup(struct rvtrace_component *comp)
+{
+     struct rvtrace_ramsink_priv *priv = 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 = rvtrace_ramsink_setup(comp);
+     if (ret)
+             return dev_err_probe(&comp->dev, ret, "failed to setup ramsink.\n");
+
+     ret = rvtrace_enable_component(comp);

Quoted 8 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 216

Quoted 5 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +5 -0

+     if (ret)
+             return dev_err_probe(&comp->dev, ret, "failed to enable ramsink.\n");
+
+     return ret;
+}

In probe, we should detect and set it to SMEM mode. The default is SRAM mode.

Actually the default is not set but I agree this needs to be handled differently. We can make this an implementation defined parameter and then cross check with trRamImpl register during probe.

Quoted 17 lines

Quoted 17 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +16 -0

+
+static void rvtrace_ramsink_remove(struct rvtrace_component *comp)
+{
+     int ret;
+
+     ret = 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[] = {
+     { .type = RVTRACE_COMPONENT_TYPE_RAMSINK,
+       .version = rvtrace_component_mkversion(1, 0), },
+     {},

Quoted 8 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 237

Quoted 5 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +5 -0

+};
+
+static struct rvtrace_driver rvtrace_ramsink_driver = {
+     .id_table = rvtrace_ramsink_ids,
+     .copyto_auxbuf = rvtrace_ramsink_copyto_auxbuf,

Should have a .start function like the encoder (setting trRamEnable), and reset the WP to priv->start, as suggested above.

The active and enable bits for all components are handled via generic rvtrace_enable_component/rvtrace_disable_component functions. When all components are disabled before copying data to perf then WP would be reset to priv->start as a part of copy_to_auxbuf callback.

Quoted 29 lines

Quoted 16 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +15 -0

+     .stop = rvtrace_ramsink_stop,
+     .probe = rvtrace_ramsink_probe,
+     .remove = rvtrace_ramsink_remove,
+     .driver = {
+             .name = "rvtrace-ramsink",
+     },
+};
+
+static int __init rvtrace_ramsink_init(void)
+{
+     return rvtrace_register_driver(&rvtrace_ramsink_driver);
+}
+
+static void __exit rvtrace_ramsink_exit(void)
+{

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 262

Quoted 10 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +10 -0

+     rvtrace_unregister_driver(&rvtrace_ramsink_driver);
+}
+
+module_init(rvtrace_ramsink_init);
+module_exit(rvtrace_ramsink_exit);
+
+/* Module information */
+MODULE_AUTHOR("Mayuresh Chitale <[email protected]>");
+MODULE_DESCRIPTION("RISC-V Trace Ramsink Driver");
+MODULE_LICENSE("GPL");

Bo

Hi Mayuresh,

Thanks for your reply. My comments below.

Quoted 108 lines · Mayuresh Chitale

Hi Bo,

Quoted 105 lines · Bo Gan

Hi Anup,

My comments below:

Quoted 56 lines · Anup Patel

From: Mayuresh Chitale <[email protected]>

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 <[email protected]>

Signed-off-by Anup Patel <[email protected]>

Signed-off-by Mayuresh Chitale <[email protected]>

---
   drivers/hwtracing/rvtrace/Kconfig           |   9 +
   drivers/hwtracing/rvtrace/Makefile          |   1 +
   drivers/hwtracing/rvtrace/rvtrace-ramsink.c | 262 ++++++++++++++++++++
   3 files changed, 272 insertions(+)

create mode 100644 drivers/hwtracing/rvtrace/rvtrace-ramsink.c

drivers/hwtracing/rvtrace/Kconfig +9 -0

index ba35c05f3f54..0577f9acb858 100644
@@ -21,3 +21,12 @@ config RVTRACE_ENCODER
       default y
       help
         This driver provides support for RISC-V Trace Encoder component.
+
+config RVTRACE_RAMSINK
+     tristate "RISC-V Trace Ramsink driver"
+     depends on RVTRACE
+     select DMA_SHARED_BUFFER
+     default y
+     help
+       This driver provides support for Risc-V E-Trace Ramsink
+       component.

drivers/hwtracing/rvtrace/Makefile +1 -0

index f320693a1fc5..122e575da9fb 100644
@@ -3,3 +3,4 @@
   obj-$(CONFIG_RVTRACE) += rvtrace.o
   rvtrace-y := rvtrace-core.o rvtrace-platform.o
   obj-$(CONFIG_RVTRACE_ENCODER) += rvtrace-encoder.o
+obj-$(CONFIG_RVTRACE_RAMSINK) += rvtrace-ramsink.o

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +9 -0

new file mode 100644
index 000000000000..676344c9387c
@@ -0,0 +1,262 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2025 Ventana Micro Systems Inc.
+ */
+
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/property.h>
+#include <linux/dma-mapping.h>

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 19

Quoted 10 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +10 -0

+#include <linux/rvtrace.h>
+#include <linux/types.h>
+#include <linux/sizes.h>
+
+#define RVTRACE_RAMSINK_STARTLOW_OFF         0x010
+#define RVTRACE_RAMSINK_STARTHIGH_OFF                0x014
+#define RVTRACE_RAMSINK_LIMITLOW_OFF         0x018
+#define RVTRACE_RAMSINK_LIMITHIGH_OFF                0x01c
+#define RVTRACE_RAMSINK_WPLOW_OFF            0x020
+#define   RVTRACE_RAMSINK_WPLOW_WRAP         0x1

nit: wrong spacing

Quoted 15 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +15 -0

+#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;

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 44

Quoted 10 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +10 -0

+     size_t size;
+     long cur;
+     size_t len;
+};
+
+static int rvtrace_ramsink_stop(struct rvtrace_component *comp)
+{
+     return rvtrace_comp_is_empty(comp);
+}
+

We should first set trRamEnable to 0, poll it, then poll trRamEmpty. It's essentially the same as encoder, so perhaps move it to core.c. Here we're just checking whether it's empty, which is wrong. We're also doing similar things in encoder.c Should fix that as well.

Quoted 5 lines

This code is called to just stop all components in a path which means:
- for encoders the driver clears the trTeInstTracing bit and then polls for empty bit to be cleared
- for ramsinks the driver just polls for the empty bit to be cleared More on this below.

Can we rename it to something like rvtrace_comp_poll_empty(...) for clarity? This name kind of confused me into thinking it's just a check.

Quoted 60 lines

Quoted 39 lines

Quoted 39 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +37 -0

+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 = src->base + src->cur;
+             dst_addr = dst->base + dst->cur;
+
+             if (dst->len - dst->cur < src->size)
+                     bytes_dst = dst->len - dst->cur;
+             else
+                     bytes_dst = src->size;
+             if (src->len - src->cur < src->size)
+                     bytes_src = src->len - src->cur;
+             else
+                     bytes_src = src->size;
+             bytes = bytes_dst < bytes_src ? bytes_dst : bytes_src;
+             memcpy(dst_addr, src_addr, bytes);
+             dst->cur = (dst->cur + bytes) % dst->len;
+             src->cur = (src->cur + bytes) % src->len;
+             src->size -= bytes;
+     }
+}
+
+static size_t rvtrace_ramsink_copyto_auxbuf(struct rvtrace_component *comp,
+                                         struct rvtrace_perf_auxbuf *buf)
+{
+     struct rvtrace_ramsink_priv *priv = dev_get_drvdata(&comp->dev);
+     struct trace_buf src, dst;
+     u32 wp_low, wp_high;
+     u64 buf_cur_head;
+     size_t size;
+
+     wp_low = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_WPLOW_OFF);
+     wp_high = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_WPHIGH_OFF);
+     buf_cur_head = (u64)(wp_high) << 32 | (wp_low & ~RVTRACE_RAMSINK_WPLOW_WRAP);

Quoted 8 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 84

Quoted 3 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +3 -0

+
+     if (buf_cur_head == priv->prev_head)
+             return 0;

cur_head == prev_head could mean that we've wrapped around and stopped at the exact position. Thus, we need to check for the wrapped around bit. If set, then this case can be merged into buf_cur_head <= priv->prev_head below.

cur_head is the current value in the wp registers whereas prev_head is the value in wp registers from the previous iteration which is saved explicitly by software. So prev_head can't change dynamically.

Quoted 9 lines

For cur_head > prev_head case, we also need to check for wrap-around. If wrapped-around, we actually filled the entire buffer, not just cur - prev We also should consider the possibility that the buffer has been wrapped around multiple times. In all cases, maintaining a prev_head seems to complicate things, so why don't we just reset the WP to priv->start each time we start the ramsink component and get rid of prev_head? This way, we'll always have cur >= start, and depending on wrapped bit, we either get the whole buffer, or cur - start.

Quoted 4 lines

Currently the software never clears trRamWrap bit because as per the spec:
- It is only set to 0 if trRamWPLow is written
- After trace is enabled and active , the trace tool should NOT write any of trRamStart/Limit/WP?? registers.

I think you missed my point. I'm not suggesting that we should change the register values when trace is active. I'm saying that there's no need to maintain a prev_head. For every trace session, we can just start fresh, and reset WP to Start before trace starts. This way we don't need to deal with the complex conditions of cur_head > prev_head, because you'll also need to deal with wrap around, and the if condition will be complex. The trace can wrap around and over-write old traces anyway, so I don't see a value of keeping track of prev_head.

Quoted 89 lines

Let me test this change to disable all the components (instead of just stopping trace) every time we want to copy data to perf buffer. This should let us use the trRamWrap bit as expected. Multiple wraparounds can't be avoided unless StopOnWrap was set. I will update the ramsink driver to set StopOnWrap based on the implementation id.

Quoted 39 lines

Quoted 39 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +37 -0

+
+     dst.base = buf->base;
+     dst.len = buf->length;
+     dst.cur = buf->pos;
+
+     src.base = priv->va;
+     src.len = priv->end - priv->start;
+     if (buf_cur_head > priv->prev_head) {
+             src.size = buf_cur_head - priv->prev_head;
+     } else {
+             src.size = priv->end - priv->prev_head;
+             src.size += buf_cur_head - priv->start;
+     }
+
+     src.cur = buf_cur_head - priv->start;
+     size = src.size;
+     tbuf_to_pbuf_copy(&src, &dst);
+     buf->pos = dst.cur;
+     priv->prev_head = buf_cur_head;
+
+     return size;
+}
+
+static int rvtrace_ramsink_setup_buf(struct rvtrace_component *comp)
+{
+     struct rvtrace_ramsink_priv *priv = dev_get_drvdata(&comp->dev);
+     u64 start_min, limit_max, end;
+     u32 low, high;
+
+     /* Probe min and max values for start and limit registers */
+     rvtrace_write32(comp->pdata, 0, RVTRACE_RAMSINK_STARTLOW_OFF);
+     rvtrace_write32(comp->pdata, 0, RVTRACE_RAMSINK_STARTHIGH_OFF);
+     low = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_STARTLOW_OFF);
+     high = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_STARTHIGH_OFF);
+     start_min = (u64)(high) << 32 | low;
+
+     rvtrace_write32(comp->pdata, 0xffffffff, RVTRACE_RAMSINK_LIMITLOW_OFF);

Quoted 8 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 127

Quoted 6 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +6 -0

+     rvtrace_write32(comp->pdata, 0xffffffff, RVTRACE_RAMSINK_LIMITHIGH_OFF);
+     low = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_LIMITLOW_OFF);
+     high = rvtrace_read32(comp->pdata, RVTRACE_RAMSINK_LIMITHIGH_OFF);
+     limit_max = (u64)(high) << 32 | low;
+
+     if (priv->end < start_min) {

Where was priv->end initialized before this check?

I will move it before the check.

Quoted 28 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 133

Quoted 7 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +6 -0

+             dev_err(&comp->dev, "DMA memory not addressable by device\n");
+             return -EINVAL;
+     }
+
+     /* Setup ram sink start addresses */
+     if (priv->start < start_min) {

No checks for start_min >= priv->end?

Quoted 18 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +18 -0

+             dev_warn(&comp->dev, "Ramsink start address updated from %llx to %llx\n",
+                      priv->start, start_min);
+             priv->va += start_min - priv->start;
+             priv->start = start_min;
+     }
+
+     priv->prev_head = priv->start;
+     priv->end = priv->start + priv->size;
+     rvtrace_write32(comp->pdata, lower_32_bits(priv->start), RVTRACE_RAMSINK_STARTLOW_OFF);
+     rvtrace_write32(comp->pdata, upper_32_bits(priv->start), RVTRACE_RAMSINK_STARTHIGH_OFF);
+     rvtrace_write32(comp->pdata, lower_32_bits(priv->start), RVTRACE_RAMSINK_WPLOW_OFF);
+     rvtrace_write32(comp->pdata, upper_32_bits(priv->start), RVTRACE_RAMSINK_WPHIGH_OFF);
+     /* Setup ram sink limit addresses */
+     if (priv->end > limit_max) {
+             dev_warn(&comp->dev, "Ramsink limit address updated from %llx to %llx\n", priv->end,
+                      limit_max);
+             priv->end = limit_max;
+             priv->size = priv->end - priv->start;

Quoted 8 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c line 155

Quoted 4 lines

drivers/hwtracing/rvtrace/rvtrace-ramsink.c new file +4 -0

+     }
+
+     /* Limit address needs to be set to end - 4 to avoid overflow */
+     end = priv->end - 4;

Should not hard-code 4, instead, do write32(0xfffffff, RamLimit), then ffs(RamLimit) to probe for the the write width, aka, "A" value in Table
47. Typical Trace RAM Sink Configuration in the Spec.

Quoted 7 lines

I dont think 'A' can be probed that way because as per section 7.1:
"Not every value may be settable in trRamStart/Limit registers. Value written may be trimmed (for example aligned on a particular 2^N boundary)". So writing 0xffffffff to limit register will reveal the boundary alignment but not 'A'. I think 'A' needs to be specified by an implementation with default as 4. I will change it accordingly.

Quoting from spec:

"Value A means alignment which depends on memory access width. If we
have memory access width of 32-bits, A=4 and value of trRamLimit register should be 0x…FC. Some implementations may impose bigger alignment of trace data (to allow more efficient transfer rates) for SMEM mode. For SRAM mode A must be 4 as access to trace via trRamData is always 32-bits wide "