[linux.git] / arch / x86 / crypto / aes-i586-asm_32.S

// -------------------------------------------------------------------------
// Copyright (c) 2001, Dr Brian Gladman <                 >, Worcester, UK.
// All rights reserved.
//
// LICENSE TERMS
//
// The free distribution and use of this software in both source and binary 
// form is allowed (with or without changes) provided that:
//
//   1. distributions of this source code include the above copyright 
//      notice, this list of conditions and the following disclaimer//
//
//   2. distributions in binary form include the above copyright
//      notice, this list of conditions and the following disclaimer
//      in the documentation and/or other associated materials//
//
//   3. the copyright holder's name is not used to endorse products 
//      built using this software without specific written permission.
//
//
// ALTERNATIVELY, provided that this notice is retained in full, this product
// may be distributed under the terms of the GNU General Public License (GPL),
// in which case the provisions of the GPL apply INSTEAD OF those given above.
//
// Copyright (c) 2004 Linus Torvalds <[email protected]>
// Copyright (c) 2004 Red Hat, Inc., James Morris <[email protected]>

// DISCLAIMER
//
// This software is provided 'as is' with no explicit or implied warranties
// in respect of its properties including, but not limited to, correctness 
// and fitness for purpose.
// -------------------------------------------------------------------------
// Issue Date: 29/07/2002

.file "aes-i586-asm.S"
.text

#include <asm/asm-offsets.h>

#define tlen 1024   // length of each of 4 'xor' arrays (256 32-bit words)

/* offsets to parameters with one register pushed onto stack */
#define ctx 8
#define out_blk 12
#define in_blk 16

/* offsets in crypto_aes_ctx structure */
#define klen (480)
#define ekey (0)
#define dkey (240)

// register mapping for encrypt and decrypt subroutines

#define r0  eax
#define r1  ebx
#define r2  ecx
#define r3  edx
#define r4  esi
#define r5  edi

#define eaxl  al
#define eaxh  ah
#define ebxl  bl
#define ebxh  bh
#define ecxl  cl
#define ecxh  ch
#define edxl  dl
#define edxh  dh

#define _h(reg) reg##h
#define h(reg) _h(reg)

#define _l(reg) reg##l
#define l(reg) _l(reg)

// This macro takes a 32-bit word representing a column and uses
// each of its four bytes to index into four tables of 256 32-bit
// words to obtain values that are then xored into the appropriate
// output registers r0, r1, r4 or r5.  

// Parameters:
// table table base address
//   %1  out_state[0]
//   %2  out_state[1]
//   %3  out_state[2]
//   %4  out_state[3]
//   idx input register for the round (destroyed)
//   tmp scratch register for the round
// sched key schedule

#define do_col(table, a1,a2,a3,a4, idx, tmp)	\
	movzx   %l(idx),%tmp;			\
	xor     table(,%tmp,4),%a1;		\
	movzx   %h(idx),%tmp;			\
	shr     $16,%idx;			\
	xor     table+tlen(,%tmp,4),%a2;	\
	movzx   %l(idx),%tmp;			\
	movzx   %h(idx),%idx;			\
	xor     table+2*tlen(,%tmp,4),%a3;	\
	xor     table+3*tlen(,%idx,4),%a4;

// initialise output registers from the key schedule
// NB1: original value of a3 is in idx on exit
// NB2: original values of a1,a2,a4 aren't used
#define do_fcol(table, a1,a2,a3,a4, idx, tmp, sched) \
	mov     0 sched,%a1;			\
	movzx   %l(idx),%tmp;			\
	mov     12 sched,%a2;			\
	xor     table(,%tmp,4),%a1;		\
	mov     4 sched,%a4;			\
	movzx   %h(idx),%tmp;			\
	shr     $16,%idx;			\
	xor     table+tlen(,%tmp,4),%a2;	\
	movzx   %l(idx),%tmp;			\
	movzx   %h(idx),%idx;			\
	xor     table+3*tlen(,%idx,4),%a4;	\
	mov     %a3,%idx;			\
	mov     8 sched,%a3;			\
	xor     table+2*tlen(,%tmp,4),%a3;

