// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (C) IBM Corporation, 2024
 */

#define pr_fmt(fmt) "htmdump: " fmt

#include <linux/debugfs.h>
#include <linux/module.h>
#include <asm/io.h>
#include <asm/machdep.h>
#include <asm/plpar_wrappers.h>
#include <asm/kvm_guest.h>

static void *htm_buf;
static void *htm_status_buf;
static void *htm_info_buf;
static void *htm_caps_buf;
static u32 nodeindex;
static u32 nodalchipindex;
static u32 coreindexonchip;
static u32 htmtype;
static u32 htmconfigure;
static u32 htmstart;
static u32 htmsetup;
static u64 htmflags;

static struct dentry *htmdump_debugfs_dir;
#define HTM_ENABLE      1
#define HTM_DISABLE     0
#define HTM_NOWRAP      1
#define HTM_WRAP        0

/*
 * Check the return code for H_HTM hcall.
 * Return non-zero value (1) if either H_PARTIAL or H_SUCCESS
 * is returned. For other return codes:
 * Return zero if H_NOT_AVAILABLE.
 * Return -EBUSY if hcall return busy.
 * Return -EINVAL if any parameter or operation is not valid.
 * Return -EPERM if HTM Virtualization Engine Technology code
 * is not applied.
 * Return -EIO if the HTM state is not valid.
 */
static ssize_t htm_return_check(long rc)
{
        switch (rc) {
        case H_SUCCESS:
        /* H_PARTIAL for the case where all available data can't be
         * returned due to buffer size constraint.
         */
        case H_PARTIAL:
                break;
        /* H_NOT_AVAILABLE indicates reading from an offset outside the range,
         * i.e. past end of file.
         */
        case H_NOT_AVAILABLE:
                return 0;
        case H_BUSY:
        case H_LONG_BUSY_ORDER_1_MSEC:
        case H_LONG_BUSY_ORDER_10_MSEC:
        case H_LONG_BUSY_ORDER_100_MSEC:
        case H_LONG_BUSY_ORDER_1_SEC:
        case H_LONG_BUSY_ORDER_10_SEC:
        case H_LONG_BUSY_ORDER_100_SEC:
                return -EBUSY;
        case H_PARAMETER:
        case H_P2:
        case H_P3:
        case H_P4:
        case H_P5:
        case H_P6:
                return -EINVAL;
        case H_STATE:
                return -EIO;
        case H_AUTHORITY:
                return -EPERM;
        }

        /*
         * Return 1 for H_SUCCESS/H_PARTIAL
         */
        return 1;
}

static ssize_t htmdump_read(struct file *filp, char __user *ubuf,
                             size_t count, loff_t *ppos)
{
        void *htm_buf = filp->private_data;
        unsigned long page, read_size, available;
        loff_t offset;
        long rc, ret;

        page = ALIGN_DOWN(*ppos, PAGE_SIZE);
        offset = (*ppos) % PAGE_SIZE;

        /*
         * Invoke H_HTM call with:
         * - operation as htm dump (H_HTM_OP_DUMP_DATA)
         * - last three values are address, size and offset
         */
        rc = htm_hcall_wrapper(htmflags, nodeindex, nodalchipindex, coreindexonchip,
                                   htmtype, H_HTM_OP_DUMP_DATA, virt_to_phys(htm_buf),
                                   PAGE_SIZE, page);

        ret = htm_return_check(rc);
        if (ret <= 0) {
                pr_debug("H_HTM hcall failed for op: H_HTM_OP_DUMP_DATA, returning %ld\n", ret);
                return ret;
        }

        available = PAGE_SIZE;
        read_size = min(count, available);
        *ppos += read_size;
        return simple_read_from_buffer(ubuf, count, &offset, htm_buf, available);
}

static const struct file_operations htmdump_fops = {
        .llseek = NULL,
        .read   = htmdump_read,
        .open   = simple_open,
};

