/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright (C) 2024 Christophe Leroy <christophe.leroy@csgroup.eu>, CS GROUP France
 */

#include <linux/linkage.h>

#include <asm/ppc_asm.h>

#define dst_bytes       r3
#define key             r4
#define counter         r5
#define nblocks         r6

#define idx_r0          r0
#define val4            r4

#define const0          0x61707865
#define const1          0x3320646e
#define const2          0x79622d32
#define const3          0x6b206574

#define key0            r5
#define key1            r6
#define key2            r7
#define key3            r8
#define key4            r9
#define key5            r10
#define key6            r11
#define key7            r12

#define counter0        r14
#define counter1        r15

#define state0          r16
#define state1          r17
#define state2          r18
#define state3          r19
#define state4          r20
#define state5          r21
#define state6          r22
#define state7          r23
#define state8          r24
#define state9          r25
#define state10         r26
#define state11         r27
#define state12         r28
#define state13         r29
#define state14         r30
#define state15         r31

.macro quarterround4 a1 b1 c1 d1 a2 b2 c2 d2 a3 b3 c3 d3 a4 b4 c4 d4
        add     \a1, \a1, \b1
        add     \a2, \a2, \b2
        add     \a3, \a3, \b3
        add     \a4, \a4, \b4
        xor     \d1, \d1, \a1
        xor     \d2, \d2, \a2
        xor     \d3, \d3, \a3
        xor     \d4, \d4, \a4
        rotlwi  \d1, \d1, 16
        rotlwi  \d2, \d2, 16
        rotlwi  \d3, \d3, 16
        rotlwi  \d4, \d4, 16
        add     \c1, \c1, \d1
        add     \c2, \c2, \d2
        add     \c3, \c3, \d3
        add     \c4, \c4, \d4
        xor     \b1, \b1, \c1
        xor     \b2, \b2, \c2
        xor     \b3, \b3, \c3
        xor     \b4, \b4, \c4
        rotlwi  \b1, \b1, 12
        rotlwi  \b2, \b2, 12
        rotlwi  \b3, \b3, 12
        rotlwi  \b4, \b4, 12
        add     \a1, \a1, \b1
        add     \a2, \a2, \b2
        add     \a3, \a3, \b3
        add     \a4, \a4, \b4
        xor     \d1, \d1, \a1
        xor     \d2, \d2, \a2
        xor     \d3, \d3, \a3
        xor     \d4, \d4, \a4
        rotlwi  \d1, \d1, 8
        rotlwi  \d2, \d2, 8
        rotlwi  \d3, \d3, 8
        rotlwi  \d4, \d4, 8
        add     \c1, \c1, \d1
        add     \c2, \c2, \d2
        add     \c3, \c3, \d3
        add     \c4, \c4, \d4
        xor     \b1, \b1, \c1
        xor     \b2, \b2, \c2
        xor     \b3, \b3, \c3
        xor     \b4, \b4, \c4
        rotlwi  \b1, \b1, 7
        rotlwi  \b2, \b2, 7
        rotlwi  \b3, \b3, 7
        rotlwi  \b4, \b4, 7
.endm

#define QUARTERROUND4(a1,b1,c1,d1,a2,b2,c2,d2,a3,b3,c3,d3,a4,b4,c4,d4) \
        quarterround4 state##a1 state##b1 state##c1 state##d1 \
                      state##a2 state##b2 state##c2 state##d2 \
                      state##a3 state##b3 state##c3 state##d3 \
                      state##a4 state##b4 state##c4 state##d4

/*
 * Very basic 32 bits implementation of ChaCha20. Produces a given positive number
 * of blocks of output with a nonce of 0, taking an input key and 8-byte
 * counter. Importantly does not spill to the stack. Its arguments are:
 *
 *      r3: output bytes
 *      r4: 32-byte key input
 *      r5: 8-byte counter input/output (saved on stack)
 *      r6: number of 64-byte blocks to write to output
 *
 *      r0: counter of blocks (initialised with r6)
 *      r4: Value '4' after key has been read.
 *      r5-r12: key
 *      r14-r15: counter
 *      r16-r31: state
 */
