Message-Id: <20220917072356.2255620-6-jiho.chu@samsung.com>
Date:   Sat, 17 Sep 2022 16:23:48 +0900
From:   Jiho Chu <jiho.chu@...sung.com>
To:     gregkh@...uxfoundation.org, arnd@...db.de, ogabbay@...nel.org,
        krzysztof.kozlowski@...aro.org, broonie@...nel.org
Cc:     linux-kernel@...r.kernel.org, yelini.jeong@...sung.com,
        myungjoo.ham@...sung.com, jiho.chu@...sung.com
Subject: [PATCH v2 05/13] trinity: Add debugfs module

This patch provides debugfs feature.

It create debugfs entry for driver and provides apis to print
out messages, model info and input info. Default directory
of debugfs is named 'trinity', and each driver has own
debug file.

Signed-off-by: Jiho Chu <jiho.chu@...sung.com>
---
 drivers/misc/trinity/Makefile        |   1 +
 drivers/misc/trinity/trinity_debug.c | 331 +++++++++++++++++++++++++++
 2 files changed, 332 insertions(+)
 create mode 100644 drivers/misc/trinity/trinity_debug.c

diff --git a/drivers/misc/trinity/Makefile b/drivers/misc/trinity/Makefile
index 2a8c4fed135e..5d3e89dd0dd7 100644
--- a/drivers/misc/trinity/Makefile
+++ b/drivers/misc/trinity/Makefile
@@ -5,5 +5,6 @@ obj-$(CONFIG_TRINITY_VISION2) += trinity_vision2.o
 trinity-y := trinity.o
 trinity-y += trinity_dma.o trinity_hwmem.o
 trinity-y += trinity_sched.o
+trinity-y += trinity_debug.o
 
 trinity_vision2-objs := $(trinity-y) trinity_vision2_drv.o