static int  htmconfigure_set(void *data, u64 val)
{
        long rc, ret;
        unsigned long param1 = -1, param2 = -1;

        /*
         * value as 1 : configure HTM.
         * value as 0 : deconfigure HTM. Return -EINVAL for
         * other values.
         */
        if (val == HTM_ENABLE) {
                /*
                 * Invoke H_HTM call with:
                 * - operation as htm configure (H_HTM_OP_CONFIGURE)
                 * - If htmflags is set, param1 and param2 will be -1
                 *   which is an indicator to use default htm mode reg mask
                 *   and htm mode reg value.
                 * - last three values are unused, hence set to zero
                 */
                if (!htmflags) {
                        param1 = 0;
                        param2 = 0;
                }

                rc = htm_hcall_wrapper(htmflags, nodeindex, nodalchipindex, coreindexonchip,
                           htmtype, H_HTM_OP_CONFIGURE, param1, param2, 0);
        } else if (val == HTM_DISABLE) {
                /*
                 * Invoke H_HTM call with:
                 * - operation as htm deconfigure (H_HTM_OP_DECONFIGURE)
                 * - last three values are unused, hence set to zero
                 */
                rc = htm_hcall_wrapper(htmflags, nodeindex, nodalchipindex, coreindexonchip,
                                htmtype, H_HTM_OP_DECONFIGURE, 0, 0, 0);
        } else
                return -EINVAL;

        ret = htm_return_check(rc);
        if (ret <= 0) {
                pr_debug("H_HTM hcall failed, returning %ld\n", ret);
                return ret;
        }

        /* Set htmconfigure if operation succeeds */
        htmconfigure = val;

        return 0;
}

static int htmconfigure_get(void *data, u64 *val)
{
        *val = htmconfigure;
        return 0;
}

static int  htmstart_set(void *data, u64 val)
{
        long rc, ret;

        /*
         * value as 1: start HTM
         * value as 0: stop HTM
         * Return -EINVAL for other values.
         */
        if (val == HTM_ENABLE) {
                /*
                 * Invoke H_HTM call with:
                 * - operation as htm start (H_HTM_OP_START)
                 * - last three values are unused, hence set to zero
                 */
                rc = htm_hcall_wrapper(htmflags, nodeindex, nodalchipindex, coreindexonchip,
                           htmtype, H_HTM_OP_START, 0, 0, 0);

        } else if (val == HTM_DISABLE) {
                /*
                 * Invoke H_HTM call with:
                 * - operation as htm stop (H_HTM_OP_STOP)
                 * - last three values are unused, hence set to zero
                 */
                rc = htm_hcall_wrapper(htmflags, nodeindex, nodalchipindex, coreindexonchip,
                                htmtype, H_HTM_OP_STOP, 0, 0, 0);
        } else
                return -EINVAL;

        ret = htm_return_check(rc);
        if (ret <= 0) {
                pr_debug("H_HTM hcall failed, returning %ld\n", ret);
                return ret;
        }

        /* Set htmstart if H_HTM_OP_START/H_HTM_OP_STOP operation succeeds */
        htmstart = val;

        return 0;
}

static int htmstart_get(void *data, u64 *val)
{
        *val = htmstart;
        return 0;
}

static ssize_t htmstatus_read(struct file *filp, char __user *ubuf,
                             size_t count, loff_t *ppos)
{
        void *htm_status_buf = filp->private_data;
        long rc, ret;
        u64 *num_entries;
        u64 to_copy;
        int htmstatus_flag;

        /*
         * Invoke H_HTM call with:
         * - operation as htm status (H_HTM_OP_STATUS)
         * - last three values as addr, size and offset
         */
        rc = htm_hcall_wrapper(htmflags, nodeindex, nodalchipindex, coreindexonchip,
                                   htmtype, H_HTM_OP_STATUS, virt_to_phys(htm_status_buf),
                                   PAGE_SIZE, 0);

        ret = htm_return_check(rc);
        if (ret <= 0) {
                pr_debug("H_HTM hcall failed for op: H_HTM_OP_STATUS, returning %ld\n", ret);
                return ret;
        }

        /*
         * HTM status buffer, start of buffer + 0x10 gives the
         * number of HTM entries in the buffer. Each nest htm status
         * entry is 0x6 bytes where each core htm status entry is
         * 0x8 bytes.
         * So total count to copy is:
         * 32 bytes (for first 7 fields) + (number of HTM entries * entry size)
         */
        num_entries = htm_status_buf + 0x10;
        if (htmtype == 0x2)
                htmstatus_flag = 0x8;
        else
                htmstatus_flag = 0x6;
        to_copy = 32 + (be64_to_cpu(*num_entries) * htmstatus_flag);
        return simple_read_from_buffer(ubuf, count, ppos, htm_status_buf, to_copy);
}

