arch/x86/crypto/morus1280-sse2-asm.S

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * SSE2 implementation of MORUS-1280
   4  *
   5  * Copyright (c) 2017-2018 Ondrej Mosnacek <omosnacek@gmail.com>
   6  * Copyright (C) 2017-2018 Red Hat, Inc. All rights reserved.
   7  */
   8
   9 #include <linux/linkage.h>
  10 #include <asm/frame.h>
  11
  12 #define SHUFFLE_MASK(i0, i1, i2, i3) \
  13         (i0 | (i1 << 2) | (i2 << 4) | (i3 << 6))
  14
  15 #define MASK2 SHUFFLE_MASK(2, 3, 0, 1)
  16
  17 #define STATE0_LO       %xmm0
  18 #define STATE0_HI       %xmm1
  19 #define STATE1_LO       %xmm2
  20 #define STATE1_HI       %xmm3
  21 #define STATE2_LO       %xmm4
  22 #define STATE2_HI       %xmm5
  23 #define STATE3_LO       %xmm6
  24 #define STATE3_HI       %xmm7
  25 #define STATE4_LO       %xmm8
  26 #define STATE4_HI       %xmm9
  27 #define KEY_LO          %xmm10
  28 #define KEY_HI          %xmm11
  29 #define MSG_LO          %xmm10
  30 #define MSG_HI          %xmm11
  31 #define T0_LO           %xmm12
  32 #define T0_HI           %xmm13
  33 #define T1_LO           %xmm14
  34 #define T1_HI           %xmm15
  35
  36 .section .rodata.cst16.morus640_const, "aM", @progbits, 16
  37 .align 16
  38 .Lmorus640_const_0:
  39         .byte 0x00, 0x01, 0x01, 0x02, 0x03, 0x05, 0x08, 0x0d
  40         .byte 0x15, 0x22, 0x37, 0x59, 0x90, 0xe9, 0x79, 0x62
  41 .Lmorus640_const_1:
  42         .byte 0xdb, 0x3d, 0x18, 0x55, 0x6d, 0xc2, 0x2f, 0xf1
  43         .byte 0x20, 0x11, 0x31, 0x42, 0x73, 0xb5, 0x28, 0xdd
  44
  45 .section .rodata.cst16.morus640_counter, "aM", @progbits, 16
  46 .align 16
  47 .Lmorus640_counter_0:
  48         .byte 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
  49         .byte 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
  50 .Lmorus640_counter_1:
  51         .byte 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17
  52         .byte 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
  53
  54 .text
  55
  56 .macro rol1 hi, lo
  57         /*
  58          * HI_1 | HI_0 || LO_1 | LO_0
  59          *  ==>
  60          * HI_0 | HI_1 || LO_1 | LO_0
  61          *  ==>
  62          * HI_0 | LO_1 || LO_0 | HI_1
  63          */
  64         pshufd $MASK2, \hi, \hi
  65         movdqa \hi, T0_LO
  66         punpcklqdq \lo, T0_LO
  67         punpckhqdq \hi, \lo
  68         movdqa \lo, \hi
  69         movdqa T0_LO, \lo
  70 .endm
  71
  72 .macro rol2 hi, lo
  73         movdqa \lo, T0_LO
  74         movdqa \hi, \lo
  75         movdqa T0_LO, \hi
  76 .endm
  77
  78 .macro rol3 hi, lo
  79         /*
  80          * HI_1 | HI_0 || LO_1 | LO_0
  81          *  ==>
  82          * HI_0 | HI_1 || LO_1 | LO_0
  83          *  ==>
  84          * LO_0 | HI_1 || HI_0 | LO_1
  85          */
  86         pshufd $MASK2, \hi, \hi
  87         movdqa \lo, T0_LO
  88         punpckhqdq \hi, T0_LO
  89         punpcklqdq \lo, \hi
  90         movdqa T0_LO, \lo
  91 .endm
  92
  93 .macro morus1280_round s0_l, s0_h, s1_l, s1_h, s2_l, s2_h, s3_l, s3_h, s4_l, s4_h, b, w
  94         movdqa \s1_l, T0_LO
  95         pand \s2_l, T0_LO
  96         pxor T0_LO, \s0_l
  97
  98         movdqa \s1_h, T0_LO
  99         pand \s2_h, T0_LO
 100         pxor T0_LO, \s0_h
 101
 102         pxor \s3_l, \s0_l
 103         pxor \s3_h, \s0_h
 104
 105         movdqa \s0_l, T0_LO
 106         psllq $\b, T0_LO
 107         psrlq $(64 - \b), \s0_l
 108         pxor T0_LO, \s0_l
 109
 110         movdqa \s0_h, T0_LO
 111         psllq $\b, T0_LO
 112         psrlq $(64 - \b), \s0_h
 113         pxor T0_LO, \s0_h
 114
 115         \w \s3_h, \s3_l
 116 .endm
 117
 118 /*
 119  * __morus1280_update: internal ABI
 120  * input:
 121  *   STATE[0-4] - input state
 122  *   MSG        - message block
 123  * output:
 124  *   STATE[0-4] - output state
 125  * changed:
 126  *   T0
 127  */
 128 __morus1280_update:
 129         morus1280_round \
 130                 STATE0_LO, STATE0_HI, \
 131                 STATE1_LO, STATE1_HI, \
 132                 STATE2_LO, STATE2_HI, \
 133                 STATE3_LO, STATE3_HI, \
 134                 STATE4_LO, STATE4_HI, \
 135                 13, rol1
 136         pxor MSG_LO, STATE1_LO
 137         pxor MSG_HI, STATE1_HI
 138         morus1280_round \
 139                 STATE1_LO, STATE1_HI, \
 140                 STATE2_LO, STATE2_HI, \
 141                 STATE3_LO, STATE3_HI, \
 142                 STATE4_LO, STATE4_HI, \
 143                 STATE0_LO, STATE0_HI, \
 144                 46, rol2
 145         pxor MSG_LO, STATE2_LO
 146         pxor MSG_HI, STATE2_HI
 147         morus1280_round \
 148                 STATE2_LO, STATE2_HI, \
 149                 STATE3_LO, STATE3_HI, \
 150                 STATE4_LO, STATE4_HI, \
 151                 STATE0_LO, STATE0_HI, \
 152                 STATE1_LO, STATE1_HI, \
 153                 38, rol3
 154         pxor MSG_LO, STATE3_LO
 155         pxor MSG_HI, STATE3_HI
 156         morus1280_round \
 157                 STATE3_LO, STATE3_HI, \
 158                 STATE4_LO, STATE4_HI, \
 159                 STATE0_LO, STATE0_HI, \
 160                 STATE1_LO, STATE1_HI, \
 161                 STATE2_LO, STATE2_HI, \
 162                 7, rol2
 163         pxor MSG_LO, STATE4_LO
 164         pxor MSG_HI, STATE4_HI
 165         morus1280_round \
 166                 STATE4_LO, STATE4_HI, \
 167                 STATE0_LO, STATE0_HI, \
 168                 STATE1_LO, STATE1_HI, \
 169                 STATE2_LO, STATE2_HI, \
 170                 STATE3_LO, STATE3_HI, \
 171                 4, rol1
 172         ret
 173 ENDPROC(__morus1280_update)
 174
 175 /*
 176  * __morus1280_update_zero: internal ABI
 177  * input:
 178  *   STATE[0-4] - input state
 179  * output:
 180  *   STATE[0-4] - output state
 181  * changed:
 182  *   T0
 183  */
 184 __morus1280_update_zero:
 185         morus1280_round \
 186                 STATE0_LO, STATE0_HI, \
 187                 STATE1_LO, STATE1_HI, \
 188                 STATE2_LO, STATE2_HI, \
 189                 STATE3_LO, STATE3_HI, \
 190                 STATE4_LO, STATE4_HI, \
 191                 13, rol1
 192         morus1280_round \
 193                 STATE1_LO, STATE1_HI, \
 194                 STATE2_LO, STATE2_HI, \
 195                 STATE3_LO, STATE3_HI, \
 196                 STATE4_LO, STATE4_HI, \
 197                 STATE0_LO, STATE0_HI, \
 198                 46, rol2
 199         morus1280_round \
 200                 STATE2_LO, STATE2_HI, \
 201                 STATE3_LO, STATE3_HI, \
 202                 STATE4_LO, STATE4_HI, \
 203                 STATE0_LO, STATE0_HI, \
 204                 STATE1_LO, STATE1_HI, \
 205                 38, rol3
 206         morus1280_round \
 207                 STATE3_LO, STATE3_HI, \
 208                 STATE4_LO, STATE4_HI, \
 209                 STATE0_LO, STATE0_HI, \
 210                 STATE1_LO, STATE1_HI, \
 211                 STATE2_LO, STATE2_HI, \
 212                 7, rol2
 213         morus1280_round \
 214                 STATE4_LO, STATE4_HI, \
 215                 STATE0_LO, STATE0_HI, \
 216                 STATE1_LO, STATE1_HI, \
 217                 STATE2_LO, STATE2_HI, \
 218                 STATE3_LO, STATE3_HI, \
 219                 4, rol1
 220         ret
 221 ENDPROC(__morus1280_update_zero)
 222
 223 /*
 224  * __load_partial: internal ABI
 225  * input:
 226  *   %rsi - src
 227  *   %rcx - bytes
 228  * output:
 229  *   MSG  - message block
 230  * changed:
 231  *   %r8
 232  *   %r9
 233  */
 234 __load_partial:
 235         xor %r9d, %r9d
 236         pxor MSG_LO, MSG_LO
 237         pxor MSG_HI, MSG_HI
 238
 239         mov %rcx, %r8
 240         and $0x1, %r8
 241         jz .Lld_partial_1
 242
 243         mov %rcx, %r8
 244         and $0x1E, %r8
 245         add %rsi, %r8
 246         mov (%r8), %r9b
 247
 248 .Lld_partial_1:
 249         mov %rcx, %r8
 250         and $0x2, %r8
 251         jz .Lld_partial_2
 252
 253         mov %rcx, %r8
 254         and $0x1C, %r8
 255         add %rsi, %r8
 256         shl $16, %r9
 257         mov (%r8), %r9w
 258
 259 .Lld_partial_2:
 260         mov %rcx, %r8
 261         and $0x4, %r8
 262         jz .Lld_partial_4
 263
 264         mov %rcx, %r8
 265         and $0x18, %r8
 266         add %rsi, %r8
 267         shl $32, %r9
 268         mov (%r8), %r8d
 269         xor %r8, %r9
 270
 271 .Lld_partial_4:
 272         movq %r9, MSG_LO
 273
 274         mov %rcx, %r8
 275         and $0x8, %r8
 276         jz .Lld_partial_8
 277
 278         mov %rcx, %r8
 279         and $0x10, %r8
 280         add %rsi, %r8
 281         pslldq $8, MSG_LO
 282         movq (%r8), T0_LO
 283         pxor T0_LO, MSG_LO
 284
 285 .Lld_partial_8:
 286         mov %rcx, %r8
 287         and $0x10, %r8
 288         jz .Lld_partial_16
 289
 290         movdqa MSG_LO, MSG_HI
 291         movdqu (%rsi), MSG_LO
 292
 293 .Lld_partial_16:
 294         ret
 295 ENDPROC(__load_partial)
 296
 297 /*
 298  * __store_partial: internal ABI
 299  * input:
 300  *   %rdx - dst
 301  *   %rcx - bytes
 302  * output:
 303  *   T0   - message block
 304  * changed:
 305  *   %r8
 306  *   %r9
 307  *   %r10
 308  */
 309 __store_partial:
 310         mov %rcx, %r8
 311         mov %rdx, %r9
 312
 313         cmp $16, %r8
 314         jl .Lst_partial_16
 315
 316         movdqu T0_LO, (%r9)
 317         movdqa T0_HI, T0_LO
 318
 319         sub $16, %r8
 320         add $16, %r9
 321
 322 .Lst_partial_16:
 323         movq T0_LO, %r10
 324
 325         cmp $8, %r8
 326         jl .Lst_partial_8
 327
 328         mov %r10, (%r9)
 329         psrldq $8, T0_LO
 330         movq T0_LO, %r10
 331
 332         sub $8, %r8
 333         add $8, %r9
 334
 335 .Lst_partial_8:
 336         cmp $4, %r8
 337         jl .Lst_partial_4
 338
 339         mov %r10d, (%r9)
 340         shr $32, %r10
 341
 342         sub $4, %r8
 343         add $4, %r9
 344
 345 .Lst_partial_4:
 346         cmp $2, %r8
 347         jl .Lst_partial_2
 348
 349         mov %r10w, (%r9)
 350         shr $16, %r10
 351
 352         sub $2, %r8
 353         add $2, %r9
 354
 355 .Lst_partial_2:
 356         cmp $1, %r8
 357         jl .Lst_partial_1
 358
 359         mov %r10b, (%r9)
 360
 361 .Lst_partial_1:
 362         ret
 363 ENDPROC(__store_partial)
 364
 365 /*
 366  * void crypto_morus1280_sse2_init(void *state, const void *key,
 367  *                                 const void *iv);
 368  */
 369 ENTRY(crypto_morus1280_sse2_init)
 370         FRAME_BEGIN
 371
 372         /* load IV: */
 373         pxor STATE0_HI, STATE0_HI
 374         movdqu (%rdx), STATE0_LO
 375         /* load key: */
 376         movdqu  0(%rsi), KEY_LO
 377         movdqu 16(%rsi), KEY_HI
 378         movdqa KEY_LO, STATE1_LO
 379         movdqa KEY_HI, STATE1_HI
 380         /* load all ones: */
 381         pcmpeqd STATE2_LO, STATE2_LO
 382         pcmpeqd STATE2_HI, STATE2_HI
 383         /* load all zeros: */
 384         pxor STATE3_LO, STATE3_LO
 385         pxor STATE3_HI, STATE3_HI
 386         /* load the constant: */
 387         movdqa .Lmorus640_const_0, STATE4_LO
 388         movdqa .Lmorus640_const_1, STATE4_HI
 389
 390         /* update 16 times with zero: */
 391         call __morus1280_update_zero
 392         call __morus1280_update_zero
 393         call __morus1280_update_zero
 394         call __morus1280_update_zero
 395         call __morus1280_update_zero
 396         call __morus1280_update_zero
 397         call __morus1280_update_zero
 398         call __morus1280_update_zero
 399         call __morus1280_update_zero
 400         call __morus1280_update_zero
 401         call __morus1280_update_zero
 402         call __morus1280_update_zero
 403         call __morus1280_update_zero
 404         call __morus1280_update_zero
 405         call __morus1280_update_zero
 406         call __morus1280_update_zero
 407
 408         /* xor-in the key again after updates: */
 409         pxor KEY_LO, STATE1_LO
 410         pxor KEY_HI, STATE1_HI
 411
 412         /* store the state: */
 413         movdqu STATE0_LO, (0 * 16)(%rdi)
 414         movdqu STATE0_HI, (1 * 16)(%rdi)
 415         movdqu STATE1_LO, (2 * 16)(%rdi)
 416         movdqu STATE1_HI, (3 * 16)(%rdi)
 417         movdqu STATE2_LO, (4 * 16)(%rdi)
 418         movdqu STATE2_HI, (5 * 16)(%rdi)
 419         movdqu STATE3_LO, (6 * 16)(%rdi)
 420         movdqu STATE3_HI, (7 * 16)(%rdi)
 421         movdqu STATE4_LO, (8 * 16)(%rdi)
 422         movdqu STATE4_HI, (9 * 16)(%rdi)
 423
 424         FRAME_END
 425         ret
 426 ENDPROC(crypto_morus1280_sse2_init)
 427
 428 /*
 429  * void crypto_morus1280_sse2_ad(void *state, const void *data,
 430  *                               unsigned int length);
 431  */
 432 ENTRY(crypto_morus1280_sse2_ad)
 433         FRAME_BEGIN
 434
 435         cmp $32, %rdx
 436         jb .Lad_out
 437
 438         /* load the state: */
 439         movdqu (0 * 16)(%rdi), STATE0_LO
 440         movdqu (1 * 16)(%rdi), STATE0_HI
 441         movdqu (2 * 16)(%rdi), STATE1_LO
 442         movdqu (3 * 16)(%rdi), STATE1_HI
 443         movdqu (4 * 16)(%rdi), STATE2_LO
 444         movdqu (5 * 16)(%rdi), STATE2_HI
 445         movdqu (6 * 16)(%rdi), STATE3_LO
 446         movdqu (7 * 16)(%rdi), STATE3_HI
 447         movdqu (8 * 16)(%rdi), STATE4_LO
 448         movdqu (9 * 16)(%rdi), STATE4_HI
 449
 450         mov %rsi, %r8
 451         and $0xF, %r8
 452         jnz .Lad_u_loop
 453
 454 .align 4
 455 .Lad_a_loop:
 456         movdqa  0(%rsi), MSG_LO
 457         movdqa 16(%rsi), MSG_HI
 458         call __morus1280_update
 459         sub $32, %rdx
 460         add $32, %rsi
 461         cmp $32, %rdx
 462         jge .Lad_a_loop
 463
 464         jmp .Lad_cont
 465 .align 4
 466 .Lad_u_loop:
 467         movdqu  0(%rsi), MSG_LO
 468         movdqu 16(%rsi), MSG_HI
 469         call __morus1280_update
 470         sub $32, %rdx
 471         add $32, %rsi
 472         cmp $32, %rdx
 473         jge .Lad_u_loop
 474
 475 .Lad_cont:
 476         /* store the state: */
 477         movdqu STATE0_LO, (0 * 16)(%rdi)
 478         movdqu STATE0_HI, (1 * 16)(%rdi)
 479         movdqu STATE1_LO, (2 * 16)(%rdi)
 480         movdqu STATE1_HI, (3 * 16)(%rdi)
 481         movdqu STATE2_LO, (4 * 16)(%rdi)
 482         movdqu STATE2_HI, (5 * 16)(%rdi)
 483         movdqu STATE3_LO, (6 * 16)(%rdi)
 484         movdqu STATE3_HI, (7 * 16)(%rdi)
 485         movdqu STATE4_LO, (8 * 16)(%rdi)
 486         movdqu STATE4_HI, (9 * 16)(%rdi)
 487
 488 .Lad_out:
 489         FRAME_END
 490         ret
 491 ENDPROC(crypto_morus1280_sse2_ad)
 492
 493 /*
 494  * void crypto_morus1280_sse2_enc(void *state, const void *src, void *dst,
 495  *                                unsigned int length);
 496  */
 497 ENTRY(crypto_morus1280_sse2_enc)
 498         FRAME_BEGIN
 499
 500         cmp $32, %rcx
 501         jb .Lenc_out
 502
 503         /* load the state: */
 504         movdqu (0 * 16)(%rdi), STATE0_LO
 505         movdqu (1 * 16)(%rdi), STATE0_HI
 506         movdqu (2 * 16)(%rdi), STATE1_LO
 507         movdqu (3 * 16)(%rdi), STATE1_HI
 508         movdqu (4 * 16)(%rdi), STATE2_LO
 509         movdqu (5 * 16)(%rdi), STATE2_HI
 510         movdqu (6 * 16)(%rdi), STATE3_LO
 511         movdqu (7 * 16)(%rdi), STATE3_HI
 512         movdqu (8 * 16)(%rdi), STATE4_LO
 513         movdqu (9 * 16)(%rdi), STATE4_HI
 514
 515         mov %rsi, %r8
 516         or  %rdx, %r8
 517         and $0xF, %r8
 518         jnz .Lenc_u_loop
 519
 520 .align 4
 521 .Lenc_a_loop:
 522         movdqa  0(%rsi), MSG_LO
 523         movdqa 16(%rsi), MSG_HI
 524         movdqa STATE1_LO, T1_LO
 525         movdqa STATE1_HI, T1_HI
 526         rol3 T1_HI, T1_LO
 527         movdqa MSG_LO, T0_LO
 528         movdqa MSG_HI, T0_HI
 529         pxor T1_LO, T0_LO
 530         pxor T1_HI, T0_HI
 531         pxor STATE0_LO, T0_LO
 532         pxor STATE0_HI, T0_HI
 533         movdqa STATE2_LO, T1_LO
 534         movdqa STATE2_HI, T1_HI
 535         pand STATE3_LO, T1_LO
 536         pand STATE3_HI, T1_HI
 537         pxor T1_LO, T0_LO
 538         pxor T1_HI, T0_HI
 539         movdqa T0_LO,  0(%rdx)
 540         movdqa T0_HI, 16(%rdx)
 541
 542         call __morus1280_update
 543         sub $32, %rcx
 544         add $32, %rsi
 545         add $32, %rdx
 546         cmp $32, %rcx
 547         jge .Lenc_a_loop
 548
 549         jmp .Lenc_cont
 550 .align 4
 551 .Lenc_u_loop:
 552         movdqu  0(%rsi), MSG_LO
 553         movdqu 16(%rsi), MSG_HI
 554         movdqa STATE1_LO, T1_LO
 555         movdqa STATE1_HI, T1_HI
 556         rol3 T1_HI, T1_LO
 557         movdqa MSG_LO, T0_LO
 558         movdqa MSG_HI, T0_HI
 559         pxor T1_LO, T0_LO
 560         pxor T1_HI, T0_HI
 561         pxor STATE0_LO, T0_LO
 562         pxor STATE0_HI, T0_HI
 563         movdqa STATE2_LO, T1_LO
 564         movdqa STATE2_HI, T1_HI
 565         pand STATE3_LO, T1_LO
 566         pand STATE3_HI, T1_HI
 567         pxor T1_LO, T0_LO
 568         pxor T1_HI, T0_HI
 569         movdqu T0_LO,  0(%rdx)
 570         movdqu T0_HI, 16(%rdx)
 571
 572         call __morus1280_update
 573         sub $32, %rcx
 574         add $32, %rsi
 575         add $32, %rdx
 576         cmp $32, %rcx
 577         jge .Lenc_u_loop
 578
 579 .Lenc_cont:
 580         /* store the state: */
 581         movdqu STATE0_LO, (0 * 16)(%rdi)
 582         movdqu STATE0_HI, (1 * 16)(%rdi)
 583         movdqu STATE1_LO, (2 * 16)(%rdi)
 584         movdqu STATE1_HI, (3 * 16)(%rdi)
 585         movdqu STATE2_LO, (4 * 16)(%rdi)
 586         movdqu STATE2_HI, (5 * 16)(%rdi)
 587         movdqu STATE3_LO, (6 * 16)(%rdi)
 588         movdqu STATE3_HI, (7 * 16)(%rdi)
 589         movdqu STATE4_LO, (8 * 16)(%rdi)
 590         movdqu STATE4_HI, (9 * 16)(%rdi)
 591
 592 .Lenc_out:
 593         FRAME_END
 594         ret
 595 ENDPROC(crypto_morus1280_sse2_enc)
 596
 597 /*
 598  * void crypto_morus1280_sse2_enc_tail(void *state, const void *src, void *dst,
 599  *                                     unsigned int length);
 600  */
 601 ENTRY(crypto_morus1280_sse2_enc_tail)
 602         FRAME_BEGIN
 603
 604         /* load the state: */
 605         movdqu (0 * 16)(%rdi), STATE0_LO
 606         movdqu (1 * 16)(%rdi), STATE0_HI
 607         movdqu (2 * 16)(%rdi), STATE1_LO
 608         movdqu (3 * 16)(%rdi), STATE1_HI
 609         movdqu (4 * 16)(%rdi), STATE2_LO
 610         movdqu (5 * 16)(%rdi), STATE2_HI
 611         movdqu (6 * 16)(%rdi), STATE3_LO
 612         movdqu (7 * 16)(%rdi), STATE3_HI
 613         movdqu (8 * 16)(%rdi), STATE4_LO
 614         movdqu (9 * 16)(%rdi), STATE4_HI
 615
 616         /* encrypt message: */
 617         call __load_partial
 618
 619         movdqa STATE1_LO, T1_LO
 620         movdqa STATE1_HI, T1_HI
 621         rol3 T1_HI, T1_LO
 622         movdqa MSG_LO, T0_LO
 623         movdqa MSG_HI, T0_HI
 624         pxor T1_LO, T0_LO
 625         pxor T1_HI, T0_HI
 626         pxor STATE0_LO, T0_LO
 627         pxor STATE0_HI, T0_HI
 628         movdqa STATE2_LO, T1_LO
 629         movdqa STATE2_HI, T1_HI
 630         pand STATE3_LO, T1_LO
 631         pand STATE3_HI, T1_HI
 632         pxor T1_LO, T0_LO
 633         pxor T1_HI, T0_HI
 634
 635         call __store_partial
 636
 637         call __morus1280_update
 638
 639         /* store the state: */
 640         movdqu STATE0_LO, (0 * 16)(%rdi)
 641         movdqu STATE0_HI, (1 * 16)(%rdi)
 642         movdqu STATE1_LO, (2 * 16)(%rdi)
 643         movdqu STATE1_HI, (3 * 16)(%rdi)
 644         movdqu STATE2_LO, (4 * 16)(%rdi)
 645         movdqu STATE2_HI, (5 * 16)(%rdi)
 646         movdqu STATE3_LO, (6 * 16)(%rdi)
 647         movdqu STATE3_HI, (7 * 16)(%rdi)
 648         movdqu STATE4_LO, (8 * 16)(%rdi)
 649         movdqu STATE4_HI, (9 * 16)(%rdi)
 650
 651         FRAME_END
 652         ret
 653 ENDPROC(crypto_morus1280_sse2_enc_tail)
 654
 655 /*
 656  * void crypto_morus1280_sse2_dec(void *state, const void *src, void *dst,
 657  *                                unsigned int length);
 658  */
 659 ENTRY(crypto_morus1280_sse2_dec)
 660         FRAME_BEGIN
 661
 662         cmp $32, %rcx
 663         jb .Ldec_out
 664
 665         /* load the state: */
 666         movdqu (0 * 16)(%rdi), STATE0_LO
 667         movdqu (1 * 16)(%rdi), STATE0_HI
 668         movdqu (2 * 16)(%rdi), STATE1_LO
 669         movdqu (3 * 16)(%rdi), STATE1_HI
 670         movdqu (4 * 16)(%rdi), STATE2_LO
 671         movdqu (5 * 16)(%rdi), STATE2_HI
 672         movdqu (6 * 16)(%rdi), STATE3_LO
 673         movdqu (7 * 16)(%rdi), STATE3_HI
 674         movdqu (8 * 16)(%rdi), STATE4_LO
 675         movdqu (9 * 16)(%rdi), STATE4_HI
 676
 677         mov %rsi, %r8
 678         or  %rdx, %r8
 679         and $0xF, %r8
 680         jnz .Ldec_u_loop
 681
 682 .align 4
 683 .Ldec_a_loop:
 684         movdqa  0(%rsi), MSG_LO
 685         movdqa 16(%rsi), MSG_HI
 686         pxor STATE0_LO, MSG_LO
 687         pxor STATE0_HI, MSG_HI
 688         movdqa STATE1_LO, T1_LO
 689         movdqa STATE1_HI, T1_HI
 690         rol3 T1_HI, T1_LO
 691         pxor T1_LO, MSG_LO
 692         pxor T1_HI, MSG_HI
 693         movdqa STATE2_LO, T1_LO
 694         movdqa STATE2_HI, T1_HI
 695         pand STATE3_LO, T1_LO
 696         pand STATE3_HI, T1_HI
 697         pxor T1_LO, MSG_LO
 698         pxor T1_HI, MSG_HI
 699         movdqa MSG_LO,  0(%rdx)
 700         movdqa MSG_HI, 16(%rdx)
 701
 702         call __morus1280_update
 703         sub $32, %rcx
 704         add $32, %rsi
 705         add $32, %rdx
 706         cmp $32, %rcx
 707         jge .Ldec_a_loop
 708
 709         jmp .Ldec_cont
 710 .align 4
 711 .Ldec_u_loop:
 712         movdqu  0(%rsi), MSG_LO
 713         movdqu 16(%rsi), MSG_HI
 714         pxor STATE0_LO, MSG_LO
 715         pxor STATE0_HI, MSG_HI
 716         movdqa STATE1_LO, T1_LO
 717         movdqa STATE1_HI, T1_HI
 718         rol3 T1_HI, T1_LO
 719         pxor T1_LO, MSG_LO
 720         pxor T1_HI, MSG_HI
 721         movdqa STATE2_LO, T1_LO
 722         movdqa STATE2_HI, T1_HI
 723         pand STATE3_LO, T1_LO
 724         pand STATE3_HI, T1_HI
 725         pxor T1_LO, MSG_LO
 726         pxor T1_HI, MSG_HI
 727         movdqu MSG_LO,  0(%rdx)
 728         movdqu MSG_HI, 16(%rdx)
 729
 730         call __morus1280_update
 731         sub $32, %rcx
 732         add $32, %rsi
 733         add $32, %rdx
 734         cmp $32, %rcx
 735         jge .Ldec_u_loop
 736
 737 .Ldec_cont:
 738         /* store the state: */
 739         movdqu STATE0_LO, (0 * 16)(%rdi)
 740         movdqu STATE0_HI, (1 * 16)(%rdi)
 741         movdqu STATE1_LO, (2 * 16)(%rdi)
 742         movdqu STATE1_HI, (3 * 16)(%rdi)
 743         movdqu STATE2_LO, (4 * 16)(%rdi)
 744         movdqu STATE2_HI, (5 * 16)(%rdi)
 745         movdqu STATE3_LO, (6 * 16)(%rdi)
 746         movdqu STATE3_HI, (7 * 16)(%rdi)
 747         movdqu STATE4_LO, (8 * 16)(%rdi)
 748         movdqu STATE4_HI, (9 * 16)(%rdi)
 749
 750 .Ldec_out:
 751         FRAME_END
 752         ret
 753 ENDPROC(crypto_morus1280_sse2_dec)
 754
 755 /*
 756  * void crypto_morus1280_sse2_dec_tail(void *state, const void *src, void *dst,
 757  *                                     unsigned int length);
 758  */
 759 ENTRY(crypto_morus1280_sse2_dec_tail)
 760         FRAME_BEGIN
 761
 762         /* load the state: */
 763         movdqu (0 * 16)(%rdi), STATE0_LO
 764         movdqu (1 * 16)(%rdi), STATE0_HI
 765         movdqu (2 * 16)(%rdi), STATE1_LO
 766         movdqu (3 * 16)(%rdi), STATE1_HI
 767         movdqu (4 * 16)(%rdi), STATE2_LO
 768         movdqu (5 * 16)(%rdi), STATE2_HI
 769         movdqu (6 * 16)(%rdi), STATE3_LO
 770         movdqu (7 * 16)(%rdi), STATE3_HI
 771         movdqu (8 * 16)(%rdi), STATE4_LO
 772         movdqu (9 * 16)(%rdi), STATE4_HI
 773
 774         /* decrypt message: */
 775         call __load_partial
 776
 777         pxor STATE0_LO, MSG_LO
 778         pxor STATE0_HI, MSG_HI
 779         movdqa STATE1_LO, T1_LO
 780         movdqa STATE1_HI, T1_HI
 781         rol3 T1_HI, T1_LO
 782         pxor T1_LO, MSG_LO
 783         pxor T1_HI, MSG_HI
 784         movdqa STATE2_LO, T1_LO
 785         movdqa STATE2_HI, T1_HI
 786         pand STATE3_LO, T1_LO
 787         pand STATE3_HI, T1_HI
 788         pxor T1_LO, MSG_LO
 789         pxor T1_HI, MSG_HI
 790         movdqa MSG_LO, T0_LO
 791         movdqa MSG_HI, T0_HI
 792
 793         call __store_partial
 794
 795         /* mask with byte count: */
 796         movq %rcx, T0_LO
 797         punpcklbw T0_LO, T0_LO
 798         punpcklbw T0_LO, T0_LO
 799         punpcklbw T0_LO, T0_LO
 800         punpcklbw T0_LO, T0_LO
 801         movdqa T0_LO, T0_HI
 802         movdqa .Lmorus640_counter_0, T1_LO
 803         movdqa .Lmorus640_counter_1, T1_HI
 804         pcmpgtb T1_LO, T0_LO
 805         pcmpgtb T1_HI, T0_HI
 806         pand T0_LO, MSG_LO
 807         pand T0_HI, MSG_HI
 808
 809         call __morus1280_update
 810
 811         /* store the state: */
 812         movdqu STATE0_LO, (0 * 16)(%rdi)
 813         movdqu STATE0_HI, (1 * 16)(%rdi)
 814         movdqu STATE1_LO, (2 * 16)(%rdi)
 815         movdqu STATE1_HI, (3 * 16)(%rdi)
 816         movdqu STATE2_LO, (4 * 16)(%rdi)
 817         movdqu STATE2_HI, (5 * 16)(%rdi)
 818         movdqu STATE3_LO, (6 * 16)(%rdi)
 819         movdqu STATE3_HI, (7 * 16)(%rdi)
 820         movdqu STATE4_LO, (8 * 16)(%rdi)
 821         movdqu STATE4_HI, (9 * 16)(%rdi)
 822
 823         FRAME_END
 824         ret
 825 ENDPROC(crypto_morus1280_sse2_dec_tail)
 826
 827 /*
 828  * void crypto_morus1280_sse2_final(void *state, void *tag_xor,
 829  *                                  u64 assoclen, u64 cryptlen);
 830  */
 831 ENTRY(crypto_morus1280_sse2_final)
 832         FRAME_BEGIN
 833
 834         /* load the state: */
 835         movdqu (0 * 16)(%rdi), STATE0_LO
 836         movdqu (1 * 16)(%rdi), STATE0_HI
 837         movdqu (2 * 16)(%rdi), STATE1_LO
 838         movdqu (3 * 16)(%rdi), STATE1_HI
 839         movdqu (4 * 16)(%rdi), STATE2_LO
 840         movdqu (5 * 16)(%rdi), STATE2_HI
 841         movdqu (6 * 16)(%rdi), STATE3_LO
 842         movdqu (7 * 16)(%rdi), STATE3_HI
 843         movdqu (8 * 16)(%rdi), STATE4_LO
 844         movdqu (9 * 16)(%rdi), STATE4_HI
 845
 846         /* xor state[0] into state[4]: */
 847         pxor STATE0_LO, STATE4_LO
 848         pxor STATE0_HI, STATE4_HI
 849
 850         /* prepare length block: */
 851         movq %rdx, MSG_LO
 852         movq %rcx, T0_LO
 853         pslldq $8, T0_LO
 854         pxor T0_LO, MSG_LO
 855         psllq $3, MSG_LO /* multiply by 8 (to get bit count) */
 856         pxor MSG_HI, MSG_HI
 857
 858         /* update state: */
 859         call __morus1280_update
 860         call __morus1280_update
 861         call __morus1280_update
 862         call __morus1280_update
 863         call __morus1280_update
 864         call __morus1280_update
 865         call __morus1280_update
 866         call __morus1280_update
 867         call __morus1280_update
 868         call __morus1280_update
 869
 870         /* xor tag: */
 871         movdqu  0(%rsi), MSG_LO
 872         movdqu 16(%rsi), MSG_HI
 873
 874         pxor STATE0_LO, MSG_LO
 875         pxor STATE0_HI, MSG_HI
 876         movdqa STATE1_LO, T0_LO
 877         movdqa STATE1_HI, T0_HI
 878         rol3 T0_HI, T0_LO
 879         pxor T0_LO, MSG_LO
 880         pxor T0_HI, MSG_HI
 881         movdqa STATE2_LO, T0_LO
 882         movdqa STATE2_HI, T0_HI
 883         pand STATE3_LO, T0_LO
 884         pand STATE3_HI, T0_HI
 885         pxor T0_LO, MSG_LO
 886         pxor T0_HI, MSG_HI
 887
 888         movdqu MSG_LO,  0(%rsi)
 889         movdqu MSG_HI, 16(%rsi)
 890
 891         FRAME_END
 892         ret
 893 ENDPROC(crypto_morus1280_sse2_final)