// SPDX-License-Identifier: GPL-2.0+
/*
 * (C) Copyright 2015
 * Texas Instruments Incorporated - http://www.ti.com/
 */
#define pr_fmt(fmt) "%s: " fmt, __func__
#include <common.h>
#include <errno.h>
#include <fdtdec.h>
#include <malloc.h>
#include <remoteproc.h>
#include <asm/io.h>
#include <dm/device-internal.h>
#include <dm.h>
#include <dm/uclass.h>
#include <dm/uclass-internal.h>

DECLARE_GLOBAL_DATA_PTR;

/**
 * for_each_remoteproc_device() - iterate through the list of rproc devices
 * @fn: check function to call per match, if this function returns fail,
 *      iteration is aborted with the resultant error value
 * @skip_dev:   Device to skip calling the callback about.
 * @data:       Data to pass to the callback function
 *
 * Return: 0 if none of the callback returned a non 0 result, else returns the
 * result from the callback function
 */
static int for_each_remoteproc_device(int (*fn) (struct udevice *dev,
                                        struct dm_rproc_uclass_pdata *uc_pdata,
                                        const void *data),
                                      struct udevice *skip_dev,
                                      const void *data)
{
        struct udevice *dev;
        struct dm_rproc_uclass_pdata *uc_pdata;
        int ret;

        for (ret = uclass_find_first_device(UCLASS_REMOTEPROC, &dev); dev;
             ret = uclass_find_next_device(&dev)) {
                if (ret || dev == skip_dev)
                        continue;
                uc_pdata = dev_get_uclass_platdata(dev);
                ret = fn(dev, uc_pdata, data);
                if (ret)
                        return ret;
        }

        return 0;
}

/**
 * _rproc_name_is_unique() - iteration helper to check if rproc name is unique
 * @dev:        device that we are checking name for
 * @uc_pdata:   uclass platform data
 * @data:       compare data (this is the name we want to ensure is unique)
 *
 * Return: 0 is there is no match(is unique); if there is a match(we dont
 * have a unique name), return -EINVAL.
 */
static int _rproc_name_is_unique(struct udevice *dev,
                                 struct dm_rproc_uclass_pdata *uc_pdata,
                                 const void *data)
{
        const char *check_name = data;

        /* devices not yet populated with data - so skip them */
        if (!uc_pdata->name || !check_name)
                return 0;

        /* Return 0 to search further if we dont match */
        if (strlen(uc_pdata->name) != strlen(check_name))
                return 0;

        if (!strcmp(uc_pdata->name, check_name))
                return -EINVAL;

        return 0;
}

/**
 * rproc_name_is_unique() - Check if the rproc name is unique
 * @check_dev:  Device we are attempting to ensure is unique
 * @check_name: Name we are trying to ensure is unique.
 *
 * Return: true if we have a unique name, false if name is not unique.
 */
static bool rproc_name_is_unique(struct udevice *check_dev,
                                 const char *check_name)
{
        int ret;

        ret = for_each_remoteproc_device(_rproc_name_is_unique,
                                         check_dev, check_name);
        return ret ? false : true;
}

/**
 * rproc_pre_probe() - Pre probe accessor for the uclass
 * @dev:        device for which we are preprobing
 *
 * Parses and fills up the uclass pdata for use as needed by core and
 * remote proc drivers.
 *
 * Return: 0 if all wernt ok, else appropriate error value.
 */
