// SPDX-License-Identifier: GPL-2.0-only

/*
 * Copyright (C) 2016 Cavium, Inc.
 */

#include <crypto/aes.h>
#include <crypto/algapi.h>
#include <crypto/authenc.h>
#include <crypto/internal/des.h>
#include <crypto/xts.h>
#include <linux/crypto.h>
#include <linux/err.h>
#include <linux/list.h>
#include <linux/scatterlist.h>

#include "cptvf.h"
#include "cptvf_algs.h"

struct cpt_device_handle {
        void *cdev[MAX_DEVICES];
        u32 dev_count;
};

static struct cpt_device_handle dev_handle;

static void cvm_callback(u32 status, void *arg)
{
        struct crypto_async_request *req = (struct crypto_async_request *)arg;

        crypto_request_complete(req, !status);
}

static inline void update_input_iv(struct cpt_request_info *req_info,
                                   u8 *iv, u32 enc_iv_len,
                                   u32 *argcnt)
{
        /* Setting the iv information */
        req_info->in[*argcnt].vptr = (void *)iv;
        req_info->in[*argcnt].size = enc_iv_len;
        req_info->req.dlen += enc_iv_len;

        ++(*argcnt);
}

static inline void update_output_iv(struct cpt_request_info *req_info,
                                    u8 *iv, u32 enc_iv_len,
                                    u32 *argcnt)
{
        /* Setting the iv information */
        req_info->out[*argcnt].vptr = (void *)iv;
        req_info->out[*argcnt].size = enc_iv_len;
        req_info->rlen += enc_iv_len;

        ++(*argcnt);
}

static inline void update_input_data(struct cpt_request_info *req_info,
                                     struct scatterlist *inp_sg,
                                     u32 nbytes, u32 *argcnt)
{
        req_info->req.dlen += nbytes;

        while (nbytes) {
                u32 len = min(nbytes, inp_sg->length);
                u8 *ptr = sg_virt(inp_sg);

                req_info->in[*argcnt].vptr = (void *)ptr;
                req_info->in[*argcnt].size = len;
                nbytes -= len;

                ++(*argcnt);
                ++inp_sg;
        }
}

static inline void update_output_data(struct cpt_request_info *req_info,
                                      struct scatterlist *outp_sg,
                                      u32 nbytes, u32 *argcnt)
{
        req_info->rlen += nbytes;

        while (nbytes) {
                u32 len = min(nbytes, outp_sg->length);
                u8 *ptr = sg_virt(outp_sg);

                req_info->out[*argcnt].vptr = (void *)ptr;
                req_info->out[*argcnt].size = len;
                nbytes -= len;
                ++(*argcnt);
                ++outp_sg;
        }
}

static inline u32 create_ctx_hdr(struct skcipher_request *req, u32 enc,
                                 u32 *argcnt)
{
        struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
        struct cvm_enc_ctx *ctx = crypto_skcipher_ctx(tfm);
        struct cvm_req_ctx *rctx = skcipher_request_ctx_dma(req);
        struct fc_context *fctx = &rctx->fctx;
        u32 enc_iv_len = crypto_skcipher_ivsize(tfm);
        struct cpt_request_info *req_info = &rctx->cpt_req;
        __be64 *ctrl_flags = NULL;
        __be64 *offset_control;

        req_info->ctrl.s.grp = 0;
        req_info->ctrl.s.dma_mode = DMA_GATHER_SCATTER;
        req_info->ctrl.s.se_req = SE_CORE_REQ;

        req_info->req.opcode.s.major = MAJOR_OP_FC |
                                        DMA_MODE_FLAG(DMA_GATHER_SCATTER);
        if (enc)
                req_info->req.opcode.s.minor = 2;
        else
                req_info->req.opcode.s.minor = 3;

        req_info->req.param1 = req->cryptlen; /* Encryption Data length */
        req_info->req.param2 = 0; /*Auth data length */

        fctx->enc.enc_ctrl.e.enc_cipher = ctx->cipher_type;
        fctx->enc.enc_ctrl.e.aes_key = ctx->key_type;
        fctx->enc.enc_ctrl.e.iv_source = FROM_DPTR;

        if (ctx->cipher_type == AES_XTS)
                memcpy(fctx->enc.encr_key, ctx->enc_key, ctx->key_len * 2);
        else
                memcpy(fctx->enc.encr_key, ctx->enc_key, ctx->key_len);
        ctrl_flags = (__be64 *)&fctx->enc.enc_ctrl.flags;
        *ctrl_flags = cpu_to_be64(fctx->enc.enc_ctrl.flags);

        offset_control = (__be64 *)&rctx->control_word;
        *offset_control = cpu_to_be64(((u64)(enc_iv_len) << 16));
        /* Storing  Packet Data Information in offset
         * Control Word First 8 bytes
         */
        req_info->in[*argcnt].vptr = (u8 *)offset_control;
        req_info->in[*argcnt].size = CONTROL_WORD_LEN;
        req_info->req.dlen += CONTROL_WORD_LEN;
        ++(*argcnt);

        req_info->in[*argcnt].vptr = (u8 *)fctx;
        req_info->in[*argcnt].size = sizeof(struct fc_context);
        req_info->req.dlen += sizeof(struct fc_context);

        ++(*argcnt);

        return 0;
}

