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

#ifndef _CRYPTO_ECB_CBC_HELPER_H
#define _CRYPTO_ECB_CBC_HELPER_H

#include <crypto/internal/skcipher.h>
#include <asm/fpu/api.h>

/*
 * Mode helpers to instantiate parameterized skcipher ECB/CBC modes without
 * having to rely on indirect calls and retpolines.
 */

#define ECB_WALK_START(req, bsize, fpu_blocks) do {                     \
        void *ctx = crypto_skcipher_ctx(crypto_skcipher_reqtfm(req));   \
        const int __fpu_blocks = (fpu_blocks);                          \
        const int __bsize = (bsize);                                    \
        struct skcipher_walk walk;                                      \
        int err = skcipher_walk_virt(&walk, (req), false);              \
        while (walk.nbytes > 0) {                                       \
                unsigned int nbytes = walk.nbytes;                      \
                bool do_fpu = __fpu_blocks != -1 &&                     \
                              nbytes >= __fpu_blocks * __bsize;         \
                const u8 *src = walk.src.virt.addr;                     \
                u8 *dst = walk.dst.virt.addr;                           \
                u8 __maybe_unused buf[(bsize)];                         \
                if (do_fpu) kernel_fpu_begin()

#define CBC_WALK_START(req, bsize, fpu_blocks)                          \
        ECB_WALK_START(req, bsize, fpu_blocks)

#define ECB_WALK_ADVANCE(blocks) do {                                   \
        dst += (blocks) * __bsize;                                      \
        src += (blocks) * __bsize;                                      \
        nbytes -= (blocks) * __bsize;                                   \
} while (0)

#define ECB_BLOCK(blocks, func) do {                                    \
        const int __blocks = (blocks);                                  \
        if (do_fpu && __blocks < __fpu_blocks) {                        \
                kernel_fpu_end();                                       \
                do_fpu = false;                                         \
        }                                                               \
        while (nbytes >= __blocks * __bsize) {                          \
                (func)(ctx, dst, src);                                  \
                ECB_WALK_ADVANCE(blocks);                               \
        }                                                               \
} while (0)

#define CBC_ENC_BLOCK(func) do {                                        \
        const u8 *__iv = walk.iv;                                       \
        while (nbytes >= __bsize) {                                     \
                crypto_xor_cpy(dst, src, __iv, __bsize);                \
                (func)(ctx, dst, dst);                                  \
                __iv = dst;                                             \
                ECB_WALK_ADVANCE(1);                                    \
        }                                                               \
        memcpy(walk.iv, __iv, __bsize);                                 \
} while (0)

#define CBC_DEC_BLOCK(blocks, func) do {                                \
        const int __blocks = (blocks);                                  \
        if (do_fpu && __blocks <  __fpu_blocks) {                       \
                kernel_fpu_end();                                       \
                do_fpu = false;                                         \
        }                                                               \
        while (nbytes >= __blocks * __bsize) {                          \
                const u8 *__iv = src + ((blocks) - 1) * __bsize;        \
                if (dst == src)                                         \
                        __iv = memcpy(buf, __iv, __bsize);              \
                (func)(ctx, dst, src);                                  \
                crypto_xor(dst, walk.iv, __bsize);                      \
                memcpy(walk.iv, __iv, __bsize);                         \
                ECB_WALK_ADVANCE(blocks);                               \
        }                                                               \
} while (0)

#define ECB_WALK_END()                                                  \
                if (do_fpu) kernel_fpu_end();                           \
                err = skcipher_walk_done(&walk, nbytes);                \
        }                                                               \
        return err;                                                     \
} while (0)

#define CBC_WALK_END() ECB_WALK_END()

#endif