path: root/arch/powerpc/crypto/aes-gcm-p10.S

/* SPDX-License-Identifier: GPL-2.0-or-later */
#
# Accelerated AES-GCM stitched implementation for ppc64le.
#
# Copyright 2024- IBM Inc.
#
#===================================================================================
# Written by Danny Tsen <dtsen@us.ibm.com>
#
# GHASH is based on the Karatsuba multiplication method.
#
#    Xi xor X1
#
#    X1 * H^4 + X2 * H^3 + x3 * H^2 + X4 * H =
#      (X1.h * H4.h + xX.l * H4.l + X1 * H4) +
#      (X2.h * H3.h + X2.l * H3.l + X2 * H3) +
#      (X3.h * H2.h + X3.l * H2.l + X3 * H2) +
#      (X4.h * H.h + X4.l * H.l + X4 * H)
#
# Xi = v0
# H Poly = v2
# Hash keys = v3 - v14
#     ( H.l, H, H.h)
#     ( H^2.l, H^2, H^2.h)
#     ( H^3.l, H^3, H^3.h)
#     ( H^4.l, H^4, H^4.h)
#
# v30 is IV
# v31 - counter 1
#
# AES used,
#     vs0 - round key 0
#     v15, v16, v17, v18, v19, v20, v21, v22 for 8 blocks (encrypted)
#
# This implementation uses stitched AES-GCM approach to improve overall performance.
# AES is implemented with 8x blocks and GHASH is using 2 4x blocks.
#
# ===================================================================================
#

#include <asm/ppc_asm.h>
#include <linux/linkage.h>

.machine        "any"
.text

.macro	SAVE_GPR GPR OFFSET FRAME
	std	\GPR,\OFFSET(\FRAME)
.endm

.macro	SAVE_VRS VRS OFFSET FRAME
	stxv	\VRS+32, \OFFSET(\FRAME)
.endm

.macro	RESTORE_GPR GPR OFFSET FRAME
	ld	\GPR,\OFFSET(\FRAME)
.endm

.macro	RESTORE_VRS VRS OFFSET FRAME
	lxv	\VRS+32, \OFFSET(\FRAME)
.endm

.macro SAVE_REGS
	mflr 0
	std 0, 16(1)
	stdu 1,-512(1)

	SAVE_GPR 14, 112, 1
	SAVE_GPR 15, 120, 1
	SAVE_GPR 16, 128, 1
	SAVE_GPR 17, 136, 1
	SAVE_GPR 18, 144, 1
	SAVE_GPR 19, 152, 1
	SAVE_GPR 20, 160, 1
	SAVE_GPR 21, 168, 1
	SAVE_GPR 22, 176, 1
	SAVE_GPR 23, 184, 1
	SAVE_GPR 24, 192, 1

	addi	9, 1, 256
	SAVE_VRS 20, 0, 9
	SAVE_VRS 21, 16, 9
	SAVE_VRS 22, 32, 9
	SAVE_VRS 23, 48, 9
	SAVE_VRS 24, 64, 9
	SAVE_VRS 25, 80, 9
	SAVE_VRS 26, 96, 9
	SAVE_VRS 27, 112, 9
	SAVE_VRS 28, 128, 9
	SAVE_VRS 29, 144, 9
	SAVE_VRS 30, 160, 9
	SAVE_VRS 31, 176, 9
.endm # SAVE_REGS

.macro RESTORE_REGS
	addi	9, 1, 256
	RESTORE_VRS 20, 0, 9
	RESTORE_VRS 21, 16, 9
	RESTORE_VRS 22, 32, 9
	RESTORE_VRS 23, 48, 9
	RESTORE_VRS 24, 64, 9
	RESTORE_VRS 25, 80, 9
	RESTORE_VRS 26, 96, 9
	RESTORE_VRS 27, 112, 9
	RESTORE_VRS 28, 128, 9
	RESTORE_VRS 29, 144, 9
	RESTORE_VRS 30, 160, 9
	RESTORE_VRS 31, 176, 9

	RESTORE_GPR 14, 112, 1
	RESTORE_GPR 15, 120, 1
	RESTORE_GPR 16, 128, 1
	RESTORE_GPR 17, 136, 1
	RESTORE_GPR 18, 144, 1
	RESTORE_GPR 19, 152, 1
	RESTORE_GPR 20, 160, 1
	RESTORE_GPR 21, 168, 1
	RESTORE_GPR 22, 176, 1
	RESTORE_GPR 23, 184, 1
	RESTORE_GPR 24, 192, 1

	addi    1, 1, 512
	ld 0, 16(1)
	mtlr 0
.endm # RESTORE_REGS

# 4x loops
.macro AES_CIPHER_4x _VCIPHER ST r
	\_VCIPHER	\ST, \ST, \r
	\_VCIPHER	\ST+1, \ST+1, \r
	\_VCIPHER	\ST+2, \ST+2, \r
	\_VCIPHER	\ST+3, \ST+3, \r
.endm