// initialise output registers from the key schedule
// NB1: original value of a3 is in idx on exit
// NB2: original values of a1,a2,a4 aren't used
#define do_icol(table, a1,a2,a3,a4, idx, tmp, sched) \
	mov     0 sched,%a1;			\
	movzx   %l(idx),%tmp;			\
	mov     4 sched,%a2;			\
	xor     table(,%tmp,4),%a1;		\
	mov     12 sched,%a4;			\
	movzx   %h(idx),%tmp;			\
	shr     $16,%idx;			\
	xor     table+tlen(,%tmp,4),%a2;	\
	movzx   %l(idx),%tmp;			\
	movzx   %h(idx),%idx;			\
	xor     table+3*tlen(,%idx,4),%a4;	\
	mov     %a3,%idx;			\
	mov     8 sched,%a3;			\
	xor     table+2*tlen(,%tmp,4),%a3;


// original Gladman had conditional saves to MMX regs.
#define save(a1, a2)		\
	mov     %a2,4*a1(%esp)

#define restore(a1, a2)		\
	mov     4*a2(%esp),%a1

// These macros perform a forward encryption cycle. They are entered with
// the first previous round column values in r0,r1,r4,r5 and
// exit with the final values in the same registers, using stack
// for temporary storage.

// round column values
// on entry: r0,r1,r4,r5
// on exit:  r2,r1,r4,r5
#define fwd_rnd1(arg, table)						\
	save   (0,r1);							\
	save   (1,r5);							\
									\
	/* compute new column values */					\
	do_fcol(table, r2,r5,r4,r1, r0,r3, arg);	/* idx=r0 */	\
	do_col (table, r4,r1,r2,r5, r0,r3);		/* idx=r4 */	\
	restore(r0,0);							\
	do_col (table, r1,r2,r5,r4, r0,r3);		/* idx=r1 */	\
	restore(r0,1);							\
	do_col (table, r5,r4,r1,r2, r0,r3);		/* idx=r5 */

// round column values
// on entry: r2,r1,r4,r5
// on exit:  r0,r1,r4,r5
#define fwd_rnd2(arg, table)						\
	save   (0,r1);							\
	save   (1,r5);							\
									\
	/* compute new column values */					\
	do_fcol(table, r0,r5,r4,r1, r2,r3, arg);	/* idx=r2 */	\
	do_col (table, r4,r1,r0,r5, r2,r3);		/* idx=r4 */	\
	restore(r2,0);							\
	do_col (table, r1,r0,r5,r4, r2,r3);		/* idx=r1 */	\
	restore(r2,1);							\
	do_col (table, r5,r4,r1,r0, r2,r3);		/* idx=r5 */

// These macros performs an inverse encryption cycle. They are entered with
// the first previous round column values in r0,r1,r4,r5 and
// exit with the final values in the same registers, using stack
// for temporary storage

// round column values
// on entry: r0,r1,r4,r5
// on exit:  r2,r1,r4,r5
#define inv_rnd1(arg, table)						\
	save    (0,r1);							\
	save    (1,r5);							\
									\
	/* compute new column values */					\
	do_icol(table, r2,r1,r4,r5, r0,r3, arg);	/* idx=r0 */	\
	do_col (table, r4,r5,r2,r1, r0,r3);		/* idx=r4 */	\
	restore(r0,0);							\
	do_col (table, r1,r4,r5,r2, r0,r3);		/* idx=r1 */	\
	restore(r0,1);							\
	do_col (table, r5,r2,r1,r4, r0,r3);		/* idx=r5 */

// round column values
// on entry: r2,r1,r4,r5
// on exit:  r0,r1,r4,r5
#define inv_rnd2(arg, table)						\
	save    (0,r1);							\
	save    (1,r5);							\
									\
	/* compute new column values */					\
	do_icol(table, r0,r1,r4,r5, r2,r3, arg);	/* idx=r2 */	\
	do_col (table, r4,r5,r0,r1, r2,r3);		/* idx=r4 */	\
	restore(r2,0);							\
	do_col (table, r1,r4,r5,r0, r2,r3);		/* idx=r1 */	\
	restore(r2,1);							\
	do_col (table, r5,r0,r1,r4, r2,r3);		/* idx=r5 */

// AES (Rijndael) Encryption Subroutine
/* void aes_enc_blk(struct crypto_aes_ctx *ctx, u8 *out_blk, const u8 *in_blk) */

.global  aes_enc_blk

.extern  crypto_ft_tab
.extern  crypto_fl_tab

.align 4

aes_enc_blk:
	push    %ebp
	mov     ctx(%esp),%ebp

