[PATCH v4 3/3] dmaengine: ptdma: Add debugfs entries for PTDMA information

Sanjay R Mehta
2020-04-28T21:14:44Z

From: Sanjay R Mehta <sanju.mehta@amd.com>

Expose data about the configuration and operation of the
PTDMA through debugfs entries: device name, capabilities,
configuration, statistics.

Signed-off-by: Sanjay R Mehta <sanju.mehta@amd.com>
---
drivers/dma/ptdma/Makefile | 3 +-
drivers/dma/ptdma/ptdma-debugfs.c | 237 ++++++++++++++++++++++++++++++++++++++
drivers/dma/ptdma/ptdma-dev.c | 26 +++++
drivers/dma/ptdma/ptdma.h | 13 +++
4 files changed, 278 insertions(+), 1 deletion(-)
create mode 100644 drivers/dma/ptdma/ptdma-debugfs.c

diff --git a/drivers/dma/ptdma/Makefile b/drivers/dma/ptdma/Makefile
index 6fcb4ad..60e7c10 100644
--- a/drivers/dma/ptdma/Makefile
+++ b/drivers/dma/ptdma/Makefile
@@ -6,6 +6,7 @@
obj-$(CONFIG_AMD_PTDMA) += ptdma.o

ptdma-objs := ptdma-dev.o \
- ptdma-dmaengine.o
+ ptdma-dmaengine.o \
+ ptdma-debugfs.o