static int rproc_pre_probe(struct udevice *dev)
{
        struct dm_rproc_uclass_pdata *uc_pdata;
        const struct dm_rproc_ops *ops;

        uc_pdata = dev_get_uclass_platdata(dev);

        /* See if we need to populate via fdt */

        if (!dev->platdata) {
#if CONFIG_IS_ENABLED(OF_CONTROL)
                int node = dev_of_offset(dev);
                const void *blob = gd->fdt_blob;
                bool tmp;
                if (!blob) {
                        debug("'%s' no dt?\n", dev->name);
                        return -EINVAL;
                }
                debug("'%s': using fdt\n", dev->name);
                uc_pdata->name = fdt_getprop(blob, node,
                                             "remoteproc-name", NULL);

                /* Default is internal memory mapped */
                uc_pdata->mem_type = RPROC_INTERNAL_MEMORY_MAPPED;
                tmp = fdtdec_get_bool(blob, node,
                                      "remoteproc-internal-memory-mapped");
                if (tmp)
                        uc_pdata->mem_type = RPROC_INTERNAL_MEMORY_MAPPED;
#else
                /* Nothing much we can do about this, can we? */
                return -EINVAL;
#endif

        } else {
                struct dm_rproc_uclass_pdata *pdata = dev->platdata;

                debug("'%s': using legacy data\n", dev->name);
                if (pdata->name)
                        uc_pdata->name = pdata->name;
                uc_pdata->mem_type = pdata->mem_type;
                uc_pdata->driver_plat_data = pdata->driver_plat_data;
        }

        /* Else try using device Name */
        if (!uc_pdata->name)
                uc_pdata->name = dev->name;
        if (!uc_pdata->name) {
                debug("Unnamed device!");
                return -EINVAL;
        }

        if (!rproc_name_is_unique(dev, uc_pdata->name)) {
                debug("%s duplicate name '%s'\n", dev->name, uc_pdata->name);
                return -EINVAL;
        }

        ops = rproc_get_ops(dev);
        if (!ops) {
                debug("%s driver has no ops?\n", dev->name);
                return -EINVAL;
        }

        if (!ops->load || !ops->start) {
                debug("%s driver has missing mandatory ops?\n", dev->name);
                return -EINVAL;
        }

        return 0;
}

/**
 * rproc_post_probe() - post probe accessor for the uclass
 * @dev:        deivce we finished probing
 *
 * initiate init function after the probe is completed. This allows
 * the remote processor drivers to split up the initializations between
 * probe and init as needed.
 *
 * Return: if the remote proc driver has a init routine, invokes it and
 * hands over the return value. overall, 0 if all went well, else appropriate
 * error value.
 */
static int rproc_post_probe(struct udevice *dev)
{
        const struct dm_rproc_ops *ops;

        ops = rproc_get_ops(dev);
        if (!ops) {
                debug("%s driver has no ops?\n", dev->name);
                return -EINVAL;
        }

        if (ops->init)
                return ops->init(dev);

        return 0;
}

UCLASS_DRIVER(rproc) = {
        .id = UCLASS_REMOTEPROC,
        .name = "remoteproc",
        .flags = DM_UC_FLAG_SEQ_ALIAS,
        .pre_probe = rproc_pre_probe,
        .post_probe = rproc_post_probe,
        .per_device_platdata_auto_alloc_size =
                sizeof(struct dm_rproc_uclass_pdata),
};

/* Remoteproc subsystem access functions */
/**
 * _rproc_probe_dev() - iteration helper to probe a rproc device
 * @dev:        device to probe
 * @uc_pdata:   uclass data allocated for the device
 * @data:       unused
 *
 * Return: 0 if all ok, else appropriate error value.
 */
static int _rproc_probe_dev(struct udevice *dev,
                            struct dm_rproc_uclass_pdata *uc_pdata,
                            const void *data)
{
        int ret;

        ret = device_probe(dev);

        if (ret)
                debug("%s: Failed to initialize - %d\n", dev->name, ret);
        return ret;
}

/**
 * _rproc_dev_is_probed() - check if the device has been probed
 * @dev:        device to check
 * @uc_pdata:   unused
 * @data:       unused
 *
 * Return: -EAGAIN if not probed else return 0
 */
static int _rproc_dev_is_probed(struct udevice *dev,
                            struct dm_rproc_uclass_pdata *uc_pdata,
                            const void *data)
{
        if (dev->flags & DM_FLAG_ACTIVATED)
                return 0;

        return -EAGAIN;
}

bool rproc_is_initialized(void)
{
        int ret = for_each_remoteproc_device(_rproc_dev_is_probed, NULL, NULL);
        return ret ? false : true;
}

int rproc_init(void)
{
        int ret;

        if (rproc_is_initialized()) {
                debug("Already initialized\n");
                return -EINVAL;
        }

        ret = for_each_remoteproc_device(_rproc_probe_dev, NULL, NULL);
        return ret;
}

