// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2018 Xilinx, Inc.
 *
 * Vasileios Bimpikas <vasileios.bimpikas@xilinx.com>
 */
#include <linux/init.h>
#include <linux/kobject.h>
#include <linux/module.h>
#include <linux/stat.h>
#include <linux/string.h>
#include <linux/sysfs.h>
#include "xroe_framer.h"

enum { XROE_SIZE_MAX = 15 };
static int xroe_size;
static char xroe_tmp[XROE_SIZE_MAX];

/**
 * version_show - Returns the block's revision number
 * @kobj:       The kernel object of the entry
 * @attr:       The attributes of the kernel object
 * @buff:       The buffer containing the revision string
 *
 * Returns the block's major, minor & version revision numbers
 * in a %d.%d.%d format
 *
 * Return: XROE_SIZE_MAX on success
 */
static ssize_t version_show(struct kobject *kobj, struct kobj_attribute *attr,
                            char *buff)
{
        u32 major_rev;
        u32 minor_rev;
        u32 version_rev;

        major_rev = utils_sysfs_show_wrapper(CFG_MAJOR_REVISION_ADDR,
                                             CFG_MAJOR_REVISION_OFFSET,
                                             CFG_MAJOR_REVISION_MASK, kobj);
        minor_rev = utils_sysfs_show_wrapper(CFG_MINOR_REVISION_ADDR,
                                             CFG_MINOR_REVISION_OFFSET,
                                             CFG_MINOR_REVISION_MASK, kobj);
        version_rev = utils_sysfs_show_wrapper(CFG_VERSION_REVISION_ADDR,
                                               CFG_VERSION_REVISION_OFFSET,
                                               CFG_VERSION_REVISION_MASK, kobj);
        sprintf(buff, "%d.%d.%d\n", major_rev, minor_rev, version_rev);
        return XROE_SIZE_MAX;
}

/**
 * version_store - Writes to the framer version sysfs entry (not permitted)
 * @kobj:       The kernel object of the entry
 * @attr:       The attributes of the kernel object
 * @buff:       The buffer containing the revision string
 * @count:      The number of characters typed by the user
 *
 * Writes to the framer version sysfs entry (not permitted)
 *
 * Return: 0
 */
static ssize_t version_store(struct  kobject *kobj, struct kobj_attribute *attr,
                             const char *buff, size_t count)
{
        return 0;
}

/**
 * enable_show - Returns the framer's enable status
 * @kobj:       The kernel object of the entry
 * @attr:       The attributes of the kernel object
 * @buff:       The buffer containing the enable status
 *
 * Reads and writes the framer's enable status to the sysfs entry
 *
 * Return: XROE_SIZE_MAX on success
 */
static ssize_t enable_show(struct kobject *kobj, struct kobj_attribute *attr,
                           char *buff)
{
        u32 enable;

        enable = utils_sysfs_show_wrapper(CFG_MASTER_INT_ENABLE_ADDR,
                                          CFG_MASTER_INT_ENABLE_OFFSET,
                                          CFG_MASTER_INT_ENABLE_MASK, kobj);
        if (enable)
                sprintf(buff, "true\n");
        else
                sprintf(buff, "false\n");
        return XROE_SIZE_MAX;
}

/**
 * version_store - Writes to the framer's enable status register
 * @kobj:       The kernel object of the entry
 * @attr:       The attributes of the kernel object
 * @buff:       The buffer containing the enable status
 * @count:      The number of characters typed by the user
 *
 * Reads the user input and accordingly writes the framer's enable status
 * to the sysfs entry
 *
 * Return: XROE_SIZE_MAX or the value of "count", if that's lesser, on success
 */
