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
  35 #ifdef __x86_64__
  36 .data
  37 POLY:   .octa 0xC2000000000000000000000000000001
  38 TWOONE: .octa 0x00000001000000000000000000000001
  39
  40 # order of these constants should not change.
  41 # more specifically, ALL_F should follow SHIFT_MASK,
  42 # and ZERO should follow ALL_F
  43
  44 SHUF_MASK:  .octa 0x000102030405060708090A0B0C0D0E0F
  45 MASK1:      .octa 0x0000000000000000ffffffffffffffff
  46 MASK2:      .octa 0xffffffffffffffff0000000000000000
  47 SHIFT_MASK: .octa 0x0f0e0d0c0b0a09080706050403020100
  48 ALL_F:      .octa 0xffffffffffffffffffffffffffffffff
  49 ZERO:       .octa 0x00000000000000000000000000000000
  50 ONE:        .octa 0x00000000000000000000000000000001
  51 F_MIN_MASK: .octa 0xf1f2f3f4f5f6f7f8f9fafbfcfdfeff0
  52 dec:        .octa 0x1
  53 enc:        .octa 0x2
  54
  55
  56 .text
  57
  58
  59 #define STACK_OFFSET    8*3
  60 #define HashKey         16*0    // store HashKey <<1 mod poly here
  61 #define HashKey_2       16*1    // store HashKey^2 <<1 mod poly here
  62 #define HashKey_3       16*2    // store HashKey^3 <<1 mod poly here
  63 #define HashKey_4       16*3    // store HashKey^4 <<1 mod poly here
  64 #define HashKey_k       16*4    // store XOR of High 64 bits and Low 64
  65                                 // bits of  HashKey <<1 mod poly here
  66                                 //(for Karatsuba purposes)
  67 #define HashKey_2_k     16*5    // store XOR of High 64 bits and Low 64
  68                                 // bits of  HashKey^2 <<1 mod poly here
  69                                 // (for Karatsuba purposes)
  70 #define HashKey_3_k     16*6    // store XOR of High 64 bits and Low 64
  71                                 // bits of  HashKey^3 <<1 mod poly here
  72                                 // (for Karatsuba purposes)
  73 #define HashKey_4_k     16*7    // store XOR of High 64 bits and Low 64
  74                                 // bits of  HashKey^4 <<1 mod poly here
  75                                 // (for Karatsuba purposes)
  76 #define VARIABLE_OFFSET 16*8
  77
  78 #define arg1 rdi
  79 #define arg2 rsi
  80 #define arg3 rdx
  81 #define arg4 rcx
  82 #define arg5 r8
  83 #define arg6 r9
  84 #define arg7 STACK_OFFSET+8(%r14)
  85 #define arg8 STACK_OFFSET+16(%r14)
  86 #define arg9 STACK_OFFSET+24(%r14)
  87 #define arg10 STACK_OFFSET+32(%r14)
  88 #endif
  89
  90
  91 #define STATE1  %xmm0
  92 #define STATE2  %xmm4
  93 #define STATE3  %xmm5
  94 #define STATE4  %xmm6
  95 #define STATE   STATE1
  96 #define IN1     %xmm1
  97 #define IN2     %xmm7
  98 #define IN3     %xmm8
  99 #define IN4     %xmm9
 100 #define IN      IN1
 101 #define KEY     %xmm2
 102 #define IV      %xmm3
 103
 104 #define BSWAP_MASK %xmm10
 105 #define CTR     %xmm11
 106 #define INC     %xmm12
 107
 108 #ifdef __x86_64__
 109 #define AREG    %rax
 110 #define KEYP    %rdi
 111 #define OUTP    %rsi
 112 #define UKEYP   OUTP
 113 #define INP     %rdx
 114 #define LEN     %rcx
 115 #define IVP     %r8
 116 #define KLEN    %r9d
 117 #define T1      %r10
 118 #define TKEYP   T1
 119 #define T2      %r11
 120 #define TCTR_LOW T2
 121 #else
 122 #define AREG    %eax
 123 #define KEYP    %edi
 124 #define OUTP    AREG
 125 #define UKEYP   OUTP
 126 #define INP     %edx
 127 #define LEN     %esi
 128 #define IVP     %ebp
 129 #define KLEN    %ebx
 130 #define T1      %ecx
 131 #define TKEYP   T1
 132 #endif
 133
 134
 135 #ifdef __x86_64__
 136 /* GHASH_MUL MACRO to implement: Data*HashKey mod (128,127,126,121,0)
 137 *
 138 *
 139 * Input: A and B (128-bits each, bit-reflected)
 140 * Output: C = A*B*x mod poly, (i.e. >>1 )
 141 * To compute GH = GH*HashKey mod poly, give HK = HashKey<<1 mod poly as input
 142 * GH = GH * HK * x mod poly which is equivalent to GH*HashKey mod poly.
 143 *
 144 */
 145 .macro GHASH_MUL GH HK TMP1 TMP2 TMP3 TMP4 TMP5
 146         movdqa    \GH, \TMP1
 147         pshufd    $78, \GH, \TMP2
 148         pshufd    $78, \HK, \TMP3
 149         pxor      \GH, \TMP2            # TMP2 = a1+a0
 150         pxor      \HK, \TMP3            # TMP3 = b1+b0
 151         PCLMULQDQ 0x11, \HK, \TMP1     # TMP1 = a1*b1
 152         PCLMULQDQ 0x00, \HK, \GH       # GH = a0*b0
 153         PCLMULQDQ 0x00, \TMP3, \TMP2   # TMP2 = (a0+a1)*(b1+b0)
 154         pxor      \GH, \TMP2
 155         pxor      \TMP1, \TMP2          # TMP2 = (a0*b0)+(a1*b0)
 156         movdqa    \TMP2, \TMP3
 157         pslldq    $8, \TMP3             # left shift TMP3 2 DWs
 158         psrldq    $8, \TMP2             # right shift TMP2 2 DWs
 159         pxor      \TMP3, \GH
 160         pxor      \TMP2, \TMP1          # TMP2:GH holds the result of GH*HK
 161
 162         # first phase of the reduction
 163
 164         movdqa    \GH, \TMP2
 165         movdqa    \GH, \TMP3
 166         movdqa    \GH, \TMP4            # copy GH into TMP2,TMP3 and TMP4
 167                                         # in in order to perform
 168                                         # independent shifts
 169         pslld     $31, \TMP2            # packed right shift <<31
 170         pslld     $30, \TMP3            # packed right shift <<30
 171         pslld     $25, \TMP4            # packed right shift <<25
 172         pxor      \TMP3, \TMP2          # xor the shifted versions
 173         pxor      \TMP4, \TMP2
 174         movdqa    \TMP2, \TMP5
 175         psrldq    $4, \TMP5             # right shift TMP5 1 DW
 176         pslldq    $12, \TMP2            # left shift TMP2 3 DWs
 177         pxor      \TMP2, \GH
 178
 179         # second phase of the reduction
 180
 181         movdqa    \GH,\TMP2             # copy GH into TMP2,TMP3 and TMP4
 182                                         # in in order to perform
 183                                         # independent shifts
 184         movdqa    \GH,\TMP3
 185         movdqa    \GH,\TMP4
 186         psrld     $1,\TMP2              # packed left shift >>1
 187         psrld     $2,\TMP3              # packed left shift >>2
 188         psrld     $7,\TMP4              # packed left shift >>7
 189         pxor      \TMP3,\TMP2           # xor the shifted versions
 190         pxor      \TMP4,\TMP2
 191         pxor      \TMP5, \TMP2
 192         pxor      \TMP2, \GH
 193         pxor      \TMP1, \GH            # result is in TMP1
 194 .endm
 195
 196 /*
 197 * if a = number of total plaintext bytes
 198 * b = floor(a/16)
 199 * num_initial_blocks = b mod 4
 200 * encrypt the initial num_initial_blocks blocks and apply ghash on
 201 * the ciphertext
 202 * %r10, %r11, %r12, %rax, %xmm5, %xmm6, %xmm7, %xmm8, %xmm9 registers
 203 * are clobbered
 204 * arg1, %arg2, %arg3, %r14 are used as a pointer only, not modified
 205 */
 206
 207 .macro INITIAL_BLOCKS num_initial_blocks TMP1 TMP2 TMP3 TMP4 TMP5 XMM0 XMM1 \
 208 XMM2 XMM3 XMM4 XMMDst TMP6 TMP7 i i_seq operation
 209
 210         mov        arg7, %r10           # %r10 = AAD
 211         mov        arg8, %r12           # %r12 = aadLen
 212         mov        %r12, %r11
 213         pxor       %xmm\i, %xmm\i
 214 _get_AAD_loop\num_initial_blocks\operation:
 215         movd       (%r10), \TMP1
 216         pslldq     $12, \TMP1
 217         psrldq     $4, %xmm\i
 218         pxor       \TMP1, %xmm\i
 219         add        $4, %r10
 220         sub        $4, %r12
 221         jne        _get_AAD_loop\num_initial_blocks\operation
 222         cmp        $16, %r11
 223         je         _get_AAD_loop2_done\num_initial_blocks\operation
 224         mov        $16, %r12
 225 _get_AAD_loop2\num_initial_blocks\operation:
 226         psrldq     $4, %xmm\i
 227         sub        $4, %r12
 228         cmp        %r11, %r12
 229         jne        _get_AAD_loop2\num_initial_blocks\operation
 230 _get_AAD_loop2_done\num_initial_blocks\operation:
 231         pshufb     SHUF_MASK(%rip), %xmm\i # byte-reflect the AAD data
 232         xor        %r11, %r11 # initialise the data pointer offset as zero
 233
 234         # start AES for num_initial_blocks blocks
 235
 236         mov        %arg5, %rax                      # %rax = *Y0
 237         movdqu     (%rax), \XMM0                    # XMM0 = Y0
 238         pshufb     SHUF_MASK(%rip), \XMM0
 239 .if \i_seq != 0
 240 .irpc index, \i_seq
 241         paddd      ONE(%rip), \XMM0                 # INCR Y0
 242         movdqa     \XMM0, %xmm\index
 243         pshufb     SHUF_MASK(%rip), %xmm\index      # perform a 16 byte swap
 244 .endr
 245 .irpc index, \i_seq
 246         pxor       16*0(%arg1), %xmm\index
 247 .endr
 248 .irpc index, \i_seq
 249         movaps 0x10(%rdi), \TMP1
 250         AESENC     \TMP1, %xmm\index          # Round 1
 251 .endr
 252 .irpc index, \i_seq
 253         movaps 0x20(%arg1), \TMP1
 254         AESENC     \TMP1, %xmm\index          # Round 2
 255 .endr
 256 .irpc index, \i_seq
 257         movaps 0x30(%arg1), \TMP1
 258         AESENC     \TMP1, %xmm\index          # Round 2
 259 .endr
 260 .irpc index, \i_seq
 261         movaps 0x40(%arg1), \TMP1
 262         AESENC     \TMP1, %xmm\index          # Round 2
 263 .endr
 264 .irpc index, \i_seq
 265         movaps 0x50(%arg1), \TMP1
 266         AESENC     \TMP1, %xmm\index          # Round 2
 267 .endr
 268 .irpc index, \i_seq
 269         movaps 0x60(%arg1), \TMP1
 270         AESENC     \TMP1, %xmm\index          # Round 2
 271 .endr
 272 .irpc index, \i_seq
 273         movaps 0x70(%arg1), \TMP1
 274         AESENC     \TMP1, %xmm\index          # Round 2
 275 .endr
 276 .irpc index, \i_seq
 277         movaps 0x80(%arg1), \TMP1
 278         AESENC     \TMP1, %xmm\index          # Round 2
 279 .endr
 280 .irpc index, \i_seq
 281         movaps 0x90(%arg1), \TMP1
 282         AESENC     \TMP1, %xmm\index          # Round 2
 283 .endr
 284 .irpc index, \i_seq
 285         movaps 0xa0(%arg1), \TMP1
 286         AESENCLAST \TMP1, %xmm\index         # Round 10
 287 .endr
 288 .irpc index, \i_seq
 289         movdqu     (%arg3 , %r11, 1), \TMP1
 290         pxor       \TMP1, %xmm\index
 291         movdqu     %xmm\index, (%arg2 , %r11, 1)
 292         # write back plaintext/ciphertext for num_initial_blocks
 293         add        $16, %r11
 294 .if \operation == dec
 295         movdqa     \TMP1, %xmm\index
 296 .endif
 297         pshufb     SHUF_MASK(%rip), %xmm\index
 298                 # prepare plaintext/ciphertext for GHASH computation
 299 .endr
 300 .endif
 301         GHASH_MUL  %xmm\i, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
 302         # apply GHASH on num_initial_blocks blocks
 303
 304 .if \i == 5
 305         pxor       %xmm5, %xmm6
 306         GHASH_MUL  %xmm6, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
 307         pxor       %xmm6, %xmm7
 308         GHASH_MUL  %xmm7, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
 309         pxor       %xmm7, %xmm8
 310         GHASH_MUL  %xmm8, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
 311 .elseif \i == 6
 312         pxor       %xmm6, %xmm7
 313         GHASH_MUL  %xmm7, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
 314         pxor       %xmm7, %xmm8
 315         GHASH_MUL  %xmm8, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
 316 .elseif \i == 7
 317         pxor       %xmm7, %xmm8
 318         GHASH_MUL  %xmm8, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
 319 .endif
 320         cmp        $64, %r13
 321         jl      _initial_blocks_done\num_initial_blocks\operation
 322         # no need for precomputed values
 323 /*
 324 *
 325 * Precomputations for HashKey parallel with encryption of first 4 blocks.
 326 * Haskey_i_k holds XORed values of the low and high parts of the Haskey_i
 327 */
 328         paddd      ONE(%rip), \XMM0              # INCR Y0
 329         movdqa     \XMM0, \XMM1
 330         pshufb     SHUF_MASK(%rip), \XMM1        # perform a 16 byte swap
 331         paddd      ONE(%rip), \XMM0              # INCR Y0
 332         movdqa     \XMM0, \XMM2
 333         pshufb     SHUF_MASK(%rip), \XMM2        # perform a 16 byte swap
 334         paddd      ONE(%rip), \XMM0              # INCR Y0
 335         movdqa     \XMM0, \XMM3
 336         pshufb     SHUF_MASK(%rip), \XMM3        # perform a 16 byte swap
 337         paddd      ONE(%rip), \XMM0              # INCR Y0
 338         movdqa     \XMM0, \XMM4
 339         pshufb     SHUF_MASK(%rip), \XMM4        # perform a 16 byte swap
 340         pxor       16*0(%arg1), \XMM1
 341         pxor       16*0(%arg1), \XMM2
 342         pxor       16*0(%arg1), \XMM3
 343         pxor       16*0(%arg1), \XMM4
 344         movdqa     \TMP3, \TMP5
 345         pshufd     $78, \TMP3, \TMP1
 346         pxor       \TMP3, \TMP1
 347         movdqa     \TMP1, HashKey_k(%rsp)
 348         GHASH_MUL  \TMP5, \TMP3, \TMP1, \TMP2, \TMP4, \TMP6, \TMP7
 349 # TMP5 = HashKey^2<<1 (mod poly)
 350         movdqa     \TMP5, HashKey_2(%rsp)
 351 # HashKey_2 = HashKey^2<<1 (mod poly)
 352         pshufd     $78, \TMP5, \TMP1
 353         pxor       \TMP5, \TMP1
 354         movdqa     \TMP1, HashKey_2_k(%rsp)
 355 .irpc index, 1234 # do 4 rounds
 356         movaps 0x10*\index(%arg1), \TMP1
 357         AESENC     \TMP1, \XMM1
 358         AESENC     \TMP1, \XMM2
 359         AESENC     \TMP1, \XMM3
 360         AESENC     \TMP1, \XMM4
 361 .endr
 362         GHASH_MUL  \TMP5, \TMP3, \TMP1, \TMP2, \TMP4, \TMP6, \TMP7
 363 # TMP5 = HashKey^3<<1 (mod poly)
 364         movdqa     \TMP5, HashKey_3(%rsp)
 365         pshufd     $78, \TMP5, \TMP1
 366         pxor       \TMP5, \TMP1
 367         movdqa     \TMP1, HashKey_3_k(%rsp)
 368 .irpc index, 56789 # do next 5 rounds
 369         movaps 0x10*\index(%arg1), \TMP1
 370         AESENC     \TMP1, \XMM1
 371         AESENC     \TMP1, \XMM2
 372         AESENC     \TMP1, \XMM3
 373         AESENC     \TMP1, \XMM4
 374 .endr
 375         GHASH_MUL  \TMP5, \TMP3, \TMP1, \TMP2, \TMP4, \TMP6, \TMP7
 376 # TMP5 = HashKey^3<<1 (mod poly)
 377         movdqa     \TMP5, HashKey_4(%rsp)
 378         pshufd     $78, \TMP5, \TMP1
 379         pxor       \TMP5, \TMP1
 380         movdqa     \TMP1, HashKey_4_k(%rsp)
 381         movaps 0xa0(%arg1), \TMP2
 382         AESENCLAST \TMP2, \XMM1
 383         AESENCLAST \TMP2, \XMM2
 384         AESENCLAST \TMP2, \XMM3
 385         AESENCLAST \TMP2, \XMM4
 386         movdqu     16*0(%arg3 , %r11 , 1), \TMP1
 387         pxor       \TMP1, \XMM1
 388 .if \operation == dec
 389         movdqu     \XMM1, 16*0(%arg2 , %r11 , 1)
 390         movdqa     \TMP1, \XMM1
 391 .endif
 392         movdqu     16*1(%arg3 , %r11 , 1), \TMP1
 393         pxor       \TMP1, \XMM2
 394 .if \operation == dec
 395         movdqu     \XMM2, 16*1(%arg2 , %r11 , 1)
 396         movdqa     \TMP1, \XMM2
 397 .endif
 398         movdqu     16*2(%arg3 , %r11 , 1), \TMP1
 399         pxor       \TMP1, \XMM3
 400 .if \operation == dec
 401         movdqu     \XMM3, 16*2(%arg2 , %r11 , 1)
 402         movdqa     \TMP1, \XMM3
 403 .endif
 404         movdqu     16*3(%arg3 , %r11 , 1), \TMP1
 405         pxor       \TMP1, \XMM4
 406 .if \operation == dec
 407         movdqu     \XMM4, 16*3(%arg2 , %r11 , 1)
 408         movdqa     \TMP1, \XMM4
 409 .else
 410         movdqu     \XMM1, 16*0(%arg2 , %r11 , 1)
 411         movdqu     \XMM2, 16*1(%arg2 , %r11 , 1)
 412         movdqu     \XMM3, 16*2(%arg2 , %r11 , 1)
 413         movdqu     \XMM4, 16*3(%arg2 , %r11 , 1)
 414 .endif
 415         add        $64, %r11
 416         pshufb     SHUF_MASK(%rip), \XMM1 # perform a 16 byte swap
 417         pxor       \XMMDst, \XMM1
 418 # combine GHASHed value with the corresponding ciphertext
 419         pshufb     SHUF_MASK(%rip), \XMM2 # perform a 16 byte swap
 420         pshufb     SHUF_MASK(%rip), \XMM3 # perform a 16 byte swap
 421         pshufb     SHUF_MASK(%rip), \XMM4 # perform a 16 byte swap
 422 _initial_blocks_done\num_initial_blocks\operation:
 423 .endm
 424
 425 /*
 426 * encrypt 4 blocks at a time
 427 * ghash the 4 previously encrypted ciphertext blocks
 428 * arg1, %arg2, %arg3 are used as pointers only, not modified
 429 * %r11 is the data offset value
 430 */
 431 .macro GHASH_4_ENCRYPT_4_PARALLEL TMP1 TMP2 TMP3 TMP4 TMP5 \
 432 TMP6 XMM0 XMM1 XMM2 XMM3 XMM4 XMM5 XMM6 XMM7 XMM8 operation
 433
 434         movdqa    \XMM1, \XMM5
 435         movdqa    \XMM2, \XMM6
 436         movdqa    \XMM3, \XMM7
 437         movdqa    \XMM4, \XMM8
 438
 439         # multiply TMP5 * HashKey using karatsuba
 440
 441         movdqa    \XMM5, \TMP4
 442         pshufd    $78, \XMM5, \TMP6
 443         pxor      \XMM5, \TMP6
 444         paddd     ONE(%rip), \XMM0              # INCR CNT
 445         movdqa    HashKey_4(%rsp), \TMP5
 446         PCLMULQDQ 0x11, \TMP5, \TMP4           # TMP4 = a1*b1
 447         movdqa    \XMM0, \XMM1
 448         paddd     ONE(%rip), \XMM0              # INCR CNT
 449         movdqa    \XMM0, \XMM2
 450         paddd     ONE(%rip), \XMM0              # INCR CNT
 451         movdqa    \XMM0, \XMM3
 452         paddd     ONE(%rip), \XMM0              # INCR CNT
 453         movdqa    \XMM0, \XMM4
 454         pshufb    SHUF_MASK(%rip), \XMM1        # perform a 16 byte swap
 455         PCLMULQDQ 0x00, \TMP5, \XMM5           # XMM5 = a0*b0
 456         pshufb    SHUF_MASK(%rip), \XMM2        # perform a 16 byte swap
 457         pshufb    SHUF_MASK(%rip), \XMM3        # perform a 16 byte swap
 458         pshufb    SHUF_MASK(%rip), \XMM4        # perform a 16 byte swap
 459         pxor      (%arg1), \XMM1
 460         pxor      (%arg1), \XMM2
 461         pxor      (%arg1), \XMM3
 462         pxor      (%arg1), \XMM4
 463         movdqa    HashKey_4_k(%rsp), \TMP5
 464         PCLMULQDQ 0x00, \TMP5, \TMP6           # TMP6 = (a1+a0)*(b1+b0)
 465         movaps 0x10(%arg1), \TMP1
 466         AESENC    \TMP1, \XMM1              # Round 1
 467         AESENC    \TMP1, \XMM2
 468         AESENC    \TMP1, \XMM3
 469         AESENC    \TMP1, \XMM4
 470         movaps 0x20(%arg1), \TMP1
 471         AESENC    \TMP1, \XMM1              # Round 2
 472         AESENC    \TMP1, \XMM2
 473         AESENC    \TMP1, \XMM3
 474         AESENC    \TMP1, \XMM4
 475         movdqa    \XMM6, \TMP1
 476         pshufd    $78, \XMM6, \TMP2
 477         pxor      \XMM6, \TMP2
 478         movdqa    HashKey_3(%rsp), \TMP5
 479         PCLMULQDQ 0x11, \TMP5, \TMP1           # TMP1 = a1 * b1
 480         movaps 0x30(%arg1), \TMP3
 481         AESENC    \TMP3, \XMM1              # Round 3
 482         AESENC    \TMP3, \XMM2
 483         AESENC    \TMP3, \XMM3
 484         AESENC    \TMP3, \XMM4
 485         PCLMULQDQ 0x00, \TMP5, \XMM6           # XMM6 = a0*b0
 486         movaps 0x40(%arg1), \TMP3
 487         AESENC    \TMP3, \XMM1              # Round 4
 488         AESENC    \TMP3, \XMM2
 489         AESENC    \TMP3, \XMM3
 490         AESENC    \TMP3, \XMM4
 491         movdqa    HashKey_3_k(%rsp), \TMP5
 492         PCLMULQDQ 0x00, \TMP5, \TMP2           # TMP2 = (a1+a0)*(b1+b0)
 493         movaps 0x50(%arg1), \TMP3
 494         AESENC    \TMP3, \XMM1              # Round 5
 495         AESENC    \TMP3, \XMM2
 496         AESENC    \TMP3, \XMM3
 497         AESENC    \TMP3, \XMM4
 498         pxor      \TMP1, \TMP4
 499 # accumulate the results in TMP4:XMM5, TMP6 holds the middle part
 500         pxor      \XMM6, \XMM5
 501         pxor      \TMP2, \TMP6
 502         movdqa    \XMM7, \TMP1
 503         pshufd    $78, \XMM7, \TMP2
 504         pxor      \XMM7, \TMP2
 505         movdqa    HashKey_2(%rsp ), \TMP5
 506
 507         # Multiply TMP5 * HashKey using karatsuba
 508
 509         PCLMULQDQ 0x11, \TMP5, \TMP1           # TMP1 = a1*b1
 510         movaps 0x60(%arg1), \TMP3
 511         AESENC    \TMP3, \XMM1              # Round 6
 512         AESENC    \TMP3, \XMM2
 513         AESENC    \TMP3, \XMM3
 514         AESENC    \TMP3, \XMM4
 515         PCLMULQDQ 0x00, \TMP5, \XMM7           # XMM7 = a0*b0
 516         movaps 0x70(%arg1), \TMP3
 517         AESENC    \TMP3, \XMM1             # Round 7
 518         AESENC    \TMP3, \XMM2
 519         AESENC    \TMP3, \XMM3
 520         AESENC    \TMP3, \XMM4
 521         movdqa    HashKey_2_k(%rsp), \TMP5
 522         PCLMULQDQ 0x00, \TMP5, \TMP2           # TMP2 = (a1+a0)*(b1+b0)
 523         movaps 0x80(%arg1), \TMP3
 524         AESENC    \TMP3, \XMM1             # Round 8
 525         AESENC    \TMP3, \XMM2
 526         AESENC    \TMP3, \XMM3
 527         AESENC    \TMP3, \XMM4
 528         pxor      \TMP1, \TMP4
 529 # accumulate the results in TMP4:XMM5, TMP6 holds the middle part
 530         pxor      \XMM7, \XMM5
 531         pxor      \TMP2, \TMP6
 532
 533         # Multiply XMM8 * HashKey
 534         # XMM8 and TMP5 hold the values for the two operands
 535
 536         movdqa    \XMM8, \TMP1
 537         pshufd    $78, \XMM8, \TMP2
 538         pxor      \XMM8, \TMP2
 539         movdqa    HashKey(%rsp), \TMP5
 540         PCLMULQDQ 0x11, \TMP5, \TMP1          # TMP1 = a1*b1
 541         movaps 0x90(%arg1), \TMP3
 542         AESENC    \TMP3, \XMM1            # Round 9
 543         AESENC    \TMP3, \XMM2
 544         AESENC    \TMP3, \XMM3
 545         AESENC    \TMP3, \XMM4
 546         PCLMULQDQ 0x00, \TMP5, \XMM8          # XMM8 = a0*b0
 547         movaps 0xa0(%arg1), \TMP3
 548         AESENCLAST \TMP3, \XMM1           # Round 10
 549         AESENCLAST \TMP3, \XMM2
 550         AESENCLAST \TMP3, \XMM3
 551         AESENCLAST \TMP3, \XMM4
 552         movdqa    HashKey_k(%rsp), \TMP5
 553         PCLMULQDQ 0x00, \TMP5, \TMP2          # TMP2 = (a1+a0)*(b1+b0)
 554         movdqu    (%arg3,%r11,1), \TMP3
 555         pxor      \TMP3, \XMM1                 # Ciphertext/Plaintext XOR EK
 556 .if \operation == dec
 557         movdqu    \XMM1, (%arg2,%r11,1)        # Write to plaintext buffer
 558         movdqa    \TMP3, \XMM1
 559 .endif
 560         movdqu    16(%arg3,%r11,1), \TMP3
 561         pxor      \TMP3, \XMM2                 # Ciphertext/Plaintext XOR EK
 562 .if \operation == dec
 563         movdqu    \XMM2, 16(%arg2,%r11,1)      # Write to plaintext buffer
 564         movdqa    \TMP3, \XMM2
 565 .endif
 566         movdqu    32(%arg3,%r11,1), \TMP3
 567         pxor      \TMP3, \XMM3                 # Ciphertext/Plaintext XOR EK
 568 .if \operation == dec
 569         movdqu    \XMM3, 32(%arg2,%r11,1)      # Write to plaintext buffer
 570         movdqa    \TMP3, \XMM3
 571 .endif
 572         movdqu    48(%arg3,%r11,1), \TMP3
 573         pxor      \TMP3, \XMM4                 # Ciphertext/Plaintext XOR EK
 574 .if \operation == dec
 575         movdqu    \XMM4, 48(%arg2,%r11,1)      # Write to plaintext buffer
 576         movdqa    \TMP3, \XMM4
 577 .else
 578     movdqu    \XMM1, (%arg2,%r11,1)        # Write to the ciphertext buffer
 579     movdqu    \XMM2, 16(%arg2,%r11,1)      # Write to the ciphertext buffer
 580     movdqu    \XMM3, 32(%arg2,%r11,1)      # Write to the ciphertext buffer
 581     movdqu    \XMM4, 48(%arg2,%r11,1)      # Write to the ciphertext buffer
 582 .endif
 583         pshufb    SHUF_MASK(%rip), \XMM1       # perform a 16 byte swap
 584         pshufb    SHUF_MASK(%rip), \XMM2       # perform a 16 byte swap
 585         pshufb    SHUF_MASK(%rip), \XMM3       # perform a 16 byte swap
 586         pshufb    SHUF_MASK(%rip), \XMM4       # perform a 16 byte sway
 587
 588         pxor      \TMP4, \TMP1
 589         pxor      \XMM8, \XMM5
 590         pxor      \TMP6, \TMP2
 591         pxor      \TMP1, \TMP2
 592         pxor      \XMM5, \TMP2
 593         movdqa    \TMP2, \TMP3
 594         pslldq    $8, \TMP3                    # left shift TMP3 2 DWs
 595         psrldq    $8, \TMP2                    # right shift TMP2 2 DWs
 596         pxor      \TMP3, \XMM5
 597         pxor      \TMP2, \TMP1    # accumulate the results in TMP1:XMM5
 598
 599         # first phase of reduction
 600
 601         movdqa    \XMM5, \TMP2
 602         movdqa    \XMM5, \TMP3
 603         movdqa    \XMM5, \TMP4
 604 # move XMM5 into TMP2, TMP3, TMP4 in order to perform shifts independently
 605         pslld     $31, \TMP2                   # packed right shift << 31
 606         pslld     $30, \TMP3                   # packed right shift << 30
 607         pslld     $25, \TMP4                   # packed right shift << 25
 608         pxor      \TMP3, \TMP2                 # xor the shifted versions
 609         pxor      \TMP4, \TMP2
 610         movdqa    \TMP2, \TMP5
 611         psrldq    $4, \TMP5                    # right shift T5 1 DW
 612         pslldq    $12, \TMP2                   # left shift T2 3 DWs
 613         pxor      \TMP2, \XMM5
 614
 615         # second phase of reduction
 616
 617         movdqa    \XMM5,\TMP2 # make 3 copies of XMM5 into TMP2, TMP3, TMP4
 618         movdqa    \XMM5,\TMP3
 619         movdqa    \XMM5,\TMP4
 620         psrld     $1, \TMP2                    # packed left shift >>1
 621         psrld     $2, \TMP3                    # packed left shift >>2
 622         psrld     $7, \TMP4                    # packed left shift >>7
 623         pxor      \TMP3,\TMP2                  # xor the shifted versions
 624         pxor      \TMP4,\TMP2
 625         pxor      \TMP5, \TMP2
 626         pxor      \TMP2, \XMM5
 627         pxor      \TMP1, \XMM5                 # result is in TMP1
 628
 629         pxor      \XMM5, \XMM1
 630 .endm
 631
 632 /* GHASH the last 4 ciphertext blocks. */
 633 .macro  GHASH_LAST_4 TMP1 TMP2 TMP3 TMP4 TMP5 TMP6 \
 634 TMP7 XMM1 XMM2 XMM3 XMM4 XMMDst
 635
 636         # Multiply TMP6 * HashKey (using Karatsuba)
 637
 638         movdqa    \XMM1, \TMP6
 639         pshufd    $78, \XMM1, \TMP2
 640         pxor      \XMM1, \TMP2
 641         movdqa    HashKey_4(%rsp), \TMP5
 642         PCLMULQDQ 0x11, \TMP5, \TMP6       # TMP6 = a1*b1
 643         PCLMULQDQ 0x00, \TMP5, \XMM1       # XMM1 = a0*b0
 644         movdqa    HashKey_4_k(%rsp), \TMP4
 645         PCLMULQDQ 0x00, \TMP4, \TMP2       # TMP2 = (a1+a0)*(b1+b0)
 646         movdqa    \XMM1, \XMMDst
 647         movdqa    \TMP2, \XMM1              # result in TMP6, XMMDst, XMM1
 648
 649         # Multiply TMP1 * HashKey (using Karatsuba)
 650
 651         movdqa    \XMM2, \TMP1
 652         pshufd    $78, \XMM2, \TMP2
 653         pxor      \XMM2, \TMP2
 654         movdqa    HashKey_3(%rsp), \TMP5
 655         PCLMULQDQ 0x11, \TMP5, \TMP1       # TMP1 = a1*b1
 656         PCLMULQDQ 0x00, \TMP5, \XMM2       # XMM2 = a0*b0
 657         movdqa    HashKey_3_k(%rsp), \TMP4
 658         PCLMULQDQ 0x00, \TMP4, \TMP2       # TMP2 = (a1+a0)*(b1+b0)
 659         pxor      \TMP1, \TMP6
 660         pxor      \XMM2, \XMMDst
 661         pxor      \TMP2, \XMM1
 662 # results accumulated in TMP6, XMMDst, XMM1
 663
 664         # Multiply TMP1 * HashKey (using Karatsuba)
 665
 666         movdqa    \XMM3, \TMP1
 667         pshufd    $78, \XMM3, \TMP2
 668         pxor      \XMM3, \TMP2
 669         movdqa    HashKey_2(%rsp), \TMP5
 670         PCLMULQDQ 0x11, \TMP5, \TMP1       # TMP1 = a1*b1
 671         PCLMULQDQ 0x00, \TMP5, \XMM3       # XMM3 = a0*b0
 672         movdqa    HashKey_2_k(%rsp), \TMP4
 673         PCLMULQDQ 0x00, \TMP4, \TMP2       # TMP2 = (a1+a0)*(b1+b0)
 674         pxor      \TMP1, \TMP6
 675         pxor      \XMM3, \XMMDst
 676         pxor      \TMP2, \XMM1   # results accumulated in TMP6, XMMDst, XMM1
 677
 678         # Multiply TMP1 * HashKey (using Karatsuba)
 679         movdqa    \XMM4, \TMP1
 680         pshufd    $78, \XMM4, \TMP2
 681         pxor      \XMM4, \TMP2
 682         movdqa    HashKey(%rsp), \TMP5
 683         PCLMULQDQ 0x11, \TMP5, \TMP1        # TMP1 = a1*b1
 684         PCLMULQDQ 0x00, \TMP5, \XMM4       # XMM4 = a0*b0
 685         movdqa    HashKey_k(%rsp), \TMP4
 686         PCLMULQDQ 0x00, \TMP4, \TMP2       # TMP2 = (a1+a0)*(b1+b0)
 687         pxor      \TMP1, \TMP6
 688         pxor      \XMM4, \XMMDst
 689         pxor      \XMM1, \TMP2
 690         pxor      \TMP6, \TMP2
 691         pxor      \XMMDst, \TMP2
 692         # middle section of the temp results combined as in karatsuba algorithm
 693         movdqa    \TMP2, \TMP4
 694         pslldq    $8, \TMP4                 # left shift TMP4 2 DWs
 695         psrldq    $8, \TMP2                 # right shift TMP2 2 DWs
 696         pxor      \TMP4, \XMMDst
 697         pxor      \TMP2, \TMP6
 698 # TMP6:XMMDst holds the result of the accumulated carry-less multiplications
 699         # first phase of the reduction
 700         movdqa    \XMMDst, \TMP2
 701         movdqa    \XMMDst, \TMP3
 702         movdqa    \XMMDst, \TMP4
 703 # move XMMDst into TMP2, TMP3, TMP4 in order to perform 3 shifts independently
 704         pslld     $31, \TMP2                # packed right shifting << 31
 705         pslld     $30, \TMP3                # packed right shifting << 30
 706         pslld     $25, \TMP4                # packed right shifting << 25
 707         pxor      \TMP3, \TMP2              # xor the shifted versions
 708         pxor      \TMP4, \TMP2
 709         movdqa    \TMP2, \TMP7
 710         psrldq    $4, \TMP7                 # right shift TMP7 1 DW
 711         pslldq    $12, \TMP2                # left shift TMP2 3 DWs
 712         pxor      \TMP2, \XMMDst
 713
 714         # second phase of the reduction
 715         movdqa    \XMMDst, \TMP2
 716         # make 3 copies of XMMDst for doing 3 shift operations
 717         movdqa    \XMMDst, \TMP3
 718         movdqa    \XMMDst, \TMP4
 719         psrld     $1, \TMP2                 # packed left shift >> 1
 720         psrld     $2, \TMP3                 # packed left shift >> 2
 721         psrld     $7, \TMP4                 # packed left shift >> 7
 722         pxor      \TMP3, \TMP2              # xor the shifted versions
 723         pxor      \TMP4, \TMP2
 724         pxor      \TMP7, \TMP2
 725         pxor      \TMP2, \XMMDst
 726         pxor      \TMP6, \XMMDst            # reduced result is in XMMDst
 727 .endm
 728
 729 /* Encryption of a single block done*/
 730 .macro ENCRYPT_SINGLE_BLOCK XMM0 TMP1
 731
 732         pxor    (%arg1), \XMM0
 733         movaps 16(%arg1), \TMP1
 734         AESENC  \TMP1, \XMM0
 735         movaps 32(%arg1), \TMP1
 736         AESENC  \TMP1, \XMM0
 737         movaps 48(%arg1), \TMP1
 738         AESENC  \TMP1, \XMM0
 739         movaps 64(%arg1), \TMP1
 740         AESENC  \TMP1, \XMM0
 741         movaps 80(%arg1), \TMP1
 742         AESENC  \TMP1, \XMM0
 743         movaps 96(%arg1), \TMP1
 744         AESENC  \TMP1, \XMM0
 745         movaps 112(%arg1), \TMP1
 746         AESENC  \TMP1, \XMM0
 747         movaps 128(%arg1), \TMP1
 748         AESENC  \TMP1, \XMM0
 749         movaps 144(%arg1), \TMP1
 750         AESENC  \TMP1, \XMM0
 751         movaps 160(%arg1), \TMP1
 752         AESENCLAST      \TMP1, \XMM0
 753 .endm
 754
 755
 756 /*****************************************************************************
 757 * void aesni_gcm_dec(void *aes_ctx,    // AES Key schedule. Starts on a 16 byte boundary.
 758 *                   u8 *out,           // Plaintext output. Encrypt in-place is allowed.
 759 *                   const u8 *in,      // Ciphertext input
 760 *                   u64 plaintext_len, // Length of data in bytes for decryption.
 761 *                   u8 *iv,            // Pre-counter block j0: 4 byte salt (from Security Association)
 762 *                                      // concatenated with 8 byte Initialisation Vector (from IPSec ESP Payload)
 763 *                                      // concatenated with 0x00000001. 16-byte aligned pointer.
 764 *                   u8 *hash_subkey,   // H, the Hash sub key input. Data starts on a 16-byte boundary.
 765 *                   const u8 *aad,     // Additional Authentication Data (AAD)
 766 *                   u64 aad_len,       // Length of AAD in bytes. With RFC4106 this is going to be 8 or 12 bytes
 767 *                   u8  *auth_tag,     // Authenticated Tag output. The driver will compare this to the
 768 *                                      // given authentication tag and only return the plaintext if they match.
 769 *                   u64 auth_tag_len); // Authenticated Tag Length in bytes. Valid values are 16
 770 *                                      // (most likely), 12 or 8.
 771 *
 772 * Assumptions:
 773 *
 774 * keys:
 775 *       keys are pre-expanded and aligned to 16 bytes. we are using the first
 776 *       set of 11 keys in the data structure void *aes_ctx
 777 *
 778 * iv:
 779 *       0                   1                   2                   3
 780 *       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
 781 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 782 *       |                             Salt  (From the SA)               |
 783 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 784 *       |                     Initialization Vector                     |
 785 *       |         (This is the sequence number from IPSec header)       |
 786 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 787 *       |                              0x1                              |
 788 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 789 *
 790 *
 791 *
 792 * AAD:
 793 *       AAD padded to 128 bits with 0
 794 *       for example, assume AAD is a u32 vector
 795 *
 796 *       if AAD is 8 bytes:
 797 *       AAD[3] = {A0, A1};
 798 *       padded AAD in xmm register = {A1 A0 0 0}
 799 *
 800 *       0                   1                   2                   3
 801 *       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
 802 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 803 *       |                               SPI (A1)                        |
 804 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 805 *       |                     32-bit Sequence Number (A0)               |
 806 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 807 *       |                              0x0                              |
 808 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 809 *
 810 *                                       AAD Format with 32-bit Sequence Number
 811 *
 812 *       if AAD is 12 bytes:
 813 *       AAD[3] = {A0, A1, A2};
 814 *       padded AAD in xmm register = {A2 A1 A0 0}
 815 *
 816 *       0                   1                   2                   3
 817 *       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
 818 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 819 *       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
 820 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 821 *       |                               SPI (A2)                        |
 822 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 823 *       |                 64-bit Extended Sequence Number {A1,A0}       |
 824 *       |                                                               |
 825 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 826 *       |                              0x0                              |
 827 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 828 *
 829 *                        AAD Format with 64-bit Extended Sequence Number
 830 *
 831 * aadLen:
 832 *       from the definition of the spec, aadLen can only be 8 or 12 bytes.
 833 *       The code supports 16 too but for other sizes, the code will fail.
 834 *
 835 * TLen:
 836 *       from the definition of the spec, TLen can only be 8, 12 or 16 bytes.
 837 *       For other sizes, the code will fail.
 838 *
 839 * poly = x^128 + x^127 + x^126 + x^121 + 1
 840 *
 841 *****************************************************************************/
 842
 843 ENTRY(aesni_gcm_dec)
 844         push    %r12
 845         push    %r13
 846         push    %r14
 847         mov     %rsp, %r14
 848 /*
 849 * states of %xmm registers %xmm6:%xmm15 not saved
 850 * all %xmm registers are clobbered
 851 */
 852         sub     $VARIABLE_OFFSET, %rsp
 853         and     $~63, %rsp                        # align rsp to 64 bytes
 854         mov     %arg6, %r12
 855         movdqu  (%r12), %xmm13                    # %xmm13 = HashKey
 856         pshufb  SHUF_MASK(%rip), %xmm13
 857
 858 # Precompute HashKey<<1 (mod poly) from the hash key (required for GHASH)
 859
 860         movdqa  %xmm13, %xmm2
 861         psllq   $1, %xmm13
 862         psrlq   $63, %xmm2
 863         movdqa  %xmm2, %xmm1
 864         pslldq  $8, %xmm2
 865         psrldq  $8, %xmm1
 866         por     %xmm2, %xmm13
 867
 868         # Reduction
 869
 870         pshufd  $0x24, %xmm1, %xmm2
 871         pcmpeqd TWOONE(%rip), %xmm2
 872         pand    POLY(%rip), %xmm2
 873         pxor    %xmm2, %xmm13     # %xmm13 holds the HashKey<<1 (mod poly)
 874
 875
 876         # Decrypt first few blocks
 877
 878         movdqa %xmm13, HashKey(%rsp)           # store HashKey<<1 (mod poly)
 879         mov %arg4, %r13    # save the number of bytes of plaintext/ciphertext
 880         and $-16, %r13                      # %r13 = %r13 - (%r13 mod 16)
 881         mov %r13, %r12
 882         and $(3<<4), %r12
 883         jz _initial_num_blocks_is_0_decrypt
 884         cmp $(2<<4), %r12
 885         jb _initial_num_blocks_is_1_decrypt
 886         je _initial_num_blocks_is_2_decrypt
 887 _initial_num_blocks_is_3_decrypt:
 888         INITIAL_BLOCKS 3, %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
 889 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 5, 678, dec
 890         sub     $48, %r13
 891         jmp     _initial_blocks_decrypted
 892 _initial_num_blocks_is_2_decrypt:
 893         INITIAL_BLOCKS  2, %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
 894 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 6, 78, dec
 895         sub     $32, %r13
 896         jmp     _initial_blocks_decrypted
 897 _initial_num_blocks_is_1_decrypt:
 898         INITIAL_BLOCKS  1, %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
 899 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 7, 8, dec
 900         sub     $16, %r13
 901         jmp     _initial_blocks_decrypted
 902 _initial_num_blocks_is_0_decrypt:
 903         INITIAL_BLOCKS  0, %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
 904 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 8, 0, dec
 905 _initial_blocks_decrypted:
 906         cmp     $0, %r13
 907         je      _zero_cipher_left_decrypt
 908         sub     $64, %r13
 909         je      _four_cipher_left_decrypt
 910 _decrypt_by_4:
 911         GHASH_4_ENCRYPT_4_PARALLEL      %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, \
 912 %xmm14, %xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7, %xmm8, dec
 913         add     $64, %r11
 914         sub     $64, %r13
 915         jne     _decrypt_by_4
 916 _four_cipher_left_decrypt:
 917         GHASH_LAST_4    %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14, \
 918 %xmm15, %xmm1, %xmm2, %xmm3, %xmm4, %xmm8
 919 _zero_cipher_left_decrypt:
 920         mov     %arg4, %r13
 921         and     $15, %r13                               # %r13 = arg4 (mod 16)
 922         je      _multiple_of_16_bytes_decrypt
 923
 924         # Handle the last <16 byte block seperately
 925
 926         paddd ONE(%rip), %xmm0         # increment CNT to get Yn
 927         pshufb SHUF_MASK(%rip), %xmm0
 928         ENCRYPT_SINGLE_BLOCK  %xmm0, %xmm1    # E(K, Yn)
 929         sub $16, %r11
 930         add %r13, %r11
 931         movdqu (%arg3,%r11,1), %xmm1   # recieve the last <16 byte block
 932         lea SHIFT_MASK+16(%rip), %r12
 933         sub %r13, %r12
 934 # adjust the shuffle mask pointer to be able to shift 16-%r13 bytes
 935 # (%r13 is the number of bytes in plaintext mod 16)
 936         movdqu (%r12), %xmm2           # get the appropriate shuffle mask
 937         pshufb %xmm2, %xmm1            # right shift 16-%r13 butes
 938         movdqa  %xmm1, %xmm2
 939         pxor %xmm1, %xmm0            # Ciphertext XOR E(K, Yn)
 940         movdqu ALL_F-SHIFT_MASK(%r12), %xmm1
 941         # get the appropriate mask to mask out top 16-%r13 bytes of %xmm0
 942         pand %xmm1, %xmm0            # mask out top 16-%r13 bytes of %xmm0
 943         pand    %xmm1, %xmm2
 944         pshufb SHUF_MASK(%rip),%xmm2
 945         pxor %xmm2, %xmm8
 946         GHASH_MUL %xmm8, %xmm13, %xmm9, %xmm10, %xmm11, %xmm5, %xmm6
 947                   # GHASH computation for the last <16 byte block
 948         sub %r13, %r11
 949         add $16, %r11
 950
 951         # output %r13 bytes
 952         movq    %xmm0, %rax
 953         cmp     $8, %r13
 954         jle     _less_than_8_bytes_left_decrypt
 955         mov     %rax, (%arg2 , %r11, 1)
 956         add     $8, %r11
 957         psrldq  $8, %xmm0
 958         movq    %xmm0, %rax
 959         sub     $8, %r13
 960 _less_than_8_bytes_left_decrypt:
 961         mov     %al,  (%arg2, %r11, 1)
 962         add     $1, %r11
 963         shr     $8, %rax
 964         sub     $1, %r13
 965         jne     _less_than_8_bytes_left_decrypt
 966 _multiple_of_16_bytes_decrypt:
 967         mov     arg8, %r12                # %r13 = aadLen (number of bytes)
 968         shl     $3, %r12                  # convert into number of bits
 969         movd    %r12d, %xmm15             # len(A) in %xmm15
 970         shl     $3, %arg4                 # len(C) in bits (*128)
 971         movq    %arg4, %xmm1
 972         pslldq  $8, %xmm15                # %xmm15 = len(A)||0x0000000000000000
 973         pxor    %xmm1, %xmm15             # %xmm15 = len(A)||len(C)
 974         pxor    %xmm15, %xmm8
 975         GHASH_MUL       %xmm8, %xmm13, %xmm9, %xmm10, %xmm11, %xmm5, %xmm6
 976                  # final GHASH computation
 977         pshufb  SHUF_MASK(%rip), %xmm8
 978         mov     %arg5, %rax               # %rax = *Y0
 979         movdqu  (%rax), %xmm0             # %xmm0 = Y0
 980         ENCRYPT_SINGLE_BLOCK    %xmm0,  %xmm1     # E(K, Y0)
 981         pxor    %xmm8, %xmm0
 982 _return_T_decrypt:
 983         mov     arg9, %r10                # %r10 = authTag
 984         mov     arg10, %r11               # %r11 = auth_tag_len
 985         cmp     $16, %r11
 986         je      _T_16_decrypt
 987         cmp     $12, %r11
 988         je      _T_12_decrypt
 989 _T_8_decrypt:
 990         movq    %xmm0, %rax
 991         mov     %rax, (%r10)
 992         jmp     _return_T_done_decrypt
 993 _T_12_decrypt:
 994         movq    %xmm0, %rax
 995         mov     %rax, (%r10)
 996         psrldq  $8, %xmm0
 997         movd    %xmm0, %eax
 998         mov     %eax, 8(%r10)
 999         jmp     _return_T_done_decrypt
