arch/x86/crypto/aesni-intel_asm.S

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