static ssize_t enable_store(struct kobject *kobj, struct kobj_attribute *attr,
                            const char *buff, size_t count)
{
        u32 enable = 0;

        xroe_size = min_t(size_t, count, (size_t)XROE_SIZE_MAX);
        strncpy(xroe_tmp, buff, xroe_size);
        if (strncmp(xroe_tmp, "true", xroe_size) == 0)
                enable = 1;
        else if (strncmp(xroe_tmp, "false", xroe_size) == 0)
                enable = 0;
        utils_sysfs_store_wrapper(CFG_MASTER_INT_ENABLE_ADDR,
                                  CFG_MASTER_INT_ENABLE_OFFSET,
                                  CFG_MASTER_INT_ENABLE_MASK, enable, kobj);
        return xroe_size;
}

/**
 * framer_restart_show - Returns the framer's restart status
 * @kobj:       The kernel object of the entry
 * @attr:       The attributes of the kernel object
 * @buff:       The buffer containing the restart status
 *
 * Reads and writes the framer's restart status to the sysfs entry
 *
 * Return: XROE_SIZE_MAX on success
 */
static ssize_t framer_restart_show(struct kobject *kobj,
                                   struct kobj_attribute *attr, char *buff)
{
        u32 restart;

        restart = utils_sysfs_show_wrapper(FRAM_DISABLE_ADDR,
                                           FRAM_DISABLE_OFFSET,
                                           FRAM_DISABLE_MASK, kobj);
        if (restart)
                sprintf(buff, "true\n");

        else
                sprintf(buff, "false\n");

        return XROE_SIZE_MAX;
}

/**
 * framer_restart_store - Writes to the framer's restart status register
 * @kobj:       The kernel object of the entry
 * @attr:       The attributes of the kernel object
 * @buff:       The buffer containing the restart status
 * @count:      The number of characters typed by the user
 *
 * Reads the user input and accordingly writes the framer's restart status
 * to the sysfs entry
 *
 * Return: XROE_SIZE_MAX or the value of "count", if that's lesser, on success
 */
static ssize_t framer_restart_store(struct  kobject *kobj,
                                    struct kobj_attribute *attr,
                                    const char *buff, size_t count)
{
        u32 restart = 0;

        xroe_size = min_t(size_t, count, (size_t)XROE_SIZE_MAX);
        strncpy(xroe_tmp, buff, xroe_size);
        if (strncmp(xroe_tmp, "true", xroe_size) == 0)
                restart = 0x01;
        else if (strncmp(xroe_tmp, "false", xroe_size) == 0)
                restart = 0x00;
        utils_sysfs_store_wrapper(FRAM_DISABLE_ADDR, FRAM_DISABLE_OFFSET,
                                  FRAM_DISABLE_MASK, restart, kobj);
        return xroe_size;
}

/**
 * deframer_restart_show - Returns the deframer's restart status
 * @kobj:       The kernel object of the entry
 * @attr:       The attributes of the kernel object
 * @buff:       The buffer containing the restart status
 *
 * Reads and writes the deframer's restart status to the sysfs entry
 *
 * Return: XROE_SIZE_MAX on success
 */
static ssize_t deframer_restart_show(struct kobject *kobj,
                                     struct kobj_attribute *attr, char *buff)
{
        u32 offset = DEFM_RESTART_OFFSET;
        u32 mask = DEFM_RESTART_MASK;
        u32 buffer = 0;
        u32 restart = 0;
        void __iomem *working_address = ((u8 *)lp->base_addr
        + DEFM_RESTART_ADDR);

        buffer = ioread32(working_address);
        restart = (buffer & mask) >> offset;

        if (restart)
                sprintf(buff, "true\n");

        else
                sprintf(buff, "false\n");

        return XROE_SIZE_MAX;
}

/**
 * deframer_restart_store - Writes to the deframer's restart status register
 * @kobj:       The kernel object of the entry
 * @attr:       The attributes of the kernel object
 * @buff:       The buffer containing the restart status
 * @count:      The number of characters typed by the user
 *
 * Reads the user input and accordingly writes the deframer's restart status
 * to the sysfs entry
 *
 * Return: XROE_SIZE_MAX or the value of "count", if that's lesser, on success
 */
