Gitweb:     
http://git.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=987c75d7170686804b404b7f917b9e4b703702ff
Commit:     987c75d7170686804b404b7f917b9e4b703702ff
Parent:     9a163ed8e0552fdcffe405d2ea7134819a81456e
Author:     Thomas Gleixner <[EMAIL PROTECTED]>
AuthorDate: Thu Oct 11 11:17:03 2007 +0200
Committer:  Thomas Gleixner <[EMAIL PROTECTED]>
CommitDate: Thu Oct 11 11:17:03 2007 +0200

    x86_64: move crypto
    
    Signed-off-by: Thomas Gleixner <[EMAIL PROTECTED]>
    Signed-off-by: Ingo Molnar <[EMAIL PROTECTED]>
---
 arch/x86/crypto/Makefile                   |    2 +-
 arch/x86/crypto/Makefile_64                |   12 +
 arch/x86/crypto/aes-x86_64-asm_64.S        |  190 ++++++++++++++++
 arch/x86/crypto/aes_64.c                   |  336 ++++++++++++++++++++++++++++
 arch/x86/crypto/twofish-x86_64-asm_64.S    |  324 +++++++++++++++++++++++++++
 arch/x86/crypto/twofish_64.c               |   97 ++++++++
 arch/x86_64/Makefile                       |    2 +-
 arch/x86_64/crypto/Makefile                |    5 -
 arch/x86_64/crypto/Makefile_64             |   12 -
 arch/x86_64/crypto/aes-x86_64-asm_64.S     |  190 ----------------
 arch/x86_64/crypto/aes_64.c                |  336 ----------------------------
 arch/x86_64/crypto/twofish-x86_64-asm_64.S |  324 ---------------------------
 arch/x86_64/crypto/twofish_64.c            |   97 --------
 13 files changed, 961 insertions(+), 966 deletions(-)

diff --git a/arch/x86/crypto/Makefile b/arch/x86/crypto/Makefile
index b1bcf7c..18dcdc6 100644
--- a/arch/x86/crypto/Makefile
+++ b/arch/x86/crypto/Makefile
@@ -1,5 +1,5 @@
 ifeq ($(CONFIG_X86_32),y)
 include ${srctree}/arch/x86/crypto/Makefile_32
 else
-include ${srctree}/arch/x86_64/crypto/Makefile_64
+include ${srctree}/arch/x86/crypto/Makefile_64
 endif
