Merge branch 'fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/evalenti/linux...
[sfrench/cifs-2.6.git] / arch / x86 / crypto / aesni-intel_asm.S
1 /*
2  * Implement AES algorithm in Intel AES-NI instructions.
3  *
4  * The white paper of AES-NI instructions can be downloaded from:
5  *   http://softwarecommunity.intel.com/isn/downloads/intelavx/AES-Instructions-Set_WP.pdf
6  *
7  * Copyright (C) 2008, Intel Corp.
8  *    Author: Huang Ying <ying.huang@intel.com>
9  *            Vinodh Gopal <vinodh.gopal@intel.com>
10  *            Kahraman Akdemir
11  *
12  * Added RFC4106 AES-GCM support for 128-bit keys under the AEAD
13  * interface for 64-bit kernels.
14  *    Authors: Erdinc Ozturk (erdinc.ozturk@intel.com)
15  *             Aidan O'Mahony (aidan.o.mahony@intel.com)
16  *             Adrian Hoban <adrian.hoban@intel.com>
17  *             James Guilford (james.guilford@intel.com)
18  *             Gabriele Paoloni <gabriele.paoloni@intel.com>
19  *             Tadeusz Struk (tadeusz.struk@intel.com)
20  *             Wajdi Feghali (wajdi.k.feghali@intel.com)
21  *    Copyright (c) 2010, Intel Corporation.
22  *
23  * Ported x86_64 version to x86:
24  *    Author: Mathias Krause <minipli@googlemail.com>
25  *
26  * This program is free software; you can redistribute it and/or modify
27  * it under the terms of the GNU General Public License as published by
28  * the Free Software Foundation; either version 2 of the License, or
29  * (at your option) any later version.
30  */
31
32 #include <linux/linkage.h>
33 #include <asm/inst.h>
34 #include <asm/frame.h>
35 #include <asm/nospec-branch.h>
36
37 /*
38  * The following macros are used to move an (un)aligned 16 byte value to/from
39  * an XMM register.  This can done for either FP or integer values, for FP use
40  * movaps (move aligned packed single) or integer use movdqa (move double quad
41  * aligned).  It doesn't make a performance difference which instruction is used
42  * since Nehalem (original Core i7) was released.  However, the movaps is a byte
43  * shorter, so that is the one we'll use for now. (same for unaligned).
44  */
45 #define MOVADQ  movaps
46 #define MOVUDQ  movups
47
48 #ifdef __x86_64__
49
50 # constants in mergeable sections, linker can reorder and merge
51 .section        .rodata.cst16.gf128mul_x_ble_mask, "aM", @progbits, 16
52 .align 16
53 .Lgf128mul_x_ble_mask:
54         .octa 0x00000000000000010000000000000087
55 .section        .rodata.cst16.POLY, "aM", @progbits, 16
56 .align 16
57 POLY:   .octa 0xC2000000000000000000000000000001
58 .section        .rodata.cst16.TWOONE, "aM", @progbits, 16
59 .align 16
60 TWOONE: .octa 0x00000001000000000000000000000001
61
62 .section        .rodata.cst16.SHUF_MASK, "aM", @progbits, 16
63 .align 16
64 SHUF_MASK:  .octa 0x000102030405060708090A0B0C0D0E0F
65 .section        .rodata.cst16.MASK1, "aM", @progbits, 16
66 .align 16
67 MASK1:      .octa 0x0000000000000000ffffffffffffffff
68 .section        .rodata.cst16.MASK2, "aM", @progbits, 16
69 .align 16
70 MASK2:      .octa 0xffffffffffffffff0000000000000000
71 .section        .rodata.cst16.ONE, "aM", @progbits, 16
72 .align 16
73 ONE:        .octa 0x00000000000000000000000000000001
74 .section        .rodata.cst16.F_MIN_MASK, "aM", @progbits, 16
75 .align 16
76 F_MIN_MASK: .octa 0xf1f2f3f4f5f6f7f8f9fafbfcfdfeff0
77 .section        .rodata.cst16.dec, "aM", @progbits, 16
78 .align 16
79 dec:        .octa 0x1
80 .section        .rodata.cst16.enc, "aM", @progbits, 16
81 .align 16
82 enc:        .octa 0x2
83
84 # order of these constants should not change.
85 # more specifically, ALL_F should follow SHIFT_MASK,
86 # and zero should follow ALL_F
87 .section        .rodata, "a", @progbits
88 .align 16
89 SHIFT_MASK: .octa 0x0f0e0d0c0b0a09080706050403020100
90 ALL_F:      .octa 0xffffffffffffffffffffffffffffffff
91             .octa 0x00000000000000000000000000000000
92
93 .text
94
95
96 #define STACK_OFFSET    8*3
97
98 #define AadHash 16*0
99 #define AadLen 16*1
100 #define InLen (16*1)+8
101 #define PBlockEncKey 16*2
102 #define OrigIV 16*3
103 #define CurCount 16*4
104 #define PBlockLen 16*5
105 #define HashKey         16*6    // store HashKey <<1 mod poly here
106 #define HashKey_2       16*7    // store HashKey^2 <<1 mod poly here
107 #define HashKey_3       16*8    // store HashKey^3 <<1 mod poly here
108 #define HashKey_4       16*9    // store HashKey^4 <<1 mod poly here
109 #define HashKey_k       16*10   // store XOR of High 64 bits and Low 64
110                                 // bits of  HashKey <<1 mod poly here
111                                 //(for Karatsuba purposes)
112 #define HashKey_2_k     16*11   // store XOR of High 64 bits and Low 64
113                                 // bits of  HashKey^2 <<1 mod poly here
114                                 // (for Karatsuba purposes)
115 #define HashKey_3_k     16*12   // store XOR of High 64 bits and Low 64
116                                 // bits of  HashKey^3 <<1 mod poly here
117                                 // (for Karatsuba purposes)
118 #define HashKey_4_k     16*13   // store XOR of High 64 bits and Low 64
119                                 // bits of  HashKey^4 <<1 mod poly here
120                                 // (for Karatsuba purposes)
121
122 #define arg1 rdi
123 #define arg2 rsi
124 #define arg3 rdx
125 #define arg4 rcx
126 #define arg5 r8
127 #define arg6 r9
128 #define arg7 STACK_OFFSET+8(%rsp)
129 #define arg8 STACK_OFFSET+16(%rsp)
130 #define arg9 STACK_OFFSET+24(%rsp)
131 #define arg10 STACK_OFFSET+32(%rsp)
132 #define arg11 STACK_OFFSET+40(%rsp)
133 #define keysize 2*15*16(%arg1)
134 #endif
135
136
137 #define STATE1  %xmm0
138 #define STATE2  %xmm4
139 #define STATE3  %xmm5
140 #define STATE4  %xmm6
141 #define STATE   STATE1
142 #define IN1     %xmm1
143 #define IN2     %xmm7
144 #define IN3     %xmm8
145 #define IN4     %xmm9
146 #define IN      IN1
147 #define KEY     %xmm2
148 #define IV      %xmm3
149
150 #define BSWAP_MASK %xmm10
151 #define CTR     %xmm11
152 #define INC     %xmm12
153
154 #define GF128MUL_MASK %xmm10
155
156 #ifdef __x86_64__
157 #define AREG    %rax
158 #define KEYP    %rdi
159 #define OUTP    %rsi
160 #define UKEYP   OUTP
161 #define INP     %rdx
162 #define LEN     %rcx
163 #define IVP     %r8
164 #define KLEN    %r9d
165 #define T1      %r10
166 #define TKEYP   T1
167 #define T2      %r11
168 #define TCTR_LOW T2
169 #else
170 #define AREG    %eax
171 #define KEYP    %edi
172 #define OUTP    AREG
173 #define UKEYP   OUTP
174 #define INP     %edx
175 #define LEN     %esi
176 #define IVP     %ebp
177 #define KLEN    %ebx
178 #define T1      %ecx
179 #define TKEYP   T1
180 #endif
181
182 .macro FUNC_SAVE
183         push    %r12
184         push    %r13
185         push    %r14
186 #
187 # states of %xmm registers %xmm6:%xmm15 not saved
188 # all %xmm registers are clobbered
189 #
190 .endm
191
192
193 .macro FUNC_RESTORE
194         pop     %r14
195         pop     %r13
196         pop     %r12
197 .endm
198
199 # Precompute hashkeys.
200 # Input: Hash subkey.
201 # Output: HashKeys stored in gcm_context_data.  Only needs to be called
202 # once per key.
203 # clobbers r12, and tmp xmm registers.
204 .macro PRECOMPUTE SUBKEY TMP1 TMP2 TMP3 TMP4 TMP5 TMP6 TMP7
205         mov     \SUBKEY, %r12
206         movdqu  (%r12), \TMP3
207         movdqa  SHUF_MASK(%rip), \TMP2
208         PSHUFB_XMM \TMP2, \TMP3
209
210         # precompute HashKey<<1 mod poly from the HashKey (required for GHASH)
211
212         movdqa  \TMP3, \TMP2
213         psllq   $1, \TMP3
214         psrlq   $63, \TMP2
215         movdqa  \TMP2, \TMP1
216         pslldq  $8, \TMP2
217         psrldq  $8, \TMP1
218         por     \TMP2, \TMP3
219
220         # reduce HashKey<<1
221
222         pshufd  $0x24, \TMP1, \TMP2
223         pcmpeqd TWOONE(%rip), \TMP2
224         pand    POLY(%rip), \TMP2
225         pxor    \TMP2, \TMP3
226         movdqa  \TMP3, HashKey(%arg2)
227
228         movdqa     \TMP3, \TMP5
229         pshufd     $78, \TMP3, \TMP1
230         pxor       \TMP3, \TMP1
231         movdqa     \TMP1, HashKey_k(%arg2)
232
233         GHASH_MUL  \TMP5, \TMP3, \TMP1, \TMP2, \TMP4, \TMP6, \TMP7
234 # TMP5 = HashKey^2<<1 (mod poly)
235         movdqa     \TMP5, HashKey_2(%arg2)
236 # HashKey_2 = HashKey^2<<1 (mod poly)
237         pshufd     $78, \TMP5, \TMP1
238         pxor       \TMP5, \TMP1
239         movdqa     \TMP1, HashKey_2_k(%arg2)
240
241         GHASH_MUL  \TMP5, \TMP3, \TMP1, \TMP2, \TMP4, \TMP6, \TMP7
242 # TMP5 = HashKey^3<<1 (mod poly)
243         movdqa     \TMP5, HashKey_3(%arg2)
244         pshufd     $78, \TMP5, \TMP1
245         pxor       \TMP5, \TMP1
246         movdqa     \TMP1, HashKey_3_k(%arg2)
247
248         GHASH_MUL  \TMP5, \TMP3, \TMP1, \TMP2, \TMP4, \TMP6, \TMP7
249 # TMP5 = HashKey^3<<1 (mod poly)
250         movdqa     \TMP5, HashKey_4(%arg2)
251         pshufd     $78, \TMP5, \TMP1
252         pxor       \TMP5, \TMP1
253         movdqa     \TMP1, HashKey_4_k(%arg2)
254 .endm
255
256 # GCM_INIT initializes a gcm_context struct to prepare for encoding/decoding.
257 # Clobbers rax, r10-r13 and xmm0-xmm6, %xmm13
258 .macro GCM_INIT Iv SUBKEY AAD AADLEN
259         mov \AADLEN, %r11
260         mov %r11, AadLen(%arg2) # ctx_data.aad_length = aad_length
261         xor %r11d, %r11d
262         mov %r11, InLen(%arg2) # ctx_data.in_length = 0
263         mov %r11, PBlockLen(%arg2) # ctx_data.partial_block_length = 0
264         mov %r11, PBlockEncKey(%arg2) # ctx_data.partial_block_enc_key = 0
265         mov \Iv, %rax
266         movdqu (%rax), %xmm0
267         movdqu %xmm0, OrigIV(%arg2) # ctx_data.orig_IV = iv
268
269         movdqa  SHUF_MASK(%rip), %xmm2
270         PSHUFB_XMM %xmm2, %xmm0
271         movdqu %xmm0, CurCount(%arg2) # ctx_data.current_counter = iv
272
273         PRECOMPUTE \SUBKEY, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
274         movdqa HashKey(%arg2), %xmm13
275
276         CALC_AAD_HASH %xmm13, \AAD, \AADLEN, %xmm0, %xmm1, %xmm2, %xmm3, \
277         %xmm4, %xmm5, %xmm6
278 .endm
279
280 # GCM_ENC_DEC Encodes/Decodes given data. Assumes that the passed gcm_context
281 # struct has been initialized by GCM_INIT.
282 # Requires the input data be at least 1 byte long because of READ_PARTIAL_BLOCK
283 # Clobbers rax, r10-r13, and xmm0-xmm15
284 .macro GCM_ENC_DEC operation
285         movdqu AadHash(%arg2), %xmm8
286         movdqu HashKey(%arg2), %xmm13
287         add %arg5, InLen(%arg2)
288
289         xor %r11d, %r11d # initialise the data pointer offset as zero
290         PARTIAL_BLOCK %arg3 %arg4 %arg5 %r11 %xmm8 \operation
291
292         sub %r11, %arg5         # sub partial block data used
293         mov %arg5, %r13         # save the number of bytes
294
295         and $-16, %r13          # %r13 = %r13 - (%r13 mod 16)
296         mov %r13, %r12
297         # Encrypt/Decrypt first few blocks
298
299         and     $(3<<4), %r12
300         jz      _initial_num_blocks_is_0_\@
301         cmp     $(2<<4), %r12
302         jb      _initial_num_blocks_is_1_\@
303         je      _initial_num_blocks_is_2_\@
304 _initial_num_blocks_is_3_\@:
305         INITIAL_BLOCKS_ENC_DEC  %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
306 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 5, 678, \operation
307         sub     $48, %r13
308         jmp     _initial_blocks_\@
309 _initial_num_blocks_is_2_\@:
310         INITIAL_BLOCKS_ENC_DEC  %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
311 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 6, 78, \operation
312         sub     $32, %r13
313         jmp     _initial_blocks_\@
314 _initial_num_blocks_is_1_\@:
315         INITIAL_BLOCKS_ENC_DEC  %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
316 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 7, 8, \operation
317         sub     $16, %r13
318         jmp     _initial_blocks_\@
319 _initial_num_blocks_is_0_\@:
320         INITIAL_BLOCKS_ENC_DEC  %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
321 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 8, 0, \operation
322 _initial_blocks_\@:
323
324         # Main loop - Encrypt/Decrypt remaining blocks
325
326         cmp     $0, %r13
327         je      _zero_cipher_left_\@
328         sub     $64, %r13
329         je      _four_cipher_left_\@
330 _crypt_by_4_\@:
331         GHASH_4_ENCRYPT_4_PARALLEL_\operation   %xmm9, %xmm10, %xmm11, %xmm12, \
332         %xmm13, %xmm14, %xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, \
333         %xmm7, %xmm8, enc
334         add     $64, %r11
335         sub     $64, %r13
336         jne     _crypt_by_4_\@
337 _four_cipher_left_\@:
338         GHASH_LAST_4    %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14, \
339 %xmm15, %xmm1, %xmm2, %xmm3, %xmm4, %xmm8
340 _zero_cipher_left_\@:
341         movdqu %xmm8, AadHash(%arg2)
342         movdqu %xmm0, CurCount(%arg2)
343
344         mov     %arg5, %r13
345         and     $15, %r13                       # %r13 = arg5 (mod 16)
346         je      _multiple_of_16_bytes_\@
347
348         mov %r13, PBlockLen(%arg2)
349
350         # Handle the last <16 Byte block separately
351         paddd ONE(%rip), %xmm0                # INCR CNT to get Yn
352         movdqu %xmm0, CurCount(%arg2)
353         movdqa SHUF_MASK(%rip), %xmm10
354         PSHUFB_XMM %xmm10, %xmm0
355
356         ENCRYPT_SINGLE_BLOCK    %xmm0, %xmm1        # Encrypt(K, Yn)
357         movdqu %xmm0, PBlockEncKey(%arg2)
358
359         cmp     $16, %arg5
360         jge _large_enough_update_\@
361
362         lea (%arg4,%r11,1), %r10
363         mov %r13, %r12
364         READ_PARTIAL_BLOCK %r10 %r12 %xmm2 %xmm1
365         jmp _data_read_\@
366
367 _large_enough_update_\@:
368         sub     $16, %r11
369         add     %r13, %r11
370
371         # receive the last <16 Byte block
372         movdqu  (%arg4, %r11, 1), %xmm1
373
374         sub     %r13, %r11
375         add     $16, %r11
376
377         lea     SHIFT_MASK+16(%rip), %r12
378         # adjust the shuffle mask pointer to be able to shift 16-r13 bytes
379         # (r13 is the number of bytes in plaintext mod 16)
380         sub     %r13, %r12
381         # get the appropriate shuffle mask
382         movdqu  (%r12), %xmm2
383         # shift right 16-r13 bytes
384         PSHUFB_XMM  %xmm2, %xmm1
385
386 _data_read_\@:
387         lea ALL_F+16(%rip), %r12
388         sub %r13, %r12
389
390 .ifc \operation, dec
391         movdqa  %xmm1, %xmm2
392 .endif
393         pxor    %xmm1, %xmm0            # XOR Encrypt(K, Yn)
394         movdqu  (%r12), %xmm1
395         # get the appropriate mask to mask out top 16-r13 bytes of xmm0
396         pand    %xmm1, %xmm0            # mask out top 16-r13 bytes of xmm0
397 .ifc \operation, dec
398         pand    %xmm1, %xmm2
399         movdqa SHUF_MASK(%rip), %xmm10
400         PSHUFB_XMM %xmm10 ,%xmm2
401
402         pxor %xmm2, %xmm8
403 .else
404         movdqa SHUF_MASK(%rip), %xmm10
405         PSHUFB_XMM %xmm10,%xmm0
406
407         pxor    %xmm0, %xmm8
408 .endif
409
410         movdqu %xmm8, AadHash(%arg2)
411 .ifc \operation, enc
412         # GHASH computation for the last <16 byte block
413         movdqa SHUF_MASK(%rip), %xmm10
414         # shuffle xmm0 back to output as ciphertext
415         PSHUFB_XMM %xmm10, %xmm0
416 .endif
417
418         # Output %r13 bytes
419         MOVQ_R64_XMM %xmm0, %rax
420         cmp $8, %r13
421         jle _less_than_8_bytes_left_\@
422         mov %rax, (%arg3 , %r11, 1)
423         add $8, %r11
424         psrldq $8, %xmm0
425         MOVQ_R64_XMM %xmm0, %rax
426         sub $8, %r13
427 _less_than_8_bytes_left_\@:
428         mov %al,  (%arg3, %r11, 1)
429         add $1, %r11
430         shr $8, %rax
431         sub $1, %r13
432         jne _less_than_8_bytes_left_\@
433 _multiple_of_16_bytes_\@:
434 .endm
435
436 # GCM_COMPLETE Finishes update of tag of last partial block
437 # Output: Authorization Tag (AUTH_TAG)
438 # Clobbers rax, r10-r12, and xmm0, xmm1, xmm5-xmm15
439 .macro GCM_COMPLETE AUTHTAG AUTHTAGLEN
440         movdqu AadHash(%arg2), %xmm8
441         movdqu HashKey(%arg2), %xmm13
442
443         mov PBlockLen(%arg2), %r12
444
445         cmp $0, %r12
446         je _partial_done\@
447
448         GHASH_MUL %xmm8, %xmm13, %xmm9, %xmm10, %xmm11, %xmm5, %xmm6
449
450 _partial_done\@:
451         mov AadLen(%arg2), %r12  # %r13 = aadLen (number of bytes)
452         shl     $3, %r12                  # convert into number of bits
453         movd    %r12d, %xmm15             # len(A) in %xmm15
454         mov InLen(%arg2), %r12
455         shl     $3, %r12                  # len(C) in bits (*128)
456         MOVQ_R64_XMM    %r12, %xmm1
457
458         pslldq  $8, %xmm15                # %xmm15 = len(A)||0x0000000000000000
459         pxor    %xmm1, %xmm15             # %xmm15 = len(A)||len(C)
460         pxor    %xmm15, %xmm8
461         GHASH_MUL       %xmm8, %xmm13, %xmm9, %xmm10, %xmm11, %xmm5, %xmm6
462         # final GHASH computation
463         movdqa SHUF_MASK(%rip), %xmm10
464         PSHUFB_XMM %xmm10, %xmm8
465
466         movdqu OrigIV(%arg2), %xmm0       # %xmm0 = Y0
467         ENCRYPT_SINGLE_BLOCK    %xmm0,  %xmm1     # E(K, Y0)
468         pxor    %xmm8, %xmm0
469 _return_T_\@:
470         mov     \AUTHTAG, %r10                     # %r10 = authTag
471         mov     \AUTHTAGLEN, %r11                    # %r11 = auth_tag_len
472         cmp     $16, %r11
473         je      _T_16_\@
474         cmp     $8, %r11
475         jl      _T_4_\@
476 _T_8_\@:
477         MOVQ_R64_XMM    %xmm0, %rax
478         mov     %rax, (%r10)
479         add     $8, %r10
480         sub     $8, %r11
481         psrldq  $8, %xmm0
482         cmp     $0, %r11
483         je      _return_T_done_\@
484 _T_4_\@:
485         movd    %xmm0, %eax
486         mov     %eax, (%r10)
487         add     $4, %r10
488         sub     $4, %r11
489         psrldq  $4, %xmm0
490         cmp     $0, %r11
491         je      _return_T_done_\@
492 _T_123_\@:
493         movd    %xmm0, %eax
494         cmp     $2, %r11
495         jl      _T_1_\@
496         mov     %ax, (%r10)
497         cmp     $2, %r11
498         je      _return_T_done_\@
499         add     $2, %r10
500         sar     $16, %eax
501 _T_1_\@:
502         mov     %al, (%r10)
503         jmp     _return_T_done_\@
504 _T_16_\@:
505         movdqu  %xmm0, (%r10)
506 _return_T_done_\@:
507 .endm
508
509 #ifdef __x86_64__
510 /* GHASH_MUL MACRO to implement: Data*HashKey mod (128,127,126,121,0)
511 *
512 *
513 * Input: A and B (128-bits each, bit-reflected)
514 * Output: C = A*B*x mod poly, (i.e. >>1 )
515 * To compute GH = GH*HashKey mod poly, give HK = HashKey<<1 mod poly as input
516 * GH = GH * HK * x mod poly which is equivalent to GH*HashKey mod poly.
517 *
518 */
519 .macro GHASH_MUL GH HK TMP1 TMP2 TMP3 TMP4 TMP5
520         movdqa    \GH, \TMP1
521         pshufd    $78, \GH, \TMP2
522         pshufd    $78, \HK, \TMP3
523         pxor      \GH, \TMP2            # TMP2 = a1+a0
524         pxor      \HK, \TMP3            # TMP3 = b1+b0
525         PCLMULQDQ 0x11, \HK, \TMP1     # TMP1 = a1*b1
526         PCLMULQDQ 0x00, \HK, \GH       # GH = a0*b0
527         PCLMULQDQ 0x00, \TMP3, \TMP2   # TMP2 = (a0+a1)*(b1+b0)
528         pxor      \GH, \TMP2
529         pxor      \TMP1, \TMP2          # TMP2 = (a0*b0)+(a1*b0)
530         movdqa    \TMP2, \TMP3
531         pslldq    $8, \TMP3             # left shift TMP3 2 DWs
532         psrldq    $8, \TMP2             # right shift TMP2 2 DWs
533         pxor      \TMP3, \GH
534         pxor      \TMP2, \TMP1          # TMP2:GH holds the result of GH*HK
535
536         # first phase of the reduction
537
538         movdqa    \GH, \TMP2
539         movdqa    \GH, \TMP3
540         movdqa    \GH, \TMP4            # copy GH into TMP2,TMP3 and TMP4
541                                         # in in order to perform
542                                         # independent shifts
543         pslld     $31, \TMP2            # packed right shift <<31
544         pslld     $30, \TMP3            # packed right shift <<30
545         pslld     $25, \TMP4            # packed right shift <<25
546         pxor      \TMP3, \TMP2          # xor the shifted versions
547         pxor      \TMP4, \TMP2
548         movdqa    \TMP2, \TMP5
549         psrldq    $4, \TMP5             # right shift TMP5 1 DW
550         pslldq    $12, \TMP2            # left shift TMP2 3 DWs
551         pxor      \TMP2, \GH
552
553         # second phase of the reduction
554
555         movdqa    \GH,\TMP2             # copy GH into TMP2,TMP3 and TMP4
556                                         # in in order to perform
557                                         # independent shifts
558         movdqa    \GH,\TMP3
559         movdqa    \GH,\TMP4
560         psrld     $1,\TMP2              # packed left shift >>1
561         psrld     $2,\TMP3              # packed left shift >>2
562         psrld     $7,\TMP4              # packed left shift >>7
563         pxor      \TMP3,\TMP2           # xor the shifted versions
564         pxor      \TMP4,\TMP2
565         pxor      \TMP5, \TMP2
566         pxor      \TMP2, \GH
567         pxor      \TMP1, \GH            # result is in TMP1
568 .endm
569
570 # Reads DLEN bytes starting at DPTR and stores in XMMDst
571 # where 0 < DLEN < 16
572 # Clobbers %rax, DLEN and XMM1
573 .macro READ_PARTIAL_BLOCK DPTR DLEN XMM1 XMMDst
574         cmp $8, \DLEN
575         jl _read_lt8_\@
576         mov (\DPTR), %rax
577         MOVQ_R64_XMM %rax, \XMMDst
578         sub $8, \DLEN
579         jz _done_read_partial_block_\@
580         xor %eax, %eax
581 _read_next_byte_\@:
582         shl $8, %rax
583         mov 7(\DPTR, \DLEN, 1), %al
584         dec \DLEN
585         jnz _read_next_byte_\@
586         MOVQ_R64_XMM %rax, \XMM1
587         pslldq $8, \XMM1
588         por \XMM1, \XMMDst
589         jmp _done_read_partial_block_\@
590 _read_lt8_\@:
591         xor %eax, %eax
592 _read_next_byte_lt8_\@:
593         shl $8, %rax
594         mov -1(\DPTR, \DLEN, 1), %al
595         dec \DLEN
596         jnz _read_next_byte_lt8_\@
597         MOVQ_R64_XMM %rax, \XMMDst
598 _done_read_partial_block_\@:
599 .endm
600
601 # CALC_AAD_HASH: Calculates the hash of the data which will not be encrypted.
602 # clobbers r10-11, xmm14
603 .macro CALC_AAD_HASH HASHKEY AAD AADLEN TMP1 TMP2 TMP3 TMP4 TMP5 \
604         TMP6 TMP7
605         MOVADQ     SHUF_MASK(%rip), %xmm14
606         mov        \AAD, %r10           # %r10 = AAD
607         mov        \AADLEN, %r11                # %r11 = aadLen
608         pxor       \TMP7, \TMP7
609         pxor       \TMP6, \TMP6
610
611         cmp        $16, %r11
612         jl         _get_AAD_rest\@
613 _get_AAD_blocks\@:
614         movdqu     (%r10), \TMP7
615         PSHUFB_XMM   %xmm14, \TMP7 # byte-reflect the AAD data
616         pxor       \TMP7, \TMP6
617         GHASH_MUL  \TMP6, \HASHKEY, \TMP1, \TMP2, \TMP3, \TMP4, \TMP5
618         add        $16, %r10
619         sub        $16, %r11
620         cmp        $16, %r11
621         jge        _get_AAD_blocks\@
622
623         movdqu     \TMP6, \TMP7
624
625         /* read the last <16B of AAD */
626 _get_AAD_rest\@:
627         cmp        $0, %r11
628         je         _get_AAD_done\@
629
630         READ_PARTIAL_BLOCK %r10, %r11, \TMP1, \TMP7
631         PSHUFB_XMM   %xmm14, \TMP7 # byte-reflect the AAD data
632         pxor       \TMP6, \TMP7
633         GHASH_MUL  \TMP7, \HASHKEY, \TMP1, \TMP2, \TMP3, \TMP4, \TMP5
634         movdqu \TMP7, \TMP6
635
636 _get_AAD_done\@:
637         movdqu \TMP6, AadHash(%arg2)
638 .endm
639
640 # PARTIAL_BLOCK: Handles encryption/decryption and the tag partial blocks
641 # between update calls.
642 # Requires the input data be at least 1 byte long due to READ_PARTIAL_BLOCK
643 # Outputs encrypted bytes, and updates hash and partial info in gcm_data_context
644 # Clobbers rax, r10, r12, r13, xmm0-6, xmm9-13
645 .macro PARTIAL_BLOCK CYPH_PLAIN_OUT PLAIN_CYPH_IN PLAIN_CYPH_LEN DATA_OFFSET \
646         AAD_HASH operation
647         mov     PBlockLen(%arg2), %r13
648         cmp     $0, %r13
649         je      _partial_block_done_\@  # Leave Macro if no partial blocks
650         # Read in input data without over reading
651         cmp     $16, \PLAIN_CYPH_LEN
652         jl      _fewer_than_16_bytes_\@
653         movups  (\PLAIN_CYPH_IN), %xmm1 # If more than 16 bytes, just fill xmm
654         jmp     _data_read_\@
655
656 _fewer_than_16_bytes_\@:
657         lea     (\PLAIN_CYPH_IN, \DATA_OFFSET, 1), %r10
658         mov     \PLAIN_CYPH_LEN, %r12
659         READ_PARTIAL_BLOCK %r10 %r12 %xmm0 %xmm1
660
661         mov PBlockLen(%arg2), %r13
662
663 _data_read_\@:                          # Finished reading in data
664
665         movdqu  PBlockEncKey(%arg2), %xmm9
666         movdqu  HashKey(%arg2), %xmm13
667
668         lea     SHIFT_MASK(%rip), %r12
669
670         # adjust the shuffle mask pointer to be able to shift r13 bytes
671         # r16-r13 is the number of bytes in plaintext mod 16)
672         add     %r13, %r12
673         movdqu  (%r12), %xmm2           # get the appropriate shuffle mask
674         PSHUFB_XMM %xmm2, %xmm9         # shift right r13 bytes
675
676 .ifc \operation, dec
677         movdqa  %xmm1, %xmm3
678         pxor    %xmm1, %xmm9            # Cyphertext XOR E(K, Yn)
679
680         mov     \PLAIN_CYPH_LEN, %r10
681         add     %r13, %r10
682         # Set r10 to be the amount of data left in CYPH_PLAIN_IN after filling
683         sub     $16, %r10
684         # Determine if if partial block is not being filled and
685         # shift mask accordingly
686         jge     _no_extra_mask_1_\@
687         sub     %r10, %r12
688 _no_extra_mask_1_\@:
689
690         movdqu  ALL_F-SHIFT_MASK(%r12), %xmm1
691         # get the appropriate mask to mask out bottom r13 bytes of xmm9
692         pand    %xmm1, %xmm9            # mask out bottom r13 bytes of xmm9
693
694         pand    %xmm1, %xmm3
695         movdqa  SHUF_MASK(%rip), %xmm10
696         PSHUFB_XMM      %xmm10, %xmm3
697         PSHUFB_XMM      %xmm2, %xmm3
698         pxor    %xmm3, \AAD_HASH
699
700         cmp     $0, %r10
701         jl      _partial_incomplete_1_\@
702
703         # GHASH computation for the last <16 Byte block
704         GHASH_MUL \AAD_HASH, %xmm13, %xmm0, %xmm10, %xmm11, %xmm5, %xmm6
705         xor     %eax, %eax
706
707         mov     %rax, PBlockLen(%arg2)
708         jmp     _dec_done_\@
709 _partial_incomplete_1_\@:
710         add     \PLAIN_CYPH_LEN, PBlockLen(%arg2)
711 _dec_done_\@:
712         movdqu  \AAD_HASH, AadHash(%arg2)
713 .else
714         pxor    %xmm1, %xmm9                    # Plaintext XOR E(K, Yn)
715
716         mov     \PLAIN_CYPH_LEN, %r10
717         add     %r13, %r10
718         # Set r10 to be the amount of data left in CYPH_PLAIN_IN after filling
719         sub     $16, %r10
720         # Determine if if partial block is not being filled and
721         # shift mask accordingly
722         jge     _no_extra_mask_2_\@
723         sub     %r10, %r12
724 _no_extra_mask_2_\@:
725
726         movdqu  ALL_F-SHIFT_MASK(%r12), %xmm1
727         # get the appropriate mask to mask out bottom r13 bytes of xmm9
728         pand    %xmm1, %xmm9
729
730         movdqa  SHUF_MASK(%rip), %xmm1
731         PSHUFB_XMM %xmm1, %xmm9
732         PSHUFB_XMM %xmm2, %xmm9
733         pxor    %xmm9, \AAD_HASH
734
735         cmp     $0, %r10
736         jl      _partial_incomplete_2_\@
737
738         # GHASH computation for the last <16 Byte block
739         GHASH_MUL \AAD_HASH, %xmm13, %xmm0, %xmm10, %xmm11, %xmm5, %xmm6
740         xor     %eax, %eax
741
742         mov     %rax, PBlockLen(%arg2)
743         jmp     _encode_done_\@
744 _partial_incomplete_2_\@:
745         add     \PLAIN_CYPH_LEN, PBlockLen(%arg2)
746 _encode_done_\@:
747         movdqu  \AAD_HASH, AadHash(%arg2)
748
749         movdqa  SHUF_MASK(%rip), %xmm10
750         # shuffle xmm9 back to output as ciphertext
751         PSHUFB_XMM      %xmm10, %xmm9
752         PSHUFB_XMM      %xmm2, %xmm9
753 .endif
754         # output encrypted Bytes
755         cmp     $0, %r10
756         jl      _partial_fill_\@
757         mov     %r13, %r12
758         mov     $16, %r13
759         # Set r13 to be the number of bytes to write out
760         sub     %r12, %r13
761         jmp     _count_set_\@
762 _partial_fill_\@:
763         mov     \PLAIN_CYPH_LEN, %r13
764 _count_set_\@:
765         movdqa  %xmm9, %xmm0
766         MOVQ_R64_XMM    %xmm0, %rax
767         cmp     $8, %r13
768         jle     _less_than_8_bytes_left_\@
769
770         mov     %rax, (\CYPH_PLAIN_OUT, \DATA_OFFSET, 1)
771         add     $8, \DATA_OFFSET
772         psrldq  $8, %xmm0
773         MOVQ_R64_XMM    %xmm0, %rax
774         sub     $8, %r13
775 _less_than_8_bytes_left_\@:
776         movb    %al, (\CYPH_PLAIN_OUT, \DATA_OFFSET, 1)
777         add     $1, \DATA_OFFSET
778         shr     $8, %rax
779         sub     $1, %r13
780         jne     _less_than_8_bytes_left_\@
781 _partial_block_done_\@:
782 .endm # PARTIAL_BLOCK
783
784 /*
785 * if a = number of total plaintext bytes
786 * b = floor(a/16)
787 * num_initial_blocks = b mod 4
788 * encrypt the initial num_initial_blocks blocks and apply ghash on
789 * the ciphertext
790 * %r10, %r11, %r12, %rax, %xmm5, %xmm6, %xmm7, %xmm8, %xmm9 registers
791 * are clobbered
792 * arg1, %arg2, %arg3 are used as a pointer only, not modified
793 */
794
795
796 .macro INITIAL_BLOCKS_ENC_DEC TMP1 TMP2 TMP3 TMP4 TMP5 XMM0 XMM1 \
797         XMM2 XMM3 XMM4 XMMDst TMP6 TMP7 i i_seq operation
798         MOVADQ          SHUF_MASK(%rip), %xmm14
799
800         movdqu AadHash(%arg2), %xmm\i               # XMM0 = Y0
801
802         # start AES for num_initial_blocks blocks
803
804         movdqu CurCount(%arg2), \XMM0                # XMM0 = Y0
805
806 .if (\i == 5) || (\i == 6) || (\i == 7)
807
808         MOVADQ          ONE(%RIP),\TMP1
809         MOVADQ          0(%arg1),\TMP2
810 .irpc index, \i_seq
811         paddd           \TMP1, \XMM0                 # INCR Y0
812 .ifc \operation, dec
813         movdqa     \XMM0, %xmm\index
814 .else
815         MOVADQ          \XMM0, %xmm\index
816 .endif
817         PSHUFB_XMM      %xmm14, %xmm\index      # perform a 16 byte swap
818         pxor            \TMP2, %xmm\index
819 .endr
820         lea     0x10(%arg1),%r10
821         mov     keysize,%eax
822         shr     $2,%eax                         # 128->4, 192->6, 256->8
823         add     $5,%eax                       # 128->9, 192->11, 256->13
824
825 aes_loop_initial_\@:
826         MOVADQ  (%r10),\TMP1
827 .irpc   index, \i_seq
828         AESENC  \TMP1, %xmm\index
829 .endr
830         add     $16,%r10
831         sub     $1,%eax
832         jnz     aes_loop_initial_\@
833
834         MOVADQ  (%r10), \TMP1
835 .irpc index, \i_seq
836         AESENCLAST \TMP1, %xmm\index         # Last Round
837 .endr
838 .irpc index, \i_seq
839         movdqu     (%arg4 , %r11, 1), \TMP1
840         pxor       \TMP1, %xmm\index
841         movdqu     %xmm\index, (%arg3 , %r11, 1)
842         # write back plaintext/ciphertext for num_initial_blocks
843         add        $16, %r11
844
845 .ifc \operation, dec
846         movdqa     \TMP1, %xmm\index
847 .endif
848         PSHUFB_XMM         %xmm14, %xmm\index
849
850                 # prepare plaintext/ciphertext for GHASH computation
851 .endr
852 .endif
853
854         # apply GHASH on num_initial_blocks blocks
855
856 .if \i == 5
857         pxor       %xmm5, %xmm6
858         GHASH_MUL  %xmm6, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
859         pxor       %xmm6, %xmm7
860         GHASH_MUL  %xmm7, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
861         pxor       %xmm7, %xmm8
862         GHASH_MUL  %xmm8, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
863 .elseif \i == 6
864         pxor       %xmm6, %xmm7
865         GHASH_MUL  %xmm7, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
866         pxor       %xmm7, %xmm8
867         GHASH_MUL  %xmm8, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
868 .elseif \i == 7
869         pxor       %xmm7, %xmm8
870         GHASH_MUL  %xmm8, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
871 .endif
872         cmp        $64, %r13
873         jl      _initial_blocks_done\@
874         # no need for precomputed values
875 /*
876 *
877 * Precomputations for HashKey parallel with encryption of first 4 blocks.
878 * Haskey_i_k holds XORed values of the low and high parts of the Haskey_i
879 */
880         MOVADQ     ONE(%RIP),\TMP1
881         paddd      \TMP1, \XMM0              # INCR Y0
882         MOVADQ     \XMM0, \XMM1
883         PSHUFB_XMM  %xmm14, \XMM1        # perform a 16 byte swap
884
885         paddd      \TMP1, \XMM0              # INCR Y0
886         MOVADQ     \XMM0, \XMM2
887         PSHUFB_XMM  %xmm14, \XMM2        # perform a 16 byte swap
888
889         paddd      \TMP1, \XMM0              # INCR Y0
890         MOVADQ     \XMM0, \XMM3
891         PSHUFB_XMM %xmm14, \XMM3        # perform a 16 byte swap
892
893         paddd      \TMP1, \XMM0              # INCR Y0
894         MOVADQ     \XMM0, \XMM4
895         PSHUFB_XMM %xmm14, \XMM4        # perform a 16 byte swap
896
897         MOVADQ     0(%arg1),\TMP1
898         pxor       \TMP1, \XMM1
899         pxor       \TMP1, \XMM2
900         pxor       \TMP1, \XMM3
901         pxor       \TMP1, \XMM4
902 .irpc index, 1234 # do 4 rounds
903         movaps 0x10*\index(%arg1), \TMP1
904         AESENC     \TMP1, \XMM1
905         AESENC     \TMP1, \XMM2
906         AESENC     \TMP1, \XMM3
907         AESENC     \TMP1, \XMM4
908 .endr
909 .irpc index, 56789 # do next 5 rounds
910         movaps 0x10*\index(%arg1), \TMP1
911         AESENC     \TMP1, \XMM1
912         AESENC     \TMP1, \XMM2
913         AESENC     \TMP1, \XMM3
914         AESENC     \TMP1, \XMM4
915 .endr
916         lea        0xa0(%arg1),%r10
917         mov        keysize,%eax
918         shr        $2,%eax                      # 128->4, 192->6, 256->8
919         sub        $4,%eax                      # 128->0, 192->2, 256->4
920         jz         aes_loop_pre_done\@
921
922 aes_loop_pre_\@:
923         MOVADQ     (%r10),\TMP2
924 .irpc   index, 1234
925         AESENC     \TMP2, %xmm\index
926 .endr
927         add        $16,%r10
928         sub        $1,%eax
929         jnz        aes_loop_pre_\@
930
931 aes_loop_pre_done\@:
932         MOVADQ     (%r10), \TMP2
933         AESENCLAST \TMP2, \XMM1
934         AESENCLAST \TMP2, \XMM2
935         AESENCLAST \TMP2, \XMM3
936         AESENCLAST \TMP2, \XMM4
937         movdqu     16*0(%arg4 , %r11 , 1), \TMP1
938         pxor       \TMP1, \XMM1
939 .ifc \operation, dec
940         movdqu     \XMM1, 16*0(%arg3 , %r11 , 1)
941         movdqa     \TMP1, \XMM1
942 .endif
943         movdqu     16*1(%arg4 , %r11 , 1), \TMP1
944         pxor       \TMP1, \XMM2
945 .ifc \operation, dec
946         movdqu     \XMM2, 16*1(%arg3 , %r11 , 1)
947         movdqa     \TMP1, \XMM2
948 .endif
949         movdqu     16*2(%arg4 , %r11 , 1), \TMP1
950         pxor       \TMP1, \XMM3
951 .ifc \operation, dec
952         movdqu     \XMM3, 16*2(%arg3 , %r11 , 1)
953         movdqa     \TMP1, \XMM3
954 .endif
955         movdqu     16*3(%arg4 , %r11 , 1), \TMP1
956         pxor       \TMP1, \XMM4
957 .ifc \operation, dec
958         movdqu     \XMM4, 16*3(%arg3 , %r11 , 1)
959         movdqa     \TMP1, \XMM4
960 .else
961         movdqu     \XMM1, 16*0(%arg3 , %r11 , 1)
962         movdqu     \XMM2, 16*1(%arg3 , %r11 , 1)
963         movdqu     \XMM3, 16*2(%arg3 , %r11 , 1)
964         movdqu     \XMM4, 16*3(%arg3 , %r11 , 1)
965 .endif
966
967         add        $64, %r11
968         PSHUFB_XMM %xmm14, \XMM1 # perform a 16 byte swap
969         pxor       \XMMDst, \XMM1
970 # combine GHASHed value with the corresponding ciphertext
971         PSHUFB_XMM %xmm14, \XMM2 # perform a 16 byte swap
972         PSHUFB_XMM %xmm14, \XMM3 # perform a 16 byte swap
973         PSHUFB_XMM %xmm14, \XMM4 # perform a 16 byte swap
974
975 _initial_blocks_done\@:
976
977 .endm
978
979 /*
980 * encrypt 4 blocks at a time
981 * ghash the 4 previously encrypted ciphertext blocks
982 * arg1, %arg3, %arg4 are used as pointers only, not modified
983 * %r11 is the data offset value
984 */
985 .macro GHASH_4_ENCRYPT_4_PARALLEL_ENC TMP1 TMP2 TMP3 TMP4 TMP5 \
986 TMP6 XMM0 XMM1 XMM2 XMM3 XMM4 XMM5 XMM6 XMM7 XMM8 operation
987
988         movdqa    \XMM1, \XMM5
989         movdqa    \XMM2, \XMM6
990         movdqa    \XMM3, \XMM7
991         movdqa    \XMM4, \XMM8
992
993         movdqa    SHUF_MASK(%rip), %xmm15
994         # multiply TMP5 * HashKey using karatsuba
995
996         movdqa    \XMM5, \TMP4
997         pshufd    $78, \XMM5, \TMP6
998         pxor      \XMM5, \TMP6
999         paddd     ONE(%rip), \XMM0              # INCR CNT
1000         movdqa    HashKey_4(%arg2), \TMP5
1001         PCLMULQDQ 0x11, \TMP5, \TMP4           # TMP4 = a1*b1
1002         movdqa    \XMM0, \XMM1
1003         paddd     ONE(%rip), \XMM0              # INCR CNT
1004         movdqa    \XMM0, \XMM2
1005         paddd     ONE(%rip), \XMM0              # INCR CNT
1006         movdqa    \XMM0, \XMM3
1007         paddd     ONE(%rip), \XMM0              # INCR CNT
1008         movdqa    \XMM0, \XMM4
1009         PSHUFB_XMM %xmm15, \XMM1        # perform a 16 byte swap
1010         PCLMULQDQ 0x00, \TMP5, \XMM5           # XMM5 = a0*b0
1011         PSHUFB_XMM %xmm15, \XMM2        # perform a 16 byte swap
1012         PSHUFB_XMM %xmm15, \XMM3        # perform a 16 byte swap
1013         PSHUFB_XMM %xmm15, \XMM4        # perform a 16 byte swap
1014
1015         pxor      (%arg1), \XMM1
1016         pxor      (%arg1), \XMM2
1017         pxor      (%arg1), \XMM3
1018         pxor      (%arg1), \XMM4
1019         movdqa    HashKey_4_k(%arg2), \TMP5
1020         PCLMULQDQ 0x00, \TMP5, \TMP6           # TMP6 = (a1+a0)*(b1+b0)
1021         movaps 0x10(%arg1), \TMP1
1022         AESENC    \TMP1, \XMM1              # Round 1
1023         AESENC    \TMP1, \XMM2
1024         AESENC    \TMP1, \XMM3
1025         AESENC    \TMP1, \XMM4
1026         movaps 0x20(%arg1), \TMP1
1027         AESENC    \TMP1, \XMM1              # Round 2
1028         AESENC    \TMP1, \XMM2
1029         AESENC    \TMP1, \XMM3
1030         AESENC    \TMP1, \XMM4
1031         movdqa    \XMM6, \TMP1
1032         pshufd    $78, \XMM6, \TMP2
1033         pxor      \XMM6, \TMP2
1034         movdqa    HashKey_3(%arg2), \TMP5
1035         PCLMULQDQ 0x11, \TMP5, \TMP1           # TMP1 = a1 * b1
1036         movaps 0x30(%arg1), \TMP3
1037         AESENC    \TMP3, \XMM1              # Round 3
1038         AESENC    \TMP3, \XMM2
1039         AESENC    \TMP3, \XMM3
1040         AESENC    \TMP3, \XMM4
1041         PCLMULQDQ 0x00, \TMP5, \XMM6           # XMM6 = a0*b0
1042         movaps 0x40(%arg1), \TMP3
1043         AESENC    \TMP3, \XMM1              # Round 4
1044         AESENC    \TMP3, \XMM2
1045         AESENC    \TMP3, \XMM3
1046         AESENC    \TMP3, \XMM4
1047         movdqa    HashKey_3_k(%arg2), \TMP5
1048         PCLMULQDQ 0x00, \TMP5, \TMP2           # TMP2 = (a1+a0)*(b1+b0)
1049         movaps 0x50(%arg1), \TMP3
1050         AESENC    \TMP3, \XMM1              # Round 5
1051         AESENC    \TMP3, \XMM2
1052         AESENC    \TMP3, \XMM3
1053         AESENC    \TMP3, \XMM4
1054         pxor      \TMP1, \TMP4
1055 # accumulate the results in TMP4:XMM5, TMP6 holds the middle part
1056         pxor      \XMM6, \XMM5
1057         pxor      \TMP2, \TMP6
1058         movdqa    \XMM7, \TMP1
1059         pshufd    $78, \XMM7, \TMP2
1060         pxor      \XMM7, \TMP2
1061         movdqa    HashKey_2(%arg2), \TMP5
1062
1063         # Multiply TMP5 * HashKey using karatsuba
1064
1065         PCLMULQDQ 0x11, \TMP5, \TMP1           # TMP1 = a1*b1
1066         movaps 0x60(%arg1), \TMP3
1067         AESENC    \TMP3, \XMM1              # Round 6
1068         AESENC    \TMP3, \XMM2
1069         AESENC    \TMP3, \XMM3
1070         AESENC    \TMP3, \XMM4
1071         PCLMULQDQ 0x00, \TMP5, \XMM7           # XMM7 = a0*b0
1072         movaps 0x70(%arg1), \TMP3
1073         AESENC    \TMP3, \XMM1             # Round 7
1074         AESENC    \TMP3, \XMM2
1075         AESENC    \TMP3, \XMM3
1076         AESENC    \TMP3, \XMM4
1077         movdqa    HashKey_2_k(%arg2), \TMP5
1078         PCLMULQDQ 0x00, \TMP5, \TMP2           # TMP2 = (a1+a0)*(b1+b0)
1079         movaps 0x80(%arg1), \TMP3
1080         AESENC    \TMP3, \XMM1             # Round 8
1081         AESENC    \TMP3, \XMM2
1082         AESENC    \TMP3, \XMM3
1083         AESENC    \TMP3, \XMM4
1084         pxor      \TMP1, \TMP4
1085 # accumulate the results in TMP4:XMM5, TMP6 holds the middle part
1086         pxor      \XMM7, \XMM5
1087         pxor      \TMP2, \TMP6
1088
1089         # Multiply XMM8 * HashKey
1090         # XMM8 and TMP5 hold the values for the two operands
1091
1092         movdqa    \XMM8, \TMP1
1093         pshufd    $78, \XMM8, \TMP2
1094         pxor      \XMM8, \TMP2
1095         movdqa    HashKey(%arg2), \TMP5
1096         PCLMULQDQ 0x11, \TMP5, \TMP1          # TMP1 = a1*b1
1097         movaps 0x90(%arg1), \TMP3
1098         AESENC    \TMP3, \XMM1            # Round 9
1099         AESENC    \TMP3, \XMM2
1100         AESENC    \TMP3, \XMM3
1101         AESENC    \TMP3, \XMM4
1102         PCLMULQDQ 0x00, \TMP5, \XMM8          # XMM8 = a0*b0
1103         lea       0xa0(%arg1),%r10
1104         mov       keysize,%eax
1105         shr       $2,%eax                       # 128->4, 192->6, 256->8
1106         sub       $4,%eax                       # 128->0, 192->2, 256->4
1107         jz        aes_loop_par_enc_done\@
1108
1109 aes_loop_par_enc\@:
1110         MOVADQ    (%r10),\TMP3
1111 .irpc   index, 1234
1112         AESENC    \TMP3, %xmm\index
1113 .endr
1114         add       $16,%r10
1115         sub       $1,%eax
1116         jnz       aes_loop_par_enc\@
1117
1118 aes_loop_par_enc_done\@:
1119         MOVADQ    (%r10), \TMP3
1120         AESENCLAST \TMP3, \XMM1           # Round 10
1121         AESENCLAST \TMP3, \XMM2
1122         AESENCLAST \TMP3, \XMM3
1123         AESENCLAST \TMP3, \XMM4
1124         movdqa    HashKey_k(%arg2), \TMP5
1125         PCLMULQDQ 0x00, \TMP5, \TMP2          # TMP2 = (a1+a0)*(b1+b0)
1126         movdqu    (%arg4,%r11,1), \TMP3
1127         pxor      \TMP3, \XMM1                 # Ciphertext/Plaintext XOR EK
1128         movdqu    16(%arg4,%r11,1), \TMP3
1129         pxor      \TMP3, \XMM2                 # Ciphertext/Plaintext XOR EK
1130         movdqu    32(%arg4,%r11,1), \TMP3
1131         pxor      \TMP3, \XMM3                 # Ciphertext/Plaintext XOR EK
1132         movdqu    48(%arg4,%r11,1), \TMP3
1133         pxor      \TMP3, \XMM4                 # Ciphertext/Plaintext XOR EK
1134         movdqu    \XMM1, (%arg3,%r11,1)        # Write to the ciphertext buffer
1135         movdqu    \XMM2, 16(%arg3,%r11,1)      # Write to the ciphertext buffer
1136         movdqu    \XMM3, 32(%arg3,%r11,1)      # Write to the ciphertext buffer
1137         movdqu    \XMM4, 48(%arg3,%r11,1)      # Write to the ciphertext buffer
1138         PSHUFB_XMM %xmm15, \XMM1        # perform a 16 byte swap
1139         PSHUFB_XMM %xmm15, \XMM2        # perform a 16 byte swap
1140         PSHUFB_XMM %xmm15, \XMM3        # perform a 16 byte swap
1141         PSHUFB_XMM %xmm15, \XMM4        # perform a 16 byte swap
1142
1143         pxor      \TMP4, \TMP1
1144         pxor      \XMM8, \XMM5
1145         pxor      \TMP6, \TMP2
1146         pxor      \TMP1, \TMP2
1147         pxor      \XMM5, \TMP2
1148         movdqa    \TMP2, \TMP3
1149         pslldq    $8, \TMP3                    # left shift TMP3 2 DWs
1150         psrldq    $8, \TMP2                    # right shift TMP2 2 DWs
1151         pxor      \TMP3, \XMM5
1152         pxor      \TMP2, \TMP1    # accumulate the results in TMP1:XMM5
1153
1154         # first phase of reduction
1155
1156         movdqa    \XMM5, \TMP2
1157         movdqa    \XMM5, \TMP3
1158         movdqa    \XMM5, \TMP4
1159 # move XMM5 into TMP2, TMP3, TMP4 in order to perform shifts independently
1160         pslld     $31, \TMP2                   # packed right shift << 31
1161         pslld     $30, \TMP3                   # packed right shift << 30
1162         pslld     $25, \TMP4                   # packed right shift << 25
1163         pxor      \TMP3, \TMP2                 # xor the shifted versions
1164         pxor      \TMP4, \TMP2
1165         movdqa    \TMP2, \TMP5
1166         psrldq    $4, \TMP5                    # right shift T5 1 DW
1167         pslldq    $12, \TMP2                   # left shift T2 3 DWs
1168         pxor      \TMP2, \XMM5
1169
1170         # second phase of reduction
1171
1172         movdqa    \XMM5,\TMP2 # make 3 copies of XMM5 into TMP2, TMP3, TMP4
1173         movdqa    \XMM5,\TMP3
1174         movdqa    \XMM5,\TMP4
1175         psrld     $1, \TMP2                    # packed left shift >>1
1176         psrld     $2, \TMP3                    # packed left shift >>2
1177         psrld     $7, \TMP4                    # packed left shift >>7
1178         pxor      \TMP3,\TMP2                  # xor the shifted versions
1179         pxor      \TMP4,\TMP2
1180         pxor      \TMP5, \TMP2
1181         pxor      \TMP2, \XMM5
1182         pxor      \TMP1, \XMM5                 # result is in TMP1
1183
1184         pxor      \XMM5, \XMM1
1185 .endm
1186
1187 /*
1188 * decrypt 4 blocks at a time
1189 * ghash the 4 previously decrypted ciphertext blocks
1190 * arg1, %arg3, %arg4 are used as pointers only, not modified
1191 * %r11 is the data offset value
1192 */
1193 .macro GHASH_4_ENCRYPT_4_PARALLEL_DEC TMP1 TMP2 TMP3 TMP4 TMP5 \
1194 TMP6 XMM0 XMM1 XMM2 XMM3 XMM4 XMM5 XMM6 XMM7 XMM8 operation
1195
1196         movdqa    \XMM1, \XMM5
1197         movdqa    \XMM2, \XMM6
1198         movdqa    \XMM3, \XMM7
1199         movdqa    \XMM4, \XMM8
1200
1201         movdqa    SHUF_MASK(%rip), %xmm15
1202         # multiply TMP5 * HashKey using karatsuba
1203
1204         movdqa    \XMM5, \TMP4
1205         pshufd    $78, \XMM5, \TMP6
1206         pxor      \XMM5, \TMP6
1207         paddd     ONE(%rip), \XMM0              # INCR CNT
1208         movdqa    HashKey_4(%arg2), \TMP5
1209         PCLMULQDQ 0x11, \TMP5, \TMP4           # TMP4 = a1*b1
1210         movdqa    \XMM0, \XMM1
1211         paddd     ONE(%rip), \XMM0              # INCR CNT
1212         movdqa    \XMM0, \XMM2
1213         paddd     ONE(%rip), \XMM0              # INCR CNT
1214         movdqa    \XMM0, \XMM3
1215         paddd     ONE(%rip), \XMM0              # INCR CNT
1216         movdqa    \XMM0, \XMM4
1217         PSHUFB_XMM %xmm15, \XMM1        # perform a 16 byte swap
1218         PCLMULQDQ 0x00, \TMP5, \XMM5           # XMM5 = a0*b0
1219         PSHUFB_XMM %xmm15, \XMM2        # perform a 16 byte swap
1220         PSHUFB_XMM %xmm15, \XMM3        # perform a 16 byte swap
1221         PSHUFB_XMM %xmm15, \XMM4        # perform a 16 byte swap
1222
1223         pxor      (%arg1), \XMM1
1224         pxor      (%arg1), \XMM2
1225         pxor      (%arg1), \XMM3
1226         pxor      (%arg1), \XMM4
1227         movdqa    HashKey_4_k(%arg2), \TMP5
1228         PCLMULQDQ 0x00, \TMP5, \TMP6           # TMP6 = (a1+a0)*(b1+b0)
1229         movaps 0x10(%arg1), \TMP1
1230         AESENC    \TMP1, \XMM1              # Round 1
1231         AESENC    \TMP1, \XMM2
1232         AESENC    \TMP1, \XMM3
1233         AESENC    \TMP1, \XMM4
1234         movaps 0x20(%arg1), \TMP1
1235         AESENC    \TMP1, \XMM1              # Round 2
1236         AESENC    \TMP1, \XMM2
1237         AESENC    \TMP1, \XMM3
1238         AESENC    \TMP1, \XMM4
1239         movdqa    \XMM6, \TMP1
1240         pshufd    $78, \XMM6, \TMP2
1241         pxor      \XMM6, \TMP2
1242         movdqa    HashKey_3(%arg2), \TMP5
1243         PCLMULQDQ 0x11, \TMP5, \TMP1           # TMP1 = a1 * b1
1244         movaps 0x30(%arg1), \TMP3
1245         AESENC    \TMP3, \XMM1              # Round 3
1246         AESENC    \TMP3, \XMM2
1247         AESENC    \TMP3, \XMM3
1248         AESENC    \TMP3, \XMM4
1249         PCLMULQDQ 0x00, \TMP5, \XMM6           # XMM6 = a0*b0
1250         movaps 0x40(%arg1), \TMP3
1251         AESENC    \TMP3, \XMM1              # Round 4
1252         AESENC    \TMP3, \XMM2
1253         AESENC    \TMP3, \XMM3
1254         AESENC    \TMP3, \XMM4
1255         movdqa    HashKey_3_k(%arg2), \TMP5
1256         PCLMULQDQ 0x00, \TMP5, \TMP2           # TMP2 = (a1+a0)*(b1+b0)
1257         movaps 0x50(%arg1), \TMP3
1258         AESENC    \TMP3, \XMM1              # Round 5
1259         AESENC    \TMP3, \XMM2
1260         AESENC    \TMP3, \XMM3
1261         AESENC    \TMP3, \XMM4
1262         pxor      \TMP1, \TMP4
1263 # accumulate the results in TMP4:XMM5, TMP6 holds the middle part
1264         pxor      \XMM6, \XMM5
1265         pxor      \TMP2, \TMP6
1266         movdqa    \XMM7, \TMP1
1267         pshufd    $78, \XMM7, \TMP2
1268         pxor      \XMM7, \TMP2
1269         movdqa    HashKey_2(%arg2), \TMP5
1270
1271         # Multiply TMP5 * HashKey using karatsuba
1272
1273         PCLMULQDQ 0x11, \TMP5, \TMP1           # TMP1 = a1*b1
1274         movaps 0x60(%arg1), \TMP3
1275         AESENC    \TMP3, \XMM1              # Round 6
1276         AESENC    \TMP3, \XMM2
1277         AESENC    \TMP3, \XMM3
1278         AESENC    \TMP3, \XMM4
1279         PCLMULQDQ 0x00, \TMP5, \XMM7           # XMM7 = a0*b0
1280         movaps 0x70(%arg1), \TMP3
1281         AESENC    \TMP3, \XMM1             # Round 7
1282         AESENC    \TMP3, \XMM2
1283         AESENC    \TMP3, \XMM3
1284         AESENC    \TMP3, \XMM4
1285         movdqa    HashKey_2_k(%arg2), \TMP5
1286         PCLMULQDQ 0x00, \TMP5, \TMP2           # TMP2 = (a1+a0)*(b1+b0)
1287         movaps 0x80(%arg1), \TMP3
1288         AESENC    \TMP3, \XMM1             # Round 8
1289         AESENC    \TMP3, \XMM2
1290         AESENC    \TMP3, \XMM3
1291         AESENC    \TMP3, \XMM4
1292         pxor      \TMP1, \TMP4
1293 # accumulate the results in TMP4:XMM5, TMP6 holds the middle part
1294         pxor      \XMM7, \XMM5
1295         pxor      \TMP2, \TMP6
1296
1297         # Multiply XMM8 * HashKey
1298         # XMM8 and TMP5 hold the values for the two operands
1299
1300         movdqa    \XMM8, \TMP1
1301         pshufd    $78, \XMM8, \TMP2
1302         pxor      \XMM8, \TMP2
1303         movdqa    HashKey(%arg2), \TMP5
1304         PCLMULQDQ 0x11, \TMP5, \TMP1          # TMP1 = a1*b1
1305         movaps 0x90(%arg1), \TMP3
1306         AESENC    \TMP3, \XMM1            # Round 9
1307         AESENC    \TMP3, \XMM2
1308         AESENC    \TMP3, \XMM3
1309         AESENC    \TMP3, \XMM4
1310         PCLMULQDQ 0x00, \TMP5, \XMM8          # XMM8 = a0*b0
1311         lea       0xa0(%arg1),%r10
1312         mov       keysize,%eax
1313         shr       $2,%eax                       # 128->4, 192->6, 256->8
1314         sub       $4,%eax                       # 128->0, 192->2, 256->4
1315         jz        aes_loop_par_dec_done\@
1316
1317 aes_loop_par_dec\@:
1318         MOVADQ    (%r10),\TMP3
1319 .irpc   index, 1234
1320         AESENC    \TMP3, %xmm\index
1321 .endr
1322         add       $16,%r10
1323         sub       $1,%eax
1324         jnz       aes_loop_par_dec\@
1325
1326 aes_loop_par_dec_done\@:
1327         MOVADQ    (%r10), \TMP3
1328         AESENCLAST \TMP3, \XMM1           # last round
1329         AESENCLAST \TMP3, \XMM2
1330         AESENCLAST \TMP3, \XMM3
1331         AESENCLAST \TMP3, \XMM4
1332         movdqa    HashKey_k(%arg2), \TMP5
1333         PCLMULQDQ 0x00, \TMP5, \TMP2          # TMP2 = (a1+a0)*(b1+b0)
1334         movdqu    (%arg4,%r11,1), \TMP3
1335         pxor      \TMP3, \XMM1                 # Ciphertext/Plaintext XOR EK
1336         movdqu    \XMM1, (%arg3,%r11,1)        # Write to plaintext buffer
1337         movdqa    \TMP3, \XMM1
1338         movdqu    16(%arg4,%r11,1), \TMP3
1339         pxor      \TMP3, \XMM2                 # Ciphertext/Plaintext XOR EK
1340         movdqu    \XMM2, 16(%arg3,%r11,1)      # Write to plaintext buffer
1341         movdqa    \TMP3, \XMM2
1342         movdqu    32(%arg4,%r11,1), \TMP3
1343         pxor      \TMP3, \XMM3                 # Ciphertext/Plaintext XOR EK
1344         movdqu    \XMM3, 32(%arg3,%r11,1)      # Write to plaintext buffer
1345         movdqa    \TMP3, \XMM3
1346         movdqu    48(%arg4,%r11,1), \TMP3
1347         pxor      \TMP3, \XMM4                 # Ciphertext/Plaintext XOR EK
1348         movdqu    \XMM4, 48(%arg3,%r11,1)      # Write to plaintext buffer
1349         movdqa    \TMP3, \XMM4
1350         PSHUFB_XMM %xmm15, \XMM1        # perform a 16 byte swap
1351         PSHUFB_XMM %xmm15, \XMM2        # perform a 16 byte swap
1352         PSHUFB_XMM %xmm15, \XMM3        # perform a 16 byte swap
1353         PSHUFB_XMM %xmm15, \XMM4        # perform a 16 byte swap
1354
1355         pxor      \TMP4, \TMP1
1356         pxor      \XMM8, \XMM5
1357         pxor      \TMP6, \TMP2
1358         pxor      \TMP1, \TMP2
1359         pxor      \XMM5, \TMP2
1360         movdqa    \TMP2, \TMP3
1361         pslldq    $8, \TMP3                    # left shift TMP3 2 DWs
1362         psrldq    $8, \TMP2                    # right shift TMP2 2 DWs
1363         pxor      \TMP3, \XMM5
1364         pxor      \TMP2, \TMP1    # accumulate the results in TMP1:XMM5
1365
1366         # first phase of reduction
1367
1368         movdqa    \XMM5, \TMP2
1369         movdqa    \XMM5, \TMP3
1370         movdqa    \XMM5, \TMP4
1371 # move XMM5 into TMP2, TMP3, TMP4 in order to perform shifts independently
1372         pslld     $31, \TMP2                   # packed right shift << 31
1373         pslld     $30, \TMP3                   # packed right shift << 30
1374         pslld     $25, \TMP4                   # packed right shift << 25
1375         pxor      \TMP3, \TMP2                 # xor the shifted versions
1376         pxor      \TMP4, \TMP2
1377         movdqa    \TMP2, \TMP5
1378         psrldq    $4, \TMP5                    # right shift T5 1 DW
1379         pslldq    $12, \TMP2                   # left shift T2 3 DWs
1380         pxor      \TMP2, \XMM5
1381
1382         # second phase of reduction
1383
1384         movdqa    \XMM5,\TMP2 # make 3 copies of XMM5 into TMP2, TMP3, TMP4
1385         movdqa    \XMM5,\TMP3
1386         movdqa    \XMM5,\TMP4
1387         psrld     $1, \TMP2                    # packed left shift >>1
1388         psrld     $2, \TMP3                    # packed left shift >>2
1389         psrld     $7, \TMP4                    # packed left shift >>7
1390         pxor      \TMP3,\TMP2                  # xor the shifted versions
1391         pxor      \TMP4,\TMP2
1392         pxor      \TMP5, \TMP2
1393         pxor      \TMP2, \XMM5
1394         pxor      \TMP1, \XMM5                 # result is in TMP1
1395
1396         pxor      \XMM5, \XMM1
1397 .endm
1398
1399 /* GHASH the last 4 ciphertext blocks. */
1400 .macro  GHASH_LAST_4 TMP1 TMP2 TMP3 TMP4 TMP5 TMP6 \
1401 TMP7 XMM1 XMM2 XMM3 XMM4 XMMDst
1402
1403         # Multiply TMP6 * HashKey (using Karatsuba)
1404
1405         movdqa    \XMM1, \TMP6
1406         pshufd    $78, \XMM1, \TMP2
1407         pxor      \XMM1, \TMP2
1408         movdqa    HashKey_4(%arg2), \TMP5
1409         PCLMULQDQ 0x11, \TMP5, \TMP6       # TMP6 = a1*b1
1410         PCLMULQDQ 0x00, \TMP5, \XMM1       # XMM1 = a0*b0
1411         movdqa    HashKey_4_k(%arg2), \TMP4
1412         PCLMULQDQ 0x00, \TMP4, \TMP2       # TMP2 = (a1+a0)*(b1+b0)
1413         movdqa    \XMM1, \XMMDst
1414         movdqa    \TMP2, \XMM1              # result in TMP6, XMMDst, XMM1
1415
1416         # Multiply TMP1 * HashKey (using Karatsuba)
1417
1418         movdqa    \XMM2, \TMP1
1419         pshufd    $78, \XMM2, \TMP2
1420         pxor      \XMM2, \TMP2
1421         movdqa    HashKey_3(%arg2), \TMP5
1422         PCLMULQDQ 0x11, \TMP5, \TMP1       # TMP1 = a1*b1
1423         PCLMULQDQ 0x00, \TMP5, \XMM2       # XMM2 = a0*b0
1424         movdqa    HashKey_3_k(%arg2), \TMP4
1425         PCLMULQDQ 0x00, \TMP4, \TMP2       # TMP2 = (a1+a0)*(b1+b0)
1426         pxor      \TMP1, \TMP6
1427         pxor      \XMM2, \XMMDst
1428         pxor      \TMP2, \XMM1
1429 # results accumulated in TMP6, XMMDst, XMM1
1430
1431         # Multiply TMP1 * HashKey (using Karatsuba)
1432
1433         movdqa    \XMM3, \TMP1
1434         pshufd    $78, \XMM3, \TMP2
1435         pxor      \XMM3, \TMP2
1436         movdqa    HashKey_2(%arg2), \TMP5
1437         PCLMULQDQ 0x11, \TMP5, \TMP1       # TMP1 = a1*b1
1438         PCLMULQDQ 0x00, \TMP5, \XMM3       # XMM3 = a0*b0
1439         movdqa    HashKey_2_k(%arg2), \TMP4
1440         PCLMULQDQ 0x00, \TMP4, \TMP2       # TMP2 = (a1+a0)*(b1+b0)
1441         pxor      \TMP1, \TMP6
1442         pxor      \XMM3, \XMMDst
1443         pxor      \TMP2, \XMM1   # results accumulated in TMP6, XMMDst, XMM1
1444
1445         # Multiply TMP1 * HashKey (using Karatsuba)
1446         movdqa    \XMM4, \TMP1
1447         pshufd    $78, \XMM4, \TMP2
1448         pxor      \XMM4, \TMP2
1449         movdqa    HashKey(%arg2), \TMP5
1450         PCLMULQDQ 0x11, \TMP5, \TMP1        # TMP1 = a1*b1
1451         PCLMULQDQ 0x00, \TMP5, \XMM4       # XMM4 = a0*b0
1452         movdqa    HashKey_k(%arg2), \TMP4
1453         PCLMULQDQ 0x00, \TMP4, \TMP2       # TMP2 = (a1+a0)*(b1+b0)
1454         pxor      \TMP1, \TMP6
1455         pxor      \XMM4, \XMMDst
1456         pxor      \XMM1, \TMP2
1457         pxor      \TMP6, \TMP2
1458         pxor      \XMMDst, \TMP2
1459         # middle section of the temp results combined as in karatsuba algorithm
1460         movdqa    \TMP2, \TMP4
1461         pslldq    $8, \TMP4                 # left shift TMP4 2 DWs
1462         psrldq    $8, \TMP2                 # right shift TMP2 2 DWs
1463         pxor      \TMP4, \XMMDst
1464         pxor      \TMP2, \TMP6
1465 # TMP6:XMMDst holds the result of the accumulated carry-less multiplications
1466         # first phase of the reduction
1467         movdqa    \XMMDst, \TMP2
1468         movdqa    \XMMDst, \TMP3
1469         movdqa    \XMMDst, \TMP4
1470 # move XMMDst into TMP2, TMP3, TMP4 in order to perform 3 shifts independently
1471         pslld     $31, \TMP2                # packed right shifting << 31
1472         pslld     $30, \TMP3                # packed right shifting << 30
1473         pslld     $25, \TMP4                # packed right shifting << 25
1474         pxor      \TMP3, \TMP2              # xor the shifted versions
1475         pxor      \TMP4, \TMP2
1476         movdqa    \TMP2, \TMP7
1477         psrldq    $4, \TMP7                 # right shift TMP7 1 DW
1478         pslldq    $12, \TMP2                # left shift TMP2 3 DWs
1479         pxor      \TMP2, \XMMDst
1480
1481         # second phase of the reduction
1482         movdqa    \XMMDst, \TMP2
1483         # make 3 copies of XMMDst for doing 3 shift operations
1484         movdqa    \XMMDst, \TMP3
1485         movdqa    \XMMDst, \TMP4
1486         psrld     $1, \TMP2                 # packed left shift >> 1
1487         psrld     $2, \TMP3                 # packed left shift >> 2
1488         psrld     $7, \TMP4                 # packed left shift >> 7
1489         pxor      \TMP3, \TMP2              # xor the shifted versions
1490         pxor      \TMP4, \TMP2
1491         pxor      \TMP7, \TMP2
1492         pxor      \TMP2, \XMMDst
1493         pxor      \TMP6, \XMMDst            # reduced result is in XMMDst
1494 .endm
1495
1496
1497 /* Encryption of a single block
1498 * uses eax & r10
1499 */
1500
1501 .macro ENCRYPT_SINGLE_BLOCK XMM0 TMP1
1502
1503         pxor            (%arg1), \XMM0
1504         mov             keysize,%eax
1505         shr             $2,%eax                 # 128->4, 192->6, 256->8
1506         add             $5,%eax                 # 128->9, 192->11, 256->13
1507         lea             16(%arg1), %r10   # get first expanded key address
1508
1509 _esb_loop_\@:
1510         MOVADQ          (%r10),\TMP1
1511         AESENC          \TMP1,\XMM0
1512         add             $16,%r10
1513         sub             $1,%eax
1514         jnz             _esb_loop_\@
1515
1516         MOVADQ          (%r10),\TMP1
1517         AESENCLAST      \TMP1,\XMM0
1518 .endm
1519 /*****************************************************************************
1520 * void aesni_gcm_dec(void *aes_ctx,    // AES Key schedule. Starts on a 16 byte boundary.
1521 *                   struct gcm_context_data *data
1522 *                                      // Context data
1523 *                   u8 *out,           // Plaintext output. Encrypt in-place is allowed.
1524 *                   const u8 *in,      // Ciphertext input
1525 *                   u64 plaintext_len, // Length of data in bytes for decryption.
1526 *                   u8 *iv,            // Pre-counter block j0: 4 byte salt (from Security Association)
1527 *                                      // concatenated with 8 byte Initialisation Vector (from IPSec ESP Payload)
1528 *                                      // concatenated with 0x00000001. 16-byte aligned pointer.
1529 *                   u8 *hash_subkey,   // H, the Hash sub key input. Data starts on a 16-byte boundary.
1530 *                   const u8 *aad,     // Additional Authentication Data (AAD)
1531 *                   u64 aad_len,       // Length of AAD in bytes. With RFC4106 this is going to be 8 or 12 bytes
1532 *                   u8  *auth_tag,     // Authenticated Tag output. The driver will compare this to the
1533 *                                      // given authentication tag and only return the plaintext if they match.
1534 *                   u64 auth_tag_len); // Authenticated Tag Length in bytes. Valid values are 16
1535 *                                      // (most likely), 12 or 8.
1536 *
1537 * Assumptions:
1538 *
1539 * keys:
1540 *       keys are pre-expanded and aligned to 16 bytes. we are using the first
1541 *       set of 11 keys in the data structure void *aes_ctx
1542 *
1543 * iv:
1544 *       0                   1                   2                   3
1545 *       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1546 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1547 *       |                             Salt  (From the SA)               |
1548 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1549 *       |                     Initialization Vector                     |
1550 *       |         (This is the sequence number from IPSec header)       |
1551 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1552 *       |                              0x1                              |
1553 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1554 *
1555 *
1556 *
1557 * AAD:
1558 *       AAD padded to 128 bits with 0
1559 *       for example, assume AAD is a u32 vector
1560 *
1561 *       if AAD is 8 bytes:
1562 *       AAD[3] = {A0, A1};
1563 *       padded AAD in xmm register = {A1 A0 0 0}
1564 *
1565 *       0                   1                   2                   3
1566 *       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1567 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1568 *       |                               SPI (A1)                        |
1569 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1570 *       |                     32-bit Sequence Number (A0)               |
1571 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1572 *       |                              0x0                              |
1573 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1574 *
1575 *                                       AAD Format with 32-bit Sequence Number
1576 *
1577 *       if AAD is 12 bytes:
1578 *       AAD[3] = {A0, A1, A2};
1579 *       padded AAD in xmm register = {A2 A1 A0 0}
1580 *
1581 *       0                   1                   2                   3
1582 *       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1583 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1584 *       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1585 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1586 *       |                               SPI (A2)                        |
1587 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1588 *       |                 64-bit Extended Sequence Number {A1,A0}       |
1589 *       |                                                               |
1590 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1591 *       |                              0x0                              |
1592 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1593 *
1594 *                        AAD Format with 64-bit Extended Sequence Number
1595 *
1596 * poly = x^128 + x^127 + x^126 + x^121 + 1
1597 *
1598 *****************************************************************************/
1599 ENTRY(aesni_gcm_dec)
1600         FUNC_SAVE
1601
1602         GCM_INIT %arg6, arg7, arg8, arg9
1603         GCM_ENC_DEC dec
1604         GCM_COMPLETE arg10, arg11
1605         FUNC_RESTORE
1606         ret
1607 ENDPROC(aesni_gcm_dec)
1608
1609
1610 /*****************************************************************************
1611 * void aesni_gcm_enc(void *aes_ctx,      // AES Key schedule. Starts on a 16 byte boundary.
1612 *                    struct gcm_context_data *data
1613 *                                        // Context data
1614 *                    u8 *out,            // Ciphertext output. Encrypt in-place is allowed.
1615 *                    const u8 *in,       // Plaintext input
1616 *                    u64 plaintext_len,  // Length of data in bytes for encryption.
1617 *                    u8 *iv,             // Pre-counter block j0: 4 byte salt (from Security Association)
1618 *                                        // concatenated with 8 byte Initialisation Vector (from IPSec ESP Payload)
1619 *                                        // concatenated with 0x00000001. 16-byte aligned pointer.
1620 *                    u8 *hash_subkey,    // H, the Hash sub key input. Data starts on a 16-byte boundary.
1621 *                    const u8 *aad,      // Additional Authentication Data (AAD)
1622 *                    u64 aad_len,        // Length of AAD in bytes. With RFC4106 this is going to be 8 or 12 bytes
1623 *                    u8 *auth_tag,       // Authenticated Tag output.
1624 *                    u64 auth_tag_len);  // Authenticated Tag Length in bytes. Valid values are 16 (most likely),
1625 *                                        // 12 or 8.
1626 *
1627 * Assumptions:
1628 *
1629 * keys:
1630 *       keys are pre-expanded and aligned to 16 bytes. we are using the
1631 *       first set of 11 keys in the data structure void *aes_ctx
1632 *
1633 *
1634 * iv:
1635 *       0                   1                   2                   3
1636 *       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1637 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1638 *       |                             Salt  (From the SA)               |
1639 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1640 *       |                     Initialization Vector                     |
1641 *       |         (This is the sequence number from IPSec header)       |
1642 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1643 *       |                              0x1                              |
1644 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1645 *
1646 *
1647 *
1648 * AAD:
1649 *       AAD padded to 128 bits with 0
1650 *       for example, assume AAD is a u32 vector
1651 *
1652 *       if AAD is 8 bytes:
1653 *       AAD[3] = {A0, A1};
1654 *       padded AAD in xmm register = {A1 A0 0 0}
1655 *
1656 *       0                   1                   2                   3
1657 *       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1658 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1659 *       |                               SPI (A1)                        |
1660 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1661 *       |                     32-bit Sequence Number (A0)               |
1662 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1663 *       |                              0x0                              |
1664 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1665 *
1666 *                                 AAD Format with 32-bit Sequence Number
1667 *
1668 *       if AAD is 12 bytes:
1669 *       AAD[3] = {A0, A1, A2};
1670 *       padded AAD in xmm register = {A2 A1 A0 0}
1671 *
1672 *       0                   1                   2                   3
1673 *       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1674 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1675 *       |                               SPI (A2)                        |
1676 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1677 *       |                 64-bit Extended Sequence Number {A1,A0}       |
1678 *       |                                                               |
1679 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1680 *       |                              0x0                              |
1681 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1682 *
1683 *                         AAD Format with 64-bit Extended Sequence Number
1684 *
1685 * poly = x^128 + x^127 + x^126 + x^121 + 1
1686 ***************************************************************************/
1687 ENTRY(aesni_gcm_enc)
1688         FUNC_SAVE
1689
1690         GCM_INIT %arg6, arg7, arg8, arg9
1691         GCM_ENC_DEC enc
1692
1693         GCM_COMPLETE arg10, arg11
1694         FUNC_RESTORE
1695         ret
1696 ENDPROC(aesni_gcm_enc)
1697
1698 /*****************************************************************************
1699 * void aesni_gcm_init(void *aes_ctx,      // AES Key schedule. Starts on a 16 byte boundary.
1700 *                     struct gcm_context_data *data,
1701 *                                         // context data
1702 *                     u8 *iv,             // Pre-counter block j0: 4 byte salt (from Security Association)
1703 *                                         // concatenated with 8 byte Initialisation Vector (from IPSec ESP Payload)
1704 *                                         // concatenated with 0x00000001. 16-byte aligned pointer.
1705 *                     u8 *hash_subkey,    // H, the Hash sub key input. Data starts on a 16-byte boundary.
1706 *                     const u8 *aad,      // Additional Authentication Data (AAD)
1707 *                     u64 aad_len)        // Length of AAD in bytes.
1708 */
1709 ENTRY(aesni_gcm_init)
1710         FUNC_SAVE
1711         GCM_INIT %arg3, %arg4,%arg5, %arg6
1712         FUNC_RESTORE
1713         ret
1714 ENDPROC(aesni_gcm_init)
1715
1716 /*****************************************************************************
1717 * void aesni_gcm_enc_update(void *aes_ctx,      // AES Key schedule. Starts on a 16 byte boundary.
1718 *                    struct gcm_context_data *data,
1719 *                                        // context data
1720 *                    u8 *out,            // Ciphertext output. Encrypt in-place is allowed.
1721 *                    const u8 *in,       // Plaintext input
1722 *                    u64 plaintext_len,  // Length of data in bytes for encryption.
1723 */
1724 ENTRY(aesni_gcm_enc_update)
1725         FUNC_SAVE
1726         GCM_ENC_DEC enc
1727         FUNC_RESTORE
1728         ret
1729 ENDPROC(aesni_gcm_enc_update)
1730
1731 /*****************************************************************************
1732 * void aesni_gcm_dec_update(void *aes_ctx,      // AES Key schedule. Starts on a 16 byte boundary.
1733 *                    struct gcm_context_data *data,
1734 *                                        // context data
1735 *                    u8 *out,            // Ciphertext output. Encrypt in-place is allowed.
1736 *                    const u8 *in,       // Plaintext input
1737 *                    u64 plaintext_len,  // Length of data in bytes for encryption.
1738 */
1739 ENTRY(aesni_gcm_dec_update)
1740         FUNC_SAVE
1741         GCM_ENC_DEC dec
1742         FUNC_RESTORE
1743         ret
1744 ENDPROC(aesni_gcm_dec_update)
1745
1746 /*****************************************************************************
1747 * void aesni_gcm_finalize(void *aes_ctx,      // AES Key schedule. Starts on a 16 byte boundary.
1748 *                    struct gcm_context_data *data,
1749 *                                        // context data
1750 *                    u8 *auth_tag,       // Authenticated Tag output.
1751 *                    u64 auth_tag_len);  // Authenticated Tag Length in bytes. Valid values are 16 (most likely),
1752 *                                        // 12 or 8.
1753 */
1754 ENTRY(aesni_gcm_finalize)
1755         FUNC_SAVE
1756         GCM_COMPLETE %arg3 %arg4
1757         FUNC_RESTORE
1758         ret
1759 ENDPROC(aesni_gcm_finalize)
1760
1761 #endif
1762
1763
1764 .align 4
1765 _key_expansion_128:
1766 _key_expansion_256a:
1767         pshufd $0b11111111, %xmm1, %xmm1
1768         shufps $0b00010000, %xmm0, %xmm4
1769         pxor %xmm4, %xmm0
1770         shufps $0b10001100, %xmm0, %xmm4
1771         pxor %xmm4, %xmm0
1772         pxor %xmm1, %xmm0
1773         movaps %xmm0, (TKEYP)
1774         add $0x10, TKEYP
1775         ret
1776 ENDPROC(_key_expansion_128)
1777 ENDPROC(_key_expansion_256a)
1778
1779 .align 4
1780 _key_expansion_192a:
1781         pshufd $0b01010101, %xmm1, %xmm1
1782         shufps $0b00010000, %xmm0, %xmm4
1783         pxor %xmm4, %xmm0
1784         shufps $0b10001100, %xmm0, %xmm4
1785         pxor %xmm4, %xmm0
1786         pxor %xmm1, %xmm0
1787
1788         movaps %xmm2, %xmm5
1789         movaps %xmm2, %xmm6
1790         pslldq $4, %xmm5
1791         pshufd $0b11111111, %xmm0, %xmm3
1792         pxor %xmm3, %xmm2
1793         pxor %xmm5, %xmm2
1794
1795         movaps %xmm0, %xmm1
1796         shufps $0b01000100, %xmm0, %xmm6
1797         movaps %xmm6, (TKEYP)
1798         shufps $0b01001110, %xmm2, %xmm1
1799         movaps %xmm1, 0x10(TKEYP)
1800         add $0x20, TKEYP
1801         ret
1802 ENDPROC(_key_expansion_192a)
1803
1804 .align 4
1805 _key_expansion_192b:
1806         pshufd $0b01010101, %xmm1, %xmm1
1807         shufps $0b00010000, %xmm0, %xmm4
1808         pxor %xmm4, %xmm0
1809         shufps $0b10001100, %xmm0, %xmm4
1810         pxor %xmm4, %xmm0
1811         pxor %xmm1, %xmm0
1812
1813         movaps %xmm2, %xmm5
1814         pslldq $4, %xmm5
1815         pshufd $0b11111111, %xmm0, %xmm3
1816         pxor %xmm3, %xmm2
1817         pxor %xmm5, %xmm2
1818
1819         movaps %xmm0, (TKEYP)
1820         add $0x10, TKEYP
1821         ret
1822 ENDPROC(_key_expansion_192b)
1823
1824 .align 4
1825 _key_expansion_256b:
1826         pshufd $0b10101010, %xmm1, %xmm1
1827         shufps $0b00010000, %xmm2, %xmm4
1828         pxor %xmm4, %xmm2
1829         shufps $0b10001100, %xmm2, %xmm4
1830         pxor %xmm4, %xmm2
1831         pxor %xmm1, %xmm2
1832         movaps %xmm2, (TKEYP)
1833         add $0x10, TKEYP
1834         ret
1835 ENDPROC(_key_expansion_256b)
1836
1837 /*
1838  * int aesni_set_key(struct crypto_aes_ctx *ctx, const u8 *in_key,
1839  *                   unsigned int key_len)
1840  */
1841 ENTRY(aesni_set_key)
1842         FRAME_BEGIN
1843 #ifndef __x86_64__
1844         pushl KEYP
1845         movl (FRAME_OFFSET+8)(%esp), KEYP       # ctx
1846         movl (FRAME_OFFSET+12)(%esp), UKEYP     # in_key
1847         movl (FRAME_OFFSET+16)(%esp), %edx      # key_len
1848 #endif
1849         movups (UKEYP), %xmm0           # user key (first 16 bytes)
1850         movaps %xmm0, (KEYP)
1851         lea 0x10(KEYP), TKEYP           # key addr
1852         movl %edx, 480(KEYP)
1853         pxor %xmm4, %xmm4               # xmm4 is assumed 0 in _key_expansion_x
1854         cmp $24, %dl
1855         jb .Lenc_key128
1856         je .Lenc_key192
1857         movups 0x10(UKEYP), %xmm2       # other user key
1858         movaps %xmm2, (TKEYP)
1859         add $0x10, TKEYP
1860         AESKEYGENASSIST 0x1 %xmm2 %xmm1         # round 1
1861         call _key_expansion_256a
1862         AESKEYGENASSIST 0x1 %xmm0 %xmm1
1863         call _key_expansion_256b
1864         AESKEYGENASSIST 0x2 %xmm2 %xmm1         # round 2
1865         call _key_expansion_256a
1866         AESKEYGENASSIST 0x2 %xmm0 %xmm1
1867         call _key_expansion_256b
1868         AESKEYGENASSIST 0x4 %xmm2 %xmm1         # round 3
1869         call _key_expansion_256a
1870         AESKEYGENASSIST 0x4 %xmm0 %xmm1
1871         call _key_expansion_256b
1872         AESKEYGENASSIST 0x8 %xmm2 %xmm1         # round 4
1873         call _key_expansion_256a
1874         AESKEYGENASSIST 0x8 %xmm0 %xmm1
1875         call _key_expansion_256b
1876         AESKEYGENASSIST 0x10 %xmm2 %xmm1        # round 5
1877         call _key_expansion_256a
1878         AESKEYGENASSIST 0x10 %xmm0 %xmm1
1879         call _key_expansion_256b
1880         AESKEYGENASSIST 0x20 %xmm2 %xmm1        # round 6
1881         call _key_expansion_256a
1882         AESKEYGENASSIST 0x20 %xmm0 %xmm1
1883         call _key_expansion_256b
1884         AESKEYGENASSIST 0x40 %xmm2 %xmm1        # round 7
1885         call _key_expansion_256a
1886         jmp .Ldec_key
1887 .Lenc_key192:
1888         movq 0x10(UKEYP), %xmm2         # other user key
1889         AESKEYGENASSIST 0x1 %xmm2 %xmm1         # round 1
1890         call _key_expansion_192a
1891         AESKEYGENASSIST 0x2 %xmm2 %xmm1         # round 2
1892         call _key_expansion_192b
1893         AESKEYGENASSIST 0x4 %xmm2 %xmm1         # round 3
1894         call _key_expansion_192a
1895         AESKEYGENASSIST 0x8 %xmm2 %xmm1         # round 4
1896         call _key_expansion_192b
1897         AESKEYGENASSIST 0x10 %xmm2 %xmm1        # round 5
1898         call _key_expansion_192a
1899         AESKEYGENASSIST 0x20 %xmm2 %xmm1        # round 6
1900         call _key_expansion_192b
1901         AESKEYGENASSIST 0x40 %xmm2 %xmm1        # round 7
1902         call _key_expansion_192a
1903         AESKEYGENASSIST 0x80 %xmm2 %xmm1        # round 8
1904         call _key_expansion_192b
1905         jmp .Ldec_key
1906 .Lenc_key128:
1907         AESKEYGENASSIST 0x1 %xmm0 %xmm1         # round 1
1908         call _key_expansion_128
1909         AESKEYGENASSIST 0x2 %xmm0 %xmm1         # round 2
1910         call _key_expansion_128
1911         AESKEYGENASSIST 0x4 %xmm0 %xmm1         # round 3
1912         call _key_expansion_128
1913         AESKEYGENASSIST 0x8 %xmm0 %xmm1         # round 4
1914         call _key_expansion_128
1915         AESKEYGENASSIST 0x10 %xmm0 %xmm1        # round 5
1916         call _key_expansion_128
1917         AESKEYGENASSIST 0x20 %xmm0 %xmm1        # round 6
1918         call _key_expansion_128
1919         AESKEYGENASSIST 0x40 %xmm0 %xmm1        # round 7
1920         call _key_expansion_128
1921         AESKEYGENASSIST 0x80 %xmm0 %xmm1        # round 8
1922         call _key_expansion_128
1923         AESKEYGENASSIST 0x1b %xmm0 %xmm1        # round 9
1924         call _key_expansion_128
1925         AESKEYGENASSIST 0x36 %xmm0 %xmm1        # round 10
1926         call _key_expansion_128
1927 .Ldec_key:
1928         sub $0x10, TKEYP
1929         movaps (KEYP), %xmm0
1930         movaps (TKEYP), %xmm1
1931         movaps %xmm0, 240(TKEYP)
1932         movaps %xmm1, 240(KEYP)
1933         add $0x10, KEYP
1934         lea 240-16(TKEYP), UKEYP
1935 .align 4
1936 .Ldec_key_loop:
1937         movaps (KEYP), %xmm0
1938         AESIMC %xmm0 %xmm1
1939         movaps %xmm1, (UKEYP)
1940         add $0x10, KEYP
1941         sub $0x10, UKEYP
1942         cmp TKEYP, KEYP
1943         jb .Ldec_key_loop
1944         xor AREG, AREG
1945 #ifndef __x86_64__
1946         popl KEYP
1947 #endif
1948         FRAME_END
1949         ret
1950 ENDPROC(aesni_set_key)
1951
1952 /*
1953  * void aesni_enc(struct crypto_aes_ctx *ctx, u8 *dst, const u8 *src)
1954  */
1955 ENTRY(aesni_enc)
1956         FRAME_BEGIN
1957 #ifndef __x86_64__
1958         pushl KEYP
1959         pushl KLEN
1960         movl (FRAME_OFFSET+12)(%esp), KEYP      # ctx
1961         movl (FRAME_OFFSET+16)(%esp), OUTP      # dst
1962         movl (FRAME_OFFSET+20)(%esp), INP       # src
1963 #endif
1964         movl 480(KEYP), KLEN            # key length
1965         movups (INP), STATE             # input
1966         call _aesni_enc1
1967         movups STATE, (OUTP)            # output
1968 #ifndef __x86_64__
1969         popl KLEN
1970         popl KEYP
1971 #endif
1972         FRAME_END
1973         ret
1974 ENDPROC(aesni_enc)
1975
1976 /*
1977  * _aesni_enc1:         internal ABI
1978  * input:
1979  *      KEYP:           key struct pointer
1980  *      KLEN:           round count
1981  *      STATE:          initial state (input)
1982  * output:
1983  *      STATE:          finial state (output)
1984  * changed:
1985  *      KEY
1986  *      TKEYP (T1)
1987  */
1988 .align 4
1989 _aesni_enc1:
1990         movaps (KEYP), KEY              # key
1991         mov KEYP, TKEYP
1992         pxor KEY, STATE         # round 0
1993         add $0x30, TKEYP
1994         cmp $24, KLEN
1995         jb .Lenc128
1996         lea 0x20(TKEYP), TKEYP
1997         je .Lenc192
1998         add $0x20, TKEYP
1999         movaps -0x60(TKEYP), KEY
2000         AESENC KEY STATE
2001         movaps -0x50(TKEYP), KEY
2002         AESENC KEY STATE
2003 .align 4
2004 .Lenc192:
2005         movaps -0x40(TKEYP), KEY
2006         AESENC KEY STATE
2007         movaps -0x30(TKEYP), KEY
2008         AESENC KEY STATE
2009 .align 4
2010 .Lenc128:
2011         movaps -0x20(TKEYP), KEY
2012         AESENC KEY STATE
2013         movaps -0x10(TKEYP), KEY
2014         AESENC KEY STATE
2015         movaps (TKEYP), KEY
2016         AESENC KEY STATE
2017         movaps 0x10(TKEYP), KEY
2018         AESENC KEY STATE
2019         movaps 0x20(TKEYP), KEY
2020         AESENC KEY STATE
2021         movaps 0x30(TKEYP), KEY
2022         AESENC KEY STATE
2023         movaps 0x40(TKEYP), KEY
2024         AESENC KEY STATE
2025         movaps 0x50(TKEYP), KEY
2026         AESENC KEY STATE
2027         movaps 0x60(TKEYP), KEY
2028         AESENC KEY STATE
2029         movaps 0x70(TKEYP), KEY
2030         AESENCLAST KEY STATE
2031         ret
2032 ENDPROC(_aesni_enc1)
2033
2034 /*
2035  * _aesni_enc4: internal ABI
2036  * input:
2037  *      KEYP:           key struct pointer
2038  *      KLEN:           round count
2039  *      STATE1:         initial state (input)
2040  *      STATE2
2041  *      STATE3
2042  *      STATE4
2043  * output:
2044  *      STATE1:         finial state (output)
2045  *      STATE2
2046  *      STATE3
2047  *      STATE4
2048  * changed:
2049  *      KEY
2050  *      TKEYP (T1)
2051  */
2052 .align 4
2053 _aesni_enc4:
2054         movaps (KEYP), KEY              # key
2055         mov KEYP, TKEYP
2056         pxor KEY, STATE1                # round 0
2057         pxor KEY, STATE2
2058         pxor KEY, STATE3
2059         pxor KEY, STATE4
2060         add $0x30, TKEYP
2061         cmp $24, KLEN
2062         jb .L4enc128
2063         lea 0x20(TKEYP), TKEYP
2064         je .L4enc192
2065         add $0x20, TKEYP
2066         movaps -0x60(TKEYP), KEY
2067         AESENC KEY STATE1
2068         AESENC KEY STATE2
2069         AESENC KEY STATE3
2070         AESENC KEY STATE4
2071         movaps -0x50(TKEYP), KEY
2072         AESENC KEY STATE1
2073         AESENC KEY STATE2
2074         AESENC KEY STATE3
2075         AESENC KEY STATE4
2076 #.align 4
2077 .L4enc192:
2078         movaps -0x40(TKEYP), KEY
2079         AESENC KEY STATE1
2080         AESENC KEY STATE2
2081         AESENC KEY STATE3
2082         AESENC KEY STATE4
2083         movaps -0x30(TKEYP), KEY
2084         AESENC KEY STATE1
2085         AESENC KEY STATE2
2086         AESENC KEY STATE3
2087         AESENC KEY STATE4
2088 #.align 4
2089 .L4enc128:
2090         movaps -0x20(TKEYP), KEY
2091         AESENC KEY STATE1
2092         AESENC KEY STATE2
2093         AESENC KEY STATE3
2094         AESENC KEY STATE4
2095         movaps -0x10(TKEYP), KEY
2096         AESENC KEY STATE1
2097         AESENC KEY STATE2
2098         AESENC KEY STATE3
2099         AESENC KEY STATE4
2100         movaps (TKEYP), KEY
2101         AESENC KEY STATE1
2102         AESENC KEY STATE2
2103         AESENC KEY STATE3
2104         AESENC KEY STATE4
2105         movaps 0x10(TKEYP), KEY
2106         AESENC KEY STATE1
2107         AESENC KEY STATE2
2108         AESENC KEY STATE3
2109         AESENC KEY STATE4
2110         movaps 0x20(TKEYP), KEY
2111         AESENC KEY STATE1
2112         AESENC KEY STATE2
2113         AESENC KEY STATE3
2114         AESENC KEY STATE4
2115         movaps 0x30(TKEYP), KEY
2116         AESENC KEY STATE1
2117         AESENC KEY STATE2
2118         AESENC KEY STATE3
2119         AESENC KEY STATE4
2120         movaps 0x40(TKEYP), KEY
2121         AESENC KEY STATE1
2122         AESENC KEY STATE2
2123         AESENC KEY STATE3
2124         AESENC KEY STATE4
2125         movaps 0x50(TKEYP), KEY
2126         AESENC KEY STATE1
2127         AESENC KEY STATE2
2128         AESENC KEY STATE3
2129         AESENC KEY STATE4
2130         movaps 0x60(TKEYP), KEY
2131         AESENC KEY STATE1
2132         AESENC KEY STATE2
2133         AESENC KEY STATE3
2134         AESENC KEY STATE4
2135         movaps 0x70(TKEYP), KEY
2136         AESENCLAST KEY STATE1           # last round
2137         AESENCLAST KEY STATE2
2138         AESENCLAST KEY STATE3
2139         AESENCLAST KEY STATE4
2140         ret
2141 ENDPROC(_aesni_enc4)
2142
2143 /*
2144  * void aesni_dec (struct crypto_aes_ctx *ctx, u8 *dst, const u8 *src)
2145  */
2146 ENTRY(aesni_dec)
2147         FRAME_BEGIN
2148 #ifndef __x86_64__
2149         pushl KEYP
2150         pushl KLEN
2151         movl (FRAME_OFFSET+12)(%esp), KEYP      # ctx
2152         movl (FRAME_OFFSET+16)(%esp), OUTP      # dst
2153         movl (FRAME_OFFSET+20)(%esp), INP       # src
2154 #endif
2155         mov 480(KEYP), KLEN             # key length
2156         add $240, KEYP
2157         movups (INP), STATE             # input
2158         call _aesni_dec1
2159         movups STATE, (OUTP)            #output
2160 #ifndef __x86_64__
2161         popl KLEN
2162         popl KEYP
2163 #endif
2164         FRAME_END
2165         ret
2166 ENDPROC(aesni_dec)
2167
2168 /*
2169  * _aesni_dec1:         internal ABI
2170  * input:
2171  *      KEYP:           key struct pointer
2172  *      KLEN:           key length
2173  *      STATE:          initial state (input)
2174  * output:
2175  *      STATE:          finial state (output)
2176  * changed:
2177  *      KEY
2178  *      TKEYP (T1)
2179  */
2180 .align 4
2181 _aesni_dec1:
2182         movaps (KEYP), KEY              # key
2183         mov KEYP, TKEYP
2184         pxor KEY, STATE         # round 0
2185         add $0x30, TKEYP
2186         cmp $24, KLEN
2187         jb .Ldec128
2188         lea 0x20(TKEYP), TKEYP
2189         je .Ldec192
2190         add $0x20, TKEYP
2191         movaps -0x60(TKEYP), KEY
2192         AESDEC KEY STATE
2193         movaps -0x50(TKEYP), KEY
2194         AESDEC KEY STATE
2195 .align 4
2196 .Ldec192:
2197         movaps -0x40(TKEYP), KEY
2198         AESDEC KEY STATE
2199         movaps -0x30(TKEYP), KEY
2200         AESDEC KEY STATE
2201 .align 4
2202 .Ldec128:
2203         movaps -0x20(TKEYP), KEY
2204         AESDEC KEY STATE
2205         movaps -0x10(TKEYP), KEY
2206         AESDEC KEY STATE
2207         movaps (TKEYP), KEY
2208         AESDEC KEY STATE
2209         movaps 0x10(TKEYP), KEY
2210         AESDEC KEY STATE
2211         movaps 0x20(TKEYP), KEY
2212         AESDEC KEY STATE
2213         movaps 0x30(TKEYP), KEY
2214         AESDEC KEY STATE
2215         movaps 0x40(TKEYP), KEY
2216         AESDEC KEY STATE
2217         movaps 0x50(TKEYP), KEY
2218         AESDEC KEY STATE
2219         movaps 0x60(TKEYP), KEY
2220         AESDEC KEY STATE
2221         movaps 0x70(TKEYP), KEY
2222         AESDECLAST KEY STATE
2223         ret
2224 ENDPROC(_aesni_dec1)
2225
2226 /*
2227  * _aesni_dec4: internal ABI
2228  * input:
2229  *      KEYP:           key struct pointer
2230  *      KLEN:           key length
2231  *      STATE1:         initial state (input)
2232  *      STATE2
2233  *      STATE3
2234  *      STATE4
2235  * output:
2236  *      STATE1:         finial state (output)
2237  *      STATE2
2238  *      STATE3
2239  *      STATE4
2240  * changed:
2241  *      KEY
2242  *      TKEYP (T1)
2243  */
2244 .align 4
2245 _aesni_dec4:
2246         movaps (KEYP), KEY              # key
2247         mov KEYP, TKEYP
2248         pxor KEY, STATE1                # round 0
2249         pxor KEY, STATE2
2250         pxor KEY, STATE3
2251         pxor KEY, STATE4
2252         add $0x30, TKEYP
2253         cmp $24, KLEN
2254         jb .L4dec128
2255         lea 0x20(TKEYP), TKEYP
2256         je .L4dec192
2257         add $0x20, TKEYP
2258         movaps -0x60(TKEYP), KEY
2259         AESDEC KEY STATE1
2260         AESDEC KEY STATE2
2261         AESDEC KEY STATE3
2262         AESDEC KEY STATE4
2263         movaps -0x50(TKEYP), KEY
2264         AESDEC KEY STATE1
2265         AESDEC KEY STATE2
2266         AESDEC KEY STATE3
2267         AESDEC KEY STATE4
2268 .align 4
2269 .L4dec192:
2270         movaps -0x40(TKEYP), KEY
2271         AESDEC KEY STATE1
2272         AESDEC KEY STATE2
2273         AESDEC KEY STATE3
2274         AESDEC KEY STATE4
2275         movaps -0x30(TKEYP), KEY
2276         AESDEC KEY STATE1
2277         AESDEC KEY STATE2
2278         AESDEC KEY STATE3
2279         AESDEC KEY STATE4
2280 .align 4
2281 .L4dec128:
2282         movaps -0x20(TKEYP), KEY
2283         AESDEC KEY STATE1
2284         AESDEC KEY STATE2
2285         AESDEC KEY STATE3
2286         AESDEC KEY STATE4
2287         movaps -0x10(TKEYP), KEY
2288         AESDEC KEY STATE1
2289         AESDEC KEY STATE2
2290         AESDEC KEY STATE3
2291         AESDEC KEY STATE4
2292         movaps (TKEYP), KEY
2293         AESDEC KEY STATE1
2294         AESDEC KEY STATE2
2295         AESDEC KEY STATE3
2296         AESDEC KEY STATE4
2297         movaps 0x10(TKEYP), KEY
2298         AESDEC KEY STATE1
2299         AESDEC KEY STATE2
2300         AESDEC KEY STATE3
2301         AESDEC KEY STATE4
2302         movaps 0x20(TKEYP), KEY
2303         AESDEC KEY STATE1
2304         AESDEC KEY STATE2
2305         AESDEC KEY STATE3
2306         AESDEC KEY STATE4
2307         movaps 0x30(TKEYP), KEY
2308         AESDEC KEY STATE1
2309         AESDEC KEY STATE2
2310         AESDEC KEY STATE3
2311         AESDEC KEY STATE4
2312         movaps 0x40(TKEYP), KEY
2313         AESDEC KEY STATE1
2314         AESDEC KEY STATE2
2315         AESDEC KEY STATE3
2316         AESDEC KEY STATE4
2317         movaps 0x50(TKEYP), KEY
2318         AESDEC KEY STATE1
2319         AESDEC KEY STATE2
2320         AESDEC KEY STATE3
2321         AESDEC KEY STATE4
2322         movaps 0x60(TKEYP), KEY
2323         AESDEC KEY STATE1
2324         AESDEC KEY STATE2
2325         AESDEC KEY STATE3
2326         AESDEC KEY STATE4
2327         movaps 0x70(TKEYP), KEY
2328         AESDECLAST KEY STATE1           # last round
2329         AESDECLAST KEY STATE2
2330         AESDECLAST KEY STATE3
2331         AESDECLAST KEY STATE4
2332         ret
2333 ENDPROC(_aesni_dec4)
2334
2335 /*
2336  * void aesni_ecb_enc(struct crypto_aes_ctx *ctx, const u8 *dst, u8 *src,
2337  *                    size_t len)
2338  */
2339 ENTRY(aesni_ecb_enc)
2340         FRAME_BEGIN
2341 #ifndef __x86_64__
2342         pushl LEN
2343         pushl KEYP
2344         pushl KLEN
2345         movl (FRAME_OFFSET+16)(%esp), KEYP      # ctx
2346         movl (FRAME_OFFSET+20)(%esp), OUTP      # dst
2347         movl (FRAME_OFFSET+24)(%esp), INP       # src
2348         movl (FRAME_OFFSET+28)(%esp), LEN       # len
2349 #endif
2350         test LEN, LEN           # check length
2351         jz .Lecb_enc_ret
2352         mov 480(KEYP), KLEN
2353         cmp $16, LEN
2354         jb .Lecb_enc_ret
2355         cmp $64, LEN
2356         jb .Lecb_enc_loop1
2357 .align 4
2358 .Lecb_enc_loop4:
2359         movups (INP), STATE1
2360         movups 0x10(INP), STATE2
2361         movups 0x20(INP), STATE3
2362         movups 0x30(INP), STATE4
2363         call _aesni_enc4
2364         movups STATE1, (OUTP)
2365         movups STATE2, 0x10(OUTP)
2366         movups STATE3, 0x20(OUTP)
2367         movups STATE4, 0x30(OUTP)
2368         sub $64, LEN
2369         add $64, INP
2370         add $64, OUTP
2371         cmp $64, LEN
2372         jge .Lecb_enc_loop4
2373         cmp $16, LEN
2374         jb .Lecb_enc_ret
2375 .align 4
2376 .Lecb_enc_loop1:
2377         movups (INP), STATE1
2378         call _aesni_enc1
2379         movups STATE1, (OUTP)
2380         sub $16, LEN
2381         add $16, INP
2382         add $16, OUTP
2383         cmp $16, LEN
2384         jge .Lecb_enc_loop1
2385 .Lecb_enc_ret:
2386 #ifndef __x86_64__
2387         popl KLEN
2388         popl KEYP
2389         popl LEN
2390 #endif
2391         FRAME_END
2392         ret
2393 ENDPROC(aesni_ecb_enc)
2394
2395 /*
2396  * void aesni_ecb_dec(struct crypto_aes_ctx *ctx, const u8 *dst, u8 *src,
2397  *                    size_t len);
2398  */
2399 ENTRY(aesni_ecb_dec)
2400         FRAME_BEGIN
2401 #ifndef __x86_64__
2402         pushl LEN
2403         pushl KEYP
2404         pushl KLEN
2405         movl (FRAME_OFFSET+16)(%esp), KEYP      # ctx
2406         movl (FRAME_OFFSET+20)(%esp), OUTP      # dst
2407         movl (FRAME_OFFSET+24)(%esp), INP       # src
2408         movl (FRAME_OFFSET+28)(%esp), LEN       # len
2409 #endif
2410         test LEN, LEN
2411         jz .Lecb_dec_ret
2412         mov 480(KEYP), KLEN
2413         add $240, KEYP
2414         cmp $16, LEN
2415         jb .Lecb_dec_ret
2416         cmp $64, LEN
2417         jb .Lecb_dec_loop1
2418 .align 4
2419 .Lecb_dec_loop4:
2420         movups (INP), STATE1
2421         movups 0x10(INP), STATE2
2422         movups 0x20(INP), STATE3
2423         movups 0x30(INP), STATE4
2424         call _aesni_dec4
2425         movups STATE1, (OUTP)
2426         movups STATE2, 0x10(OUTP)
2427         movups STATE3, 0x20(OUTP)
2428         movups STATE4, 0x30(OUTP)
2429         sub $64, LEN
2430         add $64, INP
2431         add $64, OUTP
2432         cmp $64, LEN
2433         jge .Lecb_dec_loop4
2434         cmp $16, LEN
2435         jb .Lecb_dec_ret
2436 .align 4
2437 .Lecb_dec_loop1:
2438         movups (INP), STATE1
2439         call _aesni_dec1
2440         movups STATE1, (OUTP)
2441         sub $16, LEN
2442         add $16, INP
2443         add $16, OUTP
2444         cmp $16, LEN
2445         jge .Lecb_dec_loop1
2446 .Lecb_dec_ret:
2447 #ifndef __x86_64__
2448         popl KLEN
2449         popl KEYP
2450         popl LEN
2451 #endif
2452         FRAME_END
2453         ret
2454 ENDPROC(aesni_ecb_dec)
2455
2456 /*
2457  * void aesni_cbc_enc(struct crypto_aes_ctx *ctx, const u8 *dst, u8 *src,
2458  *                    size_t len, u8 *iv)
2459  */
2460 ENTRY(aesni_cbc_enc)
2461         FRAME_BEGIN
2462 #ifndef __x86_64__
2463         pushl IVP
2464         pushl LEN
2465         pushl KEYP
2466         pushl KLEN
2467         movl (FRAME_OFFSET+20)(%esp), KEYP      # ctx
2468         movl (FRAME_OFFSET+24)(%esp), OUTP      # dst
2469         movl (FRAME_OFFSET+28)(%esp), INP       # src
2470         movl (FRAME_OFFSET+32)(%esp), LEN       # len
2471         movl (FRAME_OFFSET+36)(%esp), IVP       # iv
2472 #endif
2473         cmp $16, LEN
2474         jb .Lcbc_enc_ret
2475         mov 480(KEYP), KLEN
2476         movups (IVP), STATE     # load iv as initial state
2477 .align 4
2478 .Lcbc_enc_loop:
2479         movups (INP), IN        # load input
2480         pxor IN, STATE
2481         call _aesni_enc1
2482         movups STATE, (OUTP)    # store output
2483         sub $16, LEN
2484         add $16, INP
2485         add $16, OUTP
2486         cmp $16, LEN
2487         jge .Lcbc_enc_loop
2488         movups STATE, (IVP)
2489 .Lcbc_enc_ret:
2490 #ifndef __x86_64__
2491         popl KLEN
2492         popl KEYP
2493         popl LEN
2494         popl IVP
2495 #endif
2496         FRAME_END
2497         ret
2498 ENDPROC(aesni_cbc_enc)
2499
2500 /*
2501  * void aesni_cbc_dec(struct crypto_aes_ctx *ctx, const u8 *dst, u8 *src,
2502  *                    size_t len, u8 *iv)
2503  */
2504 ENTRY(aesni_cbc_dec)
2505         FRAME_BEGIN
2506 #ifndef __x86_64__
2507         pushl IVP
2508         pushl LEN
2509         pushl KEYP
2510         pushl KLEN
2511         movl (FRAME_OFFSET+20)(%esp), KEYP      # ctx
2512         movl (FRAME_OFFSET+24)(%esp), OUTP      # dst
2513         movl (FRAME_OFFSET+28)(%esp), INP       # src
2514         movl (FRAME_OFFSET+32)(%esp), LEN       # len
2515         movl (FRAME_OFFSET+36)(%esp), IVP       # iv
2516 #endif
2517         cmp $16, LEN
2518         jb .Lcbc_dec_just_ret
2519         mov 480(KEYP), KLEN
2520         add $240, KEYP
2521         movups (IVP), IV
2522         cmp $64, LEN
2523         jb .Lcbc_dec_loop1
2524 .align 4
2525 .Lcbc_dec_loop4:
2526         movups (INP), IN1
2527         movaps IN1, STATE1
2528         movups 0x10(INP), IN2
2529         movaps IN2, STATE2
2530 #ifdef __x86_64__
2531         movups 0x20(INP), IN3
2532         movaps IN3, STATE3
2533         movups 0x30(INP), IN4
2534         movaps IN4, STATE4
2535 #else
2536         movups 0x20(INP), IN1
2537         movaps IN1, STATE3
2538         movups 0x30(INP), IN2
2539         movaps IN2, STATE4
2540 #endif
2541         call _aesni_dec4
2542         pxor IV, STATE1
2543 #ifdef __x86_64__
2544         pxor IN1, STATE2
2545         pxor IN2, STATE3
2546         pxor IN3, STATE4
2547         movaps IN4, IV
2548 #else
2549         pxor IN1, STATE4
2550         movaps IN2, IV
2551         movups (INP), IN1
2552         pxor IN1, STATE2
2553         movups 0x10(INP), IN2
2554         pxor IN2, STATE3
2555 #endif
2556         movups STATE1, (OUTP)
2557         movups STATE2, 0x10(OUTP)
2558         movups STATE3, 0x20(OUTP)
2559         movups STATE4, 0x30(OUTP)
2560         sub $64, LEN
2561         add $64, INP
2562         add $64, OUTP
2563         cmp $64, LEN
2564         jge .Lcbc_dec_loop4
2565         cmp $16, LEN
2566         jb .Lcbc_dec_ret
2567 .align 4
2568 .Lcbc_dec_loop1:
2569         movups (INP), IN
2570         movaps IN, STATE
2571         call _aesni_dec1
2572         pxor IV, STATE
2573         movups STATE, (OUTP)
2574         movaps IN, IV
2575         sub $16, LEN
2576         add $16, INP
2577         add $16, OUTP
2578         cmp $16, LEN
2579         jge .Lcbc_dec_loop1
2580 .Lcbc_dec_ret:
2581         movups IV, (IVP)
2582 .Lcbc_dec_just_ret:
2583 #ifndef __x86_64__
2584         popl KLEN
2585         popl KEYP
2586         popl LEN
2587         popl IVP
2588 #endif
2589         FRAME_END
2590         ret
2591 ENDPROC(aesni_cbc_dec)
2592
2593 #ifdef __x86_64__
2594 .pushsection .rodata
2595 .align 16
2596 .Lbswap_mask:
2597         .byte 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
2598 .popsection
2599
2600 /*
2601  * _aesni_inc_init:     internal ABI
2602  *      setup registers used by _aesni_inc
2603  * input:
2604  *      IV
2605  * output:
2606  *      CTR:    == IV, in little endian
2607  *      TCTR_LOW: == lower qword of CTR
2608  *      INC:    == 1, in little endian
2609  *      BSWAP_MASK == endian swapping mask
2610  */
2611 .align 4
2612 _aesni_inc_init:
2613         movaps .Lbswap_mask, BSWAP_MASK
2614         movaps IV, CTR
2615         PSHUFB_XMM BSWAP_MASK CTR
2616         mov $1, TCTR_LOW
2617         MOVQ_R64_XMM TCTR_LOW INC
2618         MOVQ_R64_XMM CTR TCTR_LOW
2619         ret
2620 ENDPROC(_aesni_inc_init)
2621
2622 /*
2623  * _aesni_inc:          internal ABI
2624  *      Increase IV by 1, IV is in big endian
2625  * input:
2626  *      IV
2627  *      CTR:    == IV, in little endian
2628  *      TCTR_LOW: == lower qword of CTR
2629  *      INC:    == 1, in little endian
2630  *      BSWAP_MASK == endian swapping mask
2631  * output:
2632  *      IV:     Increase by 1
2633  * changed:
2634  *      CTR:    == output IV, in little endian
2635  *      TCTR_LOW: == lower qword of CTR
2636  */
2637 .align 4
2638 _aesni_inc:
2639         paddq INC, CTR
2640         add $1, TCTR_LOW
2641         jnc .Linc_low
2642         pslldq $8, INC
2643         paddq INC, CTR
2644         psrldq $8, INC
2645 .Linc_low:
2646         movaps CTR, IV
2647         PSHUFB_XMM BSWAP_MASK IV
2648         ret
2649 ENDPROC(_aesni_inc)
2650
2651 /*
2652  * void aesni_ctr_enc(struct crypto_aes_ctx *ctx, const u8 *dst, u8 *src,
2653  *                    size_t len, u8 *iv)
2654  */
2655 ENTRY(aesni_ctr_enc)
2656         FRAME_BEGIN
2657         cmp $16, LEN
2658         jb .Lctr_enc_just_ret
2659         mov 480(KEYP), KLEN
2660         movups (IVP), IV
2661         call _aesni_inc_init
2662         cmp $64, LEN
2663         jb .Lctr_enc_loop1
2664 .align 4
2665 .Lctr_enc_loop4:
2666         movaps IV, STATE1
2667         call _aesni_inc
2668         movups (INP), IN1
2669         movaps IV, STATE2
2670         call _aesni_inc
2671         movups 0x10(INP), IN2
2672         movaps IV, STATE3
2673         call _aesni_inc
2674         movups 0x20(INP), IN3
2675         movaps IV, STATE4
2676         call _aesni_inc
2677         movups 0x30(INP), IN4
2678         call _aesni_enc4
2679         pxor IN1, STATE1
2680         movups STATE1, (OUTP)
2681         pxor IN2, STATE2
2682         movups STATE2, 0x10(OUTP)
2683         pxor IN3, STATE3
2684         movups STATE3, 0x20(OUTP)
2685         pxor IN4, STATE4
2686         movups STATE4, 0x30(OUTP)
2687         sub $64, LEN
2688         add $64, INP
2689         add $64, OUTP
2690         cmp $64, LEN
2691         jge .Lctr_enc_loop4
2692         cmp $16, LEN
2693         jb .Lctr_enc_ret
2694 .align 4
2695 .Lctr_enc_loop1:
2696         movaps IV, STATE
2697         call _aesni_inc
2698         movups (INP), IN
2699         call _aesni_enc1
2700         pxor IN, STATE
2701         movups STATE, (OUTP)
2702         sub $16, LEN
2703         add $16, INP
2704         add $16, OUTP
2705         cmp $16, LEN
2706         jge .Lctr_enc_loop1
2707 .Lctr_enc_ret:
2708         movups IV, (IVP)
2709 .Lctr_enc_just_ret:
2710         FRAME_END
2711         ret
2712 ENDPROC(aesni_ctr_enc)
2713
2714 /*
2715  * _aesni_gf128mul_x_ble:               internal ABI
2716  *      Multiply in GF(2^128) for XTS IVs
2717  * input:
2718  *      IV:     current IV
2719  *      GF128MUL_MASK == mask with 0x87 and 0x01
2720  * output:
2721  *      IV:     next IV
2722  * changed:
2723  *      CTR:    == temporary value
2724  */
2725 #define _aesni_gf128mul_x_ble() \
2726         pshufd $0x13, IV, CTR; \
2727         paddq IV, IV; \
2728         psrad $31, CTR; \
2729         pand GF128MUL_MASK, CTR; \
2730         pxor CTR, IV;
2731
2732 /*
2733  * void aesni_xts_crypt8(struct crypto_aes_ctx *ctx, const u8 *dst, u8 *src,
2734  *                       bool enc, u8 *iv)
2735  */
2736 ENTRY(aesni_xts_crypt8)
2737         FRAME_BEGIN
2738         cmpb $0, %cl
2739         movl $0, %ecx
2740         movl $240, %r10d
2741         leaq _aesni_enc4, %r11
2742         leaq _aesni_dec4, %rax
2743         cmovel %r10d, %ecx
2744         cmoveq %rax, %r11
2745
2746         movdqa .Lgf128mul_x_ble_mask, GF128MUL_MASK
2747         movups (IVP), IV
2748
2749         mov 480(KEYP), KLEN
2750         addq %rcx, KEYP
2751
2752         movdqa IV, STATE1
2753         movdqu 0x00(INP), INC
2754         pxor INC, STATE1
2755         movdqu IV, 0x00(OUTP)
2756
2757         _aesni_gf128mul_x_ble()
2758         movdqa IV, STATE2
2759         movdqu 0x10(INP), INC
2760         pxor INC, STATE2
2761         movdqu IV, 0x10(OUTP)
2762
2763         _aesni_gf128mul_x_ble()
2764         movdqa IV, STATE3
2765         movdqu 0x20(INP), INC
2766         pxor INC, STATE3
2767         movdqu IV, 0x20(OUTP)
2768
2769         _aesni_gf128mul_x_ble()
2770         movdqa IV, STATE4
2771         movdqu 0x30(INP), INC
2772         pxor INC, STATE4
2773         movdqu IV, 0x30(OUTP)
2774
2775         CALL_NOSPEC %r11
2776
2777         movdqu 0x00(OUTP), INC
2778         pxor INC, STATE1
2779         movdqu STATE1, 0x00(OUTP)
2780
2781         _aesni_gf128mul_x_ble()
2782         movdqa IV, STATE1
2783         movdqu 0x40(INP), INC
2784         pxor INC, STATE1
2785         movdqu IV, 0x40(OUTP)
2786
2787         movdqu 0x10(OUTP), INC
2788         pxor INC, STATE2
2789         movdqu STATE2, 0x10(OUTP)
2790
2791         _aesni_gf128mul_x_ble()
2792         movdqa IV, STATE2
2793         movdqu 0x50(INP), INC
2794         pxor INC, STATE2
2795         movdqu IV, 0x50(OUTP)
2796
2797         movdqu 0x20(OUTP), INC
2798         pxor INC, STATE3
2799         movdqu STATE3, 0x20(OUTP)
2800
2801         _aesni_gf128mul_x_ble()
2802         movdqa IV, STATE3
2803         movdqu 0x60(INP), INC
2804         pxor INC, STATE3
2805         movdqu IV, 0x60(OUTP)
2806
2807         movdqu 0x30(OUTP), INC
2808         pxor INC, STATE4
2809         movdqu STATE4, 0x30(OUTP)
2810
2811         _aesni_gf128mul_x_ble()
2812         movdqa IV, STATE4
2813         movdqu 0x70(INP), INC
2814         pxor INC, STATE4
2815         movdqu IV, 0x70(OUTP)
2816
2817         _aesni_gf128mul_x_ble()
2818         movups IV, (IVP)
2819
2820         CALL_NOSPEC %r11
2821
2822         movdqu 0x40(OUTP), INC
2823         pxor INC, STATE1
2824         movdqu STATE1, 0x40(OUTP)
2825
2826         movdqu 0x50(OUTP), INC
2827         pxor INC, STATE2
2828         movdqu STATE2, 0x50(OUTP)
2829
2830         movdqu 0x60(OUTP), INC
2831         pxor INC, STATE3
2832         movdqu STATE3, 0x60(OUTP)
2833
2834         movdqu 0x70(OUTP), INC
2835         pxor INC, STATE4
2836         movdqu STATE4, 0x70(OUTP)
2837
2838         FRAME_END
2839         ret
2840 ENDPROC(aesni_xts_crypt8)
2841
2842 #endif