static const struct file_operations htmstatus_fops = {
        .llseek = NULL,
        .read   = htmstatus_read,
        .open   = simple_open,
};

static ssize_t htminfo_read(struct file *filp, char __user *ubuf,
                             size_t count, loff_t *ppos)
{
        void *htm_info_buf = filp->private_data;
        long rc, ret;
        u64 *num_entries;
        u64 to_copy;

        /*
         * Invoke H_HTM call with:
         * - operation as htm status (H_HTM_OP_STATUS)
         * - last three values as addr, size and offset
         */
        rc = htm_hcall_wrapper(htmflags, nodeindex, nodalchipindex, coreindexonchip,
                                   htmtype, H_HTM_OP_DUMP_SYSPROC_CONF, virt_to_phys(htm_info_buf),
                                   PAGE_SIZE, 0);

        ret = htm_return_check(rc);
        if (ret <= 0) {
                pr_debug("H_HTM hcall failed for op: H_HTM_OP_DUMP_SYSPROC_CONF, returning %ld\n", ret);
                return ret;
        }

        /*
         * HTM status buffer, start of buffer + 0x10 gives the
         * number of HTM entries in the buffer. Each entry of processor
         * is 16 bytes.
         *
         * So total count to copy is:
         * 32 bytes (for first 5 fields) + (number of HTM entries * entry size)
         */
        num_entries = htm_info_buf + 0x10;
        to_copy = 32 + (be64_to_cpu(*num_entries) * 16);
        return simple_read_from_buffer(ubuf, count, ppos, htm_info_buf, to_copy);
}

static ssize_t htmcaps_read(struct file *filp, char __user *ubuf,
                             size_t count, loff_t *ppos)
{
        void *htm_caps_buf = filp->private_data;
        long rc, ret;

        /*
         * Invoke H_HTM call with:
         * - operation as htm capabilities (H_HTM_OP_CAPABILITIES)
         * - last three values as addr, size (0x80 for Capabilities Output Buffer
         *   and zero
         */
        rc = htm_hcall_wrapper(htmflags, nodeindex, nodalchipindex, coreindexonchip,
                                   htmtype, H_HTM_OP_CAPABILITIES, virt_to_phys(htm_caps_buf),
                                   0x80, 0);

        ret = htm_return_check(rc);
        if (ret <= 0) {
                pr_debug("H_HTM hcall failed for op: H_HTM_OP_CAPABILITIES, returning %ld\n", ret);
                return ret;
        }

        return simple_read_from_buffer(ubuf, count, ppos, htm_caps_buf, 0x80);
}

static const struct file_operations htminfo_fops = {
        .llseek = NULL,
        .read   = htminfo_read,
        .open   = simple_open,
};

static const struct file_operations htmcaps_fops = {
        .llseek = NULL,
        .read   = htmcaps_read,
        .open   = simple_open,
};

static int  htmsetup_set(void *data, u64 val)
{
        long rc, ret;

        /*
         * Input value: HTM buffer size in the power of 2
         * example: hex value 0x21 ( decimal: 33 ) is for
         * 8GB
         * Invoke H_HTM call with:
         * - operation as htm start (H_HTM_OP_SETUP)
         * - parameter 1 set to input value.
         * - last two values are unused, hence set to zero
         */
        rc = htm_hcall_wrapper(htmflags, nodeindex, nodalchipindex, coreindexonchip,
                        htmtype, H_HTM_OP_SETUP, val, 0, 0);

        ret = htm_return_check(rc);
        if (ret <= 0) {
                pr_debug("H_HTM hcall failed for op: H_HTM_OP_SETUP, returning %ld\n", ret);
                return ret;
        }

        /* Set htmsetup if H_HTM_OP_SETUP operation succeeds */
        htmsetup = val;

        return 0;
}

static int htmsetup_get(void *data, u64 *val)
{
        *val = htmsetup;
        return 0;
}