ptdma-$(CONFIG_PCI) += ptdma-pci.o
diff --git a/drivers/dma/ptdma/ptdma-debugfs.c b/drivers/dma/ptdma/ptdma-debugfs.c
new file mode 100644
index 0000000..837c43c
--- /dev/null
+++ b/drivers/dma/ptdma/ptdma-debugfs.c
@@ -0,0 +1,237 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * AMD Passthrough DMA device driver
+ * -- Based on the CCP driver
+ *
+ * Copyright (C) 2016,2020 Advanced Micro Devices, Inc.
+ *
+ * Author: Sanjay R Mehta <sanju.mehta@amd.com>
+ * Author: Gary R Hook <gary.hook@amd.com>
+ */
+
+#include <linux/debugfs.h>
+
+#include "ptdma.h"
+
+/* DebugFS helpers */
+#define OBUFP (obuf + oboff)
+#define OBUFLEN 512
+#define OBUFSPC (OBUFLEN - oboff)
+
+#define MAX_NAME_LEN 20
+#define BUFLEN 63
+#define RI_VERSION_NUM 0x0000003F
+
+#define RI_NUM_VQM 0x00078000
+#define RI_NVQM_SHIFT 15
+#define RI_NVQM(r) (((r) * RI_NUM_VQM) >> RI_NVQM_SHIFT)
+#define RI_LSB_ENTRIES 0x0FF80000
+#define RI_NLSB_SHIFT 19
+#define RI_NLSB(r) (((r) * RI_LSB_ENTRIES) >> RI_NLSB_SHIFT)
+
+static struct dentry *pt_debugfs_dir;
+static DEFINE_MUTEX(pt_debugfs_lock);
+
+static ssize_t ptdma_debugfs_info_read(struct file *filp, char __user *ubuf,
+ size_t count, loff_t *offp)
+{
+ struct pt_device *pt = filp->private_data;
+ unsigned int oboff = 0;
+ unsigned int regval;
+ ssize_t ret;
+ char *obuf;
+
+ if (!pt)
+ return 0;
+
+ obuf = kmalloc(OBUFLEN, GFP_KERNEL);
+ if (!obuf)
+ return -ENOMEM;
+
+ oboff += snprintf(OBUFP, OBUFSPC, "Device name: %s\n", pt->name);
+ oboff += snprintf(OBUFP, OBUFSPC, " # Queues: %d\n", 1);
+ oboff += snprintf(OBUFP, OBUFSPC, " # Cmds: %d\n", pt->cmd_count);
+
+ regval = ioread32(pt->io_regs + CMD_PT_VERSION);
+
+ oboff += snprintf(OBUFP, OBUFSPC, " Version: %d\n",
+ regval & RI_VERSION_NUM);
+ oboff += snprintf(OBUFP, OBUFSPC, " Engines:");
+ oboff += snprintf(OBUFP, OBUFSPC, "\n");
+ oboff += snprintf(OBUFP, OBUFSPC, " Queues: %d\n",
+ (regval & RI_NUM_VQM) >> RI_NVQM_SHIFT);
+
+ ret = simple_read_from_buffer(ubuf, count, offp, obuf, oboff);
+ kfree(obuf);
+
+ return ret;
+}
+
+/*
+ * Return a formatted buffer containing the current
+ * statistics of queue for PTDMA
+ */
+static ssize_t ptdma_debugfs_stats_read(struct file *filp, char __user *ubuf,
+ size_t count, loff_t *offp)
+{
+ struct pt_device *pt = filp->private_data;
+ unsigned long total_pt_ops = 0;
+ unsigned int oboff = 0;
+ ssize_t ret = 0;
+ char *obuf;
+ struct pt_cmd_queue *cmd_q = &pt->cmd_q;
+
+ total_pt_ops += cmd_q->total_pt_ops;
+
+ obuf = kmalloc(OBUFLEN, GFP_KERNEL);
+ if (!obuf)
+ return -ENOMEM;
+
+ oboff += snprintf(OBUFP, OBUFSPC, "Total Interrupts Handled: %ld\n",
+ pt->total_interrupts);
+
+ ret = simple_read_from_buffer(ubuf, count, offp, obuf, oboff);
+ kfree(obuf);
+
+ return ret;
+}
+
+/*
+ * Reset the counters in a queue
+ */
+static void ptdma_debugfs_reset_queue_stats(struct pt_cmd_queue *cmd_q)
+{
+ cmd_q->total_pt_ops = 0L;
+}
+
+/*
+ * A value was written to the stats variable, which
+ * should be used to reset the queue counters across
+ * that device.
+ */
+static ssize_t ptdma_debugfs_stats_write(struct file *filp,
+ const char __user *ubuf,
+ size_t count, loff_t *offp)
+{
+ struct pt_device *pt = filp->private_data;
+
+ ptdma_debugfs_reset_queue_stats(&pt->cmd_q);
+ pt->total_interrupts = 0L;
+
+ return count;
+}
+
+/*
+ * Return a formatted buffer containing the current information
+ * for that queue
+ */
+static ssize_t ptdma_debugfs_queue_read(struct file *filp, char __user *ubuf,
+ size_t count, loff_t *offp)
+{
+ struct pt_cmd_queue *cmd_q = filp->private_data;
+ unsigned int oboff = 0;
+ unsigned int regval;
+ ssize_t ret;
+ char *obuf;
+
+ if (!cmd_q)
+ return 0;
+
+ obuf = kmalloc(OBUFLEN, GFP_KERNEL);
+ if (!obuf)
+ return -ENOMEM;
+
+ oboff += snprintf(OBUFP, OBUFSPC, " Pass-Thru: %ld\n",
+ cmd_q->total_pt_ops);
+
+ regval = ioread32(cmd_q->reg_int_enable);
+ oboff += snprintf(OBUFP, OBUFSPC, " Enabled Interrupts:");
+ if (regval & INT_EMPTY_QUEUE)
+ oboff += snprintf(OBUFP, OBUFSPC, " EMPTY");
+ if (regval & INT_QUEUE_STOPPED)
+ oboff += snprintf(OBUFP, OBUFSPC, " STOPPED");
+ if (regval & INT_ERROR)
+ oboff += snprintf(OBUFP, OBUFSPC, " ERROR");
+ if (regval & INT_COMPLETION)
+ oboff += snprintf(OBUFP, OBUFSPC, " COMPLETION");
+ oboff += snprintf(OBUFP, OBUFSPC, "\n");
+
+ ret = simple_read_from_buffer(ubuf, count, offp, obuf, oboff);
+ kfree(obuf);
+
+ return ret;
+}
+
+/*
+ * A value was written to the stats variable for a
+ * queue. Reset the queue counters to this value.
+ */
+static ssize_t ptdma_debugfs_queue_write(struct file *filp,
+ const char __user *ubuf,
+ size_t count, loff_t *offp)
+{
+ struct pt_cmd_queue *cmd_q = filp->private_data;
+
+ ptdma_debugfs_reset_queue_stats(cmd_q);
+
+ return count;
+}
+
+static const struct file_operations pt_debugfs_info_ops = {
+ .owner = THIS_MODULE,
+ .open = simple_open,
+ .read = ptdma_debugfs_info_read,
+ .write = NULL,
+};
+
+static const struct file_operations pt_debugfs_queue_ops = {
+ .owner = THIS_MODULE,
+ .open = simple_open,
+ .read = ptdma_debugfs_queue_read,
+ .write = ptdma_debugfs_queue_write,
+};
+
+static const struct file_operations pt_debugfs_stats_ops = {
+ .owner = THIS_MODULE,
+ .open = simple_open,
+ .read = ptdma_debugfs_stats_read,
+ .write = ptdma_debugfs_stats_write,
+};
+
+void ptdma_debugfs_setup(struct pt_device *pt)
+{
+ struct pt_cmd_queue *cmd_q;
+ char name[MAX_NAME_LEN + 1];
+ struct dentry *debugfs_q_instance;
+
+ if (!debugfs_initialized())
+ return;
+
+ mutex_lock(&pt_debugfs_lock);
+ if (!pt_debugfs_dir)
+ pt_debugfs_dir = debugfs_create_dir(KBUILD_MODNAME, NULL);
+ mutex_unlock(&pt_debugfs_lock);
+
+ pt->debugfs_instance = debugfs_create_dir(pt->name, pt_debugfs_dir);
+
+ debugfs_create_file("info", 0400, pt->debugfs_instance, pt,
+ &pt_debugfs_info_ops);
+
+ debugfs_create_file("stats", 0600, pt->debugfs_instance, pt,
+ &pt_debugfs_stats_ops);
+
+ cmd_q = &pt->cmd_q;
+
+ snprintf(name, MAX_NAME_LEN - 1, "q");
+
+ debugfs_q_instance =
+ debugfs_create_dir(name, pt->debugfs_instance);
+
+ debugfs_create_file("stats", 0600, debugfs_q_instance, cmd_q,
+ &pt_debugfs_queue_ops);
+}
+
+void ptdma_debugfs_destroy(void)
+{
+ debugfs_remove_recursive(pt_debugfs_dir);
+}
diff --git a/drivers/dma/ptdma/ptdma-dev.c b/drivers/dma/ptdma/ptdma-dev.c
index 14b4339..f00fb58 100644
--- a/drivers/dma/ptdma/ptdma-dev.c
+++ b/drivers/dma/ptdma/ptdma-dev.c
@@ -14,6 +14,7 @@
#include <linux/pci.h>
#include <linux/dma-mapping.h>
#include <linux/interrupt.h>
+#include <linux/debugfs.h>

