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