SYM_FUNC_START(__arch_chacha20_blocks_nostack)
#ifdef __powerpc64__
        std     counter, -216(r1)

        std     r14, -144(r1)
        std     r15, -136(r1)
        std     r16, -128(r1)
        std     r17, -120(r1)
        std     r18, -112(r1)
        std     r19, -104(r1)
        std     r20, -96(r1)
        std     r21, -88(r1)
        std     r22, -80(r1)
        std     r23, -72(r1)
        std     r24, -64(r1)
        std     r25, -56(r1)
        std     r26, -48(r1)
        std     r27, -40(r1)
        std     r28, -32(r1)
        std     r29, -24(r1)
        std     r30, -16(r1)
        std     r31, -8(r1)
#else
        stwu    r1, -96(r1)
        stw     counter, 20(r1)
#ifdef __BIG_ENDIAN__
        stmw    r14, 24(r1)
#else
        stw     r14, 24(r1)
        stw     r15, 28(r1)
        stw     r16, 32(r1)
        stw     r17, 36(r1)
        stw     r18, 40(r1)
        stw     r19, 44(r1)
        stw     r20, 48(r1)
        stw     r21, 52(r1)
        stw     r22, 56(r1)
        stw     r23, 60(r1)
        stw     r24, 64(r1)
        stw     r25, 68(r1)
        stw     r26, 72(r1)
        stw     r27, 76(r1)
        stw     r28, 80(r1)
        stw     r29, 84(r1)
        stw     r30, 88(r1)
        stw     r31, 92(r1)
#endif
#endif  /* __powerpc64__ */

        lwz     counter0, 0(counter)
        lwz     counter1, 4(counter)
#ifdef __powerpc64__
        rldimi  counter0, counter1, 32, 0
#endif
        mr      idx_r0, nblocks
        subi    dst_bytes, dst_bytes, 4

        lwz     key0, 0(key)
        lwz     key1, 4(key)
        lwz     key2, 8(key)
        lwz     key3, 12(key)
        lwz     key4, 16(key)
        lwz     key5, 20(key)
        lwz     key6, 24(key)
        lwz     key7, 28(key)

        li      val4, 4
.Lblock:
        li      r31, 10

        lis     state0, const0@ha
        lis     state1, const1@ha
        lis     state2, const2@ha
        lis     state3, const3@ha
        addi    state0, state0, const0@l
        addi    state1, state1, const1@l
        addi    state2, state2, const2@l
        addi    state3, state3, const3@l

        mtctr   r31

        mr      state4, key0
        mr      state5, key1
        mr      state6, key2
        mr      state7, key3
        mr      state8, key4
        mr      state9, key5
        mr      state10, key6
        mr      state11, key7

        mr      state12, counter0
        mr      state13, counter1

        li      state14, 0
        li      state15, 0

.Lpermute:
        QUARTERROUND4( 0, 4, 8,12, 1, 5, 9,13, 2, 6,10,14, 3, 7,11,15)
        QUARTERROUND4( 0, 5,10,15, 1, 6,11,12, 2, 7, 8,13, 3, 4, 9,14)

        bdnz    .Lpermute

        addis   state0, state0, const0@ha
        addis   state1, state1, const1@ha
        addis   state2, state2, const2@ha
        addis   state3, state3, const3@ha
        addi    state0, state0, const0@l
        addi    state1, state1, const1@l
        addi    state2, state2, const2@l
        addi    state3, state3, const3@l

        add     state4, state4, key0
        add     state5, state5, key1
        add     state6, state6, key2
        add     state7, state7, key3
        add     state8, state8, key4
        add     state9, state9, key5
        add     state10, state10, key6
        add     state11, state11, key7

        add     state12, state12, counter0
        add     state13, state13, counter1