# 8x loops
.macro AES_CIPHER_8x _VCIPHER ST r
	\_VCIPHER	\ST, \ST, \r
	\_VCIPHER	\ST+1, \ST+1, \r
	\_VCIPHER	\ST+2, \ST+2, \r
	\_VCIPHER	\ST+3, \ST+3, \r
	\_VCIPHER	\ST+4, \ST+4, \r
	\_VCIPHER	\ST+5, \ST+5, \r
	\_VCIPHER	\ST+6, \ST+6, \r
	\_VCIPHER	\ST+7, \ST+7, \r
.endm

.macro LOOP_8AES_STATE
	xxlor	32+23, 1, 1
	xxlor	32+24, 2, 2
	xxlor	32+25, 3, 3
	xxlor	32+26, 4, 4
	AES_CIPHER_8x vcipher, 15, 23
	AES_CIPHER_8x vcipher, 15, 24
	AES_CIPHER_8x vcipher, 15, 25
	AES_CIPHER_8x vcipher, 15, 26
	xxlor	32+23, 5, 5
	xxlor	32+24, 6, 6
	xxlor	32+25, 7, 7
	xxlor	32+26, 8, 8
	AES_CIPHER_8x vcipher, 15, 23
	AES_CIPHER_8x vcipher, 15, 24
	AES_CIPHER_8x vcipher, 15, 25
	AES_CIPHER_8x vcipher, 15, 26
.endm

#
# PPC_GHASH4x(H, S1, S2, S3, S4): Compute 4x hash values based on Karatsuba method.
# H: returning digest
# S#: states
#
# S1 should xor with the previous digest
#
# Xi = v0
# H Poly = v2
# Hash keys = v3 - v14
# Scratch: v23 - v29
#
.macro PPC_GHASH4x H S1 S2 S3 S4

	vpmsumd	23, 12, \S1		# H4.L * X.L
	vpmsumd	24, 9, \S2
	vpmsumd	25, 6, \S3
	vpmsumd	26, 3, \S4

	vpmsumd	27, 13, \S1		# H4.L * X.H + H4.H * X.L
	vpmsumd	28, 10, \S2		# H3.L * X1.H + H3.H * X1.L

	vxor	23, 23, 24
	vxor	23, 23, 25
	vxor	23, 23, 26		# L

	vxor	24, 27, 28
	vpmsumd	25, 7, \S3
	vpmsumd	26, 4, \S4

	vxor	24, 24, 25
	vxor	24, 24, 26		# M

	# sum hash and reduction with H Poly
	vpmsumd	28, 23, 2		# reduction

	vxor	1, 1, 1
	vsldoi	25, 24, 1, 8		# mL
	vsldoi	1, 1, 24, 8		# mH
	vxor	23, 23, 25		# mL + L

	# This performs swap and xor like,
	#   vsldoi	23, 23, 23, 8		# swap
	#   vxor	23, 23, 28
	xxlor	32+25, 10, 10
	vpermxor 23, 23, 28, 25

	vpmsumd	26, 14, \S1		# H4.H * X.H
	vpmsumd	27, 11, \S2
	vpmsumd	28, 8, \S3
	vpmsumd	29, 5, \S4

	vxor	24, 26, 27
	vxor	24, 24, 28
	vxor	24, 24, 29

	vxor	24, 24, 1

	# sum hash and reduction with H Poly
	vsldoi	25, 23, 23, 8		# swap
	vpmsumd	23, 23, 2
	vxor	27, 25, 24
	vxor	\H, 23, 27
.endm

#
# Compute update single ghash
# scratch: v1, v22..v27
#
.macro PPC_GHASH1x H S1

	vxor	1, 1, 1

	vpmsumd	22, 3, \S1		# L
	vpmsumd	23, 4, \S1		# M
	vpmsumd	24, 5, \S1		# H

	vpmsumd	27, 22, 2		# reduction

	vsldoi	25, 23, 1, 8		# mL
	vsldoi	26, 1, 23, 8		# mH
	vxor	22, 22, 25		# LL + LL
	vxor	24, 24, 26		# HH + HH

	xxlor	32+25, 10, 10
	vpermxor 22, 22, 27, 25

	vsldoi	23, 22, 22, 8		# swap
	vpmsumd	22, 22, 2		# reduction
	vxor	23, 23, 24
	vxor	\H, 22, 23
.endm

#
# LOAD_HASH_TABLE
# Xi = v0
# H Poly = v2
# Hash keys = v3 - v14
#
.macro LOAD_HASH_TABLE
	# Load Xi
	lxvb16x	32, 0, 8	# load Xi

	# load Hash - h^4, h^3, h^2, h
	li	10, 32
	lxvd2x	2+32, 10, 8	# H Poli
	li	10, 48
	lxvd2x	3+32, 10, 8	# Hl
	li	10, 64
	lxvd2x	4+32, 10, 8	# H
	li	10, 80
	lxvd2x	5+32, 10, 8	# Hh

	li	10, 96
	lxvd2x	6+32, 10, 8	# H^2l
	li	10, 112
	lxvd2x	7+32, 10, 8	# H^2
	li	10, 128
	lxvd2x	8+32, 10, 8	# H^2h

	li	10, 144
	lxvd2x	9+32, 10, 8	# H^3l
	li	10, 160
	lxvd2x	10+32, 10, 8	# H^3
	li	10, 176
	lxvd2x	11+32, 10, 8	# H^3h

	li	10, 192
	lxvd2x	12+32, 10, 8	# H^4l
	li	10, 208
	lxvd2x	13+32, 10, 8	# H^4
	li	10, 224
	lxvd2x	14+32, 10, 8	# H^4h
