// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2026, Advanced Micro Devices, Inc.
 */

#include "amdxdna_cbuf.h"
#include "amdxdna_debugfs.h"

#include <drm/drm_file.h>
#include <linux/debugfs.h>
#include <linux/pm_runtime.h>
#include <linux/seq_file.h>
#include <linux/string.h>
#include <linux/uaccess.h>

#define _DBGFS_FOPS(_open, _release, _write) \
{ \
        .owner = THIS_MODULE, \
        .open = _open, \
        .read = seq_read, \
        .llseek = seq_lseek, \
        .release = _release, \
        .write = _write, \
}

#define AMDXDNA_DBGFS_FOPS(_name, _show, _write) \
        static int amdxdna_dbgfs_##_name##_open(struct inode *inode, struct file *file) \
        { \
                return single_open(file, _show, inode->i_private); \
        } \
        static int amdxdna_dbgfs_##_name##_release(struct inode *inode, struct file *file) \
        { \
                return single_release(inode, file); \
        } \
        static const struct file_operations amdxdna_fops_##_name = \
                _DBGFS_FOPS(amdxdna_dbgfs_##_name##_open, amdxdna_dbgfs_##_name##_release, _write)

#define AMDXDNA_DBGFS_FILE(_name, _mode) { #_name, &amdxdna_fops_##_name, _mode }

#define file_to_xdna(file) (((struct seq_file *)(file)->private_data)->private)

static ssize_t amdxdna_carveout_write(struct file *file, const char __user *buf,
                                      size_t count, loff_t *ppos)
{
        struct amdxdna_dev *xdna = file_to_xdna(file);
        char kbuf[128];
        u64 size, addr;
        char *sep;
        int ret;

        if (count == 0 || count >= sizeof(kbuf))
                return -EINVAL;

        if (copy_from_user(kbuf, buf, count))
                return -EFAULT;
        kbuf[count] = '\0';
        strim(kbuf);
        XDNA_DBG(xdna, "Trying to set carveout to %s", kbuf);

        sep = strchr(kbuf, '@');
        if (!sep)
                return -EINVAL;
        *sep = '\0';
        sep++;

        ret = kstrtou64(kbuf, 0, &size);
        if (ret)
                return ret;

        ret = kstrtou64(sep, 0, &addr);
        if (ret)
                return ret;

        /* Sanity check the addr and size. */
        if (!size)
                return -EINVAL;
        if (!IS_ALIGNED(addr, PAGE_SIZE) || !IS_ALIGNED(size, PAGE_SIZE))
                return -EINVAL;

        guard(mutex)(&xdna->dev_lock);

        ret = amdxdna_carveout_init(xdna, addr, size);
        if (ret)
                return ret;

        return count;
}

static int amdxdna_carveout_show(struct seq_file *m, void *unused)
{
        struct amdxdna_dev *xdna = m->private;
        u64 addr, size;

        guard(mutex)(&xdna->dev_lock);
        amdxdna_get_carveout_conf(xdna, &addr, &size);
        seq_printf(m, "0x%llx@0x%llx\n", size, addr);
        return 0;
}

/*
 * Input/output format: <carveout_size>@<carveout_address>
 */
AMDXDNA_DBGFS_FOPS(carveout, amdxdna_carveout_show, amdxdna_carveout_write);

static const struct {
        const char *name;
        const struct file_operations *fops;
        umode_t mode;
} amdxdna_dbgfs_files[] = {
        AMDXDNA_DBGFS_FILE(carveout, 0600),
};

void amdxdna_debugfs_init(struct amdxdna_dev *xdna)
{
        struct drm_minor *minor = xdna->ddev.accel;
        int i;

        /*
         * It should be okay that debugfs fails to init.
         * We rely on DRM framework to finish debugfs.
         */
        for (i = 0; i < ARRAY_SIZE(amdxdna_dbgfs_files); i++) {
                debugfs_create_file(amdxdna_dbgfs_files[i].name,
                                    amdxdna_dbgfs_files[i].mode,
                                    minor->debugfs_root,
                                    xdna,
                                    amdxdna_dbgfs_files[i].fops);
        }
}