1000 _T_16_decrypt:
1001         movdqu  %xmm0, (%r10)
1002 _return_T_done_decrypt:
1003         mov     %r14, %rsp
1004         pop     %r14
1005         pop     %r13
1006         pop     %r12
1007         ret
1008
1009
1010 /*****************************************************************************
1011 * void aesni_gcm_enc(void *aes_ctx,      // AES Key schedule. Starts on a 16 byte boundary.
1012 *                    u8 *out,            // Ciphertext output. Encrypt in-place is allowed.
1013 *                    const u8 *in,       // Plaintext input
1014 *                    u64 plaintext_len,  // Length of data in bytes for encryption.
1015 *                    u8 *iv,             // Pre-counter block j0: 4 byte salt (from Security Association)
1016 *                                        // concatenated with 8 byte Initialisation Vector (from IPSec ESP Payload)
1017 *                                        // concatenated with 0x00000001. 16-byte aligned pointer.
1018 *                    u8 *hash_subkey,    // H, the Hash sub key input. Data starts on a 16-byte boundary.
1019 *                    const u8 *aad,      // Additional Authentication Data (AAD)
1020 *                    u64 aad_len,        // Length of AAD in bytes. With RFC4106 this is going to be 8 or 12 bytes
1021 *                    u8 *auth_tag,       // Authenticated Tag output.
1022 *                    u64 auth_tag_len);  // Authenticated Tag Length in bytes. Valid values are 16 (most likely),
1023 *                                        // 12 or 8.
1024 *
1025 * Assumptions:
1026 *
1027 * keys:
1028 *       keys are pre-expanded and aligned to 16 bytes. we are using the
1029 *       first set of 11 keys in the data structure void *aes_ctx
1030 *
1031 *
1032 * iv:
1033 *       0                   1                   2                   3
1034 *       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
1035 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1036 *       |                             Salt  (From the SA)               |
1037 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1038 *       |                     Initialization Vector                     |
1039 *       |         (This is the sequence number from IPSec header)       |
1040 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1041 *       |                              0x1                              |
1042 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1043 *
1044 *
1045 *
1046 * AAD:
1047 *       AAD padded to 128 bits with 0
1048 *       for example, assume AAD is a u32 vector
1049 *
1050 *       if AAD is 8 bytes:
1051 *       AAD[3] = {A0, A1};
1052 *       padded AAD in xmm register = {A1 A0 0 0}
1053 *
1054 *       0                   1                   2                   3
1055 *       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
1056 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1057 *       |                               SPI (A1)                        |
1058 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1059 *       |                     32-bit Sequence Number (A0)               |
1060 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1061 *       |                              0x0                              |
1062 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1063 *
1064 *                                 AAD Format with 32-bit Sequence Number
1065 *
1066 *       if AAD is 12 bytes:
1067 *       AAD[3] = {A0, A1, A2};
1068 *       padded AAD in xmm register = {A2 A1 A0 0}
1069 *
1070 *       0                   1                   2                   3
1071 *       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
1072 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1073 *       |                               SPI (A2)                        |
1074 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1075 *       |                 64-bit Extended Sequence Number {A1,A0}       |
1076 *       |                                                               |
1077 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1078 *       |                              0x0                              |
1079 *       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1080 *
1081 *                         AAD Format with 64-bit Extended Sequence Number
1082 *
1083 * aadLen:
1084 *       from the definition of the spec, aadLen can only be 8 or 12 bytes.
1085 *       The code supports 16 too but for other sizes, the code will fail.
1086 *
1087 * TLen:
1088 *       from the definition of the spec, TLen can only be 8, 12 or 16 bytes.
1089 *       For other sizes, the code will fail.
1090 *
1091 * poly = x^128 + x^127 + x^126 + x^121 + 1
1092 ***************************************************************************/
1093 ENTRY(aesni_gcm_enc)
1094         push    %r12
1095         push    %r13
1096         push    %r14
1097         mov     %rsp, %r14
1098 #
1099 # states of %xmm registers %xmm6:%xmm15 not saved
1100 # all %xmm registers are clobbered
1101 #
1102         sub     $VARIABLE_OFFSET, %rsp
1103         and     $~63, %rsp
1104         mov     %arg6, %r12
1105         movdqu  (%r12), %xmm13
1106         pshufb  SHUF_MASK(%rip), %xmm13
1107
1108 # precompute HashKey<<1 mod poly from the HashKey (required for GHASH)
1109
1110         movdqa  %xmm13, %xmm2
1111         psllq   $1, %xmm13
1112         psrlq   $63, %xmm2
1113         movdqa  %xmm2, %xmm1
1114         pslldq  $8, %xmm2
1115         psrldq  $8, %xmm1
1116         por     %xmm2, %xmm13
1117
1118         # reduce HashKey<<1
1119
1120         pshufd  $0x24, %xmm1, %xmm2
1121         pcmpeqd TWOONE(%rip), %xmm2
1122         pand    POLY(%rip), %xmm2
1123         pxor    %xmm2, %xmm13
1124         movdqa  %xmm13, HashKey(%rsp)
1125         mov     %arg4, %r13            # %xmm13 holds HashKey<<1 (mod poly)
1126         and     $-16, %r13
1127         mov     %r13, %r12
1128
1129         # Encrypt first few blocks
1130
1131         and     $(3<<4), %r12
1132         jz      _initial_num_blocks_is_0_encrypt
1133         cmp     $(2<<4), %r12
1134         jb      _initial_num_blocks_is_1_encrypt
1135         je      _initial_num_blocks_is_2_encrypt
1136 _initial_num_blocks_is_3_encrypt:
1137         INITIAL_BLOCKS  3, %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
1138 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 5, 678, enc
1139         sub     $48, %r13
1140         jmp     _initial_blocks_encrypted
1141 _initial_num_blocks_is_2_encrypt:
1142         INITIAL_BLOCKS  2, %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
1143 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 6, 78, enc
1144         sub     $32, %r13
1145         jmp     _initial_blocks_encrypted
1146 _initial_num_blocks_is_1_encrypt:
1147         INITIAL_BLOCKS  1, %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
1148 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 7, 8, enc
1149         sub     $16, %r13
1150         jmp     _initial_blocks_encrypted
1151 _initial_num_blocks_is_0_encrypt:
1152         INITIAL_BLOCKS  0, %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
1153 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 8, 0, enc
1154 _initial_blocks_encrypted:
1155
1156         # Main loop - Encrypt remaining blocks
1157
1158         cmp     $0, %r13
1159         je      _zero_cipher_left_encrypt
1160         sub     $64, %r13
1161         je      _four_cipher_left_encrypt
1162 _encrypt_by_4_encrypt:
1163         GHASH_4_ENCRYPT_4_PARALLEL      %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, \
1164 %xmm14, %xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7, %xmm8, enc
1165         add     $64, %r11
1166         sub     $64, %r13
1167         jne     _encrypt_by_4_encrypt
1168 _four_cipher_left_encrypt:
1169         GHASH_LAST_4    %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14, \
1170 %xmm15, %xmm1, %xmm2, %xmm3, %xmm4, %xmm8
1171 _zero_cipher_left_encrypt:
1172         mov     %arg4, %r13
1173         and     $15, %r13                       # %r13 = arg4 (mod 16)
1174         je      _multiple_of_16_bytes_encrypt
1175
1176          # Handle the last <16 Byte block seperately
1177         paddd ONE(%rip), %xmm0                # INCR CNT to get Yn
1178         pshufb SHUF_MASK(%rip), %xmm0
1179         ENCRYPT_SINGLE_BLOCK    %xmm0, %xmm1        # Encrypt(K, Yn)
1180         sub $16, %r11
1181         add %r13, %r11
1182         movdqu (%arg3,%r11,1), %xmm1     # receive the last <16 byte blocks
1183         lea SHIFT_MASK+16(%rip), %r12
1184         sub %r13, %r12
1185         # adjust the shuffle mask pointer to be able to shift 16-r13 bytes
1186         # (%r13 is the number of bytes in plaintext mod 16)
1187         movdqu  (%r12), %xmm2           # get the appropriate shuffle mask
1188         pshufb  %xmm2, %xmm1            # shift right 16-r13 byte
1189         pxor    %xmm1, %xmm0            # Plaintext XOR Encrypt(K, Yn)
1190         movdqu  ALL_F-SHIFT_MASK(%r12), %xmm1
1191         # get the appropriate mask to mask out top 16-r13 bytes of xmm0
1192         pand    %xmm1, %xmm0            # mask out top 16-r13 bytes of xmm0
1193
1194         pshufb  SHUF_MASK(%rip),%xmm0
1195         pxor    %xmm0, %xmm8
1196         GHASH_MUL %xmm8, %xmm13, %xmm9, %xmm10, %xmm11, %xmm5, %xmm6
1197         # GHASH computation for the last <16 byte block
1198         sub     %r13, %r11
1199         add     $16, %r11
1200         pshufb SHUF_MASK(%rip), %xmm0
1201         # shuffle xmm0 back to output as ciphertext
1202
1203         # Output %r13 bytes
1204         movq %xmm0, %rax
1205         cmp $8, %r13
1206         jle _less_than_8_bytes_left_encrypt
1207         mov %rax, (%arg2 , %r11, 1)
1208         add $8, %r11
1209         psrldq $8, %xmm0
1210         movq %xmm0, %rax
1211         sub $8, %r13
1212 _less_than_8_bytes_left_encrypt:
1213         mov %al,  (%arg2, %r11, 1)
1214         add $1, %r11
1215         shr $8, %rax
1216         sub $1, %r13
1217         jne _less_than_8_bytes_left_encrypt
1218 _multiple_of_16_bytes_encrypt:
1219         mov     arg8, %r12    # %r12 = addLen (number of bytes)
1220         shl     $3, %r12
1221         movd    %r12d, %xmm15       # len(A) in %xmm15
1222         shl     $3, %arg4               # len(C) in bits (*128)
1223         movq    %arg4, %xmm1
1224         pslldq  $8, %xmm15          # %xmm15 = len(A)||0x0000000000000000
1225         pxor    %xmm1, %xmm15       # %xmm15 = len(A)||len(C)
1226         pxor    %xmm15, %xmm8
1227         GHASH_MUL       %xmm8, %xmm13, %xmm9, %xmm10, %xmm11, %xmm5, %xmm6
1228         # final GHASH computation
1229
1230         pshufb  SHUF_MASK(%rip), %xmm8         # perform a 16 byte swap
1231         mov     %arg5, %rax                    # %rax  = *Y0
1232         movdqu  (%rax), %xmm0                  # %xmm0 = Y0
1233         ENCRYPT_SINGLE_BLOCK    %xmm0, %xmm15         # Encrypt(K, Y0)
1234         pxor    %xmm8, %xmm0
1235 _return_T_encrypt:
1236         mov     arg9, %r10                     # %r10 = authTag
1237         mov     arg10, %r11                    # %r11 = auth_tag_len
1238         cmp     $16, %r11
1239         je      _T_16_encrypt
1240         cmp     $12, %r11
1241         je      _T_12_encrypt
1242 _T_8_encrypt:
1243         movq    %xmm0, %rax
1244         mov     %rax, (%r10)
1245         jmp     _return_T_done_encrypt
1246 _T_12_encrypt:
1247         movq    %xmm0, %rax
1248         mov     %rax, (%r10)
1249         psrldq  $8, %xmm0
1250         movd    %xmm0, %eax
1251         mov     %eax, 8(%r10)
1252         jmp     _return_T_done_encrypt
1253 _T_16_encrypt:
1254         movdqu  %xmm0, (%r10)
1255 _return_T_done_encrypt:
1256         mov     %r14, %rsp
1257         pop     %r14
1258         pop     %r13
1259         pop     %r12
1260         ret
1261 #endif
1262
1263
1264 _key_expansion_128:
1265 _key_expansion_256a:
1266         pshufd $0b11111111, %xmm1, %xmm1
1267         shufps $0b00010000, %xmm0, %xmm4
1268         pxor %xmm4, %xmm0
1269         shufps $0b10001100, %xmm0, %xmm4
1270         pxor %xmm4, %xmm0
1271         pxor %xmm1, %xmm0
1272         movaps %xmm0, (TKEYP)
1273         add $0x10, TKEYP
1274         ret
1275
1276 .align 4
1277 _key_expansion_192a:
1278         pshufd $0b01010101, %xmm1, %xmm1
1279         shufps $0b00010000, %xmm0, %xmm4
1280         pxor %xmm4, %xmm0
1281         shufps $0b10001100, %xmm0, %xmm4
1282         pxor %xmm4, %xmm0
1283         pxor %xmm1, %xmm0
1284
1285         movaps %xmm2, %xmm5
1286         movaps %xmm2, %xmm6
1287         pslldq $4, %xmm5
1288         pshufd $0b11111111, %xmm0, %xmm3
1289         pxor %xmm3, %xmm2
1290         pxor %xmm5, %xmm2
1291
1292         movaps %xmm0, %xmm1
1293         shufps $0b01000100, %xmm0, %xmm6
1294         movaps %xmm6, (TKEYP)
1295         shufps $0b01001110, %xmm2, %xmm1
1296         movaps %xmm1, 0x10(TKEYP)
1297         add $0x20, TKEYP
1298         ret
1299
1300 .align 4
1301 _key_expansion_192b:
1302         pshufd $0b01010101, %xmm1, %xmm1
1303         shufps $0b00010000, %xmm0, %xmm4
1304         pxor %xmm4, %xmm0
1305         shufps $0b10001100, %xmm0, %xmm4
1306         pxor %xmm4, %xmm0
1307         pxor %xmm1, %xmm0
1308
1309         movaps %xmm2, %xmm5
1310         pslldq $4, %xmm5
1311         pshufd $0b11111111, %xmm0, %xmm3
1312         pxor %xmm3, %xmm2
1313         pxor %xmm5, %xmm2
1314
1315         movaps %xmm0, (TKEYP)
1316         add $0x10, TKEYP
1317         ret
1318
1319 .align 4
1320 _key_expansion_256b:
1321         pshufd $0b10101010, %xmm1, %xmm1
1322         shufps $0b00010000, %xmm2, %xmm4
1323         pxor %xmm4, %xmm2
1324         shufps $0b10001100, %xmm2, %xmm4
1325         pxor %xmm4, %xmm2
1326         pxor %xmm1, %xmm2
1327         movaps %xmm2, (TKEYP)
1328         add $0x10, TKEYP
1329         ret
1330
1331 /*
1332  * int aesni_set_key(struct crypto_aes_ctx *ctx, const u8 *in_key,
1333  *                   unsigned int key_len)
1334  */
1335 ENTRY(aesni_set_key)
1336 #ifndef __x86_64__
1337         pushl KEYP
1338         movl 8(%esp), KEYP              # ctx
1339         movl 12(%esp), UKEYP            # in_key
1340         movl 16(%esp), %edx             # key_len
1341 #endif
1342         movups (UKEYP), %xmm0           # user key (first 16 bytes)
1343         movaps %xmm0, (KEYP)
1344         lea 0x10(KEYP), TKEYP           # key addr
1345         movl %edx, 480(KEYP)
1346         pxor %xmm4, %xmm4               # xmm4 is assumed 0 in _key_expansion_x
1347         cmp $24, %dl
1348         jb .Lenc_key128
1349         je .Lenc_key192
1350         movups 0x10(UKEYP), %xmm2       # other user key
1351         movaps %xmm2, (TKEYP)
1352         add $0x10, TKEYP
1353         AESKEYGENASSIST 0x1 %xmm2 %xmm1         # round 1
1354         call _key_expansion_256a
1355         AESKEYGENASSIST 0x1 %xmm0 %xmm1
1356         call _key_expansion_256b
1357         AESKEYGENASSIST 0x2 %xmm2 %xmm1         # round 2
1358         call _key_expansion_256a
1359         AESKEYGENASSIST 0x2 %xmm0 %xmm1
1360         call _key_expansion_256b
1361         AESKEYGENASSIST 0x4 %xmm2 %xmm1         # round 3
1362         call _key_expansion_256a
1363         AESKEYGENASSIST 0x4 %xmm0 %xmm1
1364         call _key_expansion_256b
1365         AESKEYGENASSIST 0x8 %xmm2 %xmm1         # round 4
1366         call _key_expansion_256a
1367         AESKEYGENASSIST 0x8 %xmm0 %xmm1
1368         call _key_expansion_256b
1369         AESKEYGENASSIST 0x10 %xmm2 %xmm1        # round 5
1370         call _key_expansion_256a
1371         AESKEYGENASSIST 0x10 %xmm0 %xmm1
1372         call _key_expansion_256b
1373         AESKEYGENASSIST 0x20 %xmm2 %xmm1        # round 6
1374         call _key_expansion_256a
1375         AESKEYGENASSIST 0x20 %xmm0 %xmm1
1376         call _key_expansion_256b
1377         AESKEYGENASSIST 0x40 %xmm2 %xmm1        # round 7
1378         call _key_expansion_256a
1379         jmp .Ldec_key
1380 .Lenc_key192:
1381         movq 0x10(UKEYP), %xmm2         # other user key
1382         AESKEYGENASSIST 0x1 %xmm2 %xmm1         # round 1
1383         call _key_expansion_192a
1384         AESKEYGENASSIST 0x2 %xmm2 %xmm1         # round 2
1385         call _key_expansion_192b
1386         AESKEYGENASSIST 0x4 %xmm2 %xmm1         # round 3
1387         call _key_expansion_192a
1388         AESKEYGENASSIST 0x8 %xmm2 %xmm1         # round 4
1389         call _key_expansion_192b
1390         AESKEYGENASSIST 0x10 %xmm2 %xmm1        # round 5
1391         call _key_expansion_192a
1392         AESKEYGENASSIST 0x20 %xmm2 %xmm1        # round 6
1393         call _key_expansion_192b
1394         AESKEYGENASSIST 0x40 %xmm2 %xmm1        # round 7
1395         call _key_expansion_192a
1396         AESKEYGENASSIST 0x80 %xmm2 %xmm1        # round 8
1397         call _key_expansion_192b
1398         jmp .Ldec_key
1399 .Lenc_key128:
1400         AESKEYGENASSIST 0x1 %xmm0 %xmm1         # round 1
1401         call _key_expansion_128
1402         AESKEYGENASSIST 0x2 %xmm0 %xmm1         # round 2
1403         call _key_expansion_128
1404         AESKEYGENASSIST 0x4 %xmm0 %xmm1         # round 3
1405         call _key_expansion_128
1406         AESKEYGENASSIST 0x8 %xmm0 %xmm1         # round 4
1407         call _key_expansion_128
1408         AESKEYGENASSIST 0x10 %xmm0 %xmm1        # round 5
1409         call _key_expansion_128
1410         AESKEYGENASSIST 0x20 %xmm0 %xmm1        # round 6
1411         call _key_expansion_128
1412         AESKEYGENASSIST 0x40 %xmm0 %xmm1        # round 7
1413         call _key_expansion_128
1414         AESKEYGENASSIST 0x80 %xmm0 %xmm1        # round 8
1415         call _key_expansion_128
1416         AESKEYGENASSIST 0x1b %xmm0 %xmm1        # round 9
1417         call _key_expansion_128
1418         AESKEYGENASSIST 0x36 %xmm0 %xmm1        # round 10
1419         call _key_expansion_128
1420 .Ldec_key:
1421         sub $0x10, TKEYP
1422         movaps (KEYP), %xmm0
1423         movaps (TKEYP), %xmm1
1424         movaps %xmm0, 240(TKEYP)
1425         movaps %xmm1, 240(KEYP)
1426         add $0x10, KEYP
1427         lea 240-16(TKEYP), UKEYP
1428 .align 4
1429 .Ldec_key_loop:
1430         movaps (KEYP), %xmm0
1431         AESIMC %xmm0 %xmm1
1432         movaps %xmm1, (UKEYP)
1433         add $0x10, KEYP
1434         sub $0x10, UKEYP
1435         cmp TKEYP, KEYP
1436         jb .Ldec_key_loop
1437         xor AREG, AREG
1438 #ifndef __x86_64__
1439         popl KEYP
1440 #endif
1441         ret
1442
1443 /*
1444  * void aesni_enc(struct crypto_aes_ctx *ctx, u8 *dst, const u8 *src)
1445  */
1446 ENTRY(aesni_enc)
1447 #ifndef __x86_64__
1448         pushl KEYP
1449         pushl KLEN
1450         movl 12(%esp), KEYP
1451         movl 16(%esp), OUTP
1452         movl 20(%esp), INP
1453 #endif
1454         movl 480(KEYP), KLEN            # key length
1455         movups (INP), STATE             # input
1456         call _aesni_enc1
1457         movups STATE, (OUTP)            # output
1458 #ifndef __x86_64__
1459         popl KLEN
1460         popl KEYP
1461 #endif
1462         ret
1463
1464 /*
1465  * _aesni_enc1:         internal ABI
1466  * input:
1467  *      KEYP:           key struct pointer
1468  *      KLEN:           round count
1469  *      STATE:          initial state (input)
1470  * output:
1471  *      STATE:          finial state (output)
1472  * changed:
1473  *      KEY
1474  *      TKEYP (T1)
1475  */
1476 .align 4
1477 _aesni_enc1:
1478         movaps (KEYP), KEY              # key
1479         mov KEYP, TKEYP
1480         pxor KEY, STATE         # round 0
1481         add $0x30, TKEYP
1482         cmp $24, KLEN
1483         jb .Lenc128
1484         lea 0x20(TKEYP), TKEYP
1485         je .Lenc192
1486         add $0x20, TKEYP
1487         movaps -0x60(TKEYP), KEY
1488         AESENC KEY STATE
1489         movaps -0x50(TKEYP), KEY
1490         AESENC KEY STATE
1491 .align 4
1492 .Lenc192:
1493         movaps -0x40(TKEYP), KEY
1494         AESENC KEY STATE
1495         movaps -0x30(TKEYP), KEY
1496         AESENC KEY STATE
1497 .align 4
1498 .Lenc128:
1499         movaps -0x20(TKEYP), KEY
1500         AESENC KEY STATE
1501         movaps -0x10(TKEYP), KEY
1502         AESENC KEY STATE
1503         movaps (TKEYP), KEY
1504         AESENC KEY STATE
1505         movaps 0x10(TKEYP), KEY
1506         AESENC KEY STATE
1507         movaps 0x20(TKEYP), KEY
1508         AESENC KEY STATE
1509         movaps 0x30(TKEYP), KEY
1510         AESENC KEY STATE
1511         movaps 0x40(TKEYP), KEY
1512         AESENC KEY STATE
1513         movaps 0x50(TKEYP), KEY
1514         AESENC KEY STATE
1515         movaps 0x60(TKEYP), KEY
1516         AESENC KEY STATE
1517         movaps 0x70(TKEYP), KEY
1518         AESENCLAST KEY STATE
1519         ret
1520
1521 /*
1522  * _aesni_enc4: internal ABI
1523  * input:
1524  *      KEYP:           key struct pointer
1525  *      KLEN:           round count
1526  *      STATE1:         initial state (input)
1527  *      STATE2
1528  *      STATE3
1529  *      STATE4
1530  * output:
1531  *      STATE1:         finial state (output)
1532  *      STATE2
1533  *      STATE3
1534  *      STATE4
1535  * changed:
1536  *      KEY
1537  *      TKEYP (T1)
1538  */
1539 .align 4
1540 _aesni_enc4:
1541         movaps (KEYP), KEY              # key
1542         mov KEYP, TKEYP
1543         pxor KEY, STATE1                # round 0
1544         pxor KEY, STATE2
1545         pxor KEY, STATE3
1546         pxor KEY, STATE4
1547         add $0x30, TKEYP
1548         cmp $24, KLEN
1549         jb .L4enc128
1550         lea 0x20(TKEYP), TKEYP
1551         je .L4enc192
1552         add $0x20, TKEYP
1553         movaps -0x60(TKEYP), KEY
1554         AESENC KEY STATE1
1555         AESENC KEY STATE2
1556         AESENC KEY STATE3
1557         AESENC KEY STATE4
1558         movaps -0x50(TKEYP), KEY
1559         AESENC KEY STATE1
1560         AESENC KEY STATE2
1561         AESENC KEY STATE3
1562         AESENC KEY STATE4
1563 #.align 4
1564 .L4enc192:
1565         movaps -0x40(TKEYP), KEY
1566         AESENC KEY STATE1
1567         AESENC KEY STATE2
1568         AESENC KEY STATE3
1569         AESENC KEY STATE4
1570         movaps -0x30(TKEYP), KEY
1571         AESENC KEY STATE1
1572         AESENC KEY STATE2
1573         AESENC KEY STATE3
1574         AESENC KEY STATE4
1575 #.align 4
1576 .L4enc128:
1577         movaps -0x20(TKEYP), KEY
1578         AESENC KEY STATE1
1579         AESENC KEY STATE2
1580         AESENC KEY STATE3
1581         AESENC KEY STATE4
1582         movaps -0x10(TKEYP), KEY
1583         AESENC KEY STATE1
1584         AESENC KEY STATE2
1585         AESENC KEY STATE3
1586         AESENC KEY STATE4
1587         movaps (TKEYP), KEY
1588         AESENC KEY STATE1
1589         AESENC KEY STATE2
1590         AESENC KEY STATE3
1591         AESENC KEY STATE4
1592         movaps 0x10(TKEYP), KEY
1593         AESENC KEY STATE1
1594         AESENC KEY STATE2
1595         AESENC KEY STATE3
1596         AESENC KEY STATE4
1597         movaps 0x20(TKEYP), KEY
1598         AESENC KEY STATE1
1599         AESENC KEY STATE2
1600         AESENC KEY STATE3
1601         AESENC KEY STATE4
1602         movaps 0x30(TKEYP), KEY
1603         AESENC KEY STATE1
1604         AESENC KEY STATE2
1605         AESENC KEY STATE3
1606         AESENC KEY STATE4
1607         movaps 0x40(TKEYP), KEY
1608         AESENC KEY STATE1
1609         AESENC KEY STATE2
1610         AESENC KEY STATE3
1611         AESENC KEY STATE4
1612         movaps 0x50(TKEYP), KEY
1613         AESENC KEY STATE1
1614         AESENC KEY STATE2
1615         AESENC KEY STATE3
1616         AESENC KEY STATE4
1617         movaps 0x60(TKEYP), KEY
1618         AESENC KEY STATE1
1619         AESENC KEY STATE2
1620         AESENC KEY STATE3
1621         AESENC KEY STATE4
1622         movaps 0x70(TKEYP), KEY
1623         AESENCLAST KEY STATE1           # last round
1624         AESENCLAST KEY STATE2
1625         AESENCLAST KEY STATE3
1626         AESENCLAST KEY STATE4
1627         ret
1628
1629 /*
1630  * void aesni_dec (struct crypto_aes_ctx *ctx, u8 *dst, const u8 *src)
1631  */
1632 ENTRY(aesni_dec)
1633 #ifndef __x86_64__
1634         pushl KEYP
1635         pushl KLEN
1636         movl 12(%esp), KEYP
1637         movl 16(%esp), OUTP
1638         movl 20(%esp), INP
1639 #endif
1640         mov 480(KEYP), KLEN             # key length
1641         add $240, KEYP
1642         movups (INP), STATE             # input
1643         call _aesni_dec1
1644         movups STATE, (OUTP)            #output
1645 #ifndef __x86_64__
1646         popl KLEN
1647         popl KEYP
1648 #endif
1649         ret
1650
1651 /*
1652  * _aesni_dec1:         internal ABI
1653  * input:
1654  *      KEYP:           key struct pointer
1655  *      KLEN:           key length
1656  *      STATE:          initial state (input)
1657  * output:
1658  *      STATE:          finial state (output)
1659  * changed:
1660  *      KEY
1661  *      TKEYP (T1)
1662  */
1663 .align 4
1664 _aesni_dec1:
1665         movaps (KEYP), KEY              # key
1666         mov KEYP, TKEYP
1667         pxor KEY, STATE         # round 0
1668         add $0x30, TKEYP
1669         cmp $24, KLEN
1670         jb .Ldec128
1671         lea 0x20(TKEYP), TKEYP
1672         je .Ldec192
1673         add $0x20, TKEYP
1674         movaps -0x60(TKEYP), KEY
1675         AESDEC KEY STATE
1676         movaps -0x50(TKEYP), KEY
1677         AESDEC KEY STATE
1678 .align 4
1679 .Ldec192:
1680         movaps -0x40(TKEYP), KEY
1681         AESDEC KEY STATE
1682         movaps -0x30(TKEYP), KEY
1683         AESDEC KEY STATE
1684 .align 4
1685 .Ldec128:
1686         movaps -0x20(TKEYP), KEY
1687         AESDEC KEY STATE
1688         movaps -0x10(TKEYP), KEY
1689         AESDEC KEY STATE
1690         movaps (TKEYP), KEY
1691         AESDEC KEY STATE
1692         movaps 0x10(TKEYP), KEY
1693         AESDEC KEY STATE
1694         movaps 0x20(TKEYP), KEY
1695         AESDEC KEY STATE
1696         movaps 0x30(TKEYP), KEY
1697         AESDEC KEY STATE
1698         movaps 0x40(TKEYP), KEY
1699         AESDEC KEY STATE
1700         movaps 0x50(TKEYP), KEY
1701         AESDEC KEY STATE
1702         movaps 0x60(TKEYP), KEY
1703         AESDEC KEY STATE
1704         movaps 0x70(TKEYP), KEY
1705         AESDECLAST KEY STATE
1706         ret
1707
1708 /*
1709  * _aesni_dec4: internal ABI
1710  * input:
1711  *      KEYP:           key struct pointer
1712  *      KLEN:           key length
1713  *      STATE1:         initial state (input)
1714  *      STATE2
1715  *      STATE3
1716  *      STATE4
1717  * output:
1718  *      STATE1:         finial state (output)
1719  *      STATE2
1720  *      STATE3
1721  *      STATE4
1722  * changed:
1723  *      KEY
1724  *      TKEYP (T1)
1725  */
1726 .align 4
1727 _aesni_dec4:
1728         movaps (KEYP), KEY              # key
1729         mov KEYP, TKEYP
1730         pxor KEY, STATE1                # round 0
1731         pxor KEY, STATE2
1732         pxor KEY, STATE3
1733         pxor KEY, STATE4
1734         add $0x30, TKEYP
1735         cmp $24, KLEN
1736         jb .L4dec128
1737         lea 0x20(TKEYP), TKEYP
1738         je .L4dec192
1739         add $0x20, TKEYP
1740         movaps -0x60(TKEYP), KEY
1741         AESDEC KEY STATE1
1742         AESDEC KEY STATE2
1743         AESDEC KEY STATE3
1744         AESDEC KEY STATE4
1745         movaps -0x50(TKEYP), KEY
1746         AESDEC KEY STATE1
1747         AESDEC KEY STATE2
1748         AESDEC KEY STATE3
1749         AESDEC KEY STATE4
1750 .align 4
1751 .L4dec192:
1752         movaps -0x40(TKEYP), KEY
1753         AESDEC KEY STATE1
1754         AESDEC KEY STATE2
1755         AESDEC KEY STATE3
1756         AESDEC KEY STATE4
1757         movaps -0x30(TKEYP), KEY
1758         AESDEC KEY STATE1
1759         AESDEC KEY STATE2
1760         AESDEC KEY STATE3
1761         AESDEC KEY STATE4
1762 .align 4
1763 .L4dec128:
1764         movaps -0x20(TKEYP), KEY
1765         AESDEC KEY STATE1
1766         AESDEC KEY STATE2
1767         AESDEC KEY STATE3
1768         AESDEC KEY STATE4
1769         movaps -0x10(TKEYP), KEY
1770         AESDEC KEY STATE1
1771         AESDEC KEY STATE2
1772         AESDEC KEY STATE3
1773         AESDEC KEY STATE4
1774         movaps (TKEYP), KEY
1775         AESDEC KEY STATE1
1776         AESDEC KEY STATE2
1777         AESDEC KEY STATE3
1778         AESDEC KEY STATE4
1779         movaps 0x10(TKEYP), KEY
1780         AESDEC KEY STATE1
1781         AESDEC KEY STATE2
1782         AESDEC KEY STATE3
1783         AESDEC KEY STATE4
1784         movaps 0x20(TKEYP), KEY
1785         AESDEC KEY STATE1
1786         AESDEC KEY STATE2
1787         AESDEC KEY STATE3
1788         AESDEC KEY STATE4
1789         movaps 0x30(TKEYP), KEY
1790         AESDEC KEY STATE1
1791         AESDEC KEY STATE2
1792         AESDEC KEY STATE3
1793         AESDEC KEY STATE4
1794         movaps 0x40(TKEYP), KEY
1795         AESDEC KEY STATE1
1796         AESDEC KEY STATE2
1797         AESDEC KEY STATE3
1798         AESDEC KEY STATE4
1799         movaps 0x50(TKEYP), KEY
1800         AESDEC KEY STATE1
1801         AESDEC KEY STATE2
1802         AESDEC KEY STATE3
1803         AESDEC KEY STATE4
1804         movaps 0x60(TKEYP), KEY
1805         AESDEC KEY STATE1
1806         AESDEC KEY STATE2
1807         AESDEC KEY STATE3
1808         AESDEC KEY STATE4
1809         movaps 0x70(TKEYP), KEY
1810         AESDECLAST KEY STATE1           # last round
1811         AESDECLAST KEY STATE2
1812         AESDECLAST KEY STATE3
1813         AESDECLAST KEY STATE4
1814         ret
1815
1816 /*
1817  * void aesni_ecb_enc(struct crypto_aes_ctx *ctx, const u8 *dst, u8 *src,
1818  *                    size_t len)
1819  */
1820 ENTRY(aesni_ecb_enc)
1821 #ifndef __x86_64__
1822         pushl LEN
1823         pushl KEYP
1824         pushl KLEN
1825         movl 16(%esp), KEYP
1826         movl 20(%esp), OUTP
1827         movl 24(%esp), INP
1828         movl 28(%esp), LEN
1829 #endif
1830         test LEN, LEN           # check length
1831         jz .Lecb_enc_ret
1832         mov 480(KEYP), KLEN
1833         cmp $16, LEN
1834         jb .Lecb_enc_ret
1835         cmp $64, LEN
1836         jb .Lecb_enc_loop1
1837 .align 4
1838 .Lecb_enc_loop4:
1839         movups (INP), STATE1
1840         movups 0x10(INP), STATE2
1841         movups 0x20(INP), STATE3
1842         movups 0x30(INP), STATE4
1843         call _aesni_enc4
1844         movups STATE1, (OUTP)
1845         movups STATE2, 0x10(OUTP)
1846         movups STATE3, 0x20(OUTP)
1847         movups STATE4, 0x30(OUTP)
1848         sub $64, LEN
1849         add $64, INP
1850         add $64, OUTP
1851         cmp $64, LEN
1852         jge .Lecb_enc_loop4
1853         cmp $16, LEN
1854         jb .Lecb_enc_ret
1855 .align 4
1856 .Lecb_enc_loop1:
1857         movups (INP), STATE1
1858         call _aesni_enc1
1859         movups STATE1, (OUTP)
1860         sub $16, LEN
1861         add $16, INP
1862         add $16, OUTP
1863         cmp $16, LEN
1864         jge .Lecb_enc_loop1
1865 .Lecb_enc_ret:
1866 #ifndef __x86_64__
1867         popl KLEN
1868         popl KEYP
1869         popl LEN
1870 #endif
1871         ret
1872
1873 /*
1874  * void aesni_ecb_dec(struct crypto_aes_ctx *ctx, const u8 *dst, u8 *src,
1875  *                    size_t len);
1876  */
1877 ENTRY(aesni_ecb_dec)
1878 #ifndef __x86_64__
1879         pushl LEN
1880         pushl KEYP
1881         pushl KLEN
1882         movl 16(%esp), KEYP
1883         movl 20(%esp), OUTP
1884         movl 24(%esp), INP
1885         movl 28(%esp), LEN
1886 #endif
1887         test LEN, LEN
1888         jz .Lecb_dec_ret
1889         mov 480(KEYP), KLEN
1890         add $240, KEYP
1891         cmp $16, LEN
1892         jb .Lecb_dec_ret
1893         cmp $64, LEN
1894         jb .Lecb_dec_loop1
1895 .align 4
1896 .Lecb_dec_loop4:
1897         movups (INP), STATE1
1898         movups 0x10(INP), STATE2
1899         movups 0x20(INP), STATE3
1900         movups 0x30(INP), STATE4
1901         call _aesni_dec4
1902         movups STATE1, (OUTP)
1903         movups STATE2, 0x10(OUTP)
1904         movups STATE3, 0x20(OUTP)
1905         movups STATE4, 0x30(OUTP)
1906         sub $64, LEN
1907         add $64, INP
1908         add $64, OUTP
1909         cmp $64, LEN
1910         jge .Lecb_dec_loop4
1911         cmp $16, LEN
1912         jb .Lecb_dec_ret
1913 .align 4
1914 .Lecb_dec_loop1:
1915         movups (INP), STATE1
1916         call _aesni_dec1
1917         movups STATE1, (OUTP)
1918         sub $16, LEN
1919         add $16, INP
1920         add $16, OUTP
1921         cmp $16, LEN
1922         jge .Lecb_dec_loop1
1923 .Lecb_dec_ret:
1924 #ifndef __x86_64__
1925         popl KLEN
1926         popl KEYP
1927         popl LEN
1928 #endif
1929         ret
1930
1931 /*
1932  * void aesni_cbc_enc(struct crypto_aes_ctx *ctx, const u8 *dst, u8 *src,
1933  *                    size_t len, u8 *iv)
1934  */
1935 ENTRY(aesni_cbc_enc)
1936 #ifndef __x86_64__
1937         pushl IVP
1938         pushl LEN
1939         pushl KEYP
1940         pushl KLEN
1941         movl 20(%esp), KEYP
1942         movl 24(%esp), OUTP
1943         movl 28(%esp), INP
1944         movl 32(%esp), LEN
1945         movl 36(%esp), IVP
1946 #endif
1947         cmp $16, LEN
1948         jb .Lcbc_enc_ret
1949         mov 480(KEYP), KLEN
1950         movups (IVP), STATE     # load iv as initial state
1951 .align 4
1952 .Lcbc_enc_loop:
1953         movups (INP), IN        # load input
1954         pxor IN, STATE
1955         call _aesni_enc1
1956         movups STATE, (OUTP)    # store output
1957         sub $16, LEN
1958         add $16, INP
1959         add $16, OUTP
1960         cmp $16, LEN
1961         jge .Lcbc_enc_loop
1962         movups STATE, (IVP)
1963 .Lcbc_enc_ret:
1964 #ifndef __x86_64__
1965         popl KLEN
1966         popl KEYP
1967         popl LEN
1968         popl IVP
1969 #endif
1970         ret
1971
1972 /*
1973  * void aesni_cbc_dec(struct crypto_aes_ctx *ctx, const u8 *dst, u8 *src,
1974  *                    size_t len, u8 *iv)
1975  */
1976 ENTRY(aesni_cbc_dec)
1977 #ifndef __x86_64__
1978         pushl IVP
1979         pushl LEN
1980         pushl KEYP
1981         pushl KLEN
1982         movl 20(%esp), KEYP
1983         movl 24(%esp), OUTP
1984         movl 28(%esp), INP
1985         movl 32(%esp), LEN
1986         movl 36(%esp), IVP
1987 #endif
1988         cmp $16, LEN
1989         jb .Lcbc_dec_just_ret
1990         mov 480(KEYP), KLEN
1991         add $240, KEYP
1992         movups (IVP), IV
1993         cmp $64, LEN
1994         jb .Lcbc_dec_loop1
1995 .align 4
1996 .Lcbc_dec_loop4:
1997         movups (INP), IN1
1998         movaps IN1, STATE1
1999         movups 0x10(INP), IN2
2000         movaps IN2, STATE2
2001 #ifdef __x86_64__
2002         movups 0x20(INP), IN3
2003         movaps IN3, STATE3
2004         movups 0x30(INP), IN4
2005         movaps IN4, STATE4
2006 #else
2007         movups 0x20(INP), IN1
2008         movaps IN1, STATE3
2009         movups 0x30(INP), IN2
2010         movaps IN2, STATE4
2011 #endif
2012         call _aesni_dec4
2013         pxor IV, STATE1
2014 #ifdef __x86_64__
2015         pxor IN1, STATE2
2016         pxor IN2, STATE3
2017         pxor IN3, STATE4
2018         movaps IN4, IV
2019 #else
2020         pxor (INP), STATE2
2021         pxor 0x10(INP), STATE3
2022         pxor IN1, STATE4
2023         movaps IN2, IV
2024 #endif
2025         movups STATE1, (OUTP)
2026         movups STATE2, 0x10(OUTP)
2027         movups STATE3, 0x20(OUTP)
2028         movups STATE4, 0x30(OUTP)
2029         sub $64, LEN
2030         add $64, INP
2031         add $64, OUTP
2032         cmp $64, LEN
2033         jge .Lcbc_dec_loop4
2034         cmp $16, LEN
2035         jb .Lcbc_dec_ret
2036 .align 4
2037 .Lcbc_dec_loop1:
2038         movups (INP), IN
2039         movaps IN, STATE
2040         call _aesni_dec1
2041         pxor IV, STATE
2042         movups STATE, (OUTP)
2043         movaps IN, IV
2044         sub $16, LEN
2045         add $16, INP
2046         add $16, OUTP
2047         cmp $16, LEN
2048         jge .Lcbc_dec_loop1
2049 .Lcbc_dec_ret:
2050         movups IV, (IVP)
2051 .Lcbc_dec_just_ret:
2052 #ifndef __x86_64__
2053         popl KLEN
2054         popl KEYP
2055         popl LEN
2056         popl IVP
2057 #endif
2058         ret
2059
2060 #ifdef __x86_64__
2061 .align 16
2062 .Lbswap_mask:
2063         .byte 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
2064
2065 /*
2066  * _aesni_inc_init:     internal ABI
2067  *      setup registers used by _aesni_inc
2068  * input:
2069  *      IV
2070  * output:
2071  *      CTR:    == IV, in little endian
2072  *      TCTR_LOW: == lower qword of CTR
2073  *      INC:    == 1, in little endian
2074  *      BSWAP_MASK == endian swapping mask
2075  */
2076 .align 4
2077 _aesni_inc_init:
2078         movaps .Lbswap_mask, BSWAP_MASK
2079         movaps IV, CTR
2080         PSHUFB_XMM BSWAP_MASK CTR
2081         mov $1, TCTR_LOW
2082         MOVQ_R64_XMM TCTR_LOW INC
2083         MOVQ_R64_XMM CTR TCTR_LOW
2084         ret
2085
2086 /*
2087  * _aesni_inc:          internal ABI
2088  *      Increase IV by 1, IV is in big endian
2089  * input:
2090  *      IV
2091  *      CTR:    == IV, in little endian
2092  *      TCTR_LOW: == lower qword of CTR
2093  *      INC:    == 1, in little endian
2094  *      BSWAP_MASK == endian swapping mask
2095  * output:
2096  *      IV:     Increase by 1
2097  * changed:
2098  *      CTR:    == output IV, in little endian
2099  *      TCTR_LOW: == lower qword of CTR
2100  */
2101 .align 4
2102 _aesni_inc:
2103         paddq INC, CTR
2104         add $1, TCTR_LOW
2105         jnc .Linc_low
2106         pslldq $8, INC
2107         paddq INC, CTR
2108         psrldq $8, INC
2109 .Linc_low:
2110         movaps CTR, IV
2111         PSHUFB_XMM BSWAP_MASK IV
2112         ret
2113
2114 /*
2115  * void aesni_ctr_enc(struct crypto_aes_ctx *ctx, const u8 *dst, u8 *src,
2116  *                    size_t len, u8 *iv)
2117  */
2118 ENTRY(aesni_ctr_enc)
2119         cmp $16, LEN
2120         jb .Lctr_enc_just_ret
2121         mov 480(KEYP), KLEN
2122         movups (IVP), IV
2123         call _aesni_inc_init
2124         cmp $64, LEN
2125         jb .Lctr_enc_loop1
2126 .align 4
2127 .Lctr_enc_loop4:
2128         movaps IV, STATE1
2129         call _aesni_inc
2130         movups (INP), IN1
2131         movaps IV, STATE2
2132         call _aesni_inc
2133         movups 0x10(INP), IN2
2134         movaps IV, STATE3
2135         call _aesni_inc
2136         movups 0x20(INP), IN3
2137         movaps IV, STATE4
2138         call _aesni_inc
2139         movups 0x30(INP), IN4
2140         call _aesni_enc4
2141         pxor IN1, STATE1
2142         movups STATE1, (OUTP)
2143         pxor IN2, STATE2
2144         movups STATE2, 0x10(OUTP)
2145         pxor IN3, STATE3
2146         movups STATE3, 0x20(OUTP)
2147         pxor IN4, STATE4
2148         movups STATE4, 0x30(OUTP)
2149         sub $64, LEN
2150         add $64, INP
2151         add $64, OUTP
2152         cmp $64, LEN
2153         jge .Lctr_enc_loop4
2154         cmp $16, LEN
2155         jb .Lctr_enc_ret
2156 .align 4
2157 .Lctr_enc_loop1:
2158         movaps IV, STATE
2159         call _aesni_inc
2160         movups (INP), IN
2161         call _aesni_enc1
2162         pxor IN, STATE
2163         movups STATE, (OUTP)
2164         sub $16, LEN
2165         add $16, INP
2166         add $16, OUTP
2167         cmp $16, LEN
2168         jge .Lctr_enc_loop1
2169 .Lctr_enc_ret:
2170         movups IV, (IVP)
2171 .Lctr_enc_just_ret:
2172         ret
2173 #endif