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