// CAUTION: the order and the values used in these assigns 
// rely on the register mappings

1:	push    %ebx
	mov     in_blk+4(%esp),%r2
	push    %esi
	mov     klen(%ebp),%r3   // key size
	push    %edi
#if ekey != 0
	lea     ekey(%ebp),%ebp  // key pointer
#endif

// input four columns and xor in first round key

	mov     (%r2),%r0
	mov     4(%r2),%r1
	mov     8(%r2),%r4
	mov     12(%r2),%r5
	xor     (%ebp),%r0
	xor     4(%ebp),%r1
	xor     8(%ebp),%r4
	xor     12(%ebp),%r5

	sub     $8,%esp		// space for register saves on stack
	add     $16,%ebp	// increment to next round key
	cmp     $24,%r3
	jb      4f		// 10 rounds for 128-bit key
	lea     32(%ebp),%ebp
	je      3f		// 12 rounds for 192-bit key
	lea     32(%ebp),%ebp

2:	fwd_rnd1( -64(%ebp), crypto_ft_tab)	// 14 rounds for 256-bit key
	fwd_rnd2( -48(%ebp), crypto_ft_tab)
3:	fwd_rnd1( -32(%ebp), crypto_ft_tab)	// 12 rounds for 192-bit key
	fwd_rnd2( -16(%ebp), crypto_ft_tab)
4:	fwd_rnd1(    (%ebp), crypto_ft_tab)	// 10 rounds for 128-bit key
	fwd_rnd2( +16(%ebp), crypto_ft_tab)
	fwd_rnd1( +32(%ebp), crypto_ft_tab)
	fwd_rnd2( +48(%ebp), crypto_ft_tab)
	fwd_rnd1( +64(%ebp), crypto_ft_tab)
	fwd_rnd2( +80(%ebp), crypto_ft_tab)
	fwd_rnd1( +96(%ebp), crypto_ft_tab)
	fwd_rnd2(+112(%ebp), crypto_ft_tab)
	fwd_rnd1(+128(%ebp), crypto_ft_tab)
	fwd_rnd2(+144(%ebp), crypto_fl_tab)	// last round uses a different table

// move final values to the output array.  CAUTION: the 
// order of these assigns rely on the register mappings

	add     $8,%esp
	mov     out_blk+12(%esp),%ebp
	mov     %r5,12(%ebp)
	pop     %edi
	mov     %r4,8(%ebp)
	pop     %esi
	mov     %r1,4(%ebp)
	pop     %ebx
	mov     %r0,(%ebp)
	pop     %ebp
	ret

// AES (Rijndael) Decryption Subroutine
/* void aes_dec_blk(struct crypto_aes_ctx *ctx, u8 *out_blk, const u8 *in_blk) */

.global  aes_dec_blk

.extern  crypto_it_tab
.extern  crypto_il_tab

.align 4

aes_dec_blk:
	push    %ebp
	mov     ctx(%esp),%ebp

// CAUTION: the order and the values used in these assigns 
// rely on the register mappings

1:	push    %ebx
	mov     in_blk+4(%esp),%r2
	push    %esi
	mov     klen(%ebp),%r3   // key size
	push    %edi
#if dkey != 0
	lea     dkey(%ebp),%ebp  // key pointer
#endif
	
// input four columns and xor in first round key

	mov     (%r2),%r0
	mov     4(%r2),%r1
	mov     8(%r2),%r4
	mov     12(%r2),%r5
	xor     (%ebp),%r0
	xor     4(%ebp),%r1
	xor     8(%ebp),%r4
	xor     12(%ebp),%r5

	sub     $8,%esp		// space for register saves on stack
	add     $16,%ebp	// increment to next round key
	cmp     $24,%r3
	jb      4f		// 10 rounds for 128-bit key
	lea     32(%ebp),%ebp
	je      3f		// 12 rounds for 192-bit key
	lea     32(%ebp),%ebp

2:	inv_rnd1( -64(%ebp), crypto_it_tab)	// 14 rounds for 256-bit key
	inv_rnd2( -48(%ebp), crypto_it_tab)
3:	inv_rnd1( -32(%ebp), crypto_it_tab)	// 12 rounds for 192-bit key
	inv_rnd2( -16(%ebp), crypto_it_tab)