static inline u32 create_input_list(struct skcipher_request  *req, u32 enc,
                                    u32 enc_iv_len)
{
        struct cvm_req_ctx *rctx = skcipher_request_ctx_dma(req);
        struct cpt_request_info *req_info = &rctx->cpt_req;
        u32 argcnt =  0;

        create_ctx_hdr(req, enc, &argcnt);
        update_input_iv(req_info, req->iv, enc_iv_len, &argcnt);
        update_input_data(req_info, req->src, req->cryptlen, &argcnt);
        req_info->incnt = argcnt;

        return 0;
}

static inline void store_cb_info(struct skcipher_request *req,
                                 struct cpt_request_info *req_info)
{
        req_info->callback = (void *)cvm_callback;
        req_info->callback_arg = (void *)&req->base;
}

static inline void create_output_list(struct skcipher_request *req,
                                      u32 enc_iv_len)
{
        struct cvm_req_ctx *rctx = skcipher_request_ctx_dma(req);
        struct cpt_request_info *req_info = &rctx->cpt_req;
        u32 argcnt = 0;

        /* OUTPUT Buffer Processing
         * AES encryption/decryption output would be
         * received in the following format
         *
         * ------IV--------|------ENCRYPTED/DECRYPTED DATA-----|
         * [ 16 Bytes/     [   Request Enc/Dec/ DATA Len AES CBC ]
         */
        /* Reading IV information */
        update_output_iv(req_info, req->iv, enc_iv_len, &argcnt);
        update_output_data(req_info, req->dst, req->cryptlen, &argcnt);
        req_info->outcnt = argcnt;
}

static inline int cvm_enc_dec(struct skcipher_request *req, u32 enc)
{
        struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
        struct cvm_req_ctx *rctx = skcipher_request_ctx_dma(req);
        u32 enc_iv_len = crypto_skcipher_ivsize(tfm);
        struct fc_context *fctx = &rctx->fctx;
        struct cpt_request_info *req_info = &rctx->cpt_req;
        void *cdev = NULL;
        int status;

        memset(req_info, 0, sizeof(struct cpt_request_info));
        req_info->may_sleep = (req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) != 0;
        memset(fctx, 0, sizeof(struct fc_context));
        create_input_list(req, enc, enc_iv_len);
        create_output_list(req, enc_iv_len);
        store_cb_info(req, req_info);
        cdev = dev_handle.cdev[smp_processor_id()];
        status = cptvf_do_request(cdev, req_info);
        /* We perform an asynchronous send and once
         * the request is completed the driver would
         * intimate through  registered call back functions
         */

        if (status)
                return status;
        else
                return -EINPROGRESS;
}

static int cvm_encrypt(struct skcipher_request *req)
{
        return cvm_enc_dec(req, true);
}

static int cvm_decrypt(struct skcipher_request *req)
{
        return cvm_enc_dec(req, false);
}