.endm

################################################################################
# Compute AES and ghash one block at a time.
# r23: AES rounds
# v30: current IV
# vs0: roundkey 0
#
################################################################################
SYM_FUNC_START_LOCAL(aes_gcm_crypt_1x)

	cmpdi	5, 16
	bge	__More_1x
	blr
__More_1x:
	li      10, 16
	divdu   12, 5, 10

	xxlxor	32+15, 32+30, 0

	# Pre-load 8 AES rounds to scratch vectors.
	xxlor	32+16, 1, 1
	xxlor	32+17, 2, 2
	xxlor	32+18, 3, 3
	xxlor	32+19, 4, 4
	xxlor	32+20, 5, 5
	xxlor	32+21, 6, 6
	xxlor	32+28, 7, 7
	xxlor	32+29, 8, 8
	lwz	23, 240(6)	# n rounds
	addi	22, 23, -9	# remaing AES rounds

	cmpdi	12, 0
	bgt	__Loop_1x
	blr

__Loop_1x:
	mtctr	22
	addi	10, 6, 144
	vcipher	15, 15, 16
	vcipher	15, 15, 17
	vcipher	15, 15, 18
	vcipher	15, 15, 19
	vcipher	15, 15, 20
	vcipher	15, 15, 21
	vcipher	15, 15, 28
	vcipher	15, 15, 29

__Loop_aes_1state:
	lxv	32+1, 0(10)
	vcipher	15, 15, 1
	addi	10, 10, 16
	bdnz	__Loop_aes_1state
	lxv	32+1, 0(10)		# last round key
	lxvb16x 11, 0, 14		# load input block
	vcipherlast 15, 15, 1

	xxlxor	32+15, 32+15, 11
	stxvb16x 32+15, 0, 9	# store output
	addi	14, 14, 16
	addi	9, 9, 16

	cmpdi	24, 0	# decrypt?
	bne	__Encrypt_1x
	xxlor	15+32, 11, 11
__Encrypt_1x:
	vxor	15, 15, 0
	PPC_GHASH1x 0, 15

	addi	5, 5, -16
	addi	11, 11, 16

	vadduwm 30, 30, 31		# IV + counter
	xxlxor	32+15, 32+30, 0
	addi	12, 12, -1
	cmpdi	12, 0
	bgt	__Loop_1x

	stxvb16x 32+30, 0, 7		# update IV
	stxvb16x 32+0, 0, 8		# update Xi
	blr
SYM_FUNC_END(aes_gcm_crypt_1x)

################################################################################
# Process a normal partial block when we come here.
#  Compute partial mask, Load and store partial block to stack.
#  Update partial_len and pblock.
#  pblock is (encrypted ^ AES state) for encrypt
#        and (input ^ AES state) for decrypt.
#
################################################################################
SYM_FUNC_START_LOCAL(__Process_partial)

	# create partial mask
	vspltisb 16, -1
	li	12, 16
	sub	12, 12, 5
	sldi	12, 12, 3
	mtvsrdd	32+17, 0, 12
	vslo	16, 16, 17		# partial block mask

	lxvb16x 11, 0, 14		# load partial block
	xxland	11, 11, 32+16

	# AES crypt partial
	xxlxor	32+15, 32+30, 0
	lwz	23, 240(6)		# n rounds
	addi	22, 23, -1		# loop - 1
	mtctr	22
	addi	10, 6, 16

__Loop_aes_pstate:
	lxv	32+1, 0(10)
	vcipher	15, 15, 1
	addi	10, 10, 16
	bdnz	__Loop_aes_pstate
	lxv	32+1, 0(10)		# last round key
	vcipherlast 15, 15, 1

	xxlxor	32+15, 32+15, 11
	vand	15, 15, 16

	# AES crypt output v15
	# Write partial
	li	10, 224
	stxvb16x 15+32, 10, 1		# write v15 to stack
	addi	10, 1, 223
	addi	12, 9, -1
        mtctr	5			# partial block len
__Write_partial:
        lbzu	22, 1(10)
	stbu	22, 1(12)
        bdnz	__Write_partial

	cmpdi	24, 0			# decrypt?
	bne	__Encrypt_partial
	xxlor	32+15, 11, 11		# decrypt using the input block
__Encrypt_partial:
	#vxor	15, 15, 0		# ^ previous hash
	#PPC_GHASH1x 0, 15

	add	14, 14, 5
	add	9, 9, 5
	std	5, 56(7)		# update partial
	sub	11, 11, 5
	li	5, 0			# done last byte

	#
	# Don't increase IV since this is the last partial.
	# It should get updated in gcm_update if no more data blocks.
	#vadduwm	30, 30, 31		# increase IV
	stxvb16x 32+30, 0, 7		# update IV
	li	10, 64
	stxvb16x 32+0, 0, 8		# Update X1
	stxvb16x 32+15, 10, 7		# Update pblock
	blr