static ssize_t deframer_restart_store(struct kobject *kobj,
                                      struct kobj_attribute *attr,
                                      const char *buff, size_t count)
{
        u32 offset = DEFM_RESTART_OFFSET;
        u32 mask = DEFM_RESTART_MASK;
        void __iomem *working_address = ((u8 *)lp->base_addr
        + DEFM_RESTART_ADDR);
        u32 restart = 0;

        xroe_size = min_t(size_t, count, (size_t)XROE_SIZE_MAX);
        strncpy(xroe_tmp, buff, xroe_size);
        if (strncmp(xroe_tmp, "true", xroe_size) == 0) {
                restart = 0x01;
                utils_write32withmask(working_address, restart,
                                      mask, offset);
        } else if (strncmp(xroe_tmp, "false", xroe_size) == 0) {
                restart = 0x00;
                utils_write32withmask(working_address, restart,
                                      mask, offset);
        }

        return xroe_size;
}

/**
 * xxv_reset_show - Returns the XXV's reset status
 * @kobj:       The kernel object of the entry
 * @attr:       The attributes of the kernel object
 * @buff:       The buffer containing the reset status
 *
 * Reads and writes the XXV's reset status to the sysfs entry
 *
 * Return: XROE_SIZE_MAX on success
 */
static ssize_t xxv_reset_show(struct kobject *kobj, struct kobj_attribute *attr,
                              char *buff)
{
        u32 offset = CFG_USER_RW_OUT_OFFSET;
        u32 mask = CFG_USER_RW_OUT_MASK;
        u32 buffer = 0;
        u32 restart = 0;
        void __iomem *working_address = ((u8 *)lp->base_addr +
        CFG_USER_RW_OUT_ADDR);

        buffer = ioread32(working_address);
        restart = (buffer & mask) >> offset;
        if (restart)
                sprintf(buff, "true\n");
        else
                sprintf(buff, "false\n");
        return XROE_SIZE_MAX;
}

/**
 * xxv_reset_store - Writes to the XXV's reset register
 * @kobj:       The kernel object of the entry
 * @attr:       The attributes of the kernel object
 * @buff:       The buffer containing the reset status
 * @count:      The number of characters typed by the user
 *
 * Reads the user input and accordingly writes the XXV's reset status
 * to the sysfs entry
 *
 * Return: XROE_SIZE_MAX or the value of "count", if that's lesser, on success
 */
static ssize_t xxv_reset_store(struct  kobject *kobj,
                               struct kobj_attribute *attr,
                               const char *buff, size_t count)
{
        u32 offset = CFG_USER_RW_OUT_OFFSET;
        u32 mask = CFG_USER_RW_OUT_MASK;
        void __iomem *working_address = ((u8 *)lp->base_addr +
        CFG_USER_RW_OUT_ADDR);
        u32 restart = 0;

        xroe_size = min_t(size_t, count, (size_t)XROE_SIZE_MAX);
        strncpy(xroe_tmp, buff, xroe_size);

        if (strncmp(xroe_tmp, "true", xroe_size) == 0) {
                restart = 0x01;
                utils_write32withmask(working_address, restart,
                                      mask, offset);
        } else if (strncmp(xroe_tmp, "false", xroe_size) == 0) {
                restart = 0x00;
                utils_write32withmask(working_address, restart,
                                      mask, offset);
        }
        return xroe_size;
}

/**
 * framing_show - Returns the current framing
 * @kobj:       The kernel object of the entry
 * @attr:       The attributes of the kernel object
 * @buff:       The buffer containing the reset status
 *
 * Reads and writes the current framing type to the sysfs entry
 *
 * Return: XROE_SIZE_MAX on success
 */
static ssize_t framing_show(struct kobject *kobj, struct kobj_attribute *attr,
                            char *buff)
{
        u32 offset = (DEFM_DATA_PKT_MESSAGE_TYPE_ADDR +
        DEFM_DATA_PKT_MESSAGE_TYPE_OFFSET);
        u8 buffer = 0;
        u8 framing = 0xff;
        void __iomem *working_address = ((u8 *)lp->base_addr + offset);

        buffer = ioread8(working_address);
        framing = buffer;
        if (framing == 0)
                sprintf(buff, "eCPRI\n");
        else if (framing == 1)
                sprintf(buff, "1914.3\n");
        return XROE_SIZE_MAX;
}