4:	inv_rnd1(    (%ebp), crypto_it_tab)	// 10 rounds for 128-bit key
	inv_rnd2( +16(%ebp), crypto_it_tab)
	inv_rnd1( +32(%ebp), crypto_it_tab)
	inv_rnd2( +48(%ebp), crypto_it_tab)
	inv_rnd1( +64(%ebp), crypto_it_tab)
	inv_rnd2( +80(%ebp), crypto_it_tab)
	inv_rnd1( +96(%ebp), crypto_it_tab)
	inv_rnd2(+112(%ebp), crypto_it_tab)
	inv_rnd1(+128(%ebp), crypto_it_tab)
	inv_rnd2(+144(%ebp), crypto_il_tab)	// last round uses a different table

// move final values to the output array.  CAUTION: the 
// order of these assigns rely on the register mappings

	add     $8,%esp
	mov     out_blk+12(%esp),%ebp
	mov     %r5,12(%ebp)
	pop     %edi
	mov     %r4,8(%ebp)
	pop     %esi
	mov     %r1,4(%ebp)
	pop     %ebx
	mov     %r0,(%ebp)
	pop     %ebp
	ret
Commit	Line	Data
1da177e4 LT	1	// -------------------------------------------------------------------------
	2	// Copyright (c) 2001, Dr Brian Gladman < >, Worcester, UK.
	3	// All rights reserved.
	4	//
	5	// LICENSE TERMS
	6	//
	7	// The free distribution and use of this software in both source and binary
	8	// form is allowed (with or without changes) provided that:
	9	//
	10	// 1. distributions of this source code include the above copyright
	11	// notice, this list of conditions and the following disclaimer//
	12	//
	13	// 2. distributions in binary form include the above copyright
	14	// notice, this list of conditions and the following disclaimer
	15	// in the documentation and/or other associated materials//
	16	//
	17	// 3. the copyright holder's name is not used to endorse products
	18	// built using this software without specific written permission.
	19	//
	20	//
	21	// ALTERNATIVELY, provided that this notice is retained in full, this product
	22	// may be distributed under the terms of the GNU General Public License (GPL),
	23	// in which case the provisions of the GPL apply INSTEAD OF those given above.
	24	//
	25	// Copyright (c) 2004 Linus Torvalds <[email protected]>
	26	// Copyright (c) 2004 Red Hat, Inc., James Morris <[email protected]>
	27
	28	// DISCLAIMER
	29	//
	30	// This software is provided 'as is' with no explicit or implied warranties
	31	// in respect of its properties including, but not limited to, correctness
	32	// and fitness for purpose.
	33	// -------------------------------------------------------------------------
	34	// Issue Date: 29/07/2002
	35
	36	.file "aes-i586-asm.S"
	37	.text
	38
6c2bb98b	39	#include <asm/asm-offsets.h>
1da177e4	40
6c2bb98b	41	#define tlen 1024 // length of each of 4 'xor' arrays (256 32-bit words)
1da177e4	42
6c2bb98b	43	/* offsets to parameters with one register pushed onto stack */
07bf44f8	44	#define ctx 8
6c2bb98b HX	45	#define out_blk 12
6c2bb98b HX	46	#define in_blk 16
1da177e4	47
07bf44f8 YH	48	/* offsets in crypto_aes_ctx structure */
	49	#define klen (480)
	50	#define ekey (0)
	51	#define dkey (240)