SYM_FUNC_END(__Process_partial)

################################################################################
# Combine partial blocks and ghash when we come here.
#
# The partial block has to be shifted to the right location to encrypt/decrypt
# and compute ghash if combing the previous partial block is needed.
# - Compute ghash for a full block. Clear Partial_len and pblock. Update IV.
#   Write Xi.
# - Don't compute ghash if not full block.  gcm_update will take care of it
#   is the last block. Update Partial_len and pblock.
#
################################################################################
SYM_FUNC_START_LOCAL(__Combine_partial)

	ld	12, 56(7)
	mr	21, 5			# these bytes to be processed

	li	17, 0
	li	16, 16
	sub	22, 16, 12		# bytes to complete a block
	sub	17, 22, 5		# remaining bytes in a block
	cmpdi	5, 16
	ble	__Inp_msg_less16
	li	17, 0
	mr	21, 22
	b	__Combine_continue
__Inp_msg_less16:
	cmpd	22, 5
	bgt	__Combine_continue
	li	17, 0
	mr	21, 22			# these bytes to be processed

__Combine_continue:
	# load msg and shift to the proper location and mask
	vspltisb 16, -1
	sldi	15, 12, 3
	mtvsrdd	32+17, 0, 15
	vslo	16, 16, 17
	vsro	16, 16, 17
	sldi	15, 17, 3
	mtvsrdd	32+17, 0, 15
	vsro	16, 16, 17
	vslo	16, 16, 17		# mask

	lxvb16x 32+19, 0, 14		# load partial block
	sldi	15, 12, 3
	mtvsrdd	32+17, 0, 15
	vsro	19, 19, 17		# 0x00..xxxx??..??
	sldi	15, 17, 3
	mtvsrdd	32+17, 0, 15
	vsro	19, 19, 17		# 0x00..xxxx
	vslo	19, 19, 17		# shift back to form 0x00..xxxx00..00

	# AES crypt partial
	xxlxor	32+15, 32+30, 0
	lwz	23, 240(6)	# n rounds
	addi	22, 23, -1	# loop - 1
	mtctr	22
	addi	10, 6, 16

__Loop_aes_cpstate:
	lxv	32+1, 0(10)
	vcipher	15, 15, 1
	addi	10, 10, 16
	bdnz	__Loop_aes_cpstate
	lxv	32+1, 0(10)		# last round key
	vcipherlast 15, 15, 1

	vxor	15, 15, 19
	vand	15, 15, 16

	# AES crypt output v15
	# Write partial
	li	10, 224
	stxvb16x 15+32, 10, 1		# write v15 to stack
	addi	10, 1, 223
	add	10, 10, 12		# add offset
	addi	15, 9, -1
        mtctr	21			# partial block len
__Write_combine_partial:
        lbzu	22, 1(10)
	stbu	22, 1(15)
        bdnz	__Write_combine_partial

	add	14, 14, 21
	add	11, 11, 21
	add	9, 9, 21
	sub	5, 5, 21

	# Encrypt/Decrypt?
	cmpdi	24, 0			# decrypt?
	bne	__Encrypt_combine_partial
	vmr	15, 19		# decrypt using the input block

__Encrypt_combine_partial:
	#
	# Update partial flag and combine ghash.
__Update_partial_ghash:
	li	10, 64
	lxvb16x 32+17, 10, 7		# load previous pblock
	add	12, 12, 21		# combined pprocessed
	vxor	15, 15, 17		# combined pblock

	cmpdi	12, 16
	beq	__Clear_partial_flag
	std	12, 56(7)		# update partial len
	stxvb16x 32+15, 10, 7		# Update current pblock
	blr

__Clear_partial_flag:
	li	12, 0
	std	12, 56(7)
	# Update IV and ghash here
	vadduwm	30, 30, 31		# increase IV
	stxvb16x 32+30, 0, 7		# update IV

	# v15 either is either (input blockor encrypted)^(AES state)
	vxor	15, 15, 0
	PPC_GHASH1x 0, 15
	stxvb16x 32+0, 10, 7		# update pblock for debug?
	stxvb16x 32+0, 0, 8		# update Xi
	blr
SYM_FUNC_END(__Combine_partial)

################################################################################
# gcm_update(iv, Xi) - compute last hash
#
################################################################################
SYM_FUNC_START(gcm_update)

	ld	10, 56(3)
	cmpdi	10, 0
	beq	__no_update

	lxvb16x	32, 0, 4	# load Xi
	# load Hash - h^4, h^3, h^2, h
	li	10, 32
	lxvd2x	2+32, 10, 4	# H Poli
	li	10, 48
	lxvd2x	3+32, 10, 4	# Hl
	li	10, 64
	lxvd2x	4+32, 10, 4	# H
	li	10, 80
	lxvd2x	5+32, 10, 4	# Hh

	addis	11, 2, permx@toc@ha
	addi	11, 11, permx@toc@l
	lxv	10, 0(11)	# vs10: vpermxor vector

	li	9, 64
	lxvb16x 32+6, 9, 3		# load pblock
	vxor	6, 6, 0

	vxor	1, 1, 1
	vpmsumd	12, 3, 6		# L
	vpmsumd	13, 4, 6		# M
	vpmsumd	14, 5, 6		# H
	vpmsumd	17, 12, 2		# reduction
	vsldoi	15, 13, 1, 8		# mL
	vsldoi	16, 1, 13, 8		# mH
	vxor	12, 12, 15		# LL + LL
	vxor	14, 14, 16		# HH + HH
	xxlor	32+15, 10, 10
	vpermxor 12, 12, 17, 15
	vsldoi	13, 12, 12, 8		# swap
	vpmsumd	12, 12, 2		# reduction
	vxor	13, 13, 14
	vxor	7, 12, 13

	#vxor	0, 0, 0
	#stxvb16x 32+0, 9, 3
	li	10, 0
	std	10, 56(3)
	stxvb16x 32+7, 0, 4