#include "ptdma.h"

@@ -130,6 +131,23 @@ static void pt_del_device(struct pt_device *pt)
write_unlock_irqrestore(&pt_unit_lock, flags);
}

+/*
+ * pt_present - check if a PTDMA device is present
+ *
+ * Returns zero if a PTDMA device is present, -ENODEV otherwise.
+ */
+static int pt_present(void)
+{
+ unsigned long flags;
+ int ret;
+
+ read_lock_irqsave(&pt_unit_lock, flags);
+ ret = list_empty(&pt_units);
+ read_unlock_irqrestore(&pt_unit_lock, flags);
+
+ return ret ? -ENODEV : 0;
+}
+
void pt_start_queue(struct pt_cmd_queue *cmd_q)
{
/* Turn on the run bit */
@@ -185,6 +203,7 @@ int pt_core_perform_passthru(struct pt_cmd_queue *cmd_q,

cmd_q->cmd_error = 0;

+ cmd_q->total_pt_ops++;
memset(&desc, 0, Q_DESC_SIZE);

desc.dw0.val = CMD_DESC_DW0_VAL;
@@ -217,6 +236,7 @@ static irqreturn_t pt_core_irq_handler(int irq, void *data)
u32 status;

pt_core_disable_queue_interrupts(pt);
+ pt->total_interrupts++;

status = ioread32(cmd_q->reg_interrupt_status);
if (status) {
@@ -382,6 +402,9 @@ int pt_core_init(struct pt_device *pt)

tasklet_init(&pt->tasklet, pt_do_cmd_complete, (ulong)&pt->tdata);

+ /* Set up debugfs entries */
+ ptdma_debugfs_setup(pt);
+
return 0;

e_dmaengine:
@@ -408,6 +431,9 @@ void pt_core_destroy(struct pt_device *pt)
/* Remove this device from the list of available units first */
pt_del_device(pt);

+ if (pt_present())
+ ptdma_debugfs_destroy();
+
/* Disable and clear interrupts */
pt_core_disable_queue_interrupts(pt);

diff --git a/drivers/dma/ptdma/ptdma.h b/drivers/dma/ptdma/ptdma.h
index a807f4c..ee99b8c 100644
--- a/drivers/dma/ptdma/ptdma.h
+++ b/drivers/dma/ptdma/ptdma.h
@@ -47,6 +47,7 @@
#define CMD_QUEUE_PRIO_OFFSET 0x00
#define CMD_REQID_CONFIG_OFFSET 0x04
#define CMD_TIMEOUT_OFFSET 0x08
+#define CMD_PT_VERSION 0x10

#define CMD_Q_CONTROL_BASE 0x0000
#define CMD_Q_TAIL_LO_BASE 0x0004
@@ -245,6 +246,9 @@ struct pt_cmd_queue {
u32 q_status;
u32 q_int_status;
u32 cmd_error;
+
+ /* queue Statistics */
+ unsigned long total_pt_ops;
} ____cacheline_aligned;

struct pt_device {
@@ -283,6 +287,12 @@ struct pt_device {

wait_queue_head_t lsb_queue;

+ /* Device Statistics */
+ unsigned long total_interrupts;
+
+ /* DebugFS info */
+ struct dentry *debugfs_instance;
+
struct tasklet_struct tasklet;
struct pt_tasklet_data tdata;
};
@@ -350,6 +360,9 @@ struct pt_dev_vdata {
int pt_dmaengine_register(struct pt_device *pt);
void pt_dmaengine_unregister(struct pt_device *pt);

+void ptdma_debugfs_setup(struct pt_device *pt);
+void ptdma_debugfs_destroy(void);
+
int pt_core_init(struct pt_device *pt);
void pt_core_destroy(struct pt_device *pt);

--
2.7.4