static int cvm_xts_setkey(struct crypto_skcipher *cipher, const u8 *key,
                   u32 keylen)
{
        struct cvm_enc_ctx *ctx = crypto_skcipher_ctx(cipher);
        int err;
        const u8 *key1 = key;
        const u8 *key2 = key + (keylen / 2);

        err = xts_verify_key(cipher, key, keylen);
        if (err)
                return err;
        ctx->key_len = keylen;
        memcpy(ctx->enc_key, key1, keylen / 2);
        memcpy(ctx->enc_key + KEY2_OFFSET, key2, keylen / 2);
        ctx->cipher_type = AES_XTS;
        switch (ctx->key_len) {
        case 32:
                ctx->key_type = AES_128_BIT;
                break;
        case 64:
                ctx->key_type = AES_256_BIT;
                break;
        default:
                return -EINVAL;
        }

        return 0;
}

static int cvm_validate_keylen(struct cvm_enc_ctx *ctx, u32 keylen)
{
        if ((keylen == 16) || (keylen == 24) || (keylen == 32)) {
                ctx->key_len = keylen;
                switch (ctx->key_len) {
                case 16:
                        ctx->key_type = AES_128_BIT;
                        break;
                case 24:
                        ctx->key_type = AES_192_BIT;
                        break;
                case 32:
                        ctx->key_type = AES_256_BIT;
                        break;
                default:
                        return -EINVAL;
                }

                if (ctx->cipher_type == DES3_CBC)
                        ctx->key_type = 0;

                return 0;
        }

        return -EINVAL;
}

static int cvm_setkey(struct crypto_skcipher *cipher, const u8 *key,
                      u32 keylen, u8 cipher_type)
{
        struct cvm_enc_ctx *ctx = crypto_skcipher_ctx(cipher);

        ctx->cipher_type = cipher_type;
        if (!cvm_validate_keylen(ctx, keylen)) {
                memcpy(ctx->enc_key, key, keylen);
                return 0;
        } else {
                return -EINVAL;
        }
}

static int cvm_cbc_aes_setkey(struct crypto_skcipher *cipher, const u8 *key,
                              u32 keylen)
{
        return cvm_setkey(cipher, key, keylen, AES_CBC);
}

static int cvm_ecb_aes_setkey(struct crypto_skcipher *cipher, const u8 *key,
                              u32 keylen)
{
        return cvm_setkey(cipher, key, keylen, AES_ECB);
}

static int cvm_cbc_des3_setkey(struct crypto_skcipher *cipher, const u8 *key,
                               u32 keylen)
{
        return verify_skcipher_des3_key(cipher, key) ?:
               cvm_setkey(cipher, key, keylen, DES3_CBC);
}

static int cvm_ecb_des3_setkey(struct crypto_skcipher *cipher, const u8 *key,
                               u32 keylen)
{
        return verify_skcipher_des3_key(cipher, key) ?:
               cvm_setkey(cipher, key, keylen, DES3_ECB);
}

static int cvm_enc_dec_init(struct crypto_skcipher *tfm)
{
        crypto_skcipher_set_reqsize_dma(tfm, sizeof(struct cvm_req_ctx));

        return 0;
}

static struct skcipher_alg algs[] = { {
        .base.cra_flags         = CRYPTO_ALG_ASYNC |
                                  CRYPTO_ALG_ALLOCATES_MEMORY,
        .base.cra_blocksize     = AES_BLOCK_SIZE,
        .base.cra_ctxsize       = sizeof(struct cvm_enc_ctx),
        .base.cra_alignmask     = 7,
        .base.cra_priority      = 4001,
        .base.cra_name          = "xts(aes)",
        .base.cra_driver_name   = "cavium-xts-aes",
        .base.cra_module        = THIS_MODULE,