diff --git a/drivers/misc/trinity/trinity_debug.c b/drivers/misc/trinity/trinity_debug.c
new file mode 100644
index 000000000000..9add728a101b
--- /dev/null
+++ b/drivers/misc/trinity/trinity_debug.c
@@ -0,0 +1,331 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/**
+ * Implementation of debug functions for trinity drivers
+ *
+ * Copyright (C) 2020-2022 Samsung Electronics
+ * Copyright (C) 2020 Dongju Chae <dongju.chae@...sung.com>
+ * Copyright (C) 2022 MyungJoo Ham <myungjoo.ham@...sung.com>
+ * Copyright (C) 2022 Yelin Jeong <yelini.jeong@...sung.com>
+ * Copyright (C) 2022 Jiho Chu <jiho.chu@...sung.com>
+ */
+
+#include <linux/debugfs.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+
+#include "trinity_common.h"
+
+#define TRINITY_DEVVER(drv) (drv->desc->ver >> TRINITY_SHIFT_DEV)
+#define TRINITY_DEBUGFS_DIR ("trinity")
+#define TRINITY_DEBUGFS_MAX (1024UL)
+#define TRINITY_DEBUGFS_LENGTH (255)
+
+struct trinity_debugfs_msg {
+	char msg[TRINITY_DEBUGFS_LENGTH + 1]; /* including NULL */
+};
+
+struct trinity_debugfs_entry {
+	struct dentry *dentry;
+	spinlock_t lock;
+
+	unsigned long msg_max;
+	unsigned long msg_num;
+	unsigned long msg_off;
+
+	struct trinity_dma msg_buf;
+};
+
+static struct dentry *trinity_debugfs;
+
+static size_t trinity_debug_append_app_id(struct trinity_driver *drv, char *msg)
+{
+	return snprintf(msg, TRINITY_DEBUGFS_LENGTH, "[%d] ",
+			trinity_get_app_id());
+}
+
+static char *trinity_debug_get_msg_buf(struct trinity_driver *drv)
+{
+	struct trinity_debugfs_entry *entry = drv->debugfs_pdata;
+	struct trinity_debugfs_msg *buf;
+
+	if (!entry || entry->msg_max == 0)
+		return NULL;
+
+	spin_lock(&entry->lock);
+	if (entry->msg_num == entry->msg_max) {
+		buf = &((struct trinity_debugfs_msg *)
+				entry->msg_buf.addr)[entry->msg_off];
+		entry->msg_off = (entry->msg_off + 1) % entry->msg_max;
+	} else {
+		buf = &((struct trinity_debugfs_msg *)
+				entry->msg_buf.addr)[entry->msg_num++];
+	}
+	spin_unlock(&entry->lock);
+
+	memset(buf, '\x00', sizeof(*buf));
+	return buf->msg;
+}
+
+/**
+ * trinity_debug_dump_msg() - Dump trinity debug message
+ *
+ * @drv: an instance of the trinity driver
+ * @fmt: tag message format
+ */
+void trinity_debug_dump_msg(struct trinity_driver *drv, const char *fmt, ...)
+{
+	char *msg;
+	size_t len;
+	va_list args;
+
+	msg = trinity_debug_get_msg_buf(drv);
+	if (msg == NULL)
+		return;
+
+	len = trinity_debug_append_app_id(drv, msg);
+
+	va_start(args, fmt);
+	len += vsnprintf(msg + len, TRINITY_DEBUGFS_LENGTH - len, fmt, args);
+	va_end(args);
+}
+
+/**
+ * trinity_debug_dump_input() - Dump trinity input data
+ *
+ * @drv: an instance of the trinity driver
+ * @input: an instance of the trinity model
+ * @fmt: tag message format
+ */
+void trinity_debug_dump_model(struct trinity_driver *drv,
+			      const struct trinity_model *model,
+			      const char *fmt, ...)
+{
+	char *msg;
+	size_t len;
+	va_list args;
+
+	msg = trinity_debug_get_msg_buf(drv);
+	if (msg == NULL)
+		return;
+
+	len = trinity_debug_append_app_id(drv, msg);
+
+	va_start(args, fmt);
+	len += vsnprintf(msg + len, TRINITY_DEBUGFS_LENGTH - len, fmt, args);
+	va_end(args);
+
+	len += snprintf(msg + len, TRINITY_DEBUGFS_LENGTH - len,
+			"\n\tid(0x%llx) dbuf_fd(%d) program_offset_addr(0x%llx) program_size(0x%llx)\n",
+			model->config.id, model->config.dbuf_fd,
+			model->config.program_offset_addr, model->config.program_size);
+	len += snprintf(msg + len, TRINITY_DEBUGFS_LENGTH - len,
+			"\tmetadata_dbuf_fd(%d) metadata_ext_dbuf_fd(%d) metadata_ext_size(0x%llx)",
+			model->config.metadata_dbuf_fd,
+			model->config.metadata_ext_dbuf_fd,
+			model->config.metadata_ext_size);
+}
+
+/**
+ * trinity_debug_dump_input() - Dump trinity input data
+ *
+ * @drv: an instance of the trinity driver
+ * @input: an instance of the trinity input
+ * @fmt: tag message format
+ */
+void trinity_debug_dump_input(struct trinity_driver *drv,
+			      const struct trinity_input *input,
+			      const char *fmt, ...)
+{
+	char *msg;
+	size_t len;
+	va_list args;
+
+	msg = trinity_debug_get_msg_buf(drv);
+	if (msg == NULL)
+		return;
+
+	len = trinity_debug_append_app_id(drv, msg);
+
+	va_start(args, fmt);
+	len += vsnprintf(msg + len, TRINITY_DEBUGFS_LENGTH - len, fmt, args);
+	va_end(args);
+
+	len += snprintf(msg + len, TRINITY_DEBUGFS_LENGTH - len,
+			"\n\tdbuf_fd(%d) model_id(0x%llx)\n",
+			input->config.dbuf_fd, input->config.model_id);
+	len += snprintf(msg + len, TRINITY_DEBUGFS_LENGTH - len,
+			"\ttimeout_ms(%lld) priority(%u) num_segments(%u) input_mode(%d) output_mode(%d)",
+			input->config.timeout_ms, input->config.priority,
+			input->config.num_segments, input->config.input_mode,
+			input->config.output_mode);
+}
+
+static int trinity_debugfs_show(struct seq_file *s, void *unsed)
+{
+	struct trinity_driver *drv = s->private;
+	struct trinity_debugfs_entry *entry = drv->debugfs_pdata;
+	struct trinity_debugfs_msg *msg;
+	unsigned long i, offset;
+
+	spin_lock(&entry->lock);
+	for (i = 0; i < entry->msg_num; i++) {
+		offset = (entry->msg_off + i) % entry->msg_max;
+		msg = &((struct trinity_debugfs_msg *)
+				entry->msg_buf.addr)[offset];
+
+		seq_puts(s, msg->msg);
+		seq_puts(s, "\n");
+	}
+	spin_unlock(&entry->lock);
+
+	return 0;
+}
+
+static int trinity_debugfs_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, trinity_debugfs_show, inode->i_private);
+}
+
+static const struct file_operations trinity_debugfs_fops = {
+	.open = trinity_debugfs_open,
+	.read = seq_read,
+	.llseek = seq_lseek,
+	.release = single_release,
+};
+
+/**
+ * trinity_debug_add() - Add trinity debug file system entry
+ *
+ * @drv: an instance of the trinity driver
+ */
+int trinity_debug_add(struct trinity_driver *drv)
+{
+	struct trinity_debugfs_entry *entry;
+	struct dentry *dentry;
+	const char *name = drv->name;
+
+	if (name == NULL)
+		return -EINVAL;
+
+	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
+	if (!entry)
+		return -ENOMEM;
+
+	dentry = debugfs_create_file_unsafe(name, 0400, trinity_debugfs, drv,
+					    &trinity_debugfs_fops);
+	if (IS_ERR(dentry)) {
+		kfree(entry);
+		return PTR_ERR(dentry);
+	}
+
+	entry->dentry = dentry;
+	spin_lock_init(&entry->lock);
+
+	drv->debugfs_pdata = entry;
+
+	return 0;
+}
+
+/**
+ * trinity_debug_remove() - Remove trinity debug file system entry
+ *
+ * @drv: an instance of the trinity driver
+ */
+void trinity_debug_remove(struct trinity_driver *drv)
+{
+	struct trinity_debugfs_entry *entry = drv->debugfs_pdata;
+
+	trinity_debug_clear(drv, 0);
+
+	debugfs_remove(entry->dentry);
+	kfree(entry);
+
+	drv->debugfs_pdata = NULL;
+}
+
+/**
+ * trinity_debug_clear() - Clear debug message entity
+ *
+ * @drv: an instance of the trinity driver
+ * @msg_max: reset max size of debug message entity
+ */
+void trinity_debug_clear(struct trinity_driver *drv, unsigned long msg_max)
+{
+	struct trinity_debugfs_entry *entry = drv->debugfs_pdata;
+	struct device *dev = drv_to_dev_ptr(drv);
+	size_t size;
+
+	/* maximum size limit: 256KiB */
+	if (msg_max > TRINITY_DEBUGFS_MAX) {
+		dev_err(dev, "Too much debugfs entries (limit: %lu)",
+			TRINITY_DEBUGFS_MAX);
+		return;
+	}
+
+	spin_lock(&entry->lock);
+
+	/* disable debugfs temporally */
+	trinity_dma_free(dev, &entry->msg_buf);
+	entry->msg_max = 0;
+	entry->msg_num = 0;
+	entry->msg_off = 0;
+
+	if (msg_max == 0)
+		goto out;
+
+	/* reallocate debugfs buffer */
+	size = PAGE_ALIGN(msg_max * sizeof(struct trinity_debugfs_msg));
+	if (trinity_dma_alloc(dev, size, &entry->msg_buf) < 0) {
+		dev_warn(dev, "No available memory for debugfs");
+		goto out;
+	}
+	/* more available entries due to page size alignment */
+	entry->msg_max = size / sizeof(struct trinity_debugfs_msg);
+
+out:
+	spin_unlock(&entry->lock);
+}
+
+/**
+ * trinity_debug_exit() - Get max size of debug message entity
+ *
+ * @drv: an instance of the trinity driver
+ *
+ * Return: max size of debug message entity
+ */
+unsigned long trinity_debug_get_max(struct trinity_driver *drv)
+{
+	struct trinity_debugfs_entry *entry = drv->debugfs_pdata;
+	unsigned long msg_max;
+
+	spin_lock(&entry->lock);
+	msg_max = entry->msg_max;
+	spin_unlock(&entry->lock);
+
+	return msg_max;
+}
+
+/**
+ * trinity_debug_exit() - Initialize debug file system
+ */
+int trinity_debug_init(void)
+{
+	struct dentry *entry;
+
+	entry = debugfs_create_dir(TRINITY_DEBUGFS_DIR, NULL);
+	if (IS_ERR(entry))
+		return PTR_ERR(entry);
+
+	trinity_debugfs = entry;
+
+	return 0;
+}
+
+/**
+ * trinity_debug_exit() - Exit debug file system
+ */
+void trinity_debug_exit(void)
+{
+	debugfs_remove_recursive(trinity_debugfs);
+}
-- 
2.25.1

Powered by blists - more mailing lists