int rproc_dev_init(int id)
{
        struct udevice *dev = NULL;
        int ret;

        ret = uclass_get_device_by_seq(UCLASS_REMOTEPROC, id, &dev);
        if (ret) {
                debug("Unknown remote processor id '%d' requested(%d)\n",
                      id, ret);
                return ret;
        }

        ret = device_probe(dev);
        if (ret)
                debug("%s: Failed to initialize - %d\n", dev->name, ret);

        return ret;
}

int rproc_load(int id, ulong addr, ulong size)
{
        struct udevice *dev = NULL;
        struct dm_rproc_uclass_pdata *uc_pdata;
        const struct dm_rproc_ops *ops;
        int ret;

        ret = uclass_get_device_by_seq(UCLASS_REMOTEPROC, id, &dev);
        if (ret) {
                debug("Unknown remote processor id '%d' requested(%d)\n",
                      id, ret);
                return ret;
        }

        uc_pdata = dev_get_uclass_platdata(dev);

        ops = rproc_get_ops(dev);
        if (!ops) {
                debug("%s driver has no ops?\n", dev->name);
                return -EINVAL;
        }

        debug("Loading to '%s' from address 0x%08lX size of %lu bytes\n",
              uc_pdata->name, addr, size);
        if (ops->load)
                return ops->load(dev, addr, size);

        debug("%s: data corruption?? mandatory function is missing!\n",
              dev->name);

        return -EINVAL;
};

/*
 * Completely internal helper enums..
 * Keeping this isolated helps this code evolve independent of other
 * parts..
 */
enum rproc_ops {
        RPROC_START,
        RPROC_STOP,
        RPROC_RESET,
        RPROC_PING,
        RPROC_RUNNING,
};

/**
 * _rproc_ops_wrapper() - wrapper for invoking remote proc driver callback
 * @id:         id of the remote processor
 * @op:         one of rproc_ops that indicate what operation to invoke
 *
 * Most of the checks and verification for remoteproc operations are more
 * or less same for almost all operations. This allows us to put a wrapper
 * and use the common checks to allow the driver to function appropriately.
 *
 * Return: 0 if all ok, else appropriate error value.
 */
static int _rproc_ops_wrapper(int id, enum rproc_ops op)
{
        struct udevice *dev = NULL;
        struct dm_rproc_uclass_pdata *uc_pdata;
        const struct dm_rproc_ops *ops;
        int (*fn)(struct udevice *dev);
        bool mandatory = false;
        char *op_str;
        int ret;

        ret = uclass_get_device_by_seq(UCLASS_REMOTEPROC, id, &dev);
        if (ret) {
                debug("Unknown remote processor id '%d' requested(%d)\n",
                      id, ret);
                return ret;
        }

        uc_pdata = dev_get_uclass_platdata(dev);

        ops = rproc_get_ops(dev);
        if (!ops) {
                debug("%s driver has no ops?\n", dev->name);
                return -EINVAL;
        }
        switch (op) {
        case RPROC_START:
                fn = ops->start;
                mandatory = true;
                op_str = "Starting";
                break;
        case RPROC_STOP:
                fn = ops->stop;
                op_str = "Stopping";
                break;
        case RPROC_RESET:
                fn = ops->reset;
                op_str = "Resetting";
                break;
        case RPROC_RUNNING:
                fn = ops->is_running;
                op_str = "Checking if running:";
                break;
        case RPROC_PING:
                fn = ops->ping;
                op_str = "Pinging";
                break;
        default:
                debug("what is '%d' operation??\n", op);
                return -EINVAL;
        }

        debug("%s %s...\n", op_str, uc_pdata->name);
        if (fn)
                return fn(dev);

        if (mandatory)
                debug("%s: data corruption?? mandatory function is missing!\n",
                      dev->name);

        return -ENOSYS;
}

int rproc_start(int id)
{
        return _rproc_ops_wrapper(id, RPROC_START);
};

int rproc_stop(int id)
{
        return _rproc_ops_wrapper(id, RPROC_STOP);
};

int rproc_reset(int id)
{
        return _rproc_ops_wrapper(id, RPROC_RESET);
};

int rproc_ping(int id)
{
        return _rproc_ops_wrapper(id, RPROC_PING);
};

int rproc_is_running(int id)
{
        return _rproc_ops_wrapper(id, RPROC_RUNNING);
};