        .ivsize                 = AES_BLOCK_SIZE,
        .min_keysize            = 2 * AES_MIN_KEY_SIZE,
        .max_keysize            = 2 * AES_MAX_KEY_SIZE,
        .setkey                 = cvm_xts_setkey,
        .encrypt                = cvm_encrypt,
        .decrypt                = cvm_decrypt,
        .init                   = cvm_enc_dec_init,
}, {
        .base.cra_flags         = CRYPTO_ALG_ASYNC |
                                  CRYPTO_ALG_ALLOCATES_MEMORY,
        .base.cra_blocksize     = AES_BLOCK_SIZE,
        .base.cra_ctxsize       = sizeof(struct cvm_enc_ctx),
        .base.cra_alignmask     = 7,
        .base.cra_priority      = 4001,
        .base.cra_name          = "cbc(aes)",
        .base.cra_driver_name   = "cavium-cbc-aes",
        .base.cra_module        = THIS_MODULE,

        .ivsize                 = AES_BLOCK_SIZE,
        .min_keysize            = AES_MIN_KEY_SIZE,
        .max_keysize            = AES_MAX_KEY_SIZE,
        .setkey                 = cvm_cbc_aes_setkey,
        .encrypt                = cvm_encrypt,
        .decrypt                = cvm_decrypt,
        .init                   = cvm_enc_dec_init,
}, {
        .base.cra_flags         = CRYPTO_ALG_ASYNC |
                                  CRYPTO_ALG_ALLOCATES_MEMORY,
        .base.cra_blocksize     = AES_BLOCK_SIZE,
        .base.cra_ctxsize       = sizeof(struct cvm_enc_ctx),
        .base.cra_alignmask     = 7,
        .base.cra_priority      = 4001,
        .base.cra_name          = "ecb(aes)",
        .base.cra_driver_name   = "cavium-ecb-aes",
        .base.cra_module        = THIS_MODULE,

        .min_keysize            = AES_MIN_KEY_SIZE,
        .max_keysize            = AES_MAX_KEY_SIZE,
        .setkey                 = cvm_ecb_aes_setkey,
        .encrypt                = cvm_encrypt,
        .decrypt                = cvm_decrypt,
        .init                   = cvm_enc_dec_init,
}, {
        .base.cra_flags         = CRYPTO_ALG_ASYNC |
                                  CRYPTO_ALG_ALLOCATES_MEMORY,
        .base.cra_blocksize     = DES3_EDE_BLOCK_SIZE,
        .base.cra_ctxsize       = sizeof(struct cvm_des3_ctx),
        .base.cra_alignmask     = 7,
        .base.cra_priority      = 4001,
        .base.cra_name          = "cbc(des3_ede)",
        .base.cra_driver_name   = "cavium-cbc-des3_ede",
        .base.cra_module        = THIS_MODULE,

        .min_keysize            = DES3_EDE_KEY_SIZE,
        .max_keysize            = DES3_EDE_KEY_SIZE,
        .ivsize                 = DES_BLOCK_SIZE,
        .setkey                 = cvm_cbc_des3_setkey,
        .encrypt                = cvm_encrypt,
        .decrypt                = cvm_decrypt,
        .init                   = cvm_enc_dec_init,
}, {
        .base.cra_flags         = CRYPTO_ALG_ASYNC |
                                  CRYPTO_ALG_ALLOCATES_MEMORY,
        .base.cra_blocksize     = DES3_EDE_BLOCK_SIZE,
        .base.cra_ctxsize       = sizeof(struct cvm_des3_ctx),
        .base.cra_alignmask     = 7,
        .base.cra_priority      = 4001,
        .base.cra_name          = "ecb(des3_ede)",
        .base.cra_driver_name   = "cavium-ecb-des3_ede",
        .base.cra_module        = THIS_MODULE,

        .min_keysize            = DES3_EDE_KEY_SIZE,
        .max_keysize            = DES3_EDE_KEY_SIZE,
        .ivsize                 = DES_BLOCK_SIZE,
        .setkey                 = cvm_ecb_des3_setkey,
        .encrypt                = cvm_encrypt,
        .decrypt                = cvm_decrypt,
        .init                   = cvm_enc_dec_init,
} };

static inline int cav_register_algs(void)
{
        return crypto_register_skciphers(algs, ARRAY_SIZE(algs));
}

static inline void cav_unregister_algs(void)
{
        crypto_unregister_skciphers(algs, ARRAY_SIZE(algs));
}

int cvm_crypto_init(struct cpt_vf *cptvf)
{
        struct pci_dev *pdev = cptvf->pdev;
        u32 dev_count;

        dev_count = dev_handle.dev_count;
        dev_handle.cdev[dev_count] = cptvf;
        dev_handle.dev_count++;

        if (dev_count == 3) {
                if (cav_register_algs()) {
                        dev_err(&pdev->dev, "Error in registering crypto algorithms\n");
                        return -EINVAL;
                }
        }

        return 0;
}

void cvm_crypto_exit(void)
{
        u32 dev_count;

        dev_count = --dev_handle.dev_count;
        if (!dev_count)
                cav_unregister_algs();
}