// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2019 HiSilicon Limited. */
/* Copyright (c) 2025 Loongson Technology Corporation Limited. */

#include <linux/crypto.h>
#include <linux/err.h>
#include <linux/hw_random.h>
#include <linux/io.h>
#include <linux/iopoll.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/mfd/loongson-se.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/platform_device.h>
#include <linux/random.h>
#include <crypto/internal/rng.h>

#define SE_SEED_SIZE 32

struct loongson_rng_list {
        struct mutex lock;
        struct list_head list;
        int registered;
};

struct loongson_rng {
        u32 used;
        struct loongson_se_engine *engine;
        struct list_head list;
        struct mutex lock;
};

struct loongson_rng_ctx {
        struct loongson_rng *rng;
};

struct loongson_rng_cmd {
        u32 cmd_id;
        union {
                u32 len;
                u32 ret;
        } u;
        u32 seed_off;
        u32 out_off;
        u32 pad[4];
};

static struct loongson_rng_list rng_devices = {
        .lock = __MUTEX_INITIALIZER(rng_devices.lock),
        .list = LIST_HEAD_INIT(rng_devices.list),
};

static int loongson_rng_generate(struct crypto_rng *tfm, const u8 *src,
                          unsigned int slen, u8 *dstn, unsigned int dlen)
{
        struct loongson_rng_ctx *ctx = crypto_rng_ctx(tfm);
        struct loongson_rng *rng = ctx->rng;
        struct loongson_rng_cmd *cmd = rng->engine->command;
        int err, len;

        mutex_lock(&rng->lock);
        cmd->seed_off = 0;
        do {
                len = min(dlen, rng->engine->buffer_size);
                cmd = rng->engine->command;
                cmd->u.len = len;
                err = loongson_se_send_engine_cmd(rng->engine);
                if (err)
                        break;

                cmd = rng->engine->command_ret;
                if (cmd->u.ret) {
                        err = -EIO;
                        break;
                }

                memcpy(dstn, rng->engine->data_buffer, len);
                dlen -= len;
                dstn += len;
        } while (dlen > 0);
        mutex_unlock(&rng->lock);

        return err;
}

static int loongson_rng_init(struct crypto_tfm *tfm)
{
        struct loongson_rng_ctx *ctx = crypto_tfm_ctx(tfm);
        struct loongson_rng *rng;
        u32 min_used = U32_MAX;

        mutex_lock(&rng_devices.lock);
        list_for_each_entry(rng, &rng_devices.list, list) {
                if (rng->used < min_used) {
                        ctx->rng = rng;
                        min_used = rng->used;
                }
        }
        ctx->rng->used++;
        mutex_unlock(&rng_devices.lock);

        return 0;
}

static void loongson_rng_exit(struct crypto_tfm *tfm)
{
        struct loongson_rng_ctx *ctx = crypto_tfm_ctx(tfm);

        mutex_lock(&rng_devices.lock);
        ctx->rng->used--;
        mutex_unlock(&rng_devices.lock);
}

static int loongson_rng_seed(struct crypto_rng *tfm, const u8 *seed,
                             unsigned int slen)
{
        struct loongson_rng_ctx *ctx = crypto_rng_ctx(tfm);
        struct loongson_rng *rng = ctx->rng;
        struct loongson_rng_cmd *cmd;
        int err;

        if (slen < SE_SEED_SIZE)
                return -EINVAL;

        slen = min(slen, rng->engine->buffer_size);

        mutex_lock(&rng->lock);
        cmd = rng->engine->command;
        cmd->u.len = slen;
        cmd->seed_off = rng->engine->buffer_off;
        memcpy(rng->engine->data_buffer, seed, slen);
        err = loongson_se_send_engine_cmd(rng->engine);
        if (err)
                goto out;

        cmd = rng->engine->command_ret;
        if (cmd->u.ret)
                err = -EIO;
out:
        mutex_unlock(&rng->lock);

        return err;
}

static struct rng_alg loongson_rng_alg = {
        .generate = loongson_rng_generate,
        .seed = loongson_rng_seed,
        .seedsize = SE_SEED_SIZE,
        .base = {
                .cra_name = "stdrng",
                .cra_driver_name = "loongson_stdrng",
                .cra_priority = 300,
                .cra_ctxsize = sizeof(struct loongson_rng_ctx),
                .cra_module = THIS_MODULE,
                .cra_init = loongson_rng_init,
                .cra_exit = loongson_rng_exit,
        },
};

static int loongson_rng_probe(struct platform_device *pdev)
{
        struct loongson_rng_cmd *cmd;
        struct loongson_rng *rng;
        int ret = 0;

        rng = devm_kzalloc(&pdev->dev, sizeof(*rng), GFP_KERNEL);
        if (!rng)
                return -ENOMEM;

        rng->engine = loongson_se_init_engine(pdev->dev.parent, SE_ENGINE_RNG);
        if (!rng->engine)
                return -ENODEV;
        cmd = rng->engine->command;
        cmd->cmd_id = SE_CMD_RNG;
        cmd->out_off = rng->engine->buffer_off;
        mutex_init(&rng->lock);

        mutex_lock(&rng_devices.lock);

        if (!rng_devices.registered) {
                ret = crypto_register_rng(&loongson_rng_alg);
                if (ret) {
                        dev_err(&pdev->dev, "failed to register crypto(%d)\n", ret);
                        goto out;
                }
                rng_devices.registered = 1;
        }

        list_add_tail(&rng->list, &rng_devices.list);
out:
        mutex_unlock(&rng_devices.lock);

        return ret;
}

static struct platform_driver loongson_rng_driver = {
        .probe          = loongson_rng_probe,
        .driver         = {
                .name   = "loongson-rng",
        },
};
module_platform_driver(loongson_rng_driver);

MODULE_ALIAS("platform:loongson-rng");
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Yinggang Gu <guyinggang@loongson.cn>");
MODULE_AUTHOR("Qunqin Zhao <zhaoqunqin@loongson.cn>");
MODULE_DESCRIPTION("Loongson Random Number Generator driver");