static int  htmflags_set(void *data, u64 val)
{
        /*
         * Input value:
         * Currently supported flag value is to enable/disable
         * HTM buffer wrap. wrap is used along with "configure"
         * to prevent HTM buffer from wrapping.
         * Writing 1 will set noWrap while configuring HTM
         */
        if (val == HTM_NOWRAP)
                htmflags = H_HTM_FLAGS_NOWRAP;
        else if (val == HTM_WRAP)
                htmflags = 0;
        else
                return -EINVAL;

        return 0;
}

static int htmflags_get(void *data, u64 *val)
{
        *val = htmflags;
        return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(htmconfigure_fops, htmconfigure_get, htmconfigure_set, "%llu\n");
DEFINE_SIMPLE_ATTRIBUTE(htmstart_fops, htmstart_get, htmstart_set, "%llu\n");
DEFINE_SIMPLE_ATTRIBUTE(htmsetup_fops, htmsetup_get, htmsetup_set, "%llu\n");
DEFINE_SIMPLE_ATTRIBUTE(htmflags_fops, htmflags_get, htmflags_set, "%llu\n");

static int htmdump_init_debugfs(void)
{
        htm_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
        if (!htm_buf) {
                pr_err("Failed to allocate htmdump buf\n");
                return -ENOMEM;
        }

        htmdump_debugfs_dir = debugfs_create_dir("htmdump",
                                                  arch_debugfs_dir);

        debugfs_create_u32("nodeindex", 0600,
                        htmdump_debugfs_dir, &nodeindex);
        debugfs_create_u32("nodalchipindex", 0600,
                        htmdump_debugfs_dir, &nodalchipindex);
        debugfs_create_u32("coreindexonchip", 0600,
                        htmdump_debugfs_dir, &coreindexonchip);
        debugfs_create_u32("htmtype", 0600,
                        htmdump_debugfs_dir, &htmtype);
        debugfs_create_file("trace", 0400, htmdump_debugfs_dir, htm_buf, &htmdump_fops);

        /*
         * Debugfs interface files to control HTM operations:
         */
        debugfs_create_file("htmconfigure", 0600, htmdump_debugfs_dir, NULL, &htmconfigure_fops);
        debugfs_create_file("htmstart", 0600, htmdump_debugfs_dir, NULL, &htmstart_fops);
        debugfs_create_file("htmsetup", 0600, htmdump_debugfs_dir, NULL, &htmsetup_fops);
        debugfs_create_file("htmflags", 0600, htmdump_debugfs_dir, NULL, &htmflags_fops);

        /* Debugfs interface file to present status of HTM */
        htm_status_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
        if (!htm_status_buf) {
                pr_err("Failed to allocate htmstatus buf\n");
                return -ENOMEM;
        }

        /* Debugfs interface file to present System Processor Configuration */
        htm_info_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
        if (!htm_info_buf) {
                pr_err("Failed to allocate htm info buf\n");
                return -ENOMEM;
        }

        /* Debugfs interface file to present HTM capabilities */
        htm_caps_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
        if (!htm_caps_buf) {
                pr_err("Failed to allocate htm caps buf\n");
                return -ENOMEM;
        }

        debugfs_create_file("htmstatus", 0400, htmdump_debugfs_dir, htm_status_buf, &htmstatus_fops);
        debugfs_create_file("htminfo", 0400, htmdump_debugfs_dir, htm_info_buf, &htminfo_fops);
        debugfs_create_file("htmcaps", 0400, htmdump_debugfs_dir, htm_caps_buf, &htmcaps_fops);

        return 0;
}

static int __init htmdump_init(void)
{
        /* Disable on kvm guest */
        if (is_kvm_guest()) {
                pr_info("htmdump not supported inside KVM guest\n");
                return -EOPNOTSUPP;
        }

        if (htmdump_init_debugfs())
                return -ENOMEM;

        return 0;
}

static void __exit htmdump_exit(void)
{
        debugfs_remove_recursive(htmdump_debugfs_dir);
        kfree(htm_buf);
}

module_init(htmdump_init);
module_exit(htmdump_exit);
MODULE_DESCRIPTION("PHYP Hardware Trace Macro (HTM) data dumper");
MODULE_LICENSE("GPL");