[PATCH linux dev-6.12 v1 4/6] soc: aspeed: xdma: Add trace events

Ninad Palsule
2025-09-02T18:32:43Z

Trace the flow of the driver to aid debugging after an error.

OpenBMC-Staging-Count: 6
Signed-off-by: Eddie James <eajames@linux.ibm.com>
Acked-by: Andrew Jeffery <andrew@aj.id.au>
Link: https://lore.kernel.org/r/20220412215331.42491-1-eajames@linux.ibm.com
Signed-off-by: Joel Stanley <joel@jms.id.au>
---
drivers/soc/aspeed/aspeed-xdma.c | 18 +++-
include/trace/events/xdma.h | 139 +++++++++++++++++++++++++++++++
2 files changed, 155 insertions(+), 2 deletions(-)
create mode 100644 include/trace/events/xdma.h

diff --git a/drivers/soc/aspeed/aspeed-xdma.c b/drivers/soc/aspeed/aspeed-xdma.c
index 565486ddb3b52..33310e55eb1ce 100644
--- a/drivers/soc/aspeed/aspeed-xdma.c
+++ b/drivers/soc/aspeed/aspeed-xdma.c
@@ -253,6 +253,9 @@ struct aspeed_xdma_client {
u32 size;
};

+#define CREATE_TRACE_POINTS
+#include <trace/events/xdma.h>
+
static u32 aspeed_xdma_readl(struct aspeed_xdma *ctx, u8 reg)
{
u32 v = readl(ctx->base + reg);
@@ -448,6 +451,7 @@ static int aspeed_xdma_start(struct aspeed_xdma *ctx, unsigned int num_cmds,

ctx->upstream = upstream;
for (i = 0; i < num_cmds; ++i) {
+ trace_xdma_start(ctx, &cmds[i]);
/*
* Use memcpy_toio here to get some barriers before starting
* the operation. The command(s) need to be in physical memory
@@ -490,6 +494,8 @@ static irqreturn_t aspeed_xdma_irq(int irq, void *arg)
spin_lock(&ctx->engine_lock);
status = aspeed_xdma_readl(ctx, ctx->chip->regs.status);

+ trace_xdma_irq(status);
+
if (status & ctx->chip->status_bits.ds_dirty) {
aspeed_xdma_done(ctx, true);
} else {
@@ -514,6 +520,8 @@ static void aspeed_xdma_reset(struct aspeed_xdma *ctx)
{
unsigned long flags;

+ trace_xdma_reset(ctx);
+
reset_control_assert(ctx->reset);
usleep_range(XDMA_ENGINE_SETUP_TIME_MIN_US,
XDMA_ENGINE_SETUP_TIME_MAX_US);
@@ -544,7 +552,7 @@ static irqreturn_t aspeed_xdma_pcie_irq(int irq, void *arg)
{
struct aspeed_xdma *ctx = arg;

- dev_dbg(ctx->dev, "PCI-E reset requested.\n");
+ trace_xdma_perst(ctx);

spin_lock(&ctx->engine_lock);
if (ctx->in_reset) {
@@ -682,6 +690,7 @@ static void aspeed_xdma_vma_close(struct vm_area_struct *vma)

gen_pool_free(client->ctx->pool, (unsigned long)client->virt,
client->size);
+ trace_xdma_unmap(client);

client->virt = NULL;
client->phys = 0;
@@ -706,6 +715,7 @@ static int aspeed_xdma_mmap(struct file *file, struct vm_area_struct *vma)
client->virt = gen_pool_dma_alloc(ctx->pool, client->size,
&client->phys);
if (!client->virt) {
+ trace_xdma_mmap_error(client, 0UL);
client->phys = 0;
client->size = 0;
return -ENOMEM;
@@ -725,12 +735,14 @@ static int aspeed_xdma_mmap(struct file *file, struct vm_area_struct *vma)
gen_pool_free(ctx->pool, (unsigned long)client->virt,
client->size);

+ trace_xdma_mmap_error(client, vma->vm_start);
client->virt = NULL;
client->phys = 0;
client->size = 0;
return rc;
}

+ trace_xdma_mmap(client);
dev_dbg(ctx->dev, "mmap: v[%08lx] to p[%08x], s[%08x]\n",
vma->vm_start, (u32)client->phys, client->size);

@@ -776,9 +788,11 @@ static int aspeed_xdma_release(struct inode *inode, struct file *file)
if (reset)
aspeed_xdma_reset(ctx);

- if (client->virt)
+ if (client->virt) {
gen_pool_free(ctx->pool, (unsigned long)client->virt,
client->size);
+ trace_xdma_unmap(client);
+ }

kfree(client);
kobject_put(&ctx->kobj);
diff --git a/include/trace/events/xdma.h b/include/trace/events/xdma.h
new file mode 100644
index 0000000000000..bf515ad3d8e50
--- /dev/null
+++ b/include/trace/events/xdma.h
@@ -0,0 +1,139 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM xdma
+
+#if !defined(_TRACE_XDMA_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_XDMA_H
+
+#include <linux/tracepoint.h>
+
+TRACE_EVENT(xdma_start,
+ TP_PROTO(const struct aspeed_xdma *ctx, const struct aspeed_xdma_cmd *cmd),
+ TP_ARGS(ctx, cmd),
+ TP_STRUCT__entry(
+ __field(bool, dir_upstream)
+ __field(unsigned int, index)
+ __field(__u64, host)
+ __field(__u64, pitch)
+ __field(__u64, cmd)
+ ),
+ TP_fast_assign(
+ __entry->dir_upstream = ctx->upstream;
+ __entry->index = ctx->cmd_idx;
+ __entry->host = cmd->host_addr;
+ __entry->pitch = cmd->pitch;
+ __entry->cmd = cmd->cmd;
+ ),
+ TP_printk("%s cmd:%u [%08llx %016llx %016llx]",
+ __entry->dir_upstream ? "upstream" : "downstream",
+ __entry->index,
+ __entry->host,
+ __entry->pitch,
+ __entry->cmd
+ )
+);
+
+TRACE_EVENT(xdma_irq,
+ TP_PROTO(u32 sts),
+ TP_ARGS(sts),
+ TP_STRUCT__entry(
+ __field(__u32, status)
+ ),
+ TP_fast_assign(
+ __entry->status = sts;
+ ),
+ TP_printk("sts:%08x",
+ __entry->status
+ )
+);
+
+TRACE_EVENT(xdma_reset,
+ TP_PROTO(const struct aspeed_xdma *ctx),
+ TP_ARGS(ctx),
+ TP_STRUCT__entry(
+ __field(bool, dir_upstream)
+ __field(bool, in_progress)
+ ),
+ TP_fast_assign(
+ __entry->dir_upstream = ctx->upstream;
+ __entry->in_progress =
+ ctx->current_client ? ctx->current_client->in_progress : false;
+ ),
+ TP_printk("%sin progress%s",
+ __entry->in_progress ? "" : "not ",
+ __entry->in_progress ? (__entry->dir_upstream ? " upstream" : " downstream") : ""
+ )
+);
+
+TRACE_EVENT(xdma_perst,
+ TP_PROTO(const struct aspeed_xdma *ctx),
+ TP_ARGS(ctx),
+ TP_STRUCT__entry(
+ __field(bool, in_reset)
+ ),
+ TP_fast_assign(
+ __entry->in_reset = ctx->in_reset;
+ ),
+ TP_printk("%s",
+ __entry->in_reset ? "in reset" : ""
+ )
+);
+
+TRACE_EVENT(xdma_unmap,
+ TP_PROTO(const struct aspeed_xdma_client *client),
+ TP_ARGS(client),
+ TP_STRUCT__entry(
+ __field(__u32, phys)
+ __field(__u32, size)
+ ),
+ TP_fast_assign(
+ __entry->phys = client->phys;
+ __entry->size = client->size;
+ ),
+ TP_printk("p:%08x s:%08x",
+ __entry->phys,
+ __entry->size
+ )
+);
+
+TRACE_EVENT(xdma_mmap_error,
+ TP_PROTO(const struct aspeed_xdma_client *client, unsigned long vm_start),
+ TP_ARGS(client, vm_start),
+ TP_STRUCT__entry(
+ __field(__u32, phys)
+ __field(__u32, size)
+ __field(unsigned long, vm_start)
+ ),
+ TP_fast_assign(
+ __entry->phys = client->phys;
+ __entry->size = client->size;
+ __entry->vm_start = vm_start;
+ ),
+ TP_printk("p:%08x s:%08x v:%08lx",
+ __entry->phys,
+ __entry->size,
+ __entry->vm_start
+ )
+);
+
+TRACE_EVENT(xdma_mmap,
+ TP_PROTO(const struct aspeed_xdma_client *client),
+ TP_ARGS(client),
+ TP_STRUCT__entry(
+ __field(__u32, phys)
+ __field(__u32, size)
+ ),
+ TP_fast_assign(
+ __entry->phys = client->phys;
+ __entry->size = client->size;
+ ),
+ TP_printk("p:%08x s:%08x",
+ __entry->phys,
+ __entry->size
+ )
+);
+
+#endif /* _TRACE_XDMA_H */
+
+#include <trace/define_trace.h>
--
2.48.1