/**
 * framing_store - Writes to the current framing register
 * @kobj:       The kernel object of the entry
 * @attr:       The attributes of the kernel object
 * @buff:       The buffer containing the reset status
 * @count:      The number of characters typed by the user
 *
 * Reads the user input and accordingly writes the current framing
 * to the sysfs entry
 *
 * Return: XROE_SIZE_MAX or the value of "count", if that's lesser, on success
 */
static ssize_t framing_store(struct kobject *kobj, struct kobj_attribute *attr,
                             const char *buff, size_t count)
{
        u32 offset = (DEFM_DATA_PKT_MESSAGE_TYPE_ADDR +
        DEFM_DATA_PKT_MESSAGE_TYPE_OFFSET);
        void __iomem *working_address = ((u8 *)lp->base_addr + offset);

        xroe_size = min_t(size_t, count, (size_t)XROE_SIZE_MAX);
        strncpy(xroe_tmp, buff, xroe_size);
        if (strncmp(xroe_tmp, "eCPRI", xroe_size) == 0)
                iowrite8(0, working_address);
        else if (strncmp(xroe_tmp, "1914.3", xroe_size) == 0)
                iowrite8(1, working_address);
        return xroe_size;
}

/* TODO Use DEVICE_ATTR/_RW/_RO macros */

static struct kobj_attribute version_attribute =
        __ATTR(version, 0444, version_show, version_store);

static struct kobj_attribute enable_attribute =
        __ATTR(enable, 0660, enable_show, enable_store);

static struct kobj_attribute framer_restart =
        __ATTR(framer_restart, 0660, framer_restart_show, framer_restart_store);

static struct kobj_attribute deframer_restart =
        __ATTR(deframer_restart, 0660, deframer_restart_show,
               deframer_restart_store);

static struct kobj_attribute xxv_reset =
        __ATTR(xxv_reset, 0660, xxv_reset_show, xxv_reset_store);

static struct kobj_attribute framing_attribute =
        __ATTR(framing, 0660, framing_show, framing_store);

static struct attribute *attrs[] = {
        &version_attribute.attr,
        &enable_attribute.attr,
        &framer_restart.attr,
        &deframer_restart.attr,
        &xxv_reset.attr,
        &framing_attribute.attr,
        NULL,
};

static struct attribute_group attr_group = {
        .attrs = attrs,
};

struct kobject *root_xroe_kobj;

/**
 * xroe_sysfs_init - Creates the xroe sysfs directory and entries
 *
 * Return: 0 on success, negative value in case of failure to
 * create the sysfs group
 *
 * Creates the xroe sysfs directory and entries, as well as the
 * subdirectories for IPv4, IPv6 & UDP
 */
int xroe_sysfs_init(void)
{
        int ret;

        root_xroe_kobj = kobject_create_and_add("xroe", kernel_kobj);
        if (!root_xroe_kobj)
                return -ENOMEM;
        ret = sysfs_create_group(root_xroe_kobj, &attr_group);
        if (ret)
                kobject_put(root_xroe_kobj);
        ret = xroe_sysfs_ipv4_init();
        if (ret)
                return ret;
        ret = xroe_sysfs_ipv6_init();
        if (ret)
                return ret;
        ret = xroe_sysfs_udp_init();
        if (ret)
                return ret;
        ret = xroe_sysfs_stats_init();
        return ret;
}

/**
 * xroe_sysfs_exit - Deletes the xroe sysfs directory and entries
 *
 * Deletes the xroe sysfs directory and entries, as well as the
 * subdirectories for IPv4, IPv6 & UDP
 *
 */