1da177e4 LT	52
	53	// register mapping for encrypt and decrypt subroutines
	54
	55	#define r0 eax
	56	#define r1 ebx
	57	#define r2 ecx
	58	#define r3 edx
	59	#define r4 esi
	60	#define r5 edi
	61
	62	#define eaxl al
	63	#define eaxh ah
	64	#define ebxl bl
	65	#define ebxh bh
	66	#define ecxl cl
	67	#define ecxh ch
	68	#define edxl dl
	69	#define edxh dh
	70
	71	#define _h(reg) reg##h
	72	#define h(reg) _h(reg)
	73
	74	#define _l(reg) reg##l
	75	#define l(reg) _l(reg)
	76
	77	// This macro takes a 32-bit word representing a column and uses
	78	// each of its four bytes to index into four tables of 256 32-bit
	79	// words to obtain values that are then xored into the appropriate
	80	// output registers r0, r1, r4 or r5.
	81
	82	// Parameters:
	83	// table table base address
	84	// %1 out_state[0]
	85	// %2 out_state[1]
	86	// %3 out_state[2]
	87	// %4 out_state[3]
	88	// idx input register for the round (destroyed)
	89	// tmp scratch register for the round
	90	// sched key schedule
	91
	92	#define do_col(table, a1,a2,a3,a4, idx, tmp) \
	93	movzx %l(idx),%tmp; \
	94	xor table(,%tmp,4),%a1; \
	95	movzx %h(idx),%tmp; \
	96	shr $16,%idx; \
	97	xor table+tlen(,%tmp,4),%a2; \
	98	movzx %l(idx),%tmp; \
	99	movzx %h(idx),%idx; \
	100	xor table+2*tlen(,%tmp,4),%a3; \
	101	xor table+3*tlen(,%idx,4),%a4;
	102
	103	// initialise output registers from the key schedule
	104	// NB1: original value of a3 is in idx on exit
	105	// NB2: original values of a1,a2,a4 aren't used
	106	#define do_fcol(table, a1,a2,a3,a4, idx, tmp, sched) \
	107	mov 0 sched,%a1; \
	108	movzx %l(idx),%tmp; \
	109	mov 12 sched,%a2; \
	110	xor table(,%tmp,4),%a1; \
	111	mov 4 sched,%a4; \
	112	movzx %h(idx),%tmp; \
	113	shr $16,%idx; \
	114	xor table+tlen(,%tmp,4),%a2; \
	115	movzx %l(idx),%tmp; \