__no_update:
	blr
SYM_FUNC_END(gcm_update)

################################################################################
# aes_p10_gcm_encrypt (const void *inp, void *out, size_t len,
#               const char *rk, unsigned char iv[16], void *Xip);
#
#    r3 - inp
#    r4 - out
#    r5 - len
#    r6 - AES round keys
#    r7 - iv and other data
#    r8 - Xi, HPoli, hash keys
#
#    rounds is at offset 240 in rk
#    Xi is at 0 in gcm_table (Xip).
#
################################################################################
SYM_FUNC_START(aes_p10_gcm_encrypt)

	cmpdi	5, 0
	ble	__Invalid_msg_len

	SAVE_REGS
	LOAD_HASH_TABLE

	# initialize ICB: GHASH( IV ), IV - r7
	lxvb16x	30+32, 0, 7	# load IV  - v30

	mr	14, 3
	mr	9, 4

	# counter 1
	vxor	31, 31, 31
	vspltisb 22, 1
	vsldoi	31, 31, 22,1	# counter 1

	addis	11, 2, permx@toc@ha
	addi	11, 11, permx@toc@l
	lxv	10, 0(11)	# vs10: vpermxor vector
	li	11, 0

	# load 9 round keys to VSR
	lxv	0, 0(6)			# round key 0
	lxv	1, 16(6)		# round key 1
	lxv	2, 32(6)		# round key 2
	lxv	3, 48(6)		# round key 3
	lxv	4, 64(6)		# round key 4
	lxv	5, 80(6)		# round key 5
	lxv	6, 96(6)		# round key 6
	lxv	7, 112(6)		# round key 7
	lxv	8, 128(6)		# round key 8

	# load rounds - 10 (128), 12 (192), 14 (256)
	lwz	23, 240(6)		# n rounds
	li	24, 1			# encrypt

__Process_encrypt:
	#
	# Process different blocks
	#
	ld	12, 56(7)
	cmpdi	12, 0
	bgt	__Do_combine_enc
	cmpdi	5, 128
	blt	__Process_more_enc

#
# Process 8x AES/GCM blocks
#
__Process_8x_enc:
	# 8x blcoks
	li	10, 128
	divdu	12, 5, 10	# n 128 bytes-blocks

	addi	12, 12, -1	# loop - 1

	vmr	15, 30		# first state: IV
	vadduwm	16, 15, 31	# state + counter
	vadduwm	17, 16, 31
	vadduwm	18, 17, 31
	vadduwm	19, 18, 31
	vadduwm	20, 19, 31
	vadduwm	21, 20, 31
	vadduwm	22, 21, 31
	xxlor	9, 32+22, 32+22	# save last state

	# vxor  state, state, w # addroundkey
	xxlor	32+29, 0, 0
        vxor    15, 15, 29      # IV + round key - add round key 0
	vxor	16, 16, 29
	vxor	17, 17, 29
	vxor	18, 18, 29
	vxor	19, 19, 29
	vxor	20, 20, 29
	vxor	21, 21, 29
	vxor	22, 22, 29

	li	15, 16
	li	16, 32
	li	17, 48
	li	18, 64
	li	19, 80
	li	20, 96
	li	21, 112

	#
	# Pre-compute first 8 AES state and leave 1/3/5 more rounds
	# for the loop.
	#
	addi	22, 23, -9		# process 8 keys
	mtctr	22			# AES key loop
	addi	10, 6, 144

	LOOP_8AES_STATE			# process 8 AES keys

__PreLoop_aes_state:
	lxv	32+1, 0(10)		# round key
	AES_CIPHER_8x vcipher 15 1
	addi	10, 10, 16
	bdnz	__PreLoop_aes_state
	lxv	32+1, 0(10)		# last round key (v1)

	cmpdi	12, 0			# Only one loop (8 block)
	beq	__Finish_ghash