void xroe_sysfs_exit(void)
{
        int i;

        xroe_sysfs_ipv4_exit();
        xroe_sysfs_ipv6_exit();
        xroe_sysfs_udp_exit();
        xroe_sysfs_stats_exit();
        for (i = 0; i < MAX_NUM_ETH_PORTS; i++)
                kobject_put(kobj_eth_ports[i]);
        kobject_put(kobj_framer);
        kobject_put(root_xroe_kobj);
}

/**
 * utils_write32withmask - Writes a masked 32-bit value
 * @working_address:    The starting address to write
 * @value:                      The value to be written
 * @mask:                       The mask to be used
 * @offset:                     The offset from the provided starting address
 *
 * Writes a 32-bit value to the provided address with the input mask
 *
 * Return: 0 on success
 */
int utils_write32withmask(void __iomem *working_address, u32 value,
                          u32 mask, u32 offset)
{
        u32 read_register_value = 0;
        u32 register_value_to_write = 0;
        u32 delta = 0, buffer = 0;

        read_register_value = ioread32(working_address);
        buffer = (value << offset);
        register_value_to_write = read_register_value & ~mask;
        delta = buffer & mask;
        register_value_to_write |= delta;
        iowrite32(register_value_to_write, working_address);
        return 0;
}

/**
 * utils_sysfs_path_to_eth_port_num - Get the current ethernet port
 * @kobj:       The kobject of the entry calling the function
 *
 * Extracts the number of the current ethernet port instance
 *
 * Return: The number of the ethernet port instance (0 - MAX_NUM_ETH_PORTS) on
 * success, -1 otherwise
 */
static int utils_sysfs_path_to_eth_port_num(struct kobject *kobj)
{
        char *current_path = NULL;
        int port;
        int ret;

        current_path = kobject_get_path(kobj, GFP_KERNEL);
        ret = sscanf(current_path, "/kernel/xroe/framer/eth_port_%d/", &port);
        /* if sscanf() returns 0, no fields were assigned, therefore no
         * adjustments will be made for port number
         */
        if (ret == 0)
                port = 0;
//      printk(KERN_ALERT "current_path: %s port: %d\n", current_path, port);
        kfree(current_path);
        return port;
}

/**
 * utils_sysfs_store_wrapper - Wraps the storing function for sysfs entries
 * @address:    The address of the register to be written
 * @offset:     The offset from the address of the register
 * @mask:       The mask to be used on the value to be written
 * @value:      The value to be written to the register
 * @kobj:       The kobject of the entry calling the function
 *
 * Wraps the core functionality of all "store" functions of sysfs entries.
 * After calculating the ethernet port number (in N/A cases, it's 0), the value
 * is written to the designated register
 *
 */
void utils_sysfs_store_wrapper(u32 address, u32 offset, u32 mask, u32 value,
                               struct kobject *kobj)
{
        int port;
        void __iomem *working_address;

        port = utils_sysfs_path_to_eth_port_num(kobj);
        working_address = (void __iomem *)(lp->base_addr +
                          (address + (0x100 * port)));
        utils_write32withmask(working_address, value, mask, offset);
}

/**
 * utils_sysfs_store_wrapper - Wraps the storing function for sysfs entries
 * @address:    The address of the register to be read
 * @offset:     The offset from the address of the register
 * @mask:       The mask to be used on the value to be read
 * @kobj:       The kobject of the entry calling the function
 *
 * Wraps the core functionality of all "show" functions of sysfs entries.
 * After calculating the ethernet port number (in N/A cases, it's 0), the value
 * is read from the designated register and returned.
 *
 * Return: The value designated by the address, offset and mask
 */
u32 utils_sysfs_show_wrapper(u32 address, u32 offset, u32 mask,
                             struct kobject *kobj)
{
        int port;
        void __iomem *working_address;
        u32 buffer;

        port = utils_sysfs_path_to_eth_port_num(kobj);
        working_address = (void __iomem *)(lp->base_addr +
                          (address + (0x100 * port)));
        buffer = ioread32(working_address);
        return (buffer & mask) >> offset;
}