diff --git a/arch/x86/crypto/Makefile_64 b/arch/x86/crypto/Makefile_64
new file mode 100644
index 0000000..b408962
--- /dev/null
+++ b/arch/x86/crypto/Makefile_64
@@ -0,0 +1,12 @@
+# 
+# x86/crypto/Makefile 
+# 
+# Arch-specific CryptoAPI modules.
+# 
+
+obj-$(CONFIG_CRYPTO_AES_X86_64) += aes-x86_64.o
+obj-$(CONFIG_CRYPTO_TWOFISH_X86_64) += twofish-x86_64.o
+
+aes-x86_64-y := aes-x86_64-asm_64.o aes_64.o
+twofish-x86_64-y := twofish-x86_64-asm_64.o twofish_64.o
+
diff --git a/arch/x86/crypto/aes-x86_64-asm_64.S 
b/arch/x86/crypto/aes-x86_64-asm_64.S
new file mode 100644
index 0000000..26b40de
--- /dev/null
+++ b/arch/x86/crypto/aes-x86_64-asm_64.S
@@ -0,0 +1,190 @@
+/* AES (Rijndael) implementation (FIPS PUB 197) for x86_64
+ *
+ * Copyright (C) 2005 Andreas Steinmetz, <[EMAIL PROTECTED]>
+ *
+ * License:
+ * This code can be distributed under the terms of the GNU General Public
+ * License (GPL) Version 2 provided that the above header down to and
+ * including this sentence is retained in full.
+ */
+
+.extern aes_ft_tab
+.extern aes_it_tab
+.extern aes_fl_tab
+.extern aes_il_tab
+
+.text
+
+#include <asm/asm-offsets.h>
+
+#define BASE crypto_tfm_ctx_offset
+
+#define R1     %rax
+#define R1E    %eax
+#define R1X    %ax
+#define R1H    %ah
+#define R1L    %al
+#define R2     %rbx
+#define R2E    %ebx
+#define R2X    %bx
+#define R2H    %bh
+#define R2L    %bl
+#define R3     %rcx
+#define R3E    %ecx
+#define R3X    %cx
+#define R3H    %ch
+#define R3L    %cl
+#define R4     %rdx
+#define R4E    %edx
+#define R4X    %dx
+#define R4H    %dh
+#define R4L    %dl
+#define R5     %rsi
+#define R5E    %esi
+#define R6     %rdi
+#define R6E    %edi
+#define R7     %rbp
+#define R7E    %ebp
+#define R8     %r8
+#define R9     %r9
+#define R10    %r10
+#define R11    %r11
+
+#define prologue(FUNC,KEY,B128,B192,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11) \
+       .global FUNC;                   \
+       .type   FUNC,@function;         \
+       .align  8;                      \
+FUNC:  movq    r1,r2;                  \
+       movq    r3,r4;                  \
+       leaq    BASE+KEY+52(r8),r9;     \
+       movq    r10,r11;                \
+       movl    (r7),r5 ## E;           \
+       movl    4(r7),r1 ## E;          \
+       movl    8(r7),r6 ## E;          \
+       movl    12(r7),r7 ## E;         \
+       movl    BASE(r8),r10 ## E;      \
+       xorl    -48(r9),r5 ## E;        \
+       xorl    -44(r9),r1 ## E;        \
+       xorl    -40(r9),r6 ## E;        \
+       xorl    -36(r9),r7 ## E;        \
+       cmpl    $24,r10 ## E;           \
+       jb      B128;                   \
+       leaq    32(r9),r9;              \
+       je      B192;                   \
+       leaq    32(r9),r9;
+
+#define epilogue(r1,r2,r3,r4,r5,r6,r7,r8,r9) \
+       movq    r1,r2;                  \
+       movq    r3,r4;                  \
+       movl    r5 ## E,(r9);           \
+       movl    r6 ## E,4(r9);          \
+       movl    r7 ## E,8(r9);          \
+       movl    r8 ## E,12(r9);         \
+       ret;
+
+#define round(TAB,OFFSET,r1,r2,r3,r4,r5,r6,r7,r8,ra,rb,rc,rd) \
+       movzbl  r2 ## H,r5 ## E;        \
+       movzbl  r2 ## L,r6 ## E;        \
+       movl    TAB+1024(,r5,4),r5 ## E;\
+       movw    r4 ## X,r2 ## X;        \
+       movl    TAB(,r6,4),r6 ## E;     \
+       roll    $16,r2 ## E;            \
+       shrl    $16,r4 ## E;            \
+       movzbl  r4 ## H,r7 ## E;        \
+       movzbl  r4 ## L,r4 ## E;        \
+       xorl    OFFSET(r8),ra ## E;     \
+       xorl    OFFSET+4(r8),rb ## E;   \
+       xorl    TAB+3072(,r7,4),r5 ## E;\
+       xorl    TAB+2048(,r4,4),r6 ## E;\
+       movzbl  r1 ## L,r7 ## E;        \
+       movzbl  r1 ## H,r4 ## E;        \
+       movl    TAB+1024(,r4,4),r4 ## E;\
+       movw    r3 ## X,r1 ## X;        \
+       roll    $16,r1 ## E;            \
+       shrl    $16,r3 ## E;            \
+       xorl    TAB(,r7,4),r5 ## E;     \
+       movzbl  r3 ## H,r7 ## E;        \
+       movzbl  r3 ## L,r3 ## E;        \
+       xorl    TAB+3072(,r7,4),r4 ## E;\
+       xorl    TAB+2048(,r3,4),r5 ## E;\
+       movzbl  r1 ## H,r7 ## E;        \
+       movzbl  r1 ## L,r3 ## E;        \
+       shrl    $16,r1 ## E;            \
+       xorl    TAB+3072(,r7,4),r6 ## E;\
+       movl    TAB+2048(,r3,4),r3 ## E;\
+       movzbl  r1 ## H,r7 ## E;        \
+       movzbl  r1 ## L,r1 ## E;        \
+       xorl    TAB+1024(,r7,4),r6 ## E;\
+       xorl    TAB(,r1,4),r3 ## E;     \
+       movzbl  r2 ## H,r1 ## E;        \
+       movzbl  r2 ## L,r7 ## E;        \
+       shrl    $16,r2 ## E;            \
+       xorl    TAB+3072(,r1,4),r3 ## E;\
+       xorl    TAB+2048(,r7,4),r4 ## E;\
+       movzbl  r2 ## H,r1 ## E;        \
+       movzbl  r2 ## L,r2 ## E;        \
+       xorl    OFFSET+8(r8),rc ## E;   \
+       xorl    OFFSET+12(r8),rd ## E;  \
+       xorl    TAB+1024(,r1,4),r3 ## E;\
+       xorl    TAB(,r2,4),r4 ## E;
+
+#define move_regs(r1,r2,r3,r4) \
+       movl    r3 ## E,r1 ## E;        \
+       movl    r4 ## E,r2 ## E;
+
+#define entry(FUNC,KEY,B128,B192) \
+       prologue(FUNC,KEY,B128,B192,R2,R8,R7,R9,R1,R3,R4,R6,R10,R5,R11)
+
+#define return epilogue(R8,R2,R9,R7,R5,R6,R3,R4,R11)
+
+#define encrypt_round(TAB,OFFSET) \
+       round(TAB,OFFSET,R1,R2,R3,R4,R5,R6,R7,R10,R5,R6,R3,R4) \
+       move_regs(R1,R2,R5,R6)
+
+#define encrypt_final(TAB,OFFSET) \
+       round(TAB,OFFSET,R1,R2,R3,R4,R5,R6,R7,R10,R5,R6,R3,R4)
+
+#define decrypt_round(TAB,OFFSET) \
+       round(TAB,OFFSET,R2,R1,R4,R3,R6,R5,R7,R10,R5,R6,R3,R4) \
+       move_regs(R1,R2,R5,R6)
+
+#define decrypt_final(TAB,OFFSET) \
+       round(TAB,OFFSET,R2,R1,R4,R3,R6,R5,R7,R10,R5,R6,R3,R4)
+
+/* void aes_enc_blk(stuct crypto_tfm *tfm, u8 *out, const u8 *in) */
+
+       entry(aes_enc_blk,0,enc128,enc192)
+       encrypt_round(aes_ft_tab,-96)
+       encrypt_round(aes_ft_tab,-80)
+enc192:        encrypt_round(aes_ft_tab,-64)
+       encrypt_round(aes_ft_tab,-48)
+enc128:        encrypt_round(aes_ft_tab,-32)
+       encrypt_round(aes_ft_tab,-16)
+       encrypt_round(aes_ft_tab,  0)
+       encrypt_round(aes_ft_tab, 16)
+       encrypt_round(aes_ft_tab, 32)
+       encrypt_round(aes_ft_tab, 48)
+       encrypt_round(aes_ft_tab, 64)
+       encrypt_round(aes_ft_tab, 80)
+       encrypt_round(aes_ft_tab, 96)
+       encrypt_final(aes_fl_tab,112)
+       return
+
+/* void aes_dec_blk(struct crypto_tfm *tfm, u8 *out, const u8 *in) */
+
+       entry(aes_dec_blk,240,dec128,dec192)
+       decrypt_round(aes_it_tab,-96)
+       decrypt_round(aes_it_tab,-80)
+dec192:        decrypt_round(aes_it_tab,-64)
+       decrypt_round(aes_it_tab,-48)
+dec128:        decrypt_round(aes_it_tab,-32)
+       decrypt_round(aes_it_tab,-16)
+       decrypt_round(aes_it_tab,  0)
+       decrypt_round(aes_it_tab, 16)
+       decrypt_round(aes_it_tab, 32)
+       decrypt_round(aes_it_tab, 48)
+       decrypt_round(aes_it_tab, 64)
+       decrypt_round(aes_it_tab, 80)
+       decrypt_round(aes_it_tab, 96)
+       decrypt_final(aes_il_tab,112)
+       return
diff --git a/arch/x86/crypto/aes_64.c b/arch/x86/crypto/aes_64.c
new file mode 100644
index 0000000..5cdb13e
--- /dev/null
+++ b/arch/x86/crypto/aes_64.c
@@ -0,0 +1,336 @@
+/*
+ * Cryptographic API.
+ *
+ * AES Cipher Algorithm.
+ *
+ * Based on Brian Gladman's code.
+ *
+ * Linux developers:
+ *  Alexander Kjeldaas <[EMAIL PROTECTED]>
+ *  Herbert Valerio Riedel <[EMAIL PROTECTED]>
+ *  Kyle McMartin <[EMAIL PROTECTED]>
+ *  Adam J. Richter <[EMAIL PROTECTED]> (conversion to 2.5 API).
+ *  Andreas Steinmetz <[EMAIL PROTECTED]> (adapted to x86_64 assembler)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * ---------------------------------------------------------------------------
+ * Copyright (c) 2002, Dr Brian Gladman <[EMAIL PROTECTED]>, Worcester, UK.
+ * All rights reserved.
+ *
+ * LICENSE TERMS
+ *
+ * The free distribution and use of this software in both source and binary
+ * form is allowed (with or without changes) provided that:
+ *
+ *   1. distributions of this source code include the above copyright
+ *      notice, this list of conditions and the following disclaimer;
+ *
+ *   2. distributions in binary form include the above copyright
+ *      notice, this list of conditions and the following disclaimer
+ *      in the documentation and/or other associated materials;
+ *
+ *   3. the copyright holder's name is not used to endorse products
+ *      built using this software without specific written permission.
+ *
+ * ALTERNATIVELY, provided that this notice is retained in full, this product
+ * may be distributed under the terms of the GNU General Public License (GPL),
+ * in which case the provisions of the GPL apply INSTEAD OF those given above.
+ *
+ * DISCLAIMER
+ *
+ * This software is provided 'as is' with no explicit or implied warranties
+ * in respect of its properties, including, but not limited to, correctness
+ * and/or fitness for purpose.
+ * ---------------------------------------------------------------------------
+ */
+
+/* Some changes from the Gladman version:
+    s/RIJNDAEL(e_key)/E_KEY/g
+    s/RIJNDAEL(d_key)/D_KEY/g
+*/
+
+#include <asm/byteorder.h>
+#include <linux/bitops.h>
+#include <linux/crypto.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/types.h>
+
+#define AES_MIN_KEY_SIZE       16
+#define AES_MAX_KEY_SIZE       32
+
+#define AES_BLOCK_SIZE         16
+
+/*
+ * #define byte(x, nr) ((unsigned char)((x) >> (nr*8)))
+ */
+static inline u8 byte(const u32 x, const unsigned n)
+{
+       return x >> (n << 3);
+}
+
+struct aes_ctx
+{
+       u32 key_length;
+       u32 buf[120];
+};
+
+#define E_KEY (&ctx->buf[0])
+#define D_KEY (&ctx->buf[60])
+
+static u8 pow_tab[256] __initdata;
+static u8 log_tab[256] __initdata;
+static u8 sbx_tab[256] __initdata;
+static u8 isb_tab[256] __initdata;
+static u32 rco_tab[10];
+u32 aes_ft_tab[4][256];
+u32 aes_it_tab[4][256];
+
+u32 aes_fl_tab[4][256];
+u32 aes_il_tab[4][256];
+
+static inline u8 f_mult(u8 a, u8 b)
+{
+       u8 aa = log_tab[a], cc = aa + log_tab[b];
+
+       return pow_tab[cc + (cc < aa ? 1 : 0)];
+}
+
+#define ff_mult(a, b) (a && b ? f_mult(a, b) : 0)
+
+#define ls_box(x)                              \
+       (aes_fl_tab[0][byte(x, 0)] ^            \
+        aes_fl_tab[1][byte(x, 1)] ^            \
+        aes_fl_tab[2][byte(x, 2)] ^            \
+        aes_fl_tab[3][byte(x, 3)])
+
+static void __init gen_tabs(void)
+{
+       u32 i, t;
+       u8 p, q;
+
+       /* log and power tables for GF(2**8) finite field with
+          0x011b as modular polynomial - the simplest primitive
+          root is 0x03, used here to generate the tables */
+
+       for (i = 0, p = 1; i < 256; ++i) {
+               pow_tab[i] = (u8)p;
+               log_tab[p] = (u8)i;
+
+               p ^= (p << 1) ^ (p & 0x80 ? 0x01b : 0);
+       }
+
+       log_tab[1] = 0;
+
+       for (i = 0, p = 1; i < 10; ++i) {
+               rco_tab[i] = p;
+
+               p = (p << 1) ^ (p & 0x80 ? 0x01b : 0);
+       }
+
+       for (i = 0; i < 256; ++i) {
+               p = (i ? pow_tab[255 - log_tab[i]] : 0);
+               q = ((p >> 7) | (p << 1)) ^ ((p >> 6) | (p << 2));
+               p ^= 0x63 ^ q ^ ((q >> 6) | (q << 2));
+               sbx_tab[i] = p;
+               isb_tab[p] = (u8)i;
+       }
+
+       for (i = 0; i < 256; ++i) {
+               p = sbx_tab[i];
+
+               t = p;
+               aes_fl_tab[0][i] = t;
+               aes_fl_tab[1][i] = rol32(t, 8);
+               aes_fl_tab[2][i] = rol32(t, 16);
+               aes_fl_tab[3][i] = rol32(t, 24);
+
+               t = ((u32)ff_mult(2, p)) |
+                   ((u32)p << 8) |
+                   ((u32)p << 16) | ((u32)ff_mult(3, p) << 24);
+
+               aes_ft_tab[0][i] = t;
+               aes_ft_tab[1][i] = rol32(t, 8);
+               aes_ft_tab[2][i] = rol32(t, 16);
+               aes_ft_tab[3][i] = rol32(t, 24);
+
+               p = isb_tab[i];
+
+               t = p;
+               aes_il_tab[0][i] = t;
+               aes_il_tab[1][i] = rol32(t, 8);
+               aes_il_tab[2][i] = rol32(t, 16);
+               aes_il_tab[3][i] = rol32(t, 24);
+
+               t = ((u32)ff_mult(14, p)) |
+                   ((u32)ff_mult(9, p) << 8) |
+                   ((u32)ff_mult(13, p) << 16) |
+                   ((u32)ff_mult(11, p) << 24);
+
+               aes_it_tab[0][i] = t;
+               aes_it_tab[1][i] = rol32(t, 8);
+               aes_it_tab[2][i] = rol32(t, 16);
+               aes_it_tab[3][i] = rol32(t, 24);
+       }
+}
+
+#define star_x(x) (((x) & 0x7f7f7f7f) << 1) ^ ((((x) & 0x80808080) >> 7) * 
0x1b)
+
+#define imix_col(y, x)                 \
+       u    = star_x(x);               \
+       v    = star_x(u);               \
+       w    = star_x(v);               \
+       t    = w ^ (x);                 \
+       (y)  = u ^ v ^ w;               \
+       (y) ^= ror32(u ^ t,  8) ^       \
+              ror32(v ^ t, 16) ^       \
+              ror32(t, 24)
+
+/* initialise the key schedule from the user supplied key */
+
+#define loop4(i)                                       \
+{                                                      \
+       t = ror32(t,  8); t = ls_box(t) ^ rco_tab[i];   \
+       t ^= E_KEY[4 * i];     E_KEY[4 * i + 4] = t;    \
+       t ^= E_KEY[4 * i + 1]; E_KEY[4 * i + 5] = t;    \
+       t ^= E_KEY[4 * i + 2]; E_KEY[4 * i + 6] = t;    \
+       t ^= E_KEY[4 * i + 3]; E_KEY[4 * i + 7] = t;    \
+}
+
+#define loop6(i)                                       \
+{                                                      \
+       t = ror32(t,  8); t = ls_box(t) ^ rco_tab[i];   \
+       t ^= E_KEY[6 * i];     E_KEY[6 * i + 6] = t;    \
+       t ^= E_KEY[6 * i + 1]; E_KEY[6 * i + 7] = t;    \
+       t ^= E_KEY[6 * i + 2]; E_KEY[6 * i + 8] = t;    \
+       t ^= E_KEY[6 * i + 3]; E_KEY[6 * i + 9] = t;    \
+       t ^= E_KEY[6 * i + 4]; E_KEY[6 * i + 10] = t;   \
+       t ^= E_KEY[6 * i + 5]; E_KEY[6 * i + 11] = t;   \
+}
+
+#define loop8(i)                                       \
+{                                                      \
+       t = ror32(t,  8); ; t = ls_box(t) ^ rco_tab[i]; \
+       t ^= E_KEY[8 * i];     E_KEY[8 * i + 8] = t;    \
+       t ^= E_KEY[8 * i + 1]; E_KEY[8 * i + 9] = t;    \
+       t ^= E_KEY[8 * i + 2]; E_KEY[8 * i + 10] = t;   \
+       t ^= E_KEY[8 * i + 3]; E_KEY[8 * i + 11] = t;   \
+       t  = E_KEY[8 * i + 4] ^ ls_box(t);              \
+       E_KEY[8 * i + 12] = t;                          \
+       t ^= E_KEY[8 * i + 5]; E_KEY[8 * i + 13] = t;   \
+       t ^= E_KEY[8 * i + 6]; E_KEY[8 * i + 14] = t;   \
+       t ^= E_KEY[8 * i + 7]; E_KEY[8 * i + 15] = t;   \
+}
+
+static int aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
+                      unsigned int key_len)
+{
+       struct aes_ctx *ctx = crypto_tfm_ctx(tfm);
+       const __le32 *key = (const __le32 *)in_key;
+       u32 *flags = &tfm->crt_flags;
+       u32 i, j, t, u, v, w;
+
+       if (key_len % 8) {
+               *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
+               return -EINVAL;
+       }
+
+       ctx->key_length = key_len;
+
+       D_KEY[key_len + 24] = E_KEY[0] = le32_to_cpu(key[0]);
+       D_KEY[key_len + 25] = E_KEY[1] = le32_to_cpu(key[1]);
+       D_KEY[key_len + 26] = E_KEY[2] = le32_to_cpu(key[2]);
+       D_KEY[key_len + 27] = E_KEY[3] = le32_to_cpu(key[3]);
+
+       switch (key_len) {
+       case 16:
+               t = E_KEY[3];
+               for (i = 0; i < 10; ++i)
+                       loop4(i);
+               break;
+
+       case 24:
+               E_KEY[4] = le32_to_cpu(key[4]);
+               t = E_KEY[5] = le32_to_cpu(key[5]);
+               for (i = 0; i < 8; ++i)
+                       loop6 (i);
+               break;
+
+       case 32:
+               E_KEY[4] = le32_to_cpu(key[4]);
+               E_KEY[5] = le32_to_cpu(key[5]);
+               E_KEY[6] = le32_to_cpu(key[6]);
+               t = E_KEY[7] = le32_to_cpu(key[7]);
+               for (i = 0; i < 7; ++i)
+                       loop8(i);
+               break;
+       }
+
+       D_KEY[0] = E_KEY[key_len + 24];
+       D_KEY[1] = E_KEY[key_len + 25];
+       D_KEY[2] = E_KEY[key_len + 26];
+       D_KEY[3] = E_KEY[key_len + 27];
+
+       for (i = 4; i < key_len + 24; ++i) {
+               j = key_len + 24 - (i & ~3) + (i & 3);
+               imix_col(D_KEY[j], E_KEY[i]);
+       }
+
+       return 0;
+}
+
+asmlinkage void aes_enc_blk(struct crypto_tfm *tfm, u8 *out, const u8 *in);
+asmlinkage void aes_dec_blk(struct crypto_tfm *tfm, u8 *out, const u8 *in);
+
+static void aes_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
+{
+       aes_enc_blk(tfm, dst, src);
+}
+
+static void aes_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
+{
+       aes_dec_blk(tfm, dst, src);
+}
+
+static struct crypto_alg aes_alg = {
+       .cra_name               =       "aes",
+       .cra_driver_name        =       "aes-x86_64",
+       .cra_priority           =       200,
+       .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
+       .cra_blocksize          =       AES_BLOCK_SIZE,
+       .cra_ctxsize            =       sizeof(struct aes_ctx),
+       .cra_module             =       THIS_MODULE,
+       .cra_list               =       LIST_HEAD_INIT(aes_alg.cra_list),
+       .cra_u                  =       {
+               .cipher = {
+                       .cia_min_keysize        =       AES_MIN_KEY_SIZE,
+                       .cia_max_keysize        =       AES_MAX_KEY_SIZE,
+                       .cia_setkey             =       aes_set_key,
+                       .cia_encrypt            =       aes_encrypt,
+                       .cia_decrypt            =       aes_decrypt
+               }
+       }
+};
+
+static int __init aes_init(void)
+{
+       gen_tabs();
+       return crypto_register_alg(&aes_alg);
+}
+
+static void __exit aes_fini(void)
+{
+       crypto_unregister_alg(&aes_alg);
+}
+
+module_init(aes_init);
+module_exit(aes_fini);
+
+MODULE_DESCRIPTION("Rijndael (AES) Cipher Algorithm");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("aes");
diff --git a/arch/x86/crypto/twofish-x86_64-asm_64.S 
b/arch/x86/crypto/twofish-x86_64-asm_64.S
new file mode 100644
index 0000000..35974a5
--- /dev/null
+++ b/arch/x86/crypto/twofish-x86_64-asm_64.S
@@ -0,0 +1,324 @@
+/***************************************************************************
+*   Copyright (C) 2006 by Joachim Fritschi, <[EMAIL PROTECTED]>        *
+*                                                                         *
+*   This program is free software; you can redistribute it and/or modify  *
+*   it under the terms of the GNU General Public License as published by  *
+*   the Free Software Foundation; either version 2 of the License, or     *
+*   (at your option) any later version.                                   *
+*                                                                         *
+*   This program is distributed in the hope that it will be useful,       *
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+*   GNU General Public License for more details.                          *
+*                                                                         *
+*   You should have received a copy of the GNU General Public License     *
+*   along with this program; if not, write to the                         *
+*   Free Software Foundation, Inc.,                                       *
+*   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+***************************************************************************/
+
+.file "twofish-x86_64-asm.S"
+.text
+
+#include <asm/asm-offsets.h>
+
+#define a_offset       0
+#define b_offset       4
+#define c_offset       8
+#define d_offset       12
+
+/* Structure of the crypto context struct*/
+
+#define s0     0       /* S0 Array 256 Words each */
+#define s1     1024    /* S1 Array */
+#define s2     2048    /* S2 Array */
+#define s3     3072    /* S3 Array */
+#define w      4096    /* 8 whitening keys (word) */
+#define k      4128    /* key 1-32 ( word ) */
+
+/* define a few register aliases to allow macro substitution */
+
+#define R0     %rax
+#define R0D    %eax
+#define R0B    %al
+#define R0H    %ah
+
+#define R1     %rbx
+#define R1D    %ebx
+#define R1B    %bl
+#define R1H    %bh
+
+#define R2     %rcx
+#define R2D    %ecx
+#define R2B    %cl
+#define R2H    %ch
+
+#define R3     %rdx
+#define R3D    %edx
+#define R3B    %dl
+#define R3H    %dh
+
+
+/* performs input whitening */
+#define input_whitening(src,context,offset)\
+       xor     w+offset(context),      src;
+
+/* performs input whitening */
+#define output_whitening(src,context,offset)\
+       xor     w+16+offset(context),   src;
+
+
+/*
+ * a input register containing a (rotated 16)
+ * b input register containing b
+ * c input register containing c
+ * d input register containing d (already rol $1)
+ * operations on a and b are interleaved to increase performance
+ */
+#define encrypt_round(a,b,c,d,round)\
+       movzx   b ## B,         %edi;\
+       mov     s1(%r11,%rdi,4),%r8d;\
+       movzx   a ## B,         %edi;\
+       mov     s2(%r11,%rdi,4),%r9d;\
+       movzx   b ## H,         %edi;\
+       ror     $16,            b ## D;\
+       xor     s2(%r11,%rdi,4),%r8d;\
+       movzx   a ## H,         %edi;\
+       ror     $16,            a ## D;\
+       xor     s3(%r11,%rdi,4),%r9d;\
+       movzx   b ## B,         %edi;\
+       xor     s3(%r11,%rdi,4),%r8d;\
+       movzx   a ## B,         %edi;\
+       xor     (%r11,%rdi,4),  %r9d;\
+       movzx   b ## H,         %edi;\
+       ror     $15,            b ## D;\
+       xor     (%r11,%rdi,4),  %r8d;\
+       movzx   a ## H,         %edi;\
+       xor     s1(%r11,%rdi,4),%r9d;\
+       add     %r8d,           %r9d;\
+       add     %r9d,           %r8d;\
+       add     k+round(%r11),  %r9d;\
+       xor     %r9d,           c ## D;\
+       rol     $15,            c ## D;\
+       add     k+4+round(%r11),%r8d;\
+       xor     %r8d,           d ## D;
+
+/*
+ * a input register containing a(rotated 16)
+ * b input register containing b
+ * c input register containing c
+ * d input register containing d (already rol $1)
+ * operations on a and b are interleaved to increase performance
+ * during the round a and b are prepared for the output whitening
+ */
+#define encrypt_last_round(a,b,c,d,round)\
+       mov     b ## D,         %r10d;\
+       shl     $32,            %r10;\
+       movzx   b ## B,         %edi;\
+       mov     s1(%r11,%rdi,4),%r8d;\
+       movzx   a ## B,         %edi;\
+       mov     s2(%r11,%rdi,4),%r9d;\
+       movzx   b ## H,         %edi;\
+       ror     $16,            b ## D;\
+       xor     s2(%r11,%rdi,4),%r8d;\
+       movzx   a ## H,         %edi;\
+       ror     $16,            a ## D;\
+       xor     s3(%r11,%rdi,4),%r9d;\
+       movzx   b ## B,         %edi;\
+       xor     s3(%r11,%rdi,4),%r8d;\
+       movzx   a ## B,         %edi;\
+       xor     (%r11,%rdi,4),  %r9d;\
+       xor     a,              %r10;\
+       movzx   b ## H,         %edi;\
+       xor     (%r11,%rdi,4),  %r8d;\
+       movzx   a ## H,         %edi;\
+       xor     s1(%r11,%rdi,4),%r9d;\
+       add     %r8d,           %r9d;\
+       add     %r9d,           %r8d;\
+       add     k+round(%r11),  %r9d;\
+       xor     %r9d,           c ## D;\
+       ror     $1,             c ## D;\
+       add     k+4+round(%r11),%r8d;\
+       xor     %r8d,           d ## D
+
+/*
+ * a input register containing a
+ * b input register containing b (rotated 16)
+ * c input register containing c (already rol $1)
+ * d input register containing d
+ * operations on a and b are interleaved to increase performance
+ */
+#define decrypt_round(a,b,c,d,round)\
+       movzx   a ## B,         %edi;\
+       mov     (%r11,%rdi,4),  %r9d;\
+       movzx   b ## B,         %edi;\
+       mov     s3(%r11,%rdi,4),%r8d;\
+       movzx   a ## H,         %edi;\
+       ror     $16,            a ## D;\
+       xor     s1(%r11,%rdi,4),%r9d;\
+       movzx   b ## H,         %edi;\
+       ror     $16,            b ## D;\
+       xor     (%r11,%rdi,4),  %r8d;\
+       movzx   a ## B,         %edi;\
+       xor     s2(%r11,%rdi,4),%r9d;\
+       movzx   b ## B,         %edi;\
+       xor     s1(%r11,%rdi,4),%r8d;\
+       movzx   a ## H,         %edi;\
+       ror     $15,            a ## D;\
+       xor     s3(%r11,%rdi,4),%r9d;\
+       movzx   b ## H,         %edi;\
+       xor     s2(%r11,%rdi,4),%r8d;\
+       add     %r8d,           %r9d;\
+       add     %r9d,           %r8d;\
+       add     k+round(%r11),  %r9d;\
+       xor     %r9d,           c ## D;\
+       add     k+4+round(%r11),%r8d;\
+       xor     %r8d,           d ## D;\
+       rol     $15,            d ## D;
+
+/*
+ * a input register containing a
+ * b input register containing b
+ * c input register containing c (already rol $1)
+ * d input register containing d
+ * operations on a and b are interleaved to increase performance
+ * during the round a and b are prepared for the output whitening
+ */
+#define decrypt_last_round(a,b,c,d,round)\
+       movzx   a ## B,         %edi;\
+       mov     (%r11,%rdi,4),  %r9d;\
+       movzx   b ## B,         %edi;\
+       mov     s3(%r11,%rdi,4),%r8d;\
+       movzx   b ## H,         %edi;\
+       ror     $16,            b ## D;\
+       xor     (%r11,%rdi,4),  %r8d;\
+       movzx   a ## H,         %edi;\
+       mov     b ## D,         %r10d;\
+       shl     $32,            %r10;\
+       xor     a,              %r10;\
+       ror     $16,            a ## D;\
+       xor     s1(%r11,%rdi,4),%r9d;\
+       movzx   b ## B,         %edi;\
+       xor     s1(%r11,%rdi,4),%r8d;\
+       movzx   a ## B,         %edi;\
+       xor     s2(%r11,%rdi,4),%r9d;\
+       movzx   b ## H,         %edi;\
+       xor     s2(%r11,%rdi,4),%r8d;\
+       movzx   a ## H,         %edi;\
+       xor     s3(%r11,%rdi,4),%r9d;\
+       add     %r8d,           %r9d;\
+       add     %r9d,           %r8d;\
+       add     k+round(%r11),  %r9d;\
+       xor     %r9d,           c ## D;\
+       add     k+4+round(%r11),%r8d;\
+       xor     %r8d,           d ## D;\
+       ror     $1,             d ## D;
+
+.align 8
+.global twofish_enc_blk
+.global twofish_dec_blk
+
+twofish_enc_blk:
+       pushq    R1
+
+       /* %rdi contains the crypto tfm adress */
+       /* %rsi contains the output adress */
+       /* %rdx contains the input adress */
+       add     $crypto_tfm_ctx_offset, %rdi    /* set ctx adress */
+       /* ctx adress is moved to free one non-rex register
+       as target for the 8bit high operations */
+       mov     %rdi,           %r11
+
+       movq    (R3),   R1
+       movq    8(R3),  R3
+       input_whitening(R1,%r11,a_offset)
+       input_whitening(R3,%r11,c_offset)
+       mov     R1D,    R0D
+       rol     $16,    R0D
+       shr     $32,    R1
+       mov     R3D,    R2D
+       shr     $32,    R3
+       rol     $1,     R3D
+
+       encrypt_round(R0,R1,R2,R3,0);
+       encrypt_round(R2,R3,R0,R1,8);
+       encrypt_round(R0,R1,R2,R3,2*8);
+       encrypt_round(R2,R3,R0,R1,3*8);
+       encrypt_round(R0,R1,R2,R3,4*8);
+       encrypt_round(R2,R3,R0,R1,5*8);
+       encrypt_round(R0,R1,R2,R3,6*8);
+       encrypt_round(R2,R3,R0,R1,7*8);
+       encrypt_round(R0,R1,R2,R3,8*8);
+       encrypt_round(R2,R3,R0,R1,9*8);
+       encrypt_round(R0,R1,R2,R3,10*8);
+       encrypt_round(R2,R3,R0,R1,11*8);
+       encrypt_round(R0,R1,R2,R3,12*8);
+       encrypt_round(R2,R3,R0,R1,13*8);
+       encrypt_round(R0,R1,R2,R3,14*8);
+       encrypt_last_round(R2,R3,R0,R1,15*8);
+
+
+       output_whitening(%r10,%r11,a_offset)
+       movq    %r10,   (%rsi)
+
+       shl     $32,    R1
+       xor     R0,     R1
+
+       output_whitening(R1,%r11,c_offset)
+       movq    R1,     8(%rsi)
+
+       popq    R1
+       movq    $1,%rax
+       ret
+
+twofish_dec_blk:
+       pushq    R1
+
+       /* %rdi contains the crypto tfm adress */
+       /* %rsi contains the output adress */
+       /* %rdx contains the input adress */
+       add     $crypto_tfm_ctx_offset, %rdi    /* set ctx adress */
+       /* ctx adress is moved to free one non-rex register
+       as target for the 8bit high operations */
+       mov     %rdi,           %r11
+
+       movq    (R3),   R1
+       movq    8(R3),  R3
+       output_whitening(R1,%r11,a_offset)
+       output_whitening(R3,%r11,c_offset)
+       mov     R1D,    R0D
+       shr     $32,    R1
+       rol     $16,    R1D
+       mov     R3D,    R2D
+       shr     $32,    R3
+       rol     $1,     R2D
+
+       decrypt_round(R0,R1,R2,R3,15*8);
+       decrypt_round(R2,R3,R0,R1,14*8);
+       decrypt_round(R0,R1,R2,R3,13*8);
+       decrypt_round(R2,R3,R0,R1,12*8);
+       decrypt_round(R0,R1,R2,R3,11*8);
+       decrypt_round(R2,R3,R0,R1,10*8);
+       decrypt_round(R0,R1,R2,R3,9*8);
+       decrypt_round(R2,R3,R0,R1,8*8);
+       decrypt_round(R0,R1,R2,R3,7*8);
+       decrypt_round(R2,R3,R0,R1,6*8);
+       decrypt_round(R0,R1,R2,R3,5*8);
+       decrypt_round(R2,R3,R0,R1,4*8);
+       decrypt_round(R0,R1,R2,R3,3*8);
+       decrypt_round(R2,R3,R0,R1,2*8);
+       decrypt_round(R0,R1,R2,R3,1*8);
+       decrypt_last_round(R2,R3,R0,R1,0);
+
+       input_whitening(%r10,%r11,a_offset)
+       movq    %r10,   (%rsi)
+
+       shl     $32,    R1
+       xor     R0,     R1
+
+       input_whitening(R1,%r11,c_offset)
+       movq    R1,     8(%rsi)
+
+       popq    R1
+       movq    $1,%rax
+       ret
diff --git a/arch/x86/crypto/twofish_64.c b/arch/x86/crypto/twofish_64.c
new file mode 100644
index 0000000..182d91d
--- /dev/null
+++ b/arch/x86/crypto/twofish_64.c
@@ -0,0 +1,97 @@
+/*
+ * Glue Code for optimized x86_64 assembler version of TWOFISH
+ *
+ * Originally Twofish for GPG
+ * By Matthew Skala <[EMAIL PROTECTED]>, July 26, 1998
+ * 256-bit key length added March 20, 1999
+ * Some modifications to reduce the text size by Werner Koch, April, 1998
+ * Ported to the kerneli patch by Marc Mutz <[EMAIL PROTECTED]>
+ * Ported to CryptoAPI by Colin Slater <[EMAIL PROTECTED]>
+ *
+ * The original author has disclaimed all copyright interest in this
+ * code and thus put it in the public domain. The subsequent authors
+ * have put this under the GNU General Public License.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
+ * USA
+ *
+ * This code is a "clean room" implementation, written from the paper
+ * _Twofish: A 128-Bit Block Cipher_ by Bruce Schneier, John Kelsey,
+ * Doug Whiting, David Wagner, Chris Hall, and Niels Ferguson, available
+ * through http://www.counterpane.com/twofish.html
+ *
+ * For background information on multiplication in finite fields, used for
+ * the matrix operations in the key schedule, see the book _Contemporary
+ * Abstract Algebra_ by Joseph A. Gallian, especially chapter 22 in the
+ * Third Edition.
+ */
+
+#include <crypto/twofish.h>
+#include <linux/crypto.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/types.h>
+
+asmlinkage void twofish_enc_blk(struct crypto_tfm *tfm, u8 *dst, const u8 
*src);
+asmlinkage void twofish_dec_blk(struct crypto_tfm *tfm, u8 *dst, const u8 
*src);
+
+static void twofish_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
+{
+       twofish_enc_blk(tfm, dst, src);
+}
+
+static void twofish_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
+{
+       twofish_dec_blk(tfm, dst, src);
+}
+
+static struct crypto_alg alg = {
+       .cra_name               =       "twofish",
+       .cra_driver_name        =       "twofish-x86_64",
+       .cra_priority           =       200,
+       .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
+       .cra_blocksize          =       TF_BLOCK_SIZE,
+       .cra_ctxsize            =       sizeof(struct twofish_ctx),
+       .cra_alignmask          =       3,
+       .cra_module             =       THIS_MODULE,
+       .cra_list               =       LIST_HEAD_INIT(alg.cra_list),
+       .cra_u                  =       {
+               .cipher = {
+                       .cia_min_keysize        =       TF_MIN_KEY_SIZE,
+                       .cia_max_keysize        =       TF_MAX_KEY_SIZE,
+                       .cia_setkey             =       twofish_setkey,
+                       .cia_encrypt            =       twofish_encrypt,
+                       .cia_decrypt            =       twofish_decrypt
+               }
+       }
+};
+
+static int __init init(void)
+{
+       return crypto_register_alg(&alg);
+}
+
+static void __exit fini(void)
+{
+       crypto_unregister_alg(&alg);
+}
+
+module_init(init);
+module_exit(fini);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION ("Twofish Cipher Algorithm, x86_64 asm optimized");
+MODULE_ALIAS("twofish");
diff --git a/arch/x86_64/Makefile b/arch/x86_64/Makefile
index 0416dd2..265484c 100644
--- a/arch/x86_64/Makefile
+++ b/arch/x86_64/Makefile
@@ -76,7 +76,7 @@ head-y := arch/x86_64/kernel/head_64.o 
arch/x86_64/kernel/head64.o arch/x86_64/k
 libs-y                                         += arch/x86_64/lib/
 core-y                                 += arch/x86_64/kernel/ \
                                           arch/x86_64/mm/ \