#
# Loop 8x blocks and compute ghash
#
__Loop_8x_block_enc:
	vcipherlast     15, 15, 1
	vcipherlast     16, 16, 1
	vcipherlast     17, 17, 1
	vcipherlast     18, 18, 1
	vcipherlast     19, 19, 1
	vcipherlast     20, 20, 1
	vcipherlast     21, 21, 1
	vcipherlast     22, 22, 1

	lxvb16x	32+23, 0, 14	# load block
	lxvb16x	32+24, 15, 14	# load block
	lxvb16x	32+25, 16, 14	# load block
	lxvb16x	32+26, 17, 14	# load block
	lxvb16x	32+27, 18, 14	# load block
	lxvb16x	32+28, 19, 14	# load block
	lxvb16x	32+29, 20, 14	# load block
	lxvb16x	32+30, 21, 14	# load block
	addi	14, 14, 128

	vxor	15, 15, 23
	vxor	16, 16, 24
	vxor	17, 17, 25
	vxor	18, 18, 26
	vxor	19, 19, 27
	vxor	20, 20, 28
	vxor	21, 21, 29
	vxor	22, 22, 30

	stxvb16x 47, 0, 9	# store output
	stxvb16x 48, 15, 9	# store output
	stxvb16x 49, 16, 9	# store output
	stxvb16x 50, 17, 9	# store output
	stxvb16x 51, 18, 9	# store output
	stxvb16x 52, 19, 9	# store output
	stxvb16x 53, 20, 9	# store output
	stxvb16x 54, 21, 9	# store output
	addi	9, 9, 128

	# ghash here
	vxor	15, 15, 0
	PPC_GHASH4x 0, 15, 16, 17, 18

	vxor	19, 19, 0
	PPC_GHASH4x 0, 19, 20, 21, 22

	xxlor	32+15, 9, 9		# last state
	vadduwm 15, 15, 31		# state + counter
	vadduwm 16, 15, 31
	vadduwm 17, 16, 31
	vadduwm 18, 17, 31
	vadduwm 19, 18, 31
	vadduwm 20, 19, 31
	vadduwm 21, 20, 31
	vadduwm 22, 21, 31
	xxlor	9, 32+22, 32+22		# save last state

	xxlor	32+27, 0, 0		# restore roundkey 0
        vxor    15, 15, 27		# IV + round key - add round key 0
	vxor	16, 16, 27
	vxor	17, 17, 27
	vxor	18, 18, 27
	vxor	19, 19, 27
	vxor	20, 20, 27
	vxor	21, 21, 27
	vxor	22, 22, 27

	addi    5, 5, -128
	addi    11, 11, 128

	LOOP_8AES_STATE			# process 8 AES keys
	mtctr	22			# AES key loop
	addi	10, 6, 144
__LastLoop_aes_state:
	lxv	32+1, 0(10)		# round key
	AES_CIPHER_8x vcipher 15 1
	addi	10, 10, 16
	bdnz	__LastLoop_aes_state
	lxv	32+1, 0(10)		# last round key (v1)

	addi	12, 12, -1
	cmpdi	12, 0
	bne	__Loop_8x_block_enc

__Finish_ghash:
	vcipherlast     15, 15, 1
	vcipherlast     16, 16, 1
	vcipherlast     17, 17, 1
	vcipherlast     18, 18, 1
	vcipherlast     19, 19, 1
	vcipherlast     20, 20, 1
	vcipherlast     21, 21, 1
	vcipherlast     22, 22, 1

	lxvb16x	32+23, 0, 14	# load block
	lxvb16x	32+24, 15, 14	# load block
	lxvb16x	32+25, 16, 14	# load block
	lxvb16x	32+26, 17, 14	# load block
	lxvb16x	32+27, 18, 14	# load block
	lxvb16x	32+28, 19, 14	# load block
	lxvb16x	32+29, 20, 14	# load block
	lxvb16x	32+30, 21, 14	# load block
	addi	14, 14, 128

	vxor	15, 15, 23
	vxor	16, 16, 24
	vxor	17, 17, 25
	vxor	18, 18, 26
	vxor	19, 19, 27
	vxor	20, 20, 28
	vxor	21, 21, 29
	vxor	22, 22, 30

	stxvb16x 47, 0, 9	# store output
	stxvb16x 48, 15, 9	# store output
	stxvb16x 49, 16, 9	# store output
	stxvb16x 50, 17, 9	# store output
	stxvb16x 51, 18, 9	# store output
	stxvb16x 52, 19, 9	# store output
	stxvb16x 53, 20, 9	# store output
	stxvb16x 54, 21, 9	# store output
	addi	9, 9, 128

	vxor	15, 15, 0
	PPC_GHASH4x 0, 15, 16, 17, 18

	vxor	19, 19, 0
	PPC_GHASH4x 0, 19, 20, 21, 22

	xxlor	30+32, 9, 9		# last ctr
	vadduwm	30, 30, 31		# increase ctr
	stxvb16x 32+30, 0, 7		# update IV
	stxvb16x 32+0, 0, 8		# update Xi

	addi    5, 5, -128
	addi    11, 11, 128

	#
	# Done 8x blocks
	#

	cmpdi   5, 0
	beq     aes_gcm_out

__Process_more_enc:
	li	24, 1			# encrypt
	bl	aes_gcm_crypt_1x
	cmpdi   5, 0
	beq     aes_gcm_out

	bl	__Process_partial
	cmpdi   5, 0
	beq     aes_gcm_out
__Do_combine_enc:
	bl	__Combine_partial
	cmpdi	5, 0
	bgt	__Process_encrypt
	b	aes_gcm_out