#ifdef __BIG_ENDIAN__
        stwbrx  state0, val4, dst_bytes
        addi    dst_bytes, dst_bytes, 8
        stwbrx  state1, 0, dst_bytes
        stwbrx  state2, val4, dst_bytes
        addi    dst_bytes, dst_bytes, 8
        stwbrx  state3, 0, dst_bytes
        stwbrx  state4, val4, dst_bytes
        addi    dst_bytes, dst_bytes, 8
        stwbrx  state5, 0, dst_bytes
        stwbrx  state6, val4, dst_bytes
        addi    dst_bytes, dst_bytes, 8
        stwbrx  state7, 0, dst_bytes
        stwbrx  state8, val4, dst_bytes
        addi    dst_bytes, dst_bytes, 8
        stwbrx  state9, 0, dst_bytes
        stwbrx  state10, val4, dst_bytes
        addi    dst_bytes, dst_bytes, 8
        stwbrx  state11, 0, dst_bytes
        stwbrx  state12, val4, dst_bytes
        addi    dst_bytes, dst_bytes, 8
        stwbrx  state13, 0, dst_bytes
        stwbrx  state14, val4, dst_bytes
        addi    dst_bytes, dst_bytes, 8
        stwbrx  state15, 0, dst_bytes
#else
        stw     state0, 4(dst_bytes)
        stw     state1, 8(dst_bytes)
        stw     state2, 12(dst_bytes)
        stw     state3, 16(dst_bytes)
        stw     state4, 20(dst_bytes)
        stw     state5, 24(dst_bytes)
        stw     state6, 28(dst_bytes)
        stw     state7, 32(dst_bytes)
        stw     state8, 36(dst_bytes)
        stw     state9, 40(dst_bytes)
        stw     state10, 44(dst_bytes)
        stw     state11, 48(dst_bytes)
        stw     state12, 52(dst_bytes)
        stw     state13, 56(dst_bytes)
        stw     state14, 60(dst_bytes)
        stwu    state15, 64(dst_bytes)
#endif

        subic.  idx_r0, idx_r0, 1       /* subi. can't use r0 as source */

#ifdef __powerpc64__
        addi    counter0, counter0, 1
        srdi    counter1, counter0, 32
#else
        addic   counter0, counter0, 1
        addze   counter1, counter1
#endif

        bne     .Lblock

#ifdef __powerpc64__
        ld      counter, -216(r1)
#else
        lwz     counter, 20(r1)
#endif
        stw     counter0, 0(counter)
        stw     counter1, 4(counter)

        li      r6, 0
        li      r7, 0
        li      r8, 0
        li      r9, 0
        li      r10, 0
        li      r11, 0
        li      r12, 0

#ifdef __powerpc64__
        ld      r14, -144(r1)
        ld      r15, -136(r1)
        ld      r16, -128(r1)
        ld      r17, -120(r1)
        ld      r18, -112(r1)
        ld      r19, -104(r1)
        ld      r20, -96(r1)
        ld      r21, -88(r1)
        ld      r22, -80(r1)
        ld      r23, -72(r1)
        ld      r24, -64(r1)
        ld      r25, -56(r1)
        ld      r26, -48(r1)
        ld      r27, -40(r1)
        ld      r28, -32(r1)
        ld      r29, -24(r1)
        ld      r30, -16(r1)
        ld      r31, -8(r1)
#else
#ifdef __BIG_ENDIAN__
        lmw     r14, 24(r1)
#else
        lwz     r14, 24(r1)
        lwz     r15, 28(r1)
        lwz     r16, 32(r1)
        lwz     r17, 36(r1)
        lwz     r18, 40(r1)
        lwz     r19, 44(r1)
        lwz     r20, 48(r1)
        lwz     r21, 52(r1)
        lwz     r22, 56(r1)
        lwz     r23, 60(r1)
        lwz     r24, 64(r1)
        lwz     r25, 68(r1)
        lwz     r26, 72(r1)
        lwz     r27, 76(r1)
        lwz     r28, 80(r1)
        lwz     r29, 84(r1)
        lwz     r30, 88(r1)
        lwz     r31, 92(r1)
#endif
        addi    r1, r1, 96
#endif  /* __powerpc64__ */
        blr
SYM_FUNC_END(__arch_chacha20_blocks_nostack)