-                                          arch/x86_64/crypto/ \
+                                          arch/x86/crypto/ \
                                           arch/x86_64/vdso/
 core-$(CONFIG_IA32_EMULATION)          += arch/x86_64/ia32/
 drivers-$(CONFIG_PCI)                  += arch/x86_64/pci/
diff --git a/arch/x86_64/crypto/Makefile b/arch/x86_64/crypto/Makefile
deleted file mode 100644
index b1bcf7c..0000000
--- a/arch/x86_64/crypto/Makefile
+++ /dev/null
@@ -1,5 +0,0 @@
-ifeq ($(CONFIG_X86_32),y)
-include ${srctree}/arch/x86/crypto/Makefile_32
-else
-include ${srctree}/arch/x86_64/crypto/Makefile_64
-endif
diff --git a/arch/x86_64/crypto/Makefile_64 b/arch/x86_64/crypto/Makefile_64
deleted file mode 100644
index c96faeb..0000000
--- a/arch/x86_64/crypto/Makefile_64
+++ /dev/null
@@ -1,12 +0,0 @@
-# 
-# x86_64/crypto/Makefile 
-# 
-# Arch-specific CryptoAPI modules.
-# 
-
-obj-$(CONFIG_CRYPTO_AES_X86_64) += aes-x86_64.o
-obj-$(CONFIG_CRYPTO_TWOFISH_X86_64) += twofish-x86_64.o
-
-aes-x86_64-y := aes-x86_64-asm_64.o aes_64.o
-twofish-x86_64-y := twofish-x86_64-asm_64.o twofish_64.o
-
diff --git a/arch/x86_64/crypto/aes-x86_64-asm_64.S 
b/arch/x86_64/crypto/aes-x86_64-asm_64.S
deleted file mode 100644
index 26b40de..0000000
--- a/arch/x86_64/crypto/aes-x86_64-asm_64.S
+++ /dev/null
@@ -1,190 +0,0 @@
-/* AES (Rijndael) implementation (FIPS PUB 197) for x86_64
- *
- * Copyright (C) 2005 Andreas Steinmetz, <[EMAIL PROTECTED]>
- *
- * License:
- * This code can be distributed under the terms of the GNU General Public
- * License (GPL) Version 2 provided that the above header down to and
- * including this sentence is retained in full.
- */
-
-.extern aes_ft_tab
-.extern aes_it_tab
-.extern aes_fl_tab
-.extern aes_il_tab
-
-.text
-
-#include <asm/asm-offsets.h>
-
-#define BASE crypto_tfm_ctx_offset
-
-#define R1     %rax
-#define R1E    %eax
-#define R1X    %ax
-#define R1H    %ah
-#define R1L    %al
-#define R2     %rbx
-#define R2E    %ebx
-#define R2X    %bx
-#define R2H    %bh
-#define R2L    %bl
-#define R3     %rcx
-#define R3E    %ecx
-#define R3X    %cx
-#define R3H    %ch
-#define R3L    %cl
-#define R4     %rdx
-#define R4E    %edx
-#define R4X    %dx
-#define R4H    %dh
-#define R4L    %dl
-#define R5     %rsi
-#define R5E    %esi
-#define R6     %rdi
-#define R6E    %edi
-#define R7     %rbp
-#define R7E    %ebp
-#define R8     %r8
-#define R9     %r9
-#define R10    %r10
-#define R11    %r11
-
-#define prologue(FUNC,KEY,B128,B192,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11) \
-       .global FUNC;                   \
-       .type   FUNC,@function;         \
-       .align  8;                      \
-FUNC:  movq    r1,r2;                  \
-       movq    r3,r4;                  \
-       leaq    BASE+KEY+52(r8),r9;     \
-       movq    r10,r11;                \
-       movl    (r7),r5 ## E;           \
-       movl    4(r7),r1 ## E;          \
-       movl    8(r7),r6 ## E;          \
-       movl    12(r7),r7 ## E;         \
-       movl    BASE(r8),r10 ## E;      \
-       xorl    -48(r9),r5 ## E;        \
-       xorl    -44(r9),r1 ## E;        \
-       xorl    -40(r9),r6 ## E;        \
-       xorl    -36(r9),r7 ## E;        \
-       cmpl    $24,r10 ## E;           \
-       jb      B128;                   \
-       leaq    32(r9),r9;              \
-       je      B192;                   \
-       leaq    32(r9),r9;
-
-#define epilogue(r1,r2,r3,r4,r5,r6,r7,r8,r9) \
-       movq    r1,r2;                  \
-       movq    r3,r4;                  \
-       movl    r5 ## E,(r9);           \
-       movl    r6 ## E,4(r9);          \
-       movl    r7 ## E,8(r9);          \
-       movl    r8 ## E,12(r9);         \
-       ret;
-
-#define round(TAB,OFFSET,r1,r2,r3,r4,r5,r6,r7,r8,ra,rb,rc,rd) \
-       movzbl  r2 ## H,r5 ## E;        \
-       movzbl  r2 ## L,r6 ## E;        \
-       movl    TAB+1024(,r5,4),r5 ## E;\
-       movw    r4 ## X,r2 ## X;        \
-       movl    TAB(,r6,4),r6 ## E;     \
-       roll    $16,r2 ## E;            \
-       shrl    $16,r4 ## E;            \
-       movzbl  r4 ## H,r7 ## E;        \
-       movzbl  r4 ## L,r4 ## E;        \
-       xorl    OFFSET(r8),ra ## E;     \
-       xorl    OFFSET+4(r8),rb ## E;   \
-       xorl    TAB+3072(,r7,4),r5 ## E;\
-       xorl    TAB+2048(,r4,4),r6 ## E;\
-       movzbl  r1 ## L,r7 ## E;        \
-       movzbl  r1 ## H,r4 ## E;        \
-       movl    TAB+1024(,r4,4),r4 ## E;\
-       movw    r3 ## X,r1 ## X;        \
-       roll    $16,r1 ## E;            \
-       shrl    $16,r3 ## E;            \
-       xorl    TAB(,r7,4),r5 ## E;     \
-       movzbl  r3 ## H,r7 ## E;        \
-       movzbl  r3 ## L,r3 ## E;        \
-       xorl    TAB+3072(,r7,4),r4 ## E;\
-       xorl    TAB+2048(,r3,4),r5 ## E;\
-       movzbl  r1 ## H,r7 ## E;        \
-       movzbl  r1 ## L,r3 ## E;        \
-       shrl    $16,r1 ## E;            \
-       xorl    TAB+3072(,r7,4),r6 ## E;\
-       movl    TAB+2048(,r3,4),r3 ## E;\
-       movzbl  r1 ## H,r7 ## E;        \
-       movzbl  r1 ## L,r1 ## E;        \
-       xorl    TAB+1024(,r7,4),r6 ## E;\
-       xorl    TAB(,r1,4),r3 ## E;     \
-       movzbl  r2 ## H,r1 ## E;        \
-       movzbl  r2 ## L,r7 ## E;        \
-       shrl    $16,r2 ## E;            \
-       xorl    TAB+3072(,r1,4),r3 ## E;\
-       xorl    TAB+2048(,r7,4),r4 ## E;\
-       movzbl  r2 ## H,r1 ## E;        \
-       movzbl  r2 ## L,r2 ## E;        \
-       xorl    OFFSET+8(r8),rc ## E;   \
-       xorl    OFFSET+12(r8),rd ## E;  \
-       xorl    TAB+1024(,r1,4),r3 ## E;\
-       xorl    TAB(,r2,4),r4 ## E;
-
-#define move_regs(r1,r2,r3,r4) \
-       movl    r3 ## E,r1 ## E;        \
-       movl    r4 ## E,r2 ## E;
-
-#define entry(FUNC,KEY,B128,B192) \
-       prologue(FUNC,KEY,B128,B192,R2,R8,R7,R9,R1,R3,R4,R6,R10,R5,R11)
-
-#define return epilogue(R8,R2,R9,R7,R5,R6,R3,R4,R11)
-
-#define encrypt_round(TAB,OFFSET) \
-       round(TAB,OFFSET,R1,R2,R3,R4,R5,R6,R7,R10,R5,R6,R3,R4) \
-       move_regs(R1,R2,R5,R6)
-
-#define encrypt_final(TAB,OFFSET) \
-       round(TAB,OFFSET,R1,R2,R3,R4,R5,R6,R7,R10,R5,R6,R3,R4)
-
-#define decrypt_round(TAB,OFFSET) \
-       round(TAB,OFFSET,R2,R1,R4,R3,R6,R5,R7,R10,R5,R6,R3,R4) \
-       move_regs(R1,R2,R5,R6)
-
-#define decrypt_final(TAB,OFFSET) \
-       round(TAB,OFFSET,R2,R1,R4,R3,R6,R5,R7,R10,R5,R6,R3,R4)
-
-/* void aes_enc_blk(stuct crypto_tfm *tfm, u8 *out, const u8 *in) */
-
-       entry(aes_enc_blk,0,enc128,enc192)
-       encrypt_round(aes_ft_tab,-96)
-       encrypt_round(aes_ft_tab,-80)
-enc192:        encrypt_round(aes_ft_tab,-64)
-       encrypt_round(aes_ft_tab,-48)
-enc128:        encrypt_round(aes_ft_tab,-32)
-       encrypt_round(aes_ft_tab,-16)
-       encrypt_round(aes_ft_tab,  0)
-       encrypt_round(aes_ft_tab, 16)
-       encrypt_round(aes_ft_tab, 32)
-       encrypt_round(aes_ft_tab, 48)
-       encrypt_round(aes_ft_tab, 64)
-       encrypt_round(aes_ft_tab, 80)
-       encrypt_round(aes_ft_tab, 96)
-       encrypt_final(aes_fl_tab,112)
-       return
-
-/* void aes_dec_blk(struct crypto_tfm *tfm, u8 *out, const u8 *in) */
-
-       entry(aes_dec_blk,240,dec128,dec192)
-       decrypt_round(aes_it_tab,-96)
-       decrypt_round(aes_it_tab,-80)
-dec192:        decrypt_round(aes_it_tab,-64)
-       decrypt_round(aes_it_tab,-48)
-dec128:        decrypt_round(aes_it_tab,-32)
-       decrypt_round(aes_it_tab,-16)
-       decrypt_round(aes_it_tab,  0)
-       decrypt_round(aes_it_tab, 16)
-       decrypt_round(aes_it_tab, 32)
-       decrypt_round(aes_it_tab, 48)
-       decrypt_round(aes_it_tab, 64)
-       decrypt_round(aes_it_tab, 80)
-       decrypt_round(aes_it_tab, 96)
-       decrypt_final(aes_il_tab,112)
-       return
diff --git a/arch/x86_64/crypto/aes_64.c b/arch/x86_64/crypto/aes_64.c
deleted file mode 100644
index 5cdb13e..0000000
--- a/arch/x86_64/crypto/aes_64.c
+++ /dev/null
@@ -1,336 +0,0 @@
-/*
- * Cryptographic API.
- *
- * AES Cipher Algorithm.
- *
- * Based on Brian Gladman's code.
- *
- * Linux developers:
- *  Alexander Kjeldaas <[EMAIL PROTECTED]>
- *  Herbert Valerio Riedel <[EMAIL PROTECTED]>
- *  Kyle McMartin <[EMAIL PROTECTED]>
- *  Adam J. Richter <[EMAIL PROTECTED]> (conversion to 2.5 API).
- *  Andreas Steinmetz <[EMAIL PROTECTED]> (adapted to x86_64 assembler)
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * ---------------------------------------------------------------------------
- * Copyright (c) 2002, Dr Brian Gladman <[EMAIL PROTECTED]>, Worcester, UK.
- * All rights reserved.
- *
- * LICENSE TERMS
- *
- * The free distribution and use of this software in both source and binary
- * form is allowed (with or without changes) provided that:
- *
- *   1. distributions of this source code include the above copyright
- *      notice, this list of conditions and the following disclaimer;
- *
- *   2. distributions in binary form include the above copyright
- *      notice, this list of conditions and the following disclaimer
- *      in the documentation and/or other associated materials;
- *
- *   3. the copyright holder's name is not used to endorse products
- *      built using this software without specific written permission.
- *
- * ALTERNATIVELY, provided that this notice is retained in full, this product
- * may be distributed under the terms of the GNU General Public License (GPL),
- * in which case the provisions of the GPL apply INSTEAD OF those given above.
- *
- * DISCLAIMER
- *
- * This software is provided 'as is' with no explicit or implied warranties
- * in respect of its properties, including, but not limited to, correctness
- * and/or fitness for purpose.
- * ---------------------------------------------------------------------------
- */
-
-/* Some changes from the Gladman version:
-    s/RIJNDAEL(e_key)/E_KEY/g
-    s/RIJNDAEL(d_key)/D_KEY/g
-*/
-
-#include <asm/byteorder.h>
-#include <linux/bitops.h>
-#include <linux/crypto.h>
-#include <linux/errno.h>
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/types.h>
-
-#define AES_MIN_KEY_SIZE       16
-#define AES_MAX_KEY_SIZE       32
-
-#define AES_BLOCK_SIZE         16
-
-/*
- * #define byte(x, nr) ((unsigned char)((x) >> (nr*8)))
- */
-static inline u8 byte(const u32 x, const unsigned n)
-{
-       return x >> (n << 3);
-}
-
-struct aes_ctx
-{
-       u32 key_length;
-       u32 buf[120];
-};
-
-#define E_KEY (&ctx->buf[0])
-#define D_KEY (&ctx->buf[60])
-
-static u8 pow_tab[256] __initdata;
-static u8 log_tab[256] __initdata;
-static u8 sbx_tab[256] __initdata;
-static u8 isb_tab[256] __initdata;
-static u32 rco_tab[10];
-u32 aes_ft_tab[4][256];
-u32 aes_it_tab[4][256];
-
-u32 aes_fl_tab[4][256];
-u32 aes_il_tab[4][256];
-
-static inline u8 f_mult(u8 a, u8 b)
-{
-       u8 aa = log_tab[a], cc = aa + log_tab[b];
-
-       return pow_tab[cc + (cc < aa ? 1 : 0)];
-}
-
-#define ff_mult(a, b) (a && b ? f_mult(a, b) : 0)
-
-#define ls_box(x)                              \
-       (aes_fl_tab[0][byte(x, 0)] ^            \
-        aes_fl_tab[1][byte(x, 1)] ^            \
-        aes_fl_tab[2][byte(x, 2)] ^            \
-        aes_fl_tab[3][byte(x, 3)])
-
-static void __init gen_tabs(void)
-{
-       u32 i, t;
-       u8 p, q;
-
-       /* log and power tables for GF(2**8) finite field with
-          0x011b as modular polynomial - the simplest primitive
-          root is 0x03, used here to generate the tables */
-
-       for (i = 0, p = 1; i < 256; ++i) {
-               pow_tab[i] = (u8)p;
-               log_tab[p] = (u8)i;
-
-               p ^= (p << 1) ^ (p & 0x80 ? 0x01b : 0);
-       }
-
-       log_tab[1] = 0;
-
-       for (i = 0, p = 1; i < 10; ++i) {
-               rco_tab[i] = p;
-
-               p = (p << 1) ^ (p & 0x80 ? 0x01b : 0);
-       }
-
-       for (i = 0; i < 256; ++i) {
-               p = (i ? pow_tab[255 - log_tab[i]] : 0);
-               q = ((p >> 7) | (p << 1)) ^ ((p >> 6) | (p << 2));
-               p ^= 0x63 ^ q ^ ((q >> 6) | (q << 2));
-               sbx_tab[i] = p;
-               isb_tab[p] = (u8)i;
-       }
-
-       for (i = 0; i < 256; ++i) {
-               p = sbx_tab[i];
-
-               t = p;
-               aes_fl_tab[0][i] = t;
-               aes_fl_tab[1][i] = rol32(t, 8);
-               aes_fl_tab[2][i] = rol32(t, 16);
-               aes_fl_tab[3][i] = rol32(t, 24);
-
-               t = ((u32)ff_mult(2, p)) |
-                   ((u32)p << 8) |
-                   ((u32)p << 16) | ((u32)ff_mult(3, p) << 24);
-
-               aes_ft_tab[0][i] = t;
-               aes_ft_tab[1][i] = rol32(t, 8);
-               aes_ft_tab[2][i] = rol32(t, 16);
-               aes_ft_tab[3][i] = rol32(t, 24);
-
-               p = isb_tab[i];
-
-               t = p;
-               aes_il_tab[0][i] = t;
-               aes_il_tab[1][i] = rol32(t, 8);
-               aes_il_tab[2][i] = rol32(t, 16);
-               aes_il_tab[3][i] = rol32(t, 24);
-
-               t = ((u32)ff_mult(14, p)) |
-                   ((u32)ff_mult(9, p) << 8) |
-                   ((u32)ff_mult(13, p) << 16) |
-                   ((u32)ff_mult(11, p) << 24);
-
-               aes_it_tab[0][i] = t;
-               aes_it_tab[1][i] = rol32(t, 8);
-               aes_it_tab[2][i] = rol32(t, 16);
-               aes_it_tab[3][i] = rol32(t, 24);
-       }
-}
-
-#define star_x(x) (((x) & 0x7f7f7f7f) << 1) ^ ((((x) & 0x80808080) >> 7) * 
0x1b)
-
-#define imix_col(y, x)                 \
-       u    = star_x(x);               \
-       v    = star_x(u);               \
-       w    = star_x(v);               \
-       t    = w ^ (x);                 \
-       (y)  = u ^ v ^ w;               \
-       (y) ^= ror32(u ^ t,  8) ^       \
-              ror32(v ^ t, 16) ^       \
-              ror32(t, 24)
-
-/* initialise the key schedule from the user supplied key */
-
-#define loop4(i)                                       \
-{                                                      \
-       t = ror32(t,  8); t = ls_box(t) ^ rco_tab[i];   \
-       t ^= E_KEY[4 * i];     E_KEY[4 * i + 4] = t;    \
-       t ^= E_KEY[4 * i + 1]; E_KEY[4 * i + 5] = t;    \
-       t ^= E_KEY[4 * i + 2]; E_KEY[4 * i + 6] = t;    \
-       t ^= E_KEY[4 * i + 3]; E_KEY[4 * i + 7] = t;    \
-}
-
-#define loop6(i)                                       \
-{                                                      \
-       t = ror32(t,  8); t = ls_box(t) ^ rco_tab[i];   \
-       t ^= E_KEY[6 * i];     E_KEY[6 * i + 6] = t;    \
-       t ^= E_KEY[6 * i + 1]; E_KEY[6 * i + 7] = t;    \
-       t ^= E_KEY[6 * i + 2]; E_KEY[6 * i + 8] = t;    \
-       t ^= E_KEY[6 * i + 3]; E_KEY[6 * i + 9] = t;    \
-       t ^= E_KEY[6 * i + 4]; E_KEY[6 * i + 10] = t;   \
-       t ^= E_KEY[6 * i + 5]; E_KEY[6 * i + 11] = t;   \
-}
-
-#define loop8(i)                                       \
-{                                                      \
-       t = ror32(t,  8); ; t = ls_box(t) ^ rco_tab[i]; \
-       t ^= E_KEY[8 * i];     E_KEY[8 * i + 8] = t;    \
-       t ^= E_KEY[8 * i + 1]; E_KEY[8 * i + 9] = t;    \
-       t ^= E_KEY[8 * i + 2]; E_KEY[8 * i + 10] = t;   \
-       t ^= E_KEY[8 * i + 3]; E_KEY[8 * i + 11] = t;   \
-       t  = E_KEY[8 * i + 4] ^ ls_box(t);              \
-       E_KEY[8 * i + 12] = t;                          \
-       t ^= E_KEY[8 * i + 5]; E_KEY[8 * i + 13] = t;   \
-       t ^= E_KEY[8 * i + 6]; E_KEY[8 * i + 14] = t;   \
-       t ^= E_KEY[8 * i + 7]; E_KEY[8 * i + 15] = t;   \
-}
-
-static int aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
-                      unsigned int key_len)
-{
-       struct aes_ctx *ctx = crypto_tfm_ctx(tfm);
-       const __le32 *key = (const __le32 *)in_key;
-       u32 *flags = &tfm->crt_flags;
-       u32 i, j, t, u, v, w;
-
-       if (key_len % 8) {
-               *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
-               return -EINVAL;
-       }
-
-       ctx->key_length = key_len;
-
-       D_KEY[key_len + 24] = E_KEY[0] = le32_to_cpu(key[0]);
-       D_KEY[key_len + 25] = E_KEY[1] = le32_to_cpu(key[1]);
-       D_KEY[key_len + 26] = E_KEY[2] = le32_to_cpu(key[2]);
-       D_KEY[key_len + 27] = E_KEY[3] = le32_to_cpu(key[3]);
-
-       switch (key_len) {
-       case 16:
-               t = E_KEY[3];
-               for (i = 0; i < 10; ++i)
-                       loop4(i);
-               break;
-
-       case 24:
-               E_KEY[4] = le32_to_cpu(key[4]);
-               t = E_KEY[5] = le32_to_cpu(key[5]);
-               for (i = 0; i < 8; ++i)
-                       loop6 (i);
-               break;
-
-       case 32:
-               E_KEY[4] = le32_to_cpu(key[4]);
-               E_KEY[5] = le32_to_cpu(key[5]);
-               E_KEY[6] = le32_to_cpu(key[6]);
-               t = E_KEY[7] = le32_to_cpu(key[7]);
-               for (i = 0; i < 7; ++i)
-                       loop8(i);
-               break;
-       }
-
-       D_KEY[0] = E_KEY[key_len + 24];
-       D_KEY[1] = E_KEY[key_len + 25];
-       D_KEY[2] = E_KEY[key_len + 26];
-       D_KEY[3] = E_KEY[key_len + 27];
-
-       for (i = 4; i < key_len + 24; ++i) {
-               j = key_len + 24 - (i & ~3) + (i & 3);
-               imix_col(D_KEY[j], E_KEY[i]);
-       }
-
-       return 0;
-}
-
-asmlinkage void aes_enc_blk(struct crypto_tfm *tfm, u8 *out, const u8 *in);
-asmlinkage void aes_dec_blk(struct crypto_tfm *tfm, u8 *out, const u8 *in);
-
-static void aes_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
-{
-       aes_enc_blk(tfm, dst, src);
-}
-
-static void aes_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
-{
-       aes_dec_blk(tfm, dst, src);
-}
-
-static struct crypto_alg aes_alg = {
-       .cra_name               =       "aes",
-       .cra_driver_name        =       "aes-x86_64",
-       .cra_priority           =       200,
-       .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
-       .cra_blocksize          =       AES_BLOCK_SIZE,
-       .cra_ctxsize            =       sizeof(struct aes_ctx),
-       .cra_module             =       THIS_MODULE,
-       .cra_list               =       LIST_HEAD_INIT(aes_alg.cra_list),
-       .cra_u                  =       {
-               .cipher = {
-                       .cia_min_keysize        =       AES_MIN_KEY_SIZE,
-                       .cia_max_keysize        =       AES_MAX_KEY_SIZE,
-                       .cia_setkey             =       aes_set_key,
-                       .cia_encrypt            =       aes_encrypt,
-                       .cia_decrypt            =       aes_decrypt
-               }
-       }
-};
-
-static int __init aes_init(void)
-{
-       gen_tabs();
-       return crypto_register_alg(&aes_alg);
-}
-
-static void __exit aes_fini(void)
-{
-       crypto_unregister_alg(&aes_alg);
-}
-
-module_init(aes_init);
-module_exit(aes_fini);
-
-MODULE_DESCRIPTION("Rijndael (AES) Cipher Algorithm");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("aes");
diff --git a/arch/x86_64/crypto/twofish-x86_64-asm_64.S 
b/arch/x86_64/crypto/twofish-x86_64-asm_64.S
deleted file mode 100644
index 35974a5..0000000
--- a/arch/x86_64/crypto/twofish-x86_64-asm_64.S
+++ /dev/null
@@ -1,324 +0,0 @@
-/***************************************************************************
-*   Copyright (C) 2006 by Joachim Fritschi, <[EMAIL PROTECTED]>        *
-*                                                                         *
-*   This program is free software; you can redistribute it and/or modify  *
-*   it under the terms of the GNU General Public License as published by  *
-*   the Free Software Foundation; either version 2 of the License, or     *
-*   (at your option) any later version.                                   *
-*                                                                         *
-*   This program is distributed in the hope that it will be useful,       *
-*   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
-*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
-*   GNU General Public License for more details.                          *
-*                                                                         *
-*   You should have received a copy of the GNU General Public License     *
-*   along with this program; if not, write to the                         *
-*   Free Software Foundation, Inc.,                                       *
-*   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
-***************************************************************************/
-
-.file "twofish-x86_64-asm.S"
-.text
-
-#include <asm/asm-offsets.h>
-
-#define a_offset       0
-#define b_offset       4
-#define c_offset       8
-#define d_offset       12
-
-/* Structure of the crypto context struct*/
-
-#define s0     0       /* S0 Array 256 Words each */
-#define s1     1024    /* S1 Array */
-#define s2     2048    /* S2 Array */
-#define s3     3072    /* S3 Array */
-#define w      4096    /* 8 whitening keys (word) */
-#define k      4128    /* key 1-32 ( word ) */
-
-/* define a few register aliases to allow macro substitution */
-
-#define R0     %rax
-#define R0D    %eax
-#define R0B    %al
-#define R0H    %ah
-
-#define R1     %rbx
-#define R1D    %ebx
-#define R1B    %bl
-#define R1H    %bh
-
-#define R2     %rcx
-#define R2D    %ecx
-#define R2B    %cl
-#define R2H    %ch
-
-#define R3     %rdx
-#define R3D    %edx
-#define R3B    %dl
-#define R3H    %dh
-
-
-/* performs input whitening */
-#define input_whitening(src,context,offset)\
-       xor     w+offset(context),      src;
-
-/* performs input whitening */
-#define output_whitening(src,context,offset)\
-       xor     w+16+offset(context),   src;
-
-
-/*
- * a input register containing a (rotated 16)
- * b input register containing b
- * c input register containing c
- * d input register containing d (already rol $1)
- * operations on a and b are interleaved to increase performance
- */
-#define encrypt_round(a,b,c,d,round)\
-       movzx   b ## B,         %edi;\
-       mov     s1(%r11,%rdi,4),%r8d;\
-       movzx   a ## B,         %edi;\
-       mov     s2(%r11,%rdi,4),%r9d;\
-       movzx   b ## H,         %edi;\
-       ror     $16,            b ## D;\
-       xor     s2(%r11,%rdi,4),%r8d;\
-       movzx   a ## H,         %edi;\
-       ror     $16,            a ## D;\
-       xor     s3(%r11,%rdi,4),%r9d;\
-       movzx   b ## B,         %edi;\
-       xor     s3(%r11,%rdi,4),%r8d;\
-       movzx   a ## B,         %edi;\
-       xor     (%r11,%rdi,4),  %r9d;\
-       movzx   b ## H,         %edi;\
-       ror     $15,            b ## D;\
-       xor     (%r11,%rdi,4),  %r8d;\
-       movzx   a ## H,         %edi;\
-       xor     s1(%r11,%rdi,4),%r9d;\
-       add     %r8d,           %r9d;\
-       add     %r9d,           %r8d;\
-       add     k+round(%r11),  %r9d;\
-       xor     %r9d,           c ## D;\
-       rol     $15,            c ## D;\
-       add     k+4+round(%r11),%r8d;\
-       xor     %r8d,           d ## D;
-
-/*
- * a input register containing a(rotated 16)
- * b input register containing b
- * c input register containing c
- * d input register containing d (already rol $1)
- * operations on a and b are interleaved to increase performance
- * during the round a and b are prepared for the output whitening
- */
-#define encrypt_last_round(a,b,c,d,round)\
-       mov     b ## D,         %r10d;\
-       shl     $32,            %r10;\
-       movzx   b ## B,         %edi;\
-       mov     s1(%r11,%rdi,4),%r8d;\
-       movzx   a ## B,         %edi;\
-       mov     s2(%r11,%rdi,4),%r9d;\
-       movzx   b ## H,         %edi;\
-       ror     $16,            b ## D;\
-       xor     s2(%r11,%rdi,4),%r8d;\
-       movzx   a ## H,         %edi;\
-       ror     $16,            a ## D;\
-       xor     s3(%r11,%rdi,4),%r9d;\
-       movzx   b ## B,         %edi;\
-       xor     s3(%r11,%rdi,4),%r8d;\
-       movzx   a ## B,         %edi;\
-       xor     (%r11,%rdi,4),  %r9d;\
-       xor     a,              %r10;\
-       movzx   b ## H,         %edi;\
-       xor     (%r11,%rdi,4),  %r8d;\
-       movzx   a ## H,         %edi;\
-       xor     s1(%r11,%rdi,4),%r9d;\
-       add     %r8d,           %r9d;\
-       add     %r9d,           %r8d;\
-       add     k+round(%r11),  %r9d;\
-       xor     %r9d,           c ## D;\
-       ror     $1,             c ## D;\
-       add     k+4+round(%r11),%r8d;\
-       xor     %r8d,           d ## D
-
-/*
- * a input register containing a
- * b input register containing b (rotated 16)
- * c input register containing c (already rol $1)
- * d input register containing d
- * operations on a and b are interleaved to increase performance
- */
-#define decrypt_round(a,b,c,d,round)\
-       movzx   a ## B,         %edi;\
-       mov     (%r11,%rdi,4),  %r9d;\
-       movzx   b ## B,         %edi;\
-       mov     s3(%r11,%rdi,4),%r8d;\
-       movzx   a ## H,         %edi;\
-       ror     $16,            a ## D;\
-       xor     s1(%r11,%rdi,4),%r9d;\
-       movzx   b ## H,         %edi;\
-       ror     $16,            b ## D;\
-       xor     (%r11,%rdi,4),  %r8d;\
-       movzx   a ## B,         %edi;\
-       xor     s2(%r11,%rdi,4),%r9d;\
-       movzx   b ## B,         %edi;\
-       xor     s1(%r11,%rdi,4),%r8d;\
-       movzx   a ## H,         %edi;\
-       ror     $15,            a ## D;\
-       xor     s3(%r11,%rdi,4),%r9d;\
-       movzx   b ## H,         %edi;\
-       xor     s2(%r11,%rdi,4),%r8d;\
-       add     %r8d,           %r9d;\
-       add     %r9d,           %r8d;\
-       add     k+round(%r11),  %r9d;\
-       xor     %r9d,           c ## D;\
-       add     k+4+round(%r11),%r8d;\
-       xor     %r8d,           d ## D;\
-       rol     $15,            d ## D;
-
-/*
- * a input register containing a
- * b input register containing b
- * c input register containing c (already rol $1)
- * d input register containing d
- * operations on a and b are interleaved to increase performance
- * during the round a and b are prepared for the output whitening
- */
-#define decrypt_last_round(a,b,c,d,round)\
-       movzx   a ## B,         %edi;\
-       mov     (%r11,%rdi,4),  %r9d;\
-       movzx   b ## B,         %edi;\
-       mov     s3(%r11,%rdi,4),%r8d;\
-       movzx   b ## H,         %edi;\
-       ror     $16,            b ## D;\
-       xor     (%r11,%rdi,4),  %r8d;\
-       movzx   a ## H,         %edi;\
-       mov     b ## D,         %r10d;\
-       shl     $32,            %r10;\
-       xor     a,              %r10;\
-       ror     $16,            a ## D;\
-       xor     s1(%r11,%rdi,4),%r9d;\
-       movzx   b ## B,         %edi;\
-       xor     s1(%r11,%rdi,4),%r8d;\
-       movzx   a ## B,         %edi;\
-       xor     s2(%r11,%rdi,4),%r9d;\
-       movzx   b ## H,         %edi;\
-       xor     s2(%r11,%rdi,4),%r8d;\
-       movzx   a ## H,         %edi;\
-       xor     s3(%r11,%rdi,4),%r9d;\
-       add     %r8d,           %r9d;\
-       add     %r9d,           %r8d;\
-       add     k+round(%r11),  %r9d;\
-       xor     %r9d,           c ## D;\
-       add     k+4+round(%r11),%r8d;\
-       xor     %r8d,           d ## D;\
-       ror     $1,             d ## D;
-
-.align 8
-.global twofish_enc_blk
-.global twofish_dec_blk
-
-twofish_enc_blk:
-       pushq    R1
-
-       /* %rdi contains the crypto tfm adress */
-       /* %rsi contains the output adress */
-       /* %rdx contains the input adress */
-       add     $crypto_tfm_ctx_offset, %rdi    /* set ctx adress */
-       /* ctx adress is moved to free one non-rex register
-       as target for the 8bit high operations */
-       mov     %rdi,           %r11
-
-       movq    (R3),   R1
-       movq    8(R3),  R3
-       input_whitening(R1,%r11,a_offset)
-       input_whitening(R3,%r11,c_offset)
-       mov     R1D,    R0D
-       rol     $16,    R0D
-       shr     $32,    R1
-       mov     R3D,    R2D
-       shr     $32,    R3
-       rol     $1,     R3D
-
-       encrypt_round(R0,R1,R2,R3,0);
-       encrypt_round(R2,R3,R0,R1,8);
-       encrypt_round(R0,R1,R2,R3,2*8);
-       encrypt_round(R2,R3,R0,R1,3*8);
-       encrypt_round(R0,R1,R2,R3,4*8);
-       encrypt_round(R2,R3,R0,R1,5*8);
-       encrypt_round(R0,R1,R2,R3,6*8);
-       encrypt_round(R2,R3,R0,R1,7*8);
-       encrypt_round(R0,R1,R2,R3,8*8);
-       encrypt_round(R2,R3,R0,R1,9*8);
-       encrypt_round(R0,R1,R2,R3,10*8);
-       encrypt_round(R2,R3,R0,R1,11*8);
-       encrypt_round(R0,R1,R2,R3,12*8);
-       encrypt_round(R2,R3,R0,R1,13*8);
-       encrypt_round(R0,R1,R2,R3,14*8);
-       encrypt_last_round(R2,R3,R0,R1,15*8);
-
-
-       output_whitening(%r10,%r11,a_offset)
-       movq    %r10,   (%rsi)
-
-       shl     $32,    R1
-       xor     R0,     R1
-
-       output_whitening(R1,%r11,c_offset)
-       movq    R1,     8(%rsi)
-
-       popq    R1
-       movq    $1,%rax
-       ret
-
-twofish_dec_blk:
-       pushq    R1
-
-       /* %rdi contains the crypto tfm adress */
-       /* %rsi contains the output adress */
-       /* %rdx contains the input adress */
-       add     $crypto_tfm_ctx_offset, %rdi    /* set ctx adress */
-       /* ctx adress is moved to free one non-rex register
-       as target for the 8bit high operations */
-       mov     %rdi,           %r11
-
-       movq    (R3),   R1
-       movq    8(R3),  R3
-       output_whitening(R1,%r11,a_offset)
-       output_whitening(R3,%r11,c_offset)
-       mov     R1D,    R0D
-       shr     $32,    R1
-       rol     $16,    R1D
-       mov     R3D,    R2D
-       shr     $32,    R3
-       rol     $1,     R2D
-
-       decrypt_round(R0,R1,R2,R3,15*8);
-       decrypt_round(R2,R3,R0,R1,14*8);
-       decrypt_round(R0,R1,R2,R3,13*8);
-       decrypt_round(R2,R3,R0,R1,12*8);
-       decrypt_round(R0,R1,R2,R3,11*8);
-       decrypt_round(R2,R3,R0,R1,10*8);
-       decrypt_round(R0,R1,R2,R3,9*8);
-       decrypt_round(R2,R3,R0,R1,8*8);
-       decrypt_round(R0,R1,R2,R3,7*8);
-       decrypt_round(R2,R3,R0,R1,6*8);
-       decrypt_round(R0,R1,R2,R3,5*8);
-       decrypt_round(R2,R3,R0,R1,4*8);
-       decrypt_round(R0,R1,R2,R3,3*8);
-       decrypt_round(R2,R3,R0,R1,2*8);
-       decrypt_round(R0,R1,R2,R3,1*8);
-       decrypt_last_round(R2,R3,R0,R1,0);
-
-       input_whitening(%r10,%r11,a_offset)
-       movq    %r10,   (%rsi)
-
-       shl     $32,    R1
-       xor     R0,     R1
-
-       input_whitening(R1,%r11,c_offset)
-       movq    R1,     8(%rsi)
-
-       popq    R1
-       movq    $1,%rax
-       ret
diff --git a/arch/x86_64/crypto/twofish_64.c b/arch/x86_64/crypto/twofish_64.c
deleted file mode 100644
index 182d91d..0000000
--- a/arch/x86_64/crypto/twofish_64.c
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Glue Code for optimized x86_64 assembler version of TWOFISH
- *
- * Originally Twofish for GPG
- * By Matthew Skala <[EMAIL PROTECTED]>, July 26, 1998
- * 256-bit key length added March 20, 1999
- * Some modifications to reduce the text size by Werner Koch, April, 1998
- * Ported to the kerneli patch by Marc Mutz <[EMAIL PROTECTED]>
- * Ported to CryptoAPI by Colin Slater <[EMAIL PROTECTED]>
- *
- * The original author has disclaimed all copyright interest in this
- * code and thus put it in the public domain. The subsequent authors
- * have put this under the GNU General Public License.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
- * USA
- *
- * This code is a "clean room" implementation, written from the paper
- * _Twofish: A 128-Bit Block Cipher_ by Bruce Schneier, John Kelsey,
- * Doug Whiting, David Wagner, Chris Hall, and Niels Ferguson, available
- * through http://www.counterpane.com/twofish.html
- *
- * For background information on multiplication in finite fields, used for
- * the matrix operations in the key schedule, see the book _Contemporary
- * Abstract Algebra_ by Joseph A. Gallian, especially chapter 22 in the
- * Third Edition.
- */
-
-#include <crypto/twofish.h>
-#include <linux/crypto.h>
-#include <linux/init.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/types.h>
-
-asmlinkage void twofish_enc_blk(struct crypto_tfm *tfm, u8 *dst, const u8 
*src);
-asmlinkage void twofish_dec_blk(struct crypto_tfm *tfm, u8 *dst, const u8 
*src);
-
-static void twofish_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
-{
-       twofish_enc_blk(tfm, dst, src);
-}
-
-static void twofish_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
-{
-       twofish_dec_blk(tfm, dst, src);
-}
-
-static struct crypto_alg alg = {
-       .cra_name               =       "twofish",
-       .cra_driver_name        =       "twofish-x86_64",
-       .cra_priority           =       200,
-       .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
-       .cra_blocksize          =       TF_BLOCK_SIZE,
-       .cra_ctxsize            =       sizeof(struct twofish_ctx),
-       .cra_alignmask          =       3,
-       .cra_module             =       THIS_MODULE,
-       .cra_list               =       LIST_HEAD_INIT(alg.cra_list),
-       .cra_u                  =       {
-               .cipher = {
-                       .cia_min_keysize        =       TF_MIN_KEY_SIZE,
-                       .cia_max_keysize        =       TF_MAX_KEY_SIZE,
-                       .cia_setkey             =       twofish_setkey,
-                       .cia_encrypt            =       twofish_encrypt,
-                       .cia_decrypt            =       twofish_decrypt
-               }
-       }
-};
-
-static int __init init(void)
-{
-       return crypto_register_alg(&alg);
-}
-
-static void __exit fini(void)
-{
-       crypto_unregister_alg(&alg);
-}
-
-module_init(init);
-module_exit(fini);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION ("Twofish Cipher Algorithm, x86_64 asm optimized");
-MODULE_ALIAS("twofish");
-
To unsubscribe from this list: send the line "unsubscribe git-commits-head" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to