SYM_FUNC_END(aes_p10_gcm_encrypt)

################################################################################
# aes_p10_gcm_decrypt (const void *inp, void *out, size_t len,
#               const char *rk, unsigned char iv[16], void *Xip);
# 8x Decrypt
#
################################################################################
SYM_FUNC_START(aes_p10_gcm_decrypt)

	cmpdi	5, 0
	ble	__Invalid_msg_len

	SAVE_REGS
	LOAD_HASH_TABLE

	# initialize ICB: GHASH( IV ), IV - r7
	lxvb16x	30+32, 0, 7	# load IV  - v30

	mr	14, 3
	mr	9, 4

	# counter 1
	vxor	31, 31, 31
	vspltisb 22, 1
	vsldoi	31, 31, 22,1	# counter 1

	addis	11, 2, permx@toc@ha
	addi	11, 11, permx@toc@l
	lxv	10, 0(11)	# vs10: vpermxor vector
	li	11, 0

	# load 9 round keys to VSR
	lxv	0, 0(6)			# round key 0
	lxv	1, 16(6)		# round key 1
	lxv	2, 32(6)		# round key 2
	lxv	3, 48(6)		# round key 3
	lxv	4, 64(6)		# round key 4
	lxv	5, 80(6)		# round key 5
	lxv	6, 96(6)		# round key 6
	lxv	7, 112(6)		# round key 7
	lxv	8, 128(6)		# round key 8

	# load rounds - 10 (128), 12 (192), 14 (256)
	lwz	23, 240(6)		# n rounds
	li	24, 0			# decrypt

__Process_decrypt:
	#
	# Process different blocks
	#
	ld	12, 56(7)
	cmpdi	12, 0
	bgt	__Do_combine_dec
	cmpdi	5, 128
	blt	__Process_more_dec

#
# Process 8x AES/GCM blocks
#
__Process_8x_dec:
	# 8x blcoks
	li	10, 128
	divdu	12, 5, 10	# n 128 bytes-blocks

	addi	12, 12, -1	# loop - 1

	vmr	15, 30		# first state: IV
	vadduwm	16, 15, 31	# state + counter
	vadduwm	17, 16, 31
	vadduwm	18, 17, 31
	vadduwm	19, 18, 31
	vadduwm	20, 19, 31
	vadduwm	21, 20, 31
	vadduwm	22, 21, 31
	xxlor	9, 32+22, 32+22	# save last state

	# vxor  state, state, w # addroundkey
	xxlor	32+29, 0, 0
        vxor    15, 15, 29      # IV + round key - add round key 0
	vxor	16, 16, 29
	vxor	17, 17, 29
	vxor	18, 18, 29
	vxor	19, 19, 29
	vxor	20, 20, 29
	vxor	21, 21, 29
	vxor	22, 22, 29

	li	15, 16
	li	16, 32
	li	17, 48
	li	18, 64
	li	19, 80
	li	20, 96
	li	21, 112

	#
	# Pre-compute first 8 AES state and leave 1/3/5 more rounds
	# for the loop.
	#
	addi	22, 23, -9		# process 8 keys
	mtctr	22			# AES key loop
	addi	10, 6, 144

	LOOP_8AES_STATE			# process 8 AES keys

__PreLoop_aes_state_dec:
	lxv	32+1, 0(10)		# round key
	AES_CIPHER_8x vcipher 15 1
	addi	10, 10, 16
	bdnz	__PreLoop_aes_state_dec
	lxv	32+1, 0(10)		# last round key (v1)

	cmpdi	12, 0			# Only one loop (8 block)
	beq	__Finish_ghash_dec

#
# Loop 8x blocks and compute ghash
#
__Loop_8x_block_dec:
	vcipherlast     15, 15, 1
	vcipherlast     16, 16, 1
	vcipherlast     17, 17, 1
	vcipherlast     18, 18, 1
	vcipherlast     19, 19, 1
	vcipherlast     20, 20, 1
	vcipherlast     21, 21, 1
	vcipherlast     22, 22, 1

	lxvb16x	32+23, 0, 14	# load block
	lxvb16x	32+24, 15, 14	# load block
	lxvb16x	32+25, 16, 14	# load block
	lxvb16x	32+26, 17, 14	# load block
	lxvb16x	32+27, 18, 14	# load block
	lxvb16x	32+28, 19, 14	# load block
	lxvb16x	32+29, 20, 14	# load block
	lxvb16x	32+30, 21, 14	# load block
	addi	14, 14, 128

	vxor	15, 15, 23
	vxor	16, 16, 24
	vxor	17, 17, 25
	vxor	18, 18, 26
	vxor	19, 19, 27
	vxor	20, 20, 28
	vxor	21, 21, 29
	vxor	22, 22, 30

	stxvb16x 47, 0, 9	# store output
	stxvb16x 48, 15, 9	# store output
	stxvb16x 49, 16, 9	# store output
	stxvb16x 50, 17, 9	# store output
	stxvb16x 51, 18, 9	# store output
	stxvb16x 52, 19, 9	# store output
	stxvb16x 53, 20, 9	# store output
	stxvb16x 54, 21, 9	# store output

	addi	9, 9, 128

	vmr	15, 23
	vmr	16, 24
	vmr	17, 25
	vmr	18, 26
	vmr	19, 27
	vmr	20, 28
	vmr	21, 29
	vmr	22, 30

	# ghash here
	vxor	15, 15, 0
	PPC_GHASH4x 0, 15, 16, 17, 18

	vxor	19, 19, 0
	PPC_GHASH4x 0, 19, 20, 21, 22

	xxlor	32+15, 9, 9		# last state
	vadduwm 15, 15, 31		# state + counter
	vadduwm 16, 15, 31
	vadduwm 17, 16, 31
	vadduwm 18, 17, 31
	vadduwm 19, 18, 31
	vadduwm 20, 19, 31
	vadduwm 21, 20, 31
	vadduwm 22, 21, 31
	xxlor	9, 32+22, 32+22		# save last state

	xxlor	32+27, 0, 0		# restore roundkey 0
        vxor    15, 15, 27		# IV + round key - add round key 0
	vxor	16, 16, 27
	vxor	17, 17, 27
	vxor	18, 18, 27
	vxor	19, 19, 27
	vxor	20, 20, 27
	vxor	21, 21, 27
	vxor	22, 22, 27

	addi    5, 5, -128
	addi    11, 11, 128

	LOOP_8AES_STATE			# process 8 AES keys
	mtctr	22			# AES key loop
	addi	10, 6, 144