116	movzx %h(idx),%idx; \
117	xor table+3*tlen(,%idx,4),%a4; \
118	mov %a3,%idx; \
119	mov 8 sched,%a3; \
120	xor table+2*tlen(,%tmp,4),%a3;
121
122	// initialise output registers from the key schedule
123	// NB1: original value of a3 is in idx on exit
124	// NB2: original values of a1,a2,a4 aren't used
125	#define do_icol(table, a1,a2,a3,a4, idx, tmp, sched) \
126	mov 0 sched,%a1; \
127	movzx %l(idx),%tmp; \
128	mov 4 sched,%a2; \
129	xor table(,%tmp,4),%a1; \
130	mov 12 sched,%a4; \
131	movzx %h(idx),%tmp; \
132	shr $16,%idx; \
133	xor table+tlen(,%tmp,4),%a2; \
134	movzx %l(idx),%tmp; \
135	movzx %h(idx),%idx; \
136	xor table+3*tlen(,%idx,4),%a4; \
137	mov %a3,%idx; \
138	mov 8 sched,%a3; \
139	xor table+2*tlen(,%tmp,4),%a3;
140
141
142	// original Gladman had conditional saves to MMX regs.
143	#define save(a1, a2) \
144	mov %a2,4*a1(%esp)
145
146	#define restore(a1, a2) \
147	mov 4*a2(%esp),%a1
148
149	// These macros perform a forward encryption cycle. They are entered with
150	// the first previous round column values in r0,r1,r4,r5 and
151	// exit with the final values in the same registers, using stack
152	// for temporary storage.
153
154	// round column values
155	// on entry: r0,r1,r4,r5
156	// on exit: r2,r1,r4,r5
157	#define fwd_rnd1(arg, table) \
158	save (0,r1); \
159	save (1,r5); \
160	\
161	/* compute new column values */ \
162	do_fcol(table, r2,r5,r4,r1, r0,r3, arg); /* idx=r0 */ \
163	do_col (table, r4,r1,r2,r5, r0,r3); /* idx=r4 */ \
164	restore(r0,0); \
165	do_col (table, r1,r2,r5,r4, r0,r3); /* idx=r1 */ \
166	restore(r0,1); \
167	do_col (table, r5,r4,r1,r2, r0,r3); /* idx=r5 */
168
169	// round column values
170	// on entry: r2,r1,r4,r5
171	// on exit: r0,r1,r4,r5
172	#define fwd_rnd2(arg, table) \
173	save (0,r1); \
174	save (1,r5); \
175	\
176	/* compute new column values */ \
177	do_fcol(table, r0,r5,r4,r1, r2,r3, arg); /* idx=r2 */ \
178	do_col (table, r4,r1,r0,r5, r2,r3); /* idx=r4 */ \
179	restore(r2,0); \
180	do_col (table, r1,r0,r5,r4, r2,r3); /* idx=r1 */ \
181	restore(r2,1); \
182	do_col (table, r5,r4,r1,r0, r2,r3); /* idx=r5 */
183
184	// These macros performs an inverse encryption cycle. They are entered with
185	// the first previous round column values in r0,r1,r4,r5 and
186	// exit with the final values in the same registers, using stack
187	// for temporary storage
188
189	// round column values
190	// on entry: r0,r1,r4,r5
191	// on exit: r2,r1,r4,r5
192	#define inv_rnd1(arg, table) \
193	save (0,r1); \
194	save (1,r5); \
195	\
196	/* compute new column values */ \
197	do_icol(table, r2,r1,r4,r5, r0,r3, arg); /* idx=r0 */ \
198	do_col (table, r4,r5,r2,r1, r0,r3); /* idx=r4 */ \
199	restore(r0,0); \
200	do_col (table, r1,r4,r5,r2, r0,r3); /* idx=r1 */ \
201	restore(r0,1); \
202	do_col (table, r5,r2,r1,r4, r0,r3); /* idx=r5 */
203
204	// round column values
205	// on entry: r2,r1,r4,r5
206	// on exit: r0,r1,r4,r5
207	#define inv_rnd2(arg, table) \
208	save (0,r1); \
209	save (1,r5); \
210	\
211	/* compute new column values */ \
212	do_icol(table, r0,r1,r4,r5, r2,r3, arg); /* idx=r2 */ \
213	do_col (table, r4,r5,r0,r1, r2,r3); /* idx=r4 */ \
214	restore(r2,0); \
215	do_col (table, r1,r4,r5,r0, r2,r3); /* idx=r1 */ \
216	restore(r2,1); \
217	do_col (table, r5,r0,r1,r4, r2,r3); /* idx=r5 */
218
219	// AES (Rijndael) Encryption Subroutine
07bf44f8	220	/* void aes_enc_blk(struct crypto_aes_ctx ctx, u8 out_blk, const u8 in_blk) /
1da177e4 LT	221
	222	.global aes_enc_blk
	223
5157dea8 SS	224	.extern crypto_ft_tab
5157dea8 SS	225	.extern crypto_fl_tab
1da177e4 LT	226
	227	.align 4
	228
	229	aes_enc_blk:
	230	push %ebp
07bf44f8	231	mov ctx(%esp),%ebp
1da177e4 LT	232
	233	// CAUTION: the order and the values used in these assigns
	234	// rely on the register mappings
	235
	236	1: push %ebx
	237	mov in_blk+4(%esp),%r2
	238	push %esi
5157dea8	239	mov klen(%ebp),%r3 // key size
1da177e4 LT	240	push %edi
	241	#if ekey != 0
	242	lea ekey(%ebp),%ebp // key pointer
	243	#endif
	244
	245	// input four columns and xor in first round key
	246
	247	mov (%r2),%r0
	248	mov 4(%r2),%r1
	249	mov 8(%r2),%r4
	250	mov 12(%r2),%r5
	251	xor (%ebp),%r0
	252	xor 4(%ebp),%r1
	253	xor 8(%ebp),%r4
	254	xor 12(%ebp),%r5
	255
e6a3a925 DV	256	sub $8,%esp // space for register saves on stack
e6a3a925 DV	257	add $16,%ebp // increment to next round key
5157dea8	258	cmp $24,%r3
e6a3a925 DV	259	jb 4f // 10 rounds for 128-bit key
	260	lea 32(%ebp),%ebp
	261	je 3f // 12 rounds for 192-bit key
	262	lea 32(%ebp),%ebp
	263
5157dea8 SS	264	2: fwd_rnd1( -64(%ebp), crypto_ft_tab) // 14 rounds for 256-bit key
	265	fwd_rnd2( -48(%ebp), crypto_ft_tab)
	266	3: fwd_rnd1( -32(%ebp), crypto_ft_tab) // 12 rounds for 192-bit key
	267	fwd_rnd2( -16(%ebp), crypto_ft_tab)
	268	4: fwd_rnd1( (%ebp), crypto_ft_tab) // 10 rounds for 128-bit key
	269	fwd_rnd2( +16(%ebp), crypto_ft_tab)
	270	fwd_rnd1( +32(%ebp), crypto_ft_tab)
	271	fwd_rnd2( +48(%ebp), crypto_ft_tab)
	272	fwd_rnd1( +64(%ebp), crypto_ft_tab)
	273	fwd_rnd2( +80(%ebp), crypto_ft_tab)
	274	fwd_rnd1( +96(%ebp), crypto_ft_tab)
	275	fwd_rnd2(+112(%ebp), crypto_ft_tab)
	276	fwd_rnd1(+128(%ebp), crypto_ft_tab)
	277	fwd_rnd2(+144(%ebp), crypto_fl_tab) // last round uses a different table
1da177e4 LT	278
	279	// move final values to the output array. CAUTION: the
	280	// order of these assigns rely on the register mappings
	281
	282	add $8,%esp
	283	mov out_blk+12(%esp),%ebp
	284	mov %r5,12(%ebp)
	285	pop %edi
	286	mov %r4,8(%ebp)
	287	pop %esi
	288	mov %r1,4(%ebp)
	289	pop %ebx
	290	mov %r0,(%ebp)
	291	pop %ebp
1da177e4 LT	292	ret
	293
	294	// AES (Rijndael) Decryption Subroutine
07bf44f8	295	/* void aes_dec_blk(struct crypto_aes_ctx ctx, u8 out_blk, const u8 in_blk) /
1da177e4 LT	296
	297	.global aes_dec_blk
	298
5157dea8 SS	299	.extern crypto_it_tab
5157dea8 SS	300	.extern crypto_il_tab
1da177e4 LT	301
	302	.align 4
	303
	304	aes_dec_blk:
	305	push %ebp
07bf44f8	306	mov ctx(%esp),%ebp
1da177e4 LT	307
	308	// CAUTION: the order and the values used in these assigns
	309	// rely on the register mappings
	310
	311	1: push %ebx
	312	mov in_blk+4(%esp),%r2
	313	push %esi
5157dea8	314	mov klen(%ebp),%r3 // key size
1da177e4 LT	315	push %edi
	316	#if dkey != 0
	317	lea dkey(%ebp),%ebp // key pointer
	318	#endif
1da177e4 LT	319
	320	// input four columns and xor in first round key
	321
	322	mov (%r2),%r0
	323	mov 4(%r2),%r1
	324	mov 8(%r2),%r4
	325	mov 12(%r2),%r5
	326	xor (%ebp),%r0
	327	xor 4(%ebp),%r1
	328	xor 8(%ebp),%r4
	329	xor 12(%ebp),%r5
	330
e6a3a925	331	sub $8,%esp // space for register saves on stack
5157dea8 SS	332	add $16,%ebp // increment to next round key
5157dea8 SS	333	cmp $24,%r3
e6a3a925	334	jb 4f // 10 rounds for 128-bit key
5157dea8	335	lea 32(%ebp),%ebp
e6a3a925	336	je 3f // 12 rounds for 192-bit key
5157dea8 SS	337	lea 32(%ebp),%ebp
	338
	339	2: inv_rnd1( -64(%ebp), crypto_it_tab) // 14 rounds for 256-bit key
	340	inv_rnd2( -48(%ebp), crypto_it_tab)
	341	3: inv_rnd1( -32(%ebp), crypto_it_tab) // 12 rounds for 192-bit key
	342	inv_rnd2( -16(%ebp), crypto_it_tab)
	343	4: inv_rnd1( (%ebp), crypto_it_tab) // 10 rounds for 128-bit key
	344	inv_rnd2( +16(%ebp), crypto_it_tab)
	345	inv_rnd1( +32(%ebp), crypto_it_tab)
	346	inv_rnd2( +48(%ebp), crypto_it_tab)
	347	inv_rnd1( +64(%ebp), crypto_it_tab)
	348	inv_rnd2( +80(%ebp), crypto_it_tab)
	349	inv_rnd1( +96(%ebp), crypto_it_tab)
	350	inv_rnd2(+112(%ebp), crypto_it_tab)
	351	inv_rnd1(+128(%ebp), crypto_it_tab)
	352	inv_rnd2(+144(%ebp), crypto_il_tab) // last round uses a different table
1da177e4 LT	353
	354	// move final values to the output array. CAUTION: the
	355	// order of these assigns rely on the register mappings
	356
	357	add $8,%esp
	358	mov out_blk+12(%esp),%ebp
	359	mov %r5,12(%ebp)
	360	pop %edi
	361	mov %r4,8(%ebp)
	362	pop %esi
	363	mov %r1,4(%ebp)
	364	pop %ebx
	365	mov %r0,(%ebp)
	366	pop %ebp
1da177e4	367	ret