__LastLoop_aes_state_dec:
	lxv	32+1, 0(10)		# round key
	AES_CIPHER_8x vcipher 15 1
	addi	10, 10, 16
	bdnz	__LastLoop_aes_state_dec
	lxv	32+1, 0(10)		# last round key (v1)

	addi	12, 12, -1
	cmpdi	12, 0
	bne	__Loop_8x_block_dec

__Finish_ghash_dec:
	vcipherlast     15, 15, 1
	vcipherlast     16, 16, 1
	vcipherlast     17, 17, 1
	vcipherlast     18, 18, 1
	vcipherlast     19, 19, 1
	vcipherlast     20, 20, 1
	vcipherlast     21, 21, 1
	vcipherlast     22, 22, 1

	lxvb16x	32+23, 0, 14	# load block
	lxvb16x	32+24, 15, 14	# load block
	lxvb16x	32+25, 16, 14	# load block
	lxvb16x	32+26, 17, 14	# load block
	lxvb16x	32+27, 18, 14	# load block
	lxvb16x	32+28, 19, 14	# load block
	lxvb16x	32+29, 20, 14	# load block
	lxvb16x	32+30, 21, 14	# load block
	addi	14, 14, 128

	vxor	15, 15, 23
	vxor	16, 16, 24
	vxor	17, 17, 25
	vxor	18, 18, 26
	vxor	19, 19, 27
	vxor	20, 20, 28
	vxor	21, 21, 29
	vxor	22, 22, 30

	stxvb16x 47, 0, 9	# store output
	stxvb16x 48, 15, 9	# store output
	stxvb16x 49, 16, 9	# store output
	stxvb16x 50, 17, 9	# store output
	stxvb16x 51, 18, 9	# store output
	stxvb16x 52, 19, 9	# store output
	stxvb16x 53, 20, 9	# store output
	stxvb16x 54, 21, 9	# store output
	addi	9, 9, 128

	#vmr	15, 23
	vxor	15, 23, 0
	vmr	16, 24
	vmr	17, 25
	vmr	18, 26
	vmr	19, 27
	vmr	20, 28
	vmr	21, 29
	vmr	22, 30

	#vxor	15, 15, 0
	PPC_GHASH4x 0, 15, 16, 17, 18

	vxor	19, 19, 0
	PPC_GHASH4x 0, 19, 20, 21, 22

	xxlor	30+32, 9, 9		# last ctr
	vadduwm	30, 30, 31		# increase ctr
	stxvb16x 32+30, 0, 7		# update IV
	stxvb16x 32+0, 0, 8		# update Xi

	addi    5, 5, -128
	addi    11, 11, 128

	#
	# Done 8x blocks
	#

	cmpdi   5, 0
	beq     aes_gcm_out

__Process_more_dec:
	li	24, 0			# decrypt
	bl	aes_gcm_crypt_1x
	cmpdi   5, 0
	beq     aes_gcm_out

	bl	__Process_partial
	cmpdi   5, 0
	beq     aes_gcm_out
__Do_combine_dec:
	bl	__Combine_partial
	cmpdi	5, 0
	bgt	__Process_decrypt
	b	aes_gcm_out
SYM_FUNC_END(aes_p10_gcm_decrypt)

SYM_FUNC_START_LOCAL(aes_gcm_out)

	mr	3, 11			# return count

	RESTORE_REGS
	blr

__Invalid_msg_len:
	li	3, 0
	blr
SYM_FUNC_END(aes_gcm_out)

SYM_DATA_START_LOCAL(PERMX)
.align 4
# for vector permute and xor
permx:
.long 0x4c5d6e7f, 0x08192a3b, 0xc4d5e6f7, 0x8091a2b3
SYM_DATA_END(permx)