Added missing tegra files.HEADmaster

5 files changed, 3541 insertions, 0 deletions

diff --git a/crypto/blowfish.c b/crypto/blowfish.c
new file mode 100644
index 00000000000..a67d52ee058
--- /dev/null
+++ b/crypto/blowfish.c
@@ -0,0 +1,482 @@
+/*
+ * Cryptographic API.
+ *
+ * Blowfish Cipher Algorithm, by Bruce Schneier.
+ * http://www.counterpane.com/blowfish.html
+ *
+ * Adapted from Kerneli implementation.
+ *
+ * Copyright (c) Herbert Valerio Riedel <hvr@hvrlab.org>
+ * Copyright (c) Kyle McMartin <kyle@debian.org>
+ * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
+ *
+ * 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.
+ *
+ */
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/mm.h>
+#include <asm/byteorder.h>
+#include <linux/crypto.h>
+#include <linux/types.h>
+
+#define BF_BLOCK_SIZE 8
+#define BF_MIN_KEY_SIZE 4
+#define BF_MAX_KEY_SIZE 56
+
+struct bf_ctx {
+        u32 p[18];
+        u32 s[1024];
+};
+
+static const u32 bf_pbox[16 + 2] = {
+        0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
+        0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
+        0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
+        0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
+        0x9216d5d9, 0x8979fb1b,
+};
+
+static const u32 bf_sbox[256 * 4] = {
+        0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
+        0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
+        0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
+        0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
+        0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
+        0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
+        0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
+        0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
+        0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
+        0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
+        0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
+        0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
+        0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
+        0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
+        0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
+        0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
+        0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
+        0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
+        0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
+        0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
+        0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
+        0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
+        0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
+        0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
+        0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
+        0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
+        0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
+        0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
+        0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
+        0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
+        0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
+        0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
+        0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
+        0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
+        0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
+        0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
+        0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
+        0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
+        0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
+        0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
+        0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
+        0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
+        0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
+        0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
+        0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
+        0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
+        0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
+        0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
+        0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
+        0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
+        0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
+        0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
+        0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
+        0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
+        0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
+        0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
+        0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
+        0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
+        0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
+        0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
+        0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
+        0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
+        0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
+        0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a,
+        0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
+        0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
+        0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
+        0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
+        0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
+        0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
+        0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
+        0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
+        0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
+        0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
+        0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
+        0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
+        0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
+        0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
+        0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
+        0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
+        0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
+        0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
+        0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
+        0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
+        0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
+        0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
+        0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
+        0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
+        0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
+        0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
+        0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
+        0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
+        0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
+        0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
+        0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
+        0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
+        0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
+        0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
+        0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
+        0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
+        0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
+        0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
+        0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
+        0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
+        0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
+        0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
+        0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
+        0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
+        0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
+        0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
+        0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
+        0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
+        0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
+        0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
+        0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
+        0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
+        0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
+        0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
+        0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
+        0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
+        0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
+        0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
+        0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
+        0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
+        0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
+        0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
+        0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
+        0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7,
+        0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
+        0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
+        0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
+        0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
+        0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
+        0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
+        0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
+        0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
+        0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
+        0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
+        0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
+        0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
+        0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
+        0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
+        0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
+        0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
+        0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
+        0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
+        0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
+        0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
+        0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
+        0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
+        0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
+        0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
+        0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
+        0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
+        0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
+        0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
+        0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
+        0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
+        0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
+        0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
+        0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
+        0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
+        0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
+        0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
+        0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
+        0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
+        0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
+        0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
+        0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
+        0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
+        0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
+        0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
+        0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
+        0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
+        0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
+        0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
+        0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
+        0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
+        0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
+        0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
+        0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
+        0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
+        0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
+        0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
+        0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
+        0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
+        0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
+        0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
+        0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
+        0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
+        0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
+        0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0,
+        0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
+        0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
+        0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
+        0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
+        0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
+        0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
+        0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
+        0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
+        0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
+        0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
+        0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
+        0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
+        0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
+        0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
+        0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
+        0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
+        0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
+        0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
+        0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
+        0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
+        0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
+        0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
+        0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
+        0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
+        0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
+        0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
+        0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
+        0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
+        0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
+        0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
+        0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
+        0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
+        0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
+        0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
+        0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
+        0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
+        0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
+        0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
+        0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
+        0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
+        0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
+        0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
+        0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
+        0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
+        0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
+        0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
+        0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
+        0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
+        0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
+        0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
+        0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
+        0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
+        0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
+        0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
+        0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
+        0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
+        0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
+        0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
+        0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
+        0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
+        0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
+        0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
+        0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
+        0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6,
+};
+
+/*
+ * Round loop unrolling macros, S is a pointer to a S-Box array
+ * organized in 4 unsigned longs at a row.
+ */
+#define GET32_3(x) (((x) & 0xff))
+#define GET32_2(x) (((x) >> (8)) & (0xff))
+#define GET32_1(x) (((x) >> (16)) & (0xff))
+#define GET32_0(x) (((x) >> (24)) & (0xff))
+
+#define bf_F(x) (((S[GET32_0(x)] + S[256 + GET32_1(x)]) ^ \
+          S[512 + GET32_2(x)]) + S[768 + GET32_3(x)])
+
+#define ROUND(a, b, n)  b ^= P[n]; a ^= bf_F (b)
+
+/*
+ * The blowfish encipher, processes 64-bit blocks.
+ * NOTE: This function MUSTN'T respect endianess
+ */
+static void encrypt_block(struct bf_ctx *bctx, u32 *dst, u32 *src)
+{
+        const u32 *P = bctx->p;
+        const u32 *S = bctx->s;
+        u32 yl = src[0];
+        u32 yr = src[1];
+
+        ROUND(yr, yl, 0);
+        ROUND(yl, yr, 1);
+        ROUND(yr, yl, 2);
+        ROUND(yl, yr, 3);
+        ROUND(yr, yl, 4);
+        ROUND(yl, yr, 5);
+        ROUND(yr, yl, 6);
+        ROUND(yl, yr, 7);
+        ROUND(yr, yl, 8);
+        ROUND(yl, yr, 9);
+        ROUND(yr, yl, 10);
+        ROUND(yl, yr, 11);
+        ROUND(yr, yl, 12);
+        ROUND(yl, yr, 13);
+        ROUND(yr, yl, 14);
+        ROUND(yl, yr, 15);
+
+        yl ^= P[16];
+        yr ^= P[17];
+
+        dst[0] = yr;
+        dst[1] = yl;
+}
+
+static void bf_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
+{
+        const __be32 *in_blk = (const __be32 *)src;
+        __be32 *const out_blk = (__be32 *)dst;
+        u32 in32[2], out32[2];
+
+        in32[0] = be32_to_cpu(in_blk[0]);
+        in32[1] = be32_to_cpu(in_blk[1]);
+        encrypt_block(crypto_tfm_ctx(tfm), out32, in32);
+        out_blk[0] = cpu_to_be32(out32[0]);
+        out_blk[1] = cpu_to_be32(out32[1]);
+}
+
+static void bf_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
+{
+        struct bf_ctx *ctx = crypto_tfm_ctx(tfm);
+        const __be32 *in_blk = (const __be32 *)src;
+        __be32 *const out_blk = (__be32 *)dst;
+        const u32 *P = ctx->p;
+        const u32 *S = ctx->s;
+        u32 yl = be32_to_cpu(in_blk[0]);
+        u32 yr = be32_to_cpu(in_blk[1]);
+
+        ROUND(yr, yl, 17);
+        ROUND(yl, yr, 16);
+        ROUND(yr, yl, 15);
+        ROUND(yl, yr, 14);
+        ROUND(yr, yl, 13);
+        ROUND(yl, yr, 12);
+        ROUND(yr, yl, 11);
+        ROUND(yl, yr, 10);
+        ROUND(yr, yl, 9);
+        ROUND(yl, yr, 8);
+        ROUND(yr, yl, 7);
+        ROUND(yl, yr, 6);
+        ROUND(yr, yl, 5);
+        ROUND(yl, yr, 4);
+        ROUND(yr, yl, 3);
+        ROUND(yl, yr, 2);
+
+        yl ^= P[1];
+        yr ^= P[0];
+
+        out_blk[0] = cpu_to_be32(yr);
+        out_blk[1] = cpu_to_be32(yl);
+}
+
+/*
+ * Calculates the blowfish S and P boxes for encryption and decryption.
+ */
+static int bf_setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen)
+{
+        struct bf_ctx *ctx = crypto_tfm_ctx(tfm);
+        u32 *P = ctx->p;
+        u32 *S = ctx->s;
+        short i, j, count;
+        u32 data[2], temp;
+
+        /* Copy the initialization s-boxes */
+        for (i = 0, count = 0; i < 256; i++)
+                for (j = 0; j < 4; j++, count++)
+                        S[count] = bf_sbox[count];
+
+        /* Set the p-boxes */
+        for (i = 0; i < 16 + 2; i++)
+                P[i] = bf_pbox[i];
+
+        /* Actual subkey generation */
+        for (j = 0, i = 0; i < 16 + 2; i++) {
+                temp = (((u32)key[j] << 24) |
+                        ((u32)key[(j + 1) % keylen] << 16) |
+                        ((u32)key[(j + 2) % keylen] << 8) |
+                        ((u32)key[(j + 3) % keylen]));
+
+                P[i] = P[i] ^ temp;
+                j = (j + 4) % keylen;
+        }
+
+        data[0] = 0x00000000;
+        data[1] = 0x00000000;
+
+        for (i = 0; i < 16 + 2; i += 2) {
+                encrypt_block((struct bf_ctx *)ctx, data, data);
+
+                P[i] = data[0];
+                P[i + 1] = data[1];
+        }
+
+        for (i = 0; i < 4; i++) {
+                for (j = 0, count = i * 256; j < 256; j += 2, count += 2) {
+                        encrypt_block((struct bf_ctx *)ctx, data, data);
+
+                        S[count] = data[0];
+                        S[count + 1] = data[1];
+                }
+        }
+
+        /* Bruce says not to bother with the weak key check. */
+        return 0;
+}
+
+static struct crypto_alg alg = {
+        .cra_name               =       "blowfish",
+        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
+        .cra_blocksize          =       BF_BLOCK_SIZE,
+        .cra_ctxsize            =       sizeof(struct bf_ctx),
+        .cra_alignmask          =       3,
+        .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(alg.cra_list),
+        .cra_u                  =       { .cipher = {
+        .cia_min_keysize        =       BF_MIN_KEY_SIZE,
+        .cia_max_keysize        =       BF_MAX_KEY_SIZE,
+        .cia_setkey             =       bf_setkey,
+        .cia_encrypt            =       bf_encrypt,
+        .cia_decrypt            =       bf_decrypt } }
+};
+
+static int __init blowfish_mod_init(void)
+{
+        return crypto_register_alg(&alg);
+}
+
+static void __exit blowfish_mod_fini(void)
+{
+        crypto_unregister_alg(&alg);
+}
+
+module_init(blowfish_mod_init);
+module_exit(blowfish_mod_fini);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Blowfish Cipher Algorithm");
diff --git a/crypto/camellia.c b/crypto/camellia.c
new file mode 100644
index 00000000000..64cff46ea5e
--- /dev/null
+++ b/crypto/camellia.c
@@ -0,0 +1,1116 @@
+/*
+ * Copyright (C) 2006
+ * NTT (Nippon Telegraph and Telephone Corporation).
+ *
+ * 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.
+ */
+
+/*
+ * Algorithm Specification
+ *  http://info.isl.ntt.co.jp/crypt/eng/camellia/specifications.html
+ */
+
+/*
+ *
+ * NOTE --- NOTE --- NOTE --- NOTE
+ * This implementation assumes that all memory addresses passed
+ * as parameters are four-byte aligned.
+ *
+ */
+
+#include <linux/crypto.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/bitops.h>
+#include <asm/unaligned.h>
+
+static const u32 camellia_sp1110[256] = {
+        0x70707000, 0x82828200, 0x2c2c2c00, 0xececec00,
+        0xb3b3b300, 0x27272700, 0xc0c0c000, 0xe5e5e500,
+        0xe4e4e400, 0x85858500, 0x57575700, 0x35353500,
+        0xeaeaea00, 0x0c0c0c00, 0xaeaeae00, 0x41414100,
+        0x23232300, 0xefefef00, 0x6b6b6b00, 0x93939300,
+        0x45454500, 0x19191900, 0xa5a5a500, 0x21212100,
+        0xededed00, 0x0e0e0e00, 0x4f4f4f00, 0x4e4e4e00,
+        0x1d1d1d00, 0x65656500, 0x92929200, 0xbdbdbd00,
+        0x86868600, 0xb8b8b800, 0xafafaf00, 0x8f8f8f00,
+        0x7c7c7c00, 0xebebeb00, 0x1f1f1f00, 0xcecece00,
+        0x3e3e3e00, 0x30303000, 0xdcdcdc00, 0x5f5f5f00,
+        0x5e5e5e00, 0xc5c5c500, 0x0b0b0b00, 0x1a1a1a00,
+        0xa6a6a600, 0xe1e1e100, 0x39393900, 0xcacaca00,
+        0xd5d5d500, 0x47474700, 0x5d5d5d00, 0x3d3d3d00,
+        0xd9d9d900, 0x01010100, 0x5a5a5a00, 0xd6d6d600,
+        0x51515100, 0x56565600, 0x6c6c6c00, 0x4d4d4d00,
+        0x8b8b8b00, 0x0d0d0d00, 0x9a9a9a00, 0x66666600,
+        0xfbfbfb00, 0xcccccc00, 0xb0b0b000, 0x2d2d2d00,
+        0x74747400, 0x12121200, 0x2b2b2b00, 0x20202000,
+        0xf0f0f000, 0xb1b1b100, 0x84848400, 0x99999900,
+        0xdfdfdf00, 0x4c4c4c00, 0xcbcbcb00, 0xc2c2c200,
+        0x34343400, 0x7e7e7e00, 0x76767600, 0x05050500,
+        0x6d6d6d00, 0xb7b7b700, 0xa9a9a900, 0x31313100,
+        0xd1d1d100, 0x17171700, 0x04040400, 0xd7d7d700,
+        0x14141400, 0x58585800, 0x3a3a3a00, 0x61616100,
+        0xdedede00, 0x1b1b1b00, 0x11111100, 0x1c1c1c00,
+        0x32323200, 0x0f0f0f00, 0x9c9c9c00, 0x16161600,
+        0x53535300, 0x18181800, 0xf2f2f200, 0x22222200,
+        0xfefefe00, 0x44444400, 0xcfcfcf00, 0xb2b2b200,
+        0xc3c3c300, 0xb5b5b500, 0x7a7a7a00, 0x91919100,
+        0x24242400, 0x08080800, 0xe8e8e800, 0xa8a8a800,
+        0x60606000, 0xfcfcfc00, 0x69696900, 0x50505000,
+        0xaaaaaa00, 0xd0d0d000, 0xa0a0a000, 0x7d7d7d00,
+        0xa1a1a100, 0x89898900, 0x62626200, 0x97979700,
+        0x54545400, 0x5b5b5b00, 0x1e1e1e00, 0x95959500,
+        0xe0e0e000, 0xffffff00, 0x64646400, 0xd2d2d200,
+        0x10101000, 0xc4c4c400, 0x00000000, 0x48484800,
+        0xa3a3a300, 0xf7f7f700, 0x75757500, 0xdbdbdb00,
+        0x8a8a8a00, 0x03030300, 0xe6e6e600, 0xdadada00,
+        0x09090900, 0x3f3f3f00, 0xdddddd00, 0x94949400,
+        0x87878700, 0x5c5c5c00, 0x83838300, 0x02020200,
+        0xcdcdcd00, 0x4a4a4a00, 0x90909000, 0x33333300,
+        0x73737300, 0x67676700, 0xf6f6f600, 0xf3f3f300,
+        0x9d9d9d00, 0x7f7f7f00, 0xbfbfbf00, 0xe2e2e200,
+        0x52525200, 0x9b9b9b00, 0xd8d8d800, 0x26262600,
+        0xc8c8c800, 0x37373700, 0xc6c6c600, 0x3b3b3b00,
+        0x81818100, 0x96969600, 0x6f6f6f00, 0x4b4b4b00,
+        0x13131300, 0xbebebe00, 0x63636300, 0x2e2e2e00,
+        0xe9e9e900, 0x79797900, 0xa7a7a700, 0x8c8c8c00,
+        0x9f9f9f00, 0x6e6e6e00, 0xbcbcbc00, 0x8e8e8e00,
+        0x29292900, 0xf5f5f500, 0xf9f9f900, 0xb6b6b600,
+        0x2f2f2f00, 0xfdfdfd00, 0xb4b4b400, 0x59595900,
+        0x78787800, 0x98989800, 0x06060600, 0x6a6a6a00,
+        0xe7e7e700, 0x46464600, 0x71717100, 0xbababa00,
+        0xd4d4d400, 0x25252500, 0xababab00, 0x42424200,
+        0x88888800, 0xa2a2a200, 0x8d8d8d00, 0xfafafa00,
+        0x72727200, 0x07070700, 0xb9b9b900, 0x55555500,
+        0xf8f8f800, 0xeeeeee00, 0xacacac00, 0x0a0a0a00,
+        0x36363600, 0x49494900, 0x2a2a2a00, 0x68686800,
+        0x3c3c3c00, 0x38383800, 0xf1f1f100, 0xa4a4a400,
+        0x40404000, 0x28282800, 0xd3d3d300, 0x7b7b7b00,
+        0xbbbbbb00, 0xc9c9c900, 0x43434300, 0xc1c1c100,
+        0x15151500, 0xe3e3e300, 0xadadad00, 0xf4f4f400,
+        0x77777700, 0xc7c7c700, 0x80808000, 0x9e9e9e00,
+};
+
+static const u32 camellia_sp0222[256] = {
+        0x00e0e0e0, 0x00050505, 0x00585858, 0x00d9d9d9,
+        0x00676767, 0x004e4e4e, 0x00818181, 0x00cbcbcb,
+        0x00c9c9c9, 0x000b0b0b, 0x00aeaeae, 0x006a6a6a,
+        0x00d5d5d5, 0x00181818, 0x005d5d5d, 0x00828282,
+        0x00464646, 0x00dfdfdf, 0x00d6d6d6, 0x00272727,
+        0x008a8a8a, 0x00323232, 0x004b4b4b, 0x00424242,
+        0x00dbdbdb, 0x001c1c1c, 0x009e9e9e, 0x009c9c9c,
+        0x003a3a3a, 0x00cacaca, 0x00252525, 0x007b7b7b,
+        0x000d0d0d, 0x00717171, 0x005f5f5f, 0x001f1f1f,
+        0x00f8f8f8, 0x00d7d7d7, 0x003e3e3e, 0x009d9d9d,
+        0x007c7c7c, 0x00606060, 0x00b9b9b9, 0x00bebebe,
+        0x00bcbcbc, 0x008b8b8b, 0x00161616, 0x00343434,
+        0x004d4d4d, 0x00c3c3c3, 0x00727272, 0x00959595,
+        0x00ababab, 0x008e8e8e, 0x00bababa, 0x007a7a7a,
+        0x00b3b3b3, 0x00020202, 0x00b4b4b4, 0x00adadad,
+        0x00a2a2a2, 0x00acacac, 0x00d8d8d8, 0x009a9a9a,
+        0x00171717, 0x001a1a1a, 0x00353535, 0x00cccccc,
+        0x00f7f7f7, 0x00999999, 0x00616161, 0x005a5a5a,
+        0x00e8e8e8, 0x00242424, 0x00565656, 0x00404040,
+        0x00e1e1e1, 0x00636363, 0x00090909, 0x00333333,
+        0x00bfbfbf, 0x00989898, 0x00979797, 0x00858585,
+        0x00686868, 0x00fcfcfc, 0x00ececec, 0x000a0a0a,
+        0x00dadada, 0x006f6f6f, 0x00535353, 0x00626262,
+        0x00a3a3a3, 0x002e2e2e, 0x00080808, 0x00afafaf,
+        0x00282828, 0x00b0b0b0, 0x00747474, 0x00c2c2c2,
+        0x00bdbdbd, 0x00363636, 0x00222222, 0x00383838,
+        0x00646464, 0x001e1e1e, 0x00393939, 0x002c2c2c,
+        0x00a6a6a6, 0x00303030, 0x00e5e5e5, 0x00444444,
+        0x00fdfdfd, 0x00888888, 0x009f9f9f, 0x00656565,
+        0x00878787, 0x006b6b6b, 0x00f4f4f4, 0x00232323,
+        0x00484848, 0x00101010, 0x00d1d1d1, 0x00515151,
+        0x00c0c0c0, 0x00f9f9f9, 0x00d2d2d2, 0x00a0a0a0,
+        0x00555555, 0x00a1a1a1, 0x00414141, 0x00fafafa,
+        0x00434343, 0x00131313, 0x00c4c4c4, 0x002f2f2f,
+        0x00a8a8a8, 0x00b6b6b6, 0x003c3c3c, 0x002b2b2b,
+        0x00c1c1c1, 0x00ffffff, 0x00c8c8c8, 0x00a5a5a5,
+        0x00202020, 0x00898989, 0x00000000, 0x00909090,
+        0x00474747, 0x00efefef, 0x00eaeaea, 0x00b7b7b7,
+        0x00151515, 0x00060606, 0x00cdcdcd, 0x00b5b5b5,
+        0x00121212, 0x007e7e7e, 0x00bbbbbb, 0x00292929,
+        0x000f0f0f, 0x00b8b8b8, 0x00070707, 0x00040404,
+        0x009b9b9b, 0x00949494, 0x00212121, 0x00666666,
+        0x00e6e6e6, 0x00cecece, 0x00ededed, 0x00e7e7e7,
+        0x003b3b3b, 0x00fefefe, 0x007f7f7f, 0x00c5c5c5,
+        0x00a4a4a4, 0x00373737, 0x00b1b1b1, 0x004c4c4c,
+        0x00919191, 0x006e6e6e, 0x008d8d8d, 0x00767676,
+        0x00030303, 0x002d2d2d, 0x00dedede, 0x00969696,
+        0x00262626, 0x007d7d7d, 0x00c6c6c6, 0x005c5c5c,
+        0x00d3d3d3, 0x00f2f2f2, 0x004f4f4f, 0x00191919,
+        0x003f3f3f, 0x00dcdcdc, 0x00797979, 0x001d1d1d,
+        0x00525252, 0x00ebebeb, 0x00f3f3f3, 0x006d6d6d,
+        0x005e5e5e, 0x00fbfbfb, 0x00696969, 0x00b2b2b2,
+        0x00f0f0f0, 0x00313131, 0x000c0c0c, 0x00d4d4d4,
+        0x00cfcfcf, 0x008c8c8c, 0x00e2e2e2, 0x00757575,
+        0x00a9a9a9, 0x004a4a4a, 0x00575757, 0x00848484,
+        0x00111111, 0x00454545, 0x001b1b1b, 0x00f5f5f5,
+        0x00e4e4e4, 0x000e0e0e, 0x00737373, 0x00aaaaaa,
+        0x00f1f1f1, 0x00dddddd, 0x00595959, 0x00141414,
+        0x006c6c6c, 0x00929292, 0x00545454, 0x00d0d0d0,
+        0x00787878, 0x00707070, 0x00e3e3e3, 0x00494949,
+        0x00808080, 0x00505050, 0x00a7a7a7, 0x00f6f6f6,
+        0x00777777, 0x00939393, 0x00868686, 0x00838383,
+        0x002a2a2a, 0x00c7c7c7, 0x005b5b5b, 0x00e9e9e9,
+        0x00eeeeee, 0x008f8f8f, 0x00010101, 0x003d3d3d,
+};
+
+static const u32 camellia_sp3033[256] = {
+        0x38003838, 0x41004141, 0x16001616, 0x76007676,
+        0xd900d9d9, 0x93009393, 0x60006060, 0xf200f2f2,
+        0x72007272, 0xc200c2c2, 0xab00abab, 0x9a009a9a,
+        0x75007575, 0x06000606, 0x57005757, 0xa000a0a0,
+        0x91009191, 0xf700f7f7, 0xb500b5b5, 0xc900c9c9,
+        0xa200a2a2, 0x8c008c8c, 0xd200d2d2, 0x90009090,
+        0xf600f6f6, 0x07000707, 0xa700a7a7, 0x27002727,
+        0x8e008e8e, 0xb200b2b2, 0x49004949, 0xde00dede,
+        0x43004343, 0x5c005c5c, 0xd700d7d7, 0xc700c7c7,
+        0x3e003e3e, 0xf500f5f5, 0x8f008f8f, 0x67006767,
+        0x1f001f1f, 0x18001818, 0x6e006e6e, 0xaf00afaf,
+        0x2f002f2f, 0xe200e2e2, 0x85008585, 0x0d000d0d,
+        0x53005353, 0xf000f0f0, 0x9c009c9c, 0x65006565,
+        0xea00eaea, 0xa300a3a3, 0xae00aeae, 0x9e009e9e,
+        0xec00ecec, 0x80008080, 0x2d002d2d, 0x6b006b6b,
+        0xa800a8a8, 0x2b002b2b, 0x36003636, 0xa600a6a6,
+        0xc500c5c5, 0x86008686, 0x4d004d4d, 0x33003333,
+        0xfd00fdfd, 0x66006666, 0x58005858, 0x96009696,
+        0x3a003a3a, 0x09000909, 0x95009595, 0x10001010,
+        0x78007878, 0xd800d8d8, 0x42004242, 0xcc00cccc,
+        0xef00efef, 0x26002626, 0xe500e5e5, 0x61006161,
+        0x1a001a1a, 0x3f003f3f, 0x3b003b3b, 0x82008282,
+        0xb600b6b6, 0xdb00dbdb, 0xd400d4d4, 0x98009898,
+        0xe800e8e8, 0x8b008b8b, 0x02000202, 0xeb00ebeb,
+        0x0a000a0a, 0x2c002c2c, 0x1d001d1d, 0xb000b0b0,
+        0x6f006f6f, 0x8d008d8d, 0x88008888, 0x0e000e0e,
+        0x19001919, 0x87008787, 0x4e004e4e, 0x0b000b0b,
+        0xa900a9a9, 0x0c000c0c, 0x79007979, 0x11001111,
+        0x7f007f7f, 0x22002222, 0xe700e7e7, 0x59005959,
+        0xe100e1e1, 0xda00dada, 0x3d003d3d, 0xc800c8c8,
+        0x12001212, 0x04000404, 0x74007474, 0x54005454,
+        0x30003030, 0x7e007e7e, 0xb400b4b4, 0x28002828,
+        0x55005555, 0x68006868, 0x50005050, 0xbe00bebe,
+        0xd000d0d0, 0xc400c4c4, 0x31003131, 0xcb00cbcb,
+        0x2a002a2a, 0xad00adad, 0x0f000f0f, 0xca00caca,
+        0x70007070, 0xff00ffff, 0x32003232, 0x69006969,
+        0x08000808, 0x62006262, 0x00000000, 0x24002424,
+        0xd100d1d1, 0xfb00fbfb, 0xba00baba, 0xed00eded,
+        0x45004545, 0x81008181, 0x73007373, 0x6d006d6d,
+        0x84008484, 0x9f009f9f, 0xee00eeee, 0x4a004a4a,
+        0xc300c3c3, 0x2e002e2e, 0xc100c1c1, 0x01000101,
+        0xe600e6e6, 0x25002525, 0x48004848, 0x99009999,
+        0xb900b9b9, 0xb300b3b3, 0x7b007b7b, 0xf900f9f9,
+        0xce00cece, 0xbf00bfbf, 0xdf00dfdf, 0x71007171,
+        0x29002929, 0xcd00cdcd, 0x6c006c6c, 0x13001313,
+        0x64006464, 0x9b009b9b, 0x63006363, 0x9d009d9d,
+        0xc000c0c0, 0x4b004b4b, 0xb700b7b7, 0xa500a5a5,
+        0x89008989, 0x5f005f5f, 0xb100b1b1, 0x17001717,
+        0xf400f4f4, 0xbc00bcbc, 0xd300d3d3, 0x46004646,
+        0xcf00cfcf, 0x37003737, 0x5e005e5e, 0x47004747,
+        0x94009494, 0xfa00fafa, 0xfc00fcfc, 0x5b005b5b,
+        0x97009797, 0xfe00fefe, 0x5a005a5a, 0xac00acac,
+        0x3c003c3c, 0x4c004c4c, 0x03000303, 0x35003535,
+        0xf300f3f3, 0x23002323, 0xb800b8b8, 0x5d005d5d,
+        0x6a006a6a, 0x92009292, 0xd500d5d5, 0x21002121,
+        0x44004444, 0x51005151, 0xc600c6c6, 0x7d007d7d,
+        0x39003939, 0x83008383, 0xdc00dcdc, 0xaa00aaaa,
+        0x7c007c7c, 0x77007777, 0x56005656, 0x05000505,
+        0x1b001b1b, 0xa400a4a4, 0x15001515, 0x34003434,
+        0x1e001e1e, 0x1c001c1c, 0xf800f8f8, 0x52005252,
+        0x20002020, 0x14001414, 0xe900e9e9, 0xbd00bdbd,
+        0xdd00dddd, 0xe400e4e4, 0xa100a1a1, 0xe000e0e0,
+        0x8a008a8a, 0xf100f1f1, 0xd600d6d6, 0x7a007a7a,
+        0xbb00bbbb, 0xe300e3e3, 0x40004040, 0x4f004f4f,
+};
+
+static const u32 camellia_sp4404[256] = {
+        0x70700070, 0x2c2c002c, 0xb3b300b3, 0xc0c000c0,
+        0xe4e400e4, 0x57570057, 0xeaea00ea, 0xaeae00ae,
+        0x23230023, 0x6b6b006b, 0x45450045, 0xa5a500a5,
+        0xeded00ed, 0x4f4f004f, 0x1d1d001d, 0x92920092,
+        0x86860086, 0xafaf00af, 0x7c7c007c, 0x1f1f001f,
+        0x3e3e003e, 0xdcdc00dc, 0x5e5e005e, 0x0b0b000b,
+        0xa6a600a6, 0x39390039, 0xd5d500d5, 0x5d5d005d,
+        0xd9d900d9, 0x5a5a005a, 0x51510051, 0x6c6c006c,
+        0x8b8b008b, 0x9a9a009a, 0xfbfb00fb, 0xb0b000b0,
+        0x74740074, 0x2b2b002b, 0xf0f000f0, 0x84840084,
+        0xdfdf00df, 0xcbcb00cb, 0x34340034, 0x76760076,
+        0x6d6d006d, 0xa9a900a9, 0xd1d100d1, 0x04040004,
+        0x14140014, 0x3a3a003a, 0xdede00de, 0x11110011,
+        0x32320032, 0x9c9c009c, 0x53530053, 0xf2f200f2,
+        0xfefe00fe, 0xcfcf00cf, 0xc3c300c3, 0x7a7a007a,
+        0x24240024, 0xe8e800e8, 0x60600060, 0x69690069,
+        0xaaaa00aa, 0xa0a000a0, 0xa1a100a1, 0x62620062,
+        0x54540054, 0x1e1e001e, 0xe0e000e0, 0x64640064,
+        0x10100010, 0x00000000, 0xa3a300a3, 0x75750075,
+        0x8a8a008a, 0xe6e600e6, 0x09090009, 0xdddd00dd,
+        0x87870087, 0x83830083, 0xcdcd00cd, 0x90900090,
+        0x73730073, 0xf6f600f6, 0x9d9d009d, 0xbfbf00bf,
+        0x52520052, 0xd8d800d8, 0xc8c800c8, 0xc6c600c6,
+        0x81810081, 0x6f6f006f, 0x13130013, 0x63630063,
+        0xe9e900e9, 0xa7a700a7, 0x9f9f009f, 0xbcbc00bc,
+        0x29290029, 0xf9f900f9, 0x2f2f002f, 0xb4b400b4,
+        0x78780078, 0x06060006, 0xe7e700e7, 0x71710071,
+        0xd4d400d4, 0xabab00ab, 0x88880088, 0x8d8d008d,
+        0x72720072, 0xb9b900b9, 0xf8f800f8, 0xacac00ac,
+        0x36360036, 0x2a2a002a, 0x3c3c003c, 0xf1f100f1,
+        0x40400040, 0xd3d300d3, 0xbbbb00bb, 0x43430043,
+        0x15150015, 0xadad00ad, 0x77770077, 0x80800080,
+        0x82820082, 0xecec00ec, 0x27270027, 0xe5e500e5,
+        0x85850085, 0x35350035, 0x0c0c000c, 0x41410041,
+        0xefef00ef, 0x93930093, 0x19190019, 0x21210021,
+        0x0e0e000e, 0x4e4e004e, 0x65650065, 0xbdbd00bd,
+        0xb8b800b8, 0x8f8f008f, 0xebeb00eb, 0xcece00ce,
+        0x30300030, 0x5f5f005f, 0xc5c500c5, 0x1a1a001a,
+        0xe1e100e1, 0xcaca00ca, 0x47470047, 0x3d3d003d,
+        0x01010001, 0xd6d600d6, 0x56560056, 0x4d4d004d,
+        0x0d0d000d, 0x66660066, 0xcccc00cc, 0x2d2d002d,
+        0x12120012, 0x20200020, 0xb1b100b1, 0x99990099,
+        0x4c4c004c, 0xc2c200c2, 0x7e7e007e, 0x05050005,
+        0xb7b700b7, 0x31310031, 0x17170017, 0xd7d700d7,
+        0x58580058, 0x61610061, 0x1b1b001b, 0x1c1c001c,
+        0x0f0f000f, 0x16160016, 0x18180018, 0x22220022,
+        0x44440044, 0xb2b200b2, 0xb5b500b5, 0x91910091,
+        0x08080008, 0xa8a800a8, 0xfcfc00fc, 0x50500050,
+        0xd0d000d0, 0x7d7d007d, 0x89890089, 0x97970097,
+        0x5b5b005b, 0x95950095, 0xffff00ff, 0xd2d200d2,
+        0xc4c400c4, 0x48480048, 0xf7f700f7, 0xdbdb00db,
+        0x03030003, 0xdada00da, 0x3f3f003f, 0x94940094,
+        0x5c5c005c, 0x02020002, 0x4a4a004a, 0x33330033,
+        0x67670067, 0xf3f300f3, 0x7f7f007f, 0xe2e200e2,
+        0x9b9b009b, 0x26260026, 0x37370037, 0x3b3b003b,
+        0x96960096, 0x4b4b004b, 0xbebe00be, 0x2e2e002e,
+        0x79790079, 0x8c8c008c, 0x6e6e006e, 0x8e8e008e,
+        0xf5f500f5, 0xb6b600b6, 0xfdfd00fd, 0x59590059,
+        0x98980098, 0x6a6a006a, 0x46460046, 0xbaba00ba,
+        0x25250025, 0x42420042, 0xa2a200a2, 0xfafa00fa,
+        0x07070007, 0x55550055, 0xeeee00ee, 0x0a0a000a,
+        0x49490049, 0x68680068, 0x38380038, 0xa4a400a4,
+        0x28280028, 0x7b7b007b, 0xc9c900c9, 0xc1c100c1,
+        0xe3e300e3, 0xf4f400f4, 0xc7c700c7, 0x9e9e009e,
+};
+
+
+#define CAMELLIA_MIN_KEY_SIZE        16
+#define CAMELLIA_MAX_KEY_SIZE        32
+#define CAMELLIA_BLOCK_SIZE          16
+#define CAMELLIA_TABLE_BYTE_LEN     272
+
+/*
+ * NB: L and R below stand for 'left' and 'right' as in written numbers.
+ * That is, in (xxxL,xxxR) pair xxxL holds most significant digits,
+ * _not_ least significant ones!
+ */
+
+
+/* key constants */
+
+#define CAMELLIA_SIGMA1L (0xA09E667FL)
+#define CAMELLIA_SIGMA1R (0x3BCC908BL)
+#define CAMELLIA_SIGMA2L (0xB67AE858L)
+#define CAMELLIA_SIGMA2R (0x4CAA73B2L)
+#define CAMELLIA_SIGMA3L (0xC6EF372FL)
+#define CAMELLIA_SIGMA3R (0xE94F82BEL)
+#define CAMELLIA_SIGMA4L (0x54FF53A5L)
+#define CAMELLIA_SIGMA4R (0xF1D36F1CL)
+#define CAMELLIA_SIGMA5L (0x10E527FAL)
+#define CAMELLIA_SIGMA5R (0xDE682D1DL)
+#define CAMELLIA_SIGMA6L (0xB05688C2L)
+#define CAMELLIA_SIGMA6R (0xB3E6C1FDL)
+
+/*
+ *  macros
+ */
+#define ROLDQ(ll, lr, rl, rr, w0, w1, bits)             \
+    do {                                                \
+        w0 = ll;                                        \
+        ll = (ll << bits) + (lr >> (32 - bits));        \
+        lr = (lr << bits) + (rl >> (32 - bits));        \
+        rl = (rl << bits) + (rr >> (32 - bits));        \
+        rr = (rr << bits) + (w0 >> (32 - bits));        \
+    } while (0)
+
+#define ROLDQo32(ll, lr, rl, rr, w0, w1, bits)          \
+    do {                                                \
+        w0 = ll;                                        \
+        w1 = lr;                                        \
+        ll = (lr << (bits - 32)) + (rl >> (64 - bits)); \
+        lr = (rl << (bits - 32)) + (rr >> (64 - bits)); \
+        rl = (rr << (bits - 32)) + (w0 >> (64 - bits)); \
+        rr = (w0 << (bits - 32)) + (w1 >> (64 - bits)); \
+    } while (0)
+
+#define CAMELLIA_F(xl, xr, kl, kr, yl, yr, il, ir, t0, t1)      \
+    do {                                                        \
+        il = xl ^ kl;                                           \
+        ir = xr ^ kr;                                           \
+        t0 = il >> 16;                                          \
+        t1 = ir >> 16;                                          \
+        yl = camellia_sp1110[(u8)(ir     )]                     \
+           ^ camellia_sp0222[    (t1 >> 8)]                     \
+           ^ camellia_sp3033[(u8)(t1     )]                     \
+           ^ camellia_sp4404[(u8)(ir >> 8)];                    \
+        yr = camellia_sp1110[    (t0 >> 8)]                     \
+           ^ camellia_sp0222[(u8)(t0     )]                     \
+           ^ camellia_sp3033[(u8)(il >> 8)]                     \
+           ^ camellia_sp4404[(u8)(il     )];                    \
+        yl ^= yr;                                               \
+        yr = ror32(yr, 8);                                      \
+        yr ^= yl;                                               \
+    } while (0)
+
+#define SUBKEY_L(INDEX) (subkey[(INDEX)*2])
+#define SUBKEY_R(INDEX) (subkey[(INDEX)*2 + 1])
+
+static void camellia_setup_tail(u32 *subkey, u32 *subL, u32 *subR, int max)
+{
+        u32 dw, tl, tr;
+        u32 kw4l, kw4r;
+        int i;
+
+        /* absorb kw2 to other subkeys */
+        /* round 2 */
+        subL[3] ^= subL[1]; subR[3] ^= subR[1];
+        /* round 4 */
+        subL[5] ^= subL[1]; subR[5] ^= subR[1];
+        /* round 6 */
+        subL[7] ^= subL[1]; subR[7] ^= subR[1];
+        subL[1] ^= subR[1] & ~subR[9];
+        dw = subL[1] & subL[9],
+                subR[1] ^= rol32(dw, 1); /* modified for FLinv(kl2) */
+        /* round 8 */
+        subL[11] ^= subL[1]; subR[11] ^= subR[1];
+        /* round 10 */
+        subL[13] ^= subL[1]; subR[13] ^= subR[1];
+        /* round 12 */
+        subL[15] ^= subL[1]; subR[15] ^= subR[1];
+        subL[1] ^= subR[1] & ~subR[17];
+        dw = subL[1] & subL[17],
+                subR[1] ^= rol32(dw, 1); /* modified for FLinv(kl4) */
+        /* round 14 */
+        subL[19] ^= subL[1]; subR[19] ^= subR[1];
+        /* round 16 */
+        subL[21] ^= subL[1]; subR[21] ^= subR[1];
+        /* round 18 */
+        subL[23] ^= subL[1]; subR[23] ^= subR[1];
+        if (max == 24) {
+                /* kw3 */
+                subL[24] ^= subL[1]; subR[24] ^= subR[1];
+
+        /* absorb kw4 to other subkeys */
+                kw4l = subL[25]; kw4r = subR[25];
+        } else {
+                subL[1] ^= subR[1] & ~subR[25];
+                dw = subL[1] & subL[25],
+                        subR[1] ^= rol32(dw, 1); /* modified for FLinv(kl6) */
+                /* round 20 */
+                subL[27] ^= subL[1]; subR[27] ^= subR[1];
+                /* round 22 */
+                subL[29] ^= subL[1]; subR[29] ^= subR[1];
+                /* round 24 */
+                subL[31] ^= subL[1]; subR[31] ^= subR[1];
+                /* kw3 */
+                subL[32] ^= subL[1]; subR[32] ^= subR[1];
+
+        /* absorb kw4 to other subkeys */
+                kw4l = subL[33]; kw4r = subR[33];
+                /* round 23 */
+                subL[30] ^= kw4l; subR[30] ^= kw4r;
+                /* round 21 */
+                subL[28] ^= kw4l; subR[28] ^= kw4r;
+                /* round 19 */
+                subL[26] ^= kw4l; subR[26] ^= kw4r;
+                kw4l ^= kw4r & ~subR[24];
+                dw = kw4l & subL[24],
+                        kw4r ^= rol32(dw, 1); /* modified for FL(kl5) */
+        }
+        /* round 17 */
+        subL[22] ^= kw4l; subR[22] ^= kw4r;
+        /* round 15 */
+        subL[20] ^= kw4l; subR[20] ^= kw4r;
+        /* round 13 */
+        subL[18] ^= kw4l; subR[18] ^= kw4r;
+        kw4l ^= kw4r & ~subR[16];
+        dw = kw4l & subL[16],
+                kw4r ^= rol32(dw, 1); /* modified for FL(kl3) */
+        /* round 11 */
+        subL[14] ^= kw4l; subR[14] ^= kw4r;
+        /* round 9 */
+        subL[12] ^= kw4l; subR[12] ^= kw4r;
+        /* round 7 */
+        subL[10] ^= kw4l; subR[10] ^= kw4r;
+        kw4l ^= kw4r & ~subR[8];
+        dw = kw4l & subL[8],
+                kw4r ^= rol32(dw, 1); /* modified for FL(kl1) */
+        /* round 5 */
+        subL[6] ^= kw4l; subR[6] ^= kw4r;
+        /* round 3 */
+        subL[4] ^= kw4l; subR[4] ^= kw4r;
+        /* round 1 */
+        subL[2] ^= kw4l; subR[2] ^= kw4r;
+        /* kw1 */
+        subL[0] ^= kw4l; subR[0] ^= kw4r;
+
+        /* key XOR is end of F-function */
+        SUBKEY_L(0) = subL[0] ^ subL[2];/* kw1 */
+        SUBKEY_R(0) = subR[0] ^ subR[2];
+        SUBKEY_L(2) = subL[3];       /* round 1 */
+        SUBKEY_R(2) = subR[3];
+        SUBKEY_L(3) = subL[2] ^ subL[4]; /* round 2 */
+        SUBKEY_R(3) = subR[2] ^ subR[4];
+        SUBKEY_L(4) = subL[3] ^ subL[5]; /* round 3 */
+        SUBKEY_R(4) = subR[3] ^ subR[5];
+        SUBKEY_L(5) = subL[4] ^ subL[6]; /* round 4 */
+        SUBKEY_R(5) = subR[4] ^ subR[6];
+        SUBKEY_L(6) = subL[5] ^ subL[7]; /* round 5 */
+        SUBKEY_R(6) = subR[5] ^ subR[7];
+        tl = subL[10] ^ (subR[10] & ~subR[8]);
+        dw = tl & subL[8],  /* FL(kl1) */
+                tr = subR[10] ^ rol32(dw, 1);
+        SUBKEY_L(7) = subL[6] ^ tl; /* round 6 */
+        SUBKEY_R(7) = subR[6] ^ tr;
+        SUBKEY_L(8) = subL[8];       /* FL(kl1) */
+        SUBKEY_R(8) = subR[8];
+        SUBKEY_L(9) = subL[9];       /* FLinv(kl2) */
+        SUBKEY_R(9) = subR[9];
+        tl = subL[7] ^ (subR[7] & ~subR[9]);
+        dw = tl & subL[9],  /* FLinv(kl2) */
+                tr = subR[7] ^ rol32(dw, 1);
+        SUBKEY_L(10) = tl ^ subL[11]; /* round 7 */
+        SUBKEY_R(10) = tr ^ subR[11];
+        SUBKEY_L(11) = subL[10] ^ subL[12]; /* round 8 */
+        SUBKEY_R(11) = subR[10] ^ subR[12];
+        SUBKEY_L(12) = subL[11] ^ subL[13]; /* round 9 */
+        SUBKEY_R(12) = subR[11] ^ subR[13];
+        SUBKEY_L(13) = subL[12] ^ subL[14]; /* round 10 */
+        SUBKEY_R(13) = subR[12] ^ subR[14];
+        SUBKEY_L(14) = subL[13] ^ subL[15]; /* round 11 */
+        SUBKEY_R(14) = subR[13] ^ subR[15];
+        tl = subL[18] ^ (subR[18] & ~subR[16]);
+        dw = tl & subL[16], /* FL(kl3) */
+                tr = subR[18] ^ rol32(dw, 1);
+        SUBKEY_L(15) = subL[14] ^ tl; /* round 12 */
+        SUBKEY_R(15) = subR[14] ^ tr;
+        SUBKEY_L(16) = subL[16];     /* FL(kl3) */
+        SUBKEY_R(16) = subR[16];
+        SUBKEY_L(17) = subL[17];     /* FLinv(kl4) */
+        SUBKEY_R(17) = subR[17];
+        tl = subL[15] ^ (subR[15] & ~subR[17]);
+        dw = tl & subL[17], /* FLinv(kl4) */
+                tr = subR[15] ^ rol32(dw, 1);
+        SUBKEY_L(18) = tl ^ subL[19]; /* round 13 */
+        SUBKEY_R(18) = tr ^ subR[19];
+        SUBKEY_L(19) = subL[18] ^ subL[20]; /* round 14 */
+        SUBKEY_R(19) = subR[18] ^ subR[20];
+        SUBKEY_L(20) = subL[19] ^ subL[21]; /* round 15 */
+        SUBKEY_R(20) = subR[19] ^ subR[21];
+        SUBKEY_L(21) = subL[20] ^ subL[22]; /* round 16 */
+        SUBKEY_R(21) = subR[20] ^ subR[22];
+        SUBKEY_L(22) = subL[21] ^ subL[23]; /* round 17 */
+        SUBKEY_R(22) = subR[21] ^ subR[23];
+        if (max == 24) {
+                SUBKEY_L(23) = subL[22];     /* round 18 */
+                SUBKEY_R(23) = subR[22];
+                SUBKEY_L(24) = subL[24] ^ subL[23]; /* kw3 */
+                SUBKEY_R(24) = subR[24] ^ subR[23];
+        } else {
+                tl = subL[26] ^ (subR[26] & ~subR[24]);
+                dw = tl & subL[24], /* FL(kl5) */
+                        tr = subR[26] ^ rol32(dw, 1);
+                SUBKEY_L(23) = subL[22] ^ tl; /* round 18 */
+                SUBKEY_R(23) = subR[22] ^ tr;
+                SUBKEY_L(24) = subL[24];     /* FL(kl5) */
+                SUBKEY_R(24) = subR[24];
+                SUBKEY_L(25) = subL[25];     /* FLinv(kl6) */
+                SUBKEY_R(25) = subR[25];
+                tl = subL[23] ^ (subR[23] & ~subR[25]);
+                dw = tl & subL[25], /* FLinv(kl6) */
+                        tr = subR[23] ^ rol32(dw, 1);
+                SUBKEY_L(26) = tl ^ subL[27]; /* round 19 */
+                SUBKEY_R(26) = tr ^ subR[27];
+                SUBKEY_L(27) = subL[26] ^ subL[28]; /* round 20 */
+                SUBKEY_R(27) = subR[26] ^ subR[28];
+                SUBKEY_L(28) = subL[27] ^ subL[29]; /* round 21 */
+                SUBKEY_R(28) = subR[27] ^ subR[29];
+                SUBKEY_L(29) = subL[28] ^ subL[30]; /* round 22 */
+                SUBKEY_R(29) = subR[28] ^ subR[30];
+                SUBKEY_L(30) = subL[29] ^ subL[31]; /* round 23 */
+                SUBKEY_R(30) = subR[29] ^ subR[31];
+                SUBKEY_L(31) = subL[30];     /* round 24 */
+                SUBKEY_R(31) = subR[30];
+                SUBKEY_L(32) = subL[32] ^ subL[31]; /* kw3 */
+                SUBKEY_R(32) = subR[32] ^ subR[31];
+        }
+
+        /* apply the inverse of the last half of P-function */
+        i = 2;
+        do {
+                dw = SUBKEY_L(i + 0) ^ SUBKEY_R(i + 0); dw = rol32(dw, 8);/* round 1 */
+                SUBKEY_R(i + 0) = SUBKEY_L(i + 0) ^ dw; SUBKEY_L(i + 0) = dw;
+                dw = SUBKEY_L(i + 1) ^ SUBKEY_R(i + 1); dw = rol32(dw, 8);/* round 2 */
+                SUBKEY_R(i + 1) = SUBKEY_L(i + 1) ^ dw; SUBKEY_L(i + 1) = dw;
+                dw = SUBKEY_L(i + 2) ^ SUBKEY_R(i + 2); dw = rol32(dw, 8);/* round 3 */
+                SUBKEY_R(i + 2) = SUBKEY_L(i + 2) ^ dw; SUBKEY_L(i + 2) = dw;
+                dw = SUBKEY_L(i + 3) ^ SUBKEY_R(i + 3); dw = rol32(dw, 8);/* round 4 */
+                SUBKEY_R(i + 3) = SUBKEY_L(i + 3) ^ dw; SUBKEY_L(i + 3) = dw;
+                dw = SUBKEY_L(i + 4) ^ SUBKEY_R(i + 4); dw = rol32(dw, 8);/* round 5 */
+                SUBKEY_R(i + 4) = SUBKEY_L(i + 4) ^ dw; SUBKEY_L(i + 4) = dw;
+                dw = SUBKEY_L(i + 5) ^ SUBKEY_R(i + 5); dw = rol32(dw, 8);/* round 6 */
+                SUBKEY_R(i + 5) = SUBKEY_L(i + 5) ^ dw; SUBKEY_L(i + 5) = dw;
+                i += 8;
+        } while (i < max);
+}
+
+static void camellia_setup128(const unsigned char *key, u32 *subkey)
+{
+        u32 kll, klr, krl, krr;
+        u32 il, ir, t0, t1, w0, w1;
+        u32 subL[26];
+        u32 subR[26];
+
+        /**
+         *  k == kll || klr || krl || krr (|| is concatenation)
+         */
+        kll = get_unaligned_be32(key);
+        klr = get_unaligned_be32(key + 4);
+        krl = get_unaligned_be32(key + 8);
+        krr = get_unaligned_be32(key + 12);
+
+        /* generate KL dependent subkeys */
+        /* kw1 */
+        subL[0] = kll; subR[0] = klr;
+        /* kw2 */
+        subL[1] = krl; subR[1] = krr;
+        /* rotation left shift 15bit */
+        ROLDQ(kll, klr, krl, krr, w0, w1, 15);
+        /* k3 */
+        subL[4] = kll; subR[4] = klr;
+        /* k4 */
+        subL[5] = krl; subR[5] = krr;
+        /* rotation left shift 15+30bit */
+        ROLDQ(kll, klr, krl, krr, w0, w1, 30);
+        /* k7 */
+        subL[10] = kll; subR[10] = klr;
+        /* k8 */
+        subL[11] = krl; subR[11] = krr;
+        /* rotation left shift 15+30+15bit */
+        ROLDQ(kll, klr, krl, krr, w0, w1, 15);
+        /* k10 */
+        subL[13] = krl; subR[13] = krr;
+        /* rotation left shift 15+30+15+17 bit */
+        ROLDQ(kll, klr, krl, krr, w0, w1, 17);
+        /* kl3 */
+        subL[16] = kll; subR[16] = klr;
+        /* kl4 */
+        subL[17] = krl; subR[17] = krr;
+        /* rotation left shift 15+30+15+17+17 bit */
+        ROLDQ(kll, klr, krl, krr, w0, w1, 17);
+        /* k13 */
+        subL[18] = kll; subR[18] = klr;
+        /* k14 */
+        subL[19] = krl; subR[19] = krr;
+        /* rotation left shift 15+30+15+17+17+17 bit */
+        ROLDQ(kll, klr, krl, krr, w0, w1, 17);
+        /* k17 */
+        subL[22] = kll; subR[22] = klr;
+        /* k18 */
+        subL[23] = krl; subR[23] = krr;
+
+        /* generate KA */
+        kll = subL[0]; klr = subR[0];
+        krl = subL[1]; krr = subR[1];
+        CAMELLIA_F(kll, klr,
+                   CAMELLIA_SIGMA1L, CAMELLIA_SIGMA1R,
+                   w0, w1, il, ir, t0, t1);
+        krl ^= w0; krr ^= w1;
+        CAMELLIA_F(krl, krr,
+                   CAMELLIA_SIGMA2L, CAMELLIA_SIGMA2R,
+                   kll, klr, il, ir, t0, t1);
+        /* current status == (kll, klr, w0, w1) */
+        CAMELLIA_F(kll, klr,
+                   CAMELLIA_SIGMA3L, CAMELLIA_SIGMA3R,
+                   krl, krr, il, ir, t0, t1);
+        krl ^= w0; krr ^= w1;
+        CAMELLIA_F(krl, krr,
+                   CAMELLIA_SIGMA4L, CAMELLIA_SIGMA4R,
+                   w0, w1, il, ir, t0, t1);
+        kll ^= w0; klr ^= w1;
+
+        /* generate KA dependent subkeys */
+        /* k1, k2 */
+        subL[2] = kll; subR[2] = klr;
+        subL[3] = krl; subR[3] = krr;
+        ROLDQ(kll, klr, krl, krr, w0, w1, 15);
+        /* k5,k6 */
+        subL[6] = kll; subR[6] = klr;
+        subL[7] = krl; subR[7] = krr;
+        ROLDQ(kll, klr, krl, krr, w0, w1, 15);
+        /* kl1, kl2 */
+        subL[8] = kll; subR[8] = klr;
+        subL[9] = krl; subR[9] = krr;
+        ROLDQ(kll, klr, krl, krr, w0, w1, 15);
+        /* k9 */
+        subL[12] = kll; subR[12] = klr;
+        ROLDQ(kll, klr, krl, krr, w0, w1, 15);
+        /* k11, k12 */
+        subL[14] = kll; subR[14] = klr;
+        subL[15] = krl; subR[15] = krr;
+        ROLDQo32(kll, klr, krl, krr, w0, w1, 34);
+        /* k15, k16 */
+        subL[20] = kll; subR[20] = klr;
+        subL[21] = krl; subR[21] = krr;
+        ROLDQ(kll, klr, krl, krr, w0, w1, 17);
+        /* kw3, kw4 */
+        subL[24] = kll; subR[24] = klr;
+        subL[25] = krl; subR[25] = krr;
+
+        camellia_setup_tail(subkey, subL, subR, 24);
+}
+
+static void camellia_setup256(const unsigned char *key, u32 *subkey)
+{
+        u32 kll, klr, krl, krr;        /* left half of key */
+        u32 krll, krlr, krrl, krrr;    /* right half of key */
+        u32 il, ir, t0, t1, w0, w1;    /* temporary variables */
+        u32 subL[34];
+        u32 subR[34];
+
+        /**
+         *  key = (kll || klr || krl || krr || krll || krlr || krrl || krrr)
+         *  (|| is concatenation)
+         */
+        kll = get_unaligned_be32(key);
+        klr = get_unaligned_be32(key + 4);
+        krl = get_unaligned_be32(key + 8);
+        krr = get_unaligned_be32(key + 12);
+        krll = get_unaligned_be32(key + 16);
+        krlr = get_unaligned_be32(key + 20);
+        krrl = get_unaligned_be32(key + 24);
+        krrr = get_unaligned_be32(key + 28);
+
+        /* generate KL dependent subkeys */
+        /* kw1 */
+        subL[0] = kll; subR[0] = klr;
+        /* kw2 */
+        subL[1] = krl; subR[1] = krr;
+        ROLDQo32(kll, klr, krl, krr, w0, w1, 45);
+        /* k9 */
+        subL[12] = kll; subR[12] = klr;
+        /* k10 */
+        subL[13] = krl; subR[13] = krr;
+        ROLDQ(kll, klr, krl, krr, w0, w1, 15);
+        /* kl3 */
+        subL[16] = kll; subR[16] = klr;
+        /* kl4 */
+        subL[17] = krl; subR[17] = krr;
+        ROLDQ(kll, klr, krl, krr, w0, w1, 17);
+        /* k17 */
+        subL[22] = kll; subR[22] = klr;
+        /* k18 */
+        subL[23] = krl; subR[23] = krr;
+        ROLDQo32(kll, klr, krl, krr, w0, w1, 34);
+        /* k23 */
+        subL[30] = kll; subR[30] = klr;
+        /* k24 */
+        subL[31] = krl; subR[31] = krr;
+
+        /* generate KR dependent subkeys */
+        ROLDQ(krll, krlr, krrl, krrr, w0, w1, 15);
+        /* k3 */
+        subL[4] = krll; subR[4] = krlr;
+        /* k4 */
+        subL[5] = krrl; subR[5] = krrr;
+        ROLDQ(krll, krlr, krrl, krrr, w0, w1, 15);
+        /* kl1 */
+        subL[8] = krll; subR[8] = krlr;
+        /* kl2 */
+        subL[9] = krrl; subR[9] = krrr;
+        ROLDQ(krll, krlr, krrl, krrr, w0, w1, 30);
+        /* k13 */
+        subL[18] = krll; subR[18] = krlr;
+        /* k14 */
+        subL[19] = krrl; subR[19] = krrr;
+        ROLDQo32(krll, krlr, krrl, krrr, w0, w1, 34);
+        /* k19 */
+        subL[26] = krll; subR[26] = krlr;
+        /* k20 */
+        subL[27] = krrl; subR[27] = krrr;
+        ROLDQo32(krll, krlr, krrl, krrr, w0, w1, 34);
+
+        /* generate KA */
+        kll = subL[0] ^ krll; klr = subR[0] ^ krlr;
+        krl = subL[1] ^ krrl; krr = subR[1] ^ krrr;
+        CAMELLIA_F(kll, klr,
+                   CAMELLIA_SIGMA1L, CAMELLIA_SIGMA1R,
+                   w0, w1, il, ir, t0, t1);
+        krl ^= w0; krr ^= w1;
+        CAMELLIA_F(krl, krr,
+                   CAMELLIA_SIGMA2L, CAMELLIA_SIGMA2R,
+                   kll, klr, il, ir, t0, t1);
+        kll ^= krll; klr ^= krlr;
+        CAMELLIA_F(kll, klr,
+                   CAMELLIA_SIGMA3L, CAMELLIA_SIGMA3R,
+                   krl, krr, il, ir, t0, t1);
+        krl ^= w0 ^ krrl; krr ^= w1 ^ krrr;
+        CAMELLIA_F(krl, krr,
+                   CAMELLIA_SIGMA4L, CAMELLIA_SIGMA4R,
+                   w0, w1, il, ir, t0, t1);
+        kll ^= w0; klr ^= w1;
+
+        /* generate KB */
+        krll ^= kll; krlr ^= klr;
+        krrl ^= krl; krrr ^= krr;
+        CAMELLIA_F(krll, krlr,
+                   CAMELLIA_SIGMA5L, CAMELLIA_SIGMA5R,
+                   w0, w1, il, ir, t0, t1);
+        krrl ^= w0; krrr ^= w1;
+        CAMELLIA_F(krrl, krrr,
+                   CAMELLIA_SIGMA6L, CAMELLIA_SIGMA6R,
+                   w0, w1, il, ir, t0, t1);
+        krll ^= w0; krlr ^= w1;
+
+        /* generate KA dependent subkeys */
+        ROLDQ(kll, klr, krl, krr, w0, w1, 15);
+        /* k5 */
+        subL[6] = kll; subR[6] = klr;
+        /* k6 */
+        subL[7] = krl; subR[7] = krr;
+        ROLDQ(kll, klr, krl, krr, w0, w1, 30);
+        /* k11 */
+        subL[14] = kll; subR[14] = klr;
+        /* k12 */
+        subL[15] = krl; subR[15] = krr;
+        /* rotation left shift 32bit */
+        /* kl5 */
+        subL[24] = klr; subR[24] = krl;
+        /* kl6 */
+        subL[25] = krr; subR[25] = kll;
+        /* rotation left shift 49 from k11,k12 -> k21,k22 */
+        ROLDQo32(kll, klr, krl, krr, w0, w1, 49);
+        /* k21 */
+        subL[28] = kll; subR[28] = klr;
+        /* k22 */
+        subL[29] = krl; subR[29] = krr;
+
+        /* generate KB dependent subkeys */
+        /* k1 */
+        subL[2] = krll; subR[2] = krlr;
+        /* k2 */
+        subL[3] = krrl; subR[3] = krrr;
+        ROLDQ(krll, krlr, krrl, krrr, w0, w1, 30);
+        /* k7 */
+        subL[10] = krll; subR[10] = krlr;
+        /* k8 */
+        subL[11] = krrl; subR[11] = krrr;
+        ROLDQ(krll, krlr, krrl, krrr, w0, w1, 30);
+        /* k15 */
+        subL[20] = krll; subR[20] = krlr;
+        /* k16 */
+        subL[21] = krrl; subR[21] = krrr;
+        ROLDQo32(krll, krlr, krrl, krrr, w0, w1, 51);
+        /* kw3 */
+        subL[32] = krll; subR[32] = krlr;
+        /* kw4 */
+        subL[33] = krrl; subR[33] = krrr;
+
+        camellia_setup_tail(subkey, subL, subR, 32);
+}
+
+static void camellia_setup192(const unsigned char *key, u32 *subkey)
+{
+        unsigned char kk[32];
+        u32 krll, krlr, krrl, krrr;
+
+        memcpy(kk, key, 24);
+        memcpy((unsigned char *)&krll, key+16, 4);
+        memcpy((unsigned char *)&krlr, key+20, 4);
+        krrl = ~krll;
+        krrr = ~krlr;
+        memcpy(kk+24, (unsigned char *)&krrl, 4);
+        memcpy(kk+28, (unsigned char *)&krrr, 4);
+        camellia_setup256(kk, subkey);
+}
+
+
+/*
+ * Encrypt/decrypt
+ */
+#define CAMELLIA_FLS(ll, lr, rl, rr, kll, klr, krl, krr, t0, t1, t2, t3) \
+    do {                                                                \
+        t0 = kll;                                                       \
+        t2 = krr;                                                       \
+        t0 &= ll;                                                       \
+        t2 |= rr;                                                       \
+        rl ^= t2;                                                       \
+        lr ^= rol32(t0, 1);                                             \
+        t3 = krl;                                                       \
+        t1 = klr;                                                       \
+        t3 &= rl;                                                       \
+        t1 |= lr;                                                       \
+        ll ^= t1;                                                       \
+        rr ^= rol32(t3, 1);                                             \
+    } while (0)
+
+#define CAMELLIA_ROUNDSM(xl, xr, kl, kr, yl, yr, il, ir)                \
+    do {                                                                \
+        ir =  camellia_sp1110[(u8)xr];                                  \
+        il =  camellia_sp1110[    (xl >> 24)];                          \
+        ir ^= camellia_sp0222[    (xr >> 24)];                          \
+        il ^= camellia_sp0222[(u8)(xl >> 16)];                          \
+        ir ^= camellia_sp3033[(u8)(xr >> 16)];                          \
+        il ^= camellia_sp3033[(u8)(xl >> 8)];                           \
+        ir ^= camellia_sp4404[(u8)(xr >> 8)];                           \
+        il ^= camellia_sp4404[(u8)xl];                                  \
+        il ^= kl;                                                       \
+        ir ^= il ^ kr;                                                  \
+        yl ^= ir;                                                       \
+        yr ^= ror32(il, 8) ^ ir;                                                \
+    } while (0)
+
+/* max = 24: 128bit encrypt, max = 32: 256bit encrypt */
+static void camellia_do_encrypt(const u32 *subkey, u32 *io, unsigned max)
+{
+        u32 il, ir, t0, t1;            /* temporary variables */
+
+        /* pre whitening but absorb kw2 */
+        io[0] ^= SUBKEY_L(0);
+        io[1] ^= SUBKEY_R(0);
+
+        /* main iteration */
+#define ROUNDS(i) do { \
+        CAMELLIA_ROUNDSM(io[0], io[1], \
+                         SUBKEY_L(i + 2), SUBKEY_R(i + 2), \
+                         io[2], io[3], il, ir); \
+        CAMELLIA_ROUNDSM(io[2], io[3], \
+                         SUBKEY_L(i + 3), SUBKEY_R(i + 3), \
+                         io[0], io[1], il, ir); \
+        CAMELLIA_ROUNDSM(io[0], io[1], \
+                         SUBKEY_L(i + 4), SUBKEY_R(i + 4), \
+                         io[2], io[3], il, ir); \
+        CAMELLIA_ROUNDSM(io[2], io[3], \
+                         SUBKEY_L(i + 5), SUBKEY_R(i + 5), \
+                         io[0], io[1], il, ir); \
+        CAMELLIA_ROUNDSM(io[0], io[1], \
+                         SUBKEY_L(i + 6), SUBKEY_R(i + 6), \
+                         io[2], io[3], il, ir); \
+        CAMELLIA_ROUNDSM(io[2], io[3], \
+                         SUBKEY_L(i + 7), SUBKEY_R(i + 7), \
+                         io[0], io[1], il, ir); \
+} while (0)
+#define FLS(i) do { \
+        CAMELLIA_FLS(io[0], io[1], io[2], io[3], \
+                     SUBKEY_L(i + 0), SUBKEY_R(i + 0), \
+                     SUBKEY_L(i + 1), SUBKEY_R(i + 1), \
+                     t0, t1, il, ir); \
+} while (0)
+
+        ROUNDS(0);
+        FLS(8);
+        ROUNDS(8);
+        FLS(16);
+        ROUNDS(16);
+        if (max == 32) {
+                FLS(24);
+                ROUNDS(24);
+        }
+
+#undef ROUNDS
+#undef FLS
+
+        /* post whitening but kw4 */
+        io[2] ^= SUBKEY_L(max);
+        io[3] ^= SUBKEY_R(max);
+        /* NB: io[0],[1] should be swapped with [2],[3] by caller! */
+}
+
+static void camellia_do_decrypt(const u32 *subkey, u32 *io, unsigned i)
+{
+        u32 il, ir, t0, t1;            /* temporary variables */
+
+        /* pre whitening but absorb kw2 */
+        io[0] ^= SUBKEY_L(i);
+        io[1] ^= SUBKEY_R(i);
+
+        /* main iteration */
+#define ROUNDS(i) do { \
+        CAMELLIA_ROUNDSM(io[0], io[1], \
+                         SUBKEY_L(i + 7), SUBKEY_R(i + 7), \
+                         io[2], io[3], il, ir); \
+        CAMELLIA_ROUNDSM(io[2], io[3], \
+                         SUBKEY_L(i + 6), SUBKEY_R(i + 6), \
+                         io[0], io[1], il, ir); \
+        CAMELLIA_ROUNDSM(io[0], io[1], \
+                         SUBKEY_L(i + 5), SUBKEY_R(i + 5), \
+                         io[2], io[3], il, ir); \
+        CAMELLIA_ROUNDSM(io[2], io[3], \
+                         SUBKEY_L(i + 4), SUBKEY_R(i + 4), \
+                         io[0], io[1], il, ir); \
+        CAMELLIA_ROUNDSM(io[0], io[1], \
+                         SUBKEY_L(i + 3), SUBKEY_R(i + 3), \
+                         io[2], io[3], il, ir); \
+        CAMELLIA_ROUNDSM(io[2], io[3], \
+                         SUBKEY_L(i + 2), SUBKEY_R(i + 2), \
+                         io[0], io[1], il, ir); \
+} while (0)
+#define FLS(i) do { \
+        CAMELLIA_FLS(io[0], io[1], io[2], io[3], \
+                     SUBKEY_L(i + 1), SUBKEY_R(i + 1), \
+                     SUBKEY_L(i + 0), SUBKEY_R(i + 0), \
+                     t0, t1, il, ir); \
+} while (0)
+
+        if (i == 32) {
+                ROUNDS(24);
+                FLS(24);
+        }
+        ROUNDS(16);
+        FLS(16);
+        ROUNDS(8);
+        FLS(8);
+        ROUNDS(0);
+
+#undef ROUNDS
+#undef FLS
+
+        /* post whitening but kw4 */
+        io[2] ^= SUBKEY_L(0);
+        io[3] ^= SUBKEY_R(0);
+        /* NB: 0,1 should be swapped with 2,3 by caller! */
+}
+
+
+struct camellia_ctx {
+        int key_length;
+        u32 key_table[CAMELLIA_TABLE_BYTE_LEN / sizeof(u32)];
+};
+
+static int
+camellia_set_key(struct crypto_tfm *tfm, const u8 *in_key,
+                 unsigned int key_len)
+{
+        struct camellia_ctx *cctx = crypto_tfm_ctx(tfm);
+        const unsigned char *key = (const unsigned char *)in_key;
+        u32 *flags = &tfm->crt_flags;
+
+        if (key_len != 16 && key_len != 24 && key_len != 32) {
+                *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
+                return -EINVAL;
+        }
+
+        cctx->key_length = key_len;
+
+        switch (key_len) {
+        case 16:
+                camellia_setup128(key, cctx->key_table);
+                break;
+        case 24:
+                camellia_setup192(key, cctx->key_table);
+                break;
+        case 32:
+                camellia_setup256(key, cctx->key_table);
+                break;
+        }
+
+        return 0;
+}
+
+static void camellia_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
+{
+        const struct camellia_ctx *cctx = crypto_tfm_ctx(tfm);
+        const __be32 *src = (const __be32 *)in;
+        __be32 *dst = (__be32 *)out;
+
+        u32 tmp[4];
+
+        tmp[0] = be32_to_cpu(src[0]);
+        tmp[1] = be32_to_cpu(src[1]);
+        tmp[2] = be32_to_cpu(src[2]);
+        tmp[3] = be32_to_cpu(src[3]);
+
+        camellia_do_encrypt(cctx->key_table, tmp,
+                cctx->key_length == 16 ? 24 : 32 /* for key lengths of 24 and 32 */
+        );
+
+        /* do_encrypt returns 0,1 swapped with 2,3 */
+        dst[0] = cpu_to_be32(tmp[2]);
+        dst[1] = cpu_to_be32(tmp[3]);
+        dst[2] = cpu_to_be32(tmp[0]);
+        dst[3] = cpu_to_be32(tmp[1]);
+}
+
+static void camellia_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
+{
+        const struct camellia_ctx *cctx = crypto_tfm_ctx(tfm);
+        const __be32 *src = (const __be32 *)in;
+        __be32 *dst = (__be32 *)out;
+
+        u32 tmp[4];
+
+        tmp[0] = be32_to_cpu(src[0]);
+        tmp[1] = be32_to_cpu(src[1]);
+        tmp[2] = be32_to_cpu(src[2]);
+        tmp[3] = be32_to_cpu(src[3]);
+
+        camellia_do_decrypt(cctx->key_table, tmp,
+                cctx->key_length == 16 ? 24 : 32 /* for key lengths of 24 and 32 */
+        );
+
+        /* do_decrypt returns 0,1 swapped with 2,3 */
+        dst[0] = cpu_to_be32(tmp[2]);
+        dst[1] = cpu_to_be32(tmp[3]);
+        dst[2] = cpu_to_be32(tmp[0]);
+        dst[3] = cpu_to_be32(tmp[1]);
+}
+
+static struct crypto_alg camellia_alg = {
+        .cra_name               =       "camellia",
+        .cra_driver_name        =       "camellia-generic",
+        .cra_priority           =       100,
+        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
+        .cra_blocksize          =       CAMELLIA_BLOCK_SIZE,
+        .cra_ctxsize            =       sizeof(struct camellia_ctx),
+        .cra_alignmask          =       3,
+        .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(camellia_alg.cra_list),
+        .cra_u                  =       {
+                .cipher = {
+                        .cia_min_keysize        =       CAMELLIA_MIN_KEY_SIZE,
+                        .cia_max_keysize        =       CAMELLIA_MAX_KEY_SIZE,
+                        .cia_setkey             =       camellia_set_key,
+                        .cia_encrypt            =       camellia_encrypt,
+                        .cia_decrypt            =       camellia_decrypt
+                }
+        }
+};
+
+static int __init camellia_init(void)
+{
+        return crypto_register_alg(&camellia_alg);
+}
+
+static void __exit camellia_fini(void)
+{
+        crypto_unregister_alg(&camellia_alg);
+}
+
+module_init(camellia_init);
+module_exit(camellia_fini);
+
+MODULE_DESCRIPTION("Camellia Cipher Algorithm");
+MODULE_LICENSE("GPL");
diff --git a/crypto/cast5.c b/crypto/cast5.c
new file mode 100644
index 00000000000..4a230ddec87
--- /dev/null
+++ b/crypto/cast5.c
@@ -0,0 +1,809 @@
+/* Kernel cryptographic api.
+* cast5.c - Cast5 cipher algorithm (rfc2144).
+*
+* Derived from GnuPG implementation of cast5.
+*
+* Major Changes.
+*       Complete conformance to rfc2144.
+*       Supports key size from 40 to 128 bits.
+*
+* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+* Copyright (C) 2003 Kartikey Mahendra Bhatt <kartik_me@hotmail.com>.
+*
+* This program is free software; you can redistribute it and/or modify it
+* under the terms of GNU General Public License as published by the Free
+* Software Foundation; either version 2 of the License, or (at your option)
+* any later version.
+*
+* 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
+*/
+
+
+#include <asm/byteorder.h>
+#include <linux/init.h>
+#include <linux/crypto.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/types.h>
+
+#define CAST5_BLOCK_SIZE 8
+#define CAST5_MIN_KEY_SIZE 5
+#define CAST5_MAX_KEY_SIZE 16
+
+struct cast5_ctx {
+        u32 Km[16];
+        u8 Kr[16];
+        int rr; /* rr?number of rounds = 16:number of rounds = 12; (rfc 2144) */
+};
+
+
+static const u32 s1[256] = {
+        0x30fb40d4, 0x9fa0ff0b, 0x6beccd2f, 0x3f258c7a, 0x1e213f2f,
+        0x9c004dd3, 0x6003e540, 0xcf9fc949,
+        0xbfd4af27, 0x88bbbdb5, 0xe2034090, 0x98d09675, 0x6e63a0e0,
+        0x15c361d2, 0xc2e7661d, 0x22d4ff8e,
+        0x28683b6f, 0xc07fd059, 0xff2379c8, 0x775f50e2, 0x43c340d3,
+        0xdf2f8656, 0x887ca41a, 0xa2d2bd2d,
+        0xa1c9e0d6, 0x346c4819, 0x61b76d87, 0x22540f2f, 0x2abe32e1,
+        0xaa54166b, 0x22568e3a, 0xa2d341d0,
+        0x66db40c8, 0xa784392f, 0x004dff2f, 0x2db9d2de, 0x97943fac,
+        0x4a97c1d8, 0x527644b7, 0xb5f437a7,
+        0xb82cbaef, 0xd751d159, 0x6ff7f0ed, 0x5a097a1f, 0x827b68d0,
+        0x90ecf52e, 0x22b0c054, 0xbc8e5935,
+        0x4b6d2f7f, 0x50bb64a2, 0xd2664910, 0xbee5812d, 0xb7332290,
+        0xe93b159f, 0xb48ee411, 0x4bff345d,
+        0xfd45c240, 0xad31973f, 0xc4f6d02e, 0x55fc8165, 0xd5b1caad,
+        0xa1ac2dae, 0xa2d4b76d, 0xc19b0c50,
+        0x882240f2, 0x0c6e4f38, 0xa4e4bfd7, 0x4f5ba272, 0x564c1d2f,
+        0xc59c5319, 0xb949e354, 0xb04669fe,
+        0xb1b6ab8a, 0xc71358dd, 0x6385c545, 0x110f935d, 0x57538ad5,
+        0x6a390493, 0xe63d37e0, 0x2a54f6b3,
+        0x3a787d5f, 0x6276a0b5, 0x19a6fcdf, 0x7a42206a, 0x29f9d4d5,
+        0xf61b1891, 0xbb72275e, 0xaa508167,
+        0x38901091, 0xc6b505eb, 0x84c7cb8c, 0x2ad75a0f, 0x874a1427,
+        0xa2d1936b, 0x2ad286af, 0xaa56d291,
+        0xd7894360, 0x425c750d, 0x93b39e26, 0x187184c9, 0x6c00b32d,
+        0x73e2bb14, 0xa0bebc3c, 0x54623779,
+        0x64459eab, 0x3f328b82, 0x7718cf82, 0x59a2cea6, 0x04ee002e,
+        0x89fe78e6, 0x3fab0950, 0x325ff6c2,
+        0x81383f05, 0x6963c5c8, 0x76cb5ad6, 0xd49974c9, 0xca180dcf,
+        0x380782d5, 0xc7fa5cf6, 0x8ac31511,
+        0x35e79e13, 0x47da91d0, 0xf40f9086, 0xa7e2419e, 0x31366241,
+        0x051ef495, 0xaa573b04, 0x4a805d8d,
+        0x548300d0, 0x00322a3c, 0xbf64cddf, 0xba57a68e, 0x75c6372b,
+        0x50afd341, 0xa7c13275, 0x915a0bf5,
+        0x6b54bfab, 0x2b0b1426, 0xab4cc9d7, 0x449ccd82, 0xf7fbf265,
+        0xab85c5f3, 0x1b55db94, 0xaad4e324,
+        0xcfa4bd3f, 0x2deaa3e2, 0x9e204d02, 0xc8bd25ac, 0xeadf55b3,
+        0xd5bd9e98, 0xe31231b2, 0x2ad5ad6c,
+        0x954329de, 0xadbe4528, 0xd8710f69, 0xaa51c90f, 0xaa786bf6,
+        0x22513f1e, 0xaa51a79b, 0x2ad344cc,
+        0x7b5a41f0, 0xd37cfbad, 0x1b069505, 0x41ece491, 0xb4c332e6,
+        0x032268d4, 0xc9600acc, 0xce387e6d,
+        0xbf6bb16c, 0x6a70fb78, 0x0d03d9c9, 0xd4df39de, 0xe01063da,
+        0x4736f464, 0x5ad328d8, 0xb347cc96,
+        0x75bb0fc3, 0x98511bfb, 0x4ffbcc35, 0xb58bcf6a, 0xe11f0abc,
+        0xbfc5fe4a, 0xa70aec10, 0xac39570a,
+        0x3f04442f, 0x6188b153, 0xe0397a2e, 0x5727cb79, 0x9ceb418f,
+        0x1cacd68d, 0x2ad37c96, 0x0175cb9d,
+        0xc69dff09, 0xc75b65f0, 0xd9db40d8, 0xec0e7779, 0x4744ead4,
+        0xb11c3274, 0xdd24cb9e, 0x7e1c54bd,
+        0xf01144f9, 0xd2240eb1, 0x9675b3fd, 0xa3ac3755, 0xd47c27af,
+        0x51c85f4d, 0x56907596, 0xa5bb15e6,
+        0x580304f0, 0xca042cf1, 0x011a37ea, 0x8dbfaadb, 0x35ba3e4a,
+        0x3526ffa0, 0xc37b4d09, 0xbc306ed9,
+        0x98a52666, 0x5648f725, 0xff5e569d, 0x0ced63d0, 0x7c63b2cf,
+        0x700b45e1, 0xd5ea50f1, 0x85a92872,
+        0xaf1fbda7, 0xd4234870, 0xa7870bf3, 0x2d3b4d79, 0x42e04198,
+        0x0cd0ede7, 0x26470db8, 0xf881814c,
+        0x474d6ad7, 0x7c0c5e5c, 0xd1231959, 0x381b7298, 0xf5d2f4db,
+        0xab838653, 0x6e2f1e23, 0x83719c9e,
+        0xbd91e046, 0x9a56456e, 0xdc39200c, 0x20c8c571, 0x962bda1c,
+        0xe1e696ff, 0xb141ab08, 0x7cca89b9,
+        0x1a69e783, 0x02cc4843, 0xa2f7c579, 0x429ef47d, 0x427b169c,
+        0x5ac9f049, 0xdd8f0f00, 0x5c8165bf
+};
+static const u32 s2[256] = {
+        0x1f201094, 0xef0ba75b, 0x69e3cf7e, 0x393f4380, 0xfe61cf7a,
+        0xeec5207a, 0x55889c94, 0x72fc0651,
+        0xada7ef79, 0x4e1d7235, 0xd55a63ce, 0xde0436ba, 0x99c430ef,
+        0x5f0c0794, 0x18dcdb7d, 0xa1d6eff3,
+        0xa0b52f7b, 0x59e83605, 0xee15b094, 0xe9ffd909, 0xdc440086,
+        0xef944459, 0xba83ccb3, 0xe0c3cdfb,
+        0xd1da4181, 0x3b092ab1, 0xf997f1c1, 0xa5e6cf7b, 0x01420ddb,
+        0xe4e7ef5b, 0x25a1ff41, 0xe180f806,
+        0x1fc41080, 0x179bee7a, 0xd37ac6a9, 0xfe5830a4, 0x98de8b7f,
+        0x77e83f4e, 0x79929269, 0x24fa9f7b,
+        0xe113c85b, 0xacc40083, 0xd7503525, 0xf7ea615f, 0x62143154,
+        0x0d554b63, 0x5d681121, 0xc866c359,
+        0x3d63cf73, 0xcee234c0, 0xd4d87e87, 0x5c672b21, 0x071f6181,
+        0x39f7627f, 0x361e3084, 0xe4eb573b,
+        0x602f64a4, 0xd63acd9c, 0x1bbc4635, 0x9e81032d, 0x2701f50c,
+        0x99847ab4, 0xa0e3df79, 0xba6cf38c,
+        0x10843094, 0x2537a95e, 0xf46f6ffe, 0xa1ff3b1f, 0x208cfb6a,
+        0x8f458c74, 0xd9e0a227, 0x4ec73a34,
+        0xfc884f69, 0x3e4de8df, 0xef0e0088, 0x3559648d, 0x8a45388c,
+        0x1d804366, 0x721d9bfd, 0xa58684bb,
+        0xe8256333, 0x844e8212, 0x128d8098, 0xfed33fb4, 0xce280ae1,
+        0x27e19ba5, 0xd5a6c252, 0xe49754bd,
+        0xc5d655dd, 0xeb667064, 0x77840b4d, 0xa1b6a801, 0x84db26a9,
+        0xe0b56714, 0x21f043b7, 0xe5d05860,
+        0x54f03084, 0x066ff472, 0xa31aa153, 0xdadc4755, 0xb5625dbf,
+        0x68561be6, 0x83ca6b94, 0x2d6ed23b,
+        0xeccf01db, 0xa6d3d0ba, 0xb6803d5c, 0xaf77a709, 0x33b4a34c,
+        0x397bc8d6, 0x5ee22b95, 0x5f0e5304,
+        0x81ed6f61, 0x20e74364, 0xb45e1378, 0xde18639b, 0x881ca122,
+        0xb96726d1, 0x8049a7e8, 0x22b7da7b,
+        0x5e552d25, 0x5272d237, 0x79d2951c, 0xc60d894c, 0x488cb402,
+        0x1ba4fe5b, 0xa4b09f6b, 0x1ca815cf,
+        0xa20c3005, 0x8871df63, 0xb9de2fcb, 0x0cc6c9e9, 0x0beeff53,
+        0xe3214517, 0xb4542835, 0x9f63293c,
+        0xee41e729, 0x6e1d2d7c, 0x50045286, 0x1e6685f3, 0xf33401c6,
+        0x30a22c95, 0x31a70850, 0x60930f13,
+        0x73f98417, 0xa1269859, 0xec645c44, 0x52c877a9, 0xcdff33a6,
+        0xa02b1741, 0x7cbad9a2, 0x2180036f,
+        0x50d99c08, 0xcb3f4861, 0xc26bd765, 0x64a3f6ab, 0x80342676,
+        0x25a75e7b, 0xe4e6d1fc, 0x20c710e6,
+        0xcdf0b680, 0x17844d3b, 0x31eef84d, 0x7e0824e4, 0x2ccb49eb,
+        0x846a3bae, 0x8ff77888, 0xee5d60f6,
+        0x7af75673, 0x2fdd5cdb, 0xa11631c1, 0x30f66f43, 0xb3faec54,
+        0x157fd7fa, 0xef8579cc, 0xd152de58,
+        0xdb2ffd5e, 0x8f32ce19, 0x306af97a, 0x02f03ef8, 0x99319ad5,
+        0xc242fa0f, 0xa7e3ebb0, 0xc68e4906,
+        0xb8da230c, 0x80823028, 0xdcdef3c8, 0xd35fb171, 0x088a1bc8,
+        0xbec0c560, 0x61a3c9e8, 0xbca8f54d,
+        0xc72feffa, 0x22822e99, 0x82c570b4, 0xd8d94e89, 0x8b1c34bc,
+        0x301e16e6, 0x273be979, 0xb0ffeaa6,
+        0x61d9b8c6, 0x00b24869, 0xb7ffce3f, 0x08dc283b, 0x43daf65a,
+        0xf7e19798, 0x7619b72f, 0x8f1c9ba4,
+        0xdc8637a0, 0x16a7d3b1, 0x9fc393b7, 0xa7136eeb, 0xc6bcc63e,
+        0x1a513742, 0xef6828bc, 0x520365d6,
+        0x2d6a77ab, 0x3527ed4b, 0x821fd216, 0x095c6e2e, 0xdb92f2fb,
+        0x5eea29cb, 0x145892f5, 0x91584f7f,
+        0x5483697b, 0x2667a8cc, 0x85196048, 0x8c4bacea, 0x833860d4,
+        0x0d23e0f9, 0x6c387e8a, 0x0ae6d249,
+        0xb284600c, 0xd835731d, 0xdcb1c647, 0xac4c56ea, 0x3ebd81b3,
+        0x230eabb0, 0x6438bc87, 0xf0b5b1fa,
+        0x8f5ea2b3, 0xfc184642, 0x0a036b7a, 0x4fb089bd, 0x649da589,
+        0xa345415e, 0x5c038323, 0x3e5d3bb9,
+        0x43d79572, 0x7e6dd07c, 0x06dfdf1e, 0x6c6cc4ef, 0x7160a539,
+        0x73bfbe70, 0x83877605, 0x4523ecf1
+};
+static const u32 s3[256] = {
+        0x8defc240, 0x25fa5d9f, 0xeb903dbf, 0xe810c907, 0x47607fff,
+        0x369fe44b, 0x8c1fc644, 0xaececa90,
+        0xbeb1f9bf, 0xeefbcaea, 0xe8cf1950, 0x51df07ae, 0x920e8806,
+        0xf0ad0548, 0xe13c8d83, 0x927010d5,
+        0x11107d9f, 0x07647db9, 0xb2e3e4d4, 0x3d4f285e, 0xb9afa820,
+        0xfade82e0, 0xa067268b, 0x8272792e,
+        0x553fb2c0, 0x489ae22b, 0xd4ef9794, 0x125e3fbc, 0x21fffcee,
+        0x825b1bfd, 0x9255c5ed, 0x1257a240,
+        0x4e1a8302, 0xbae07fff, 0x528246e7, 0x8e57140e, 0x3373f7bf,
+        0x8c9f8188, 0xa6fc4ee8, 0xc982b5a5,
+        0xa8c01db7, 0x579fc264, 0x67094f31, 0xf2bd3f5f, 0x40fff7c1,
+        0x1fb78dfc, 0x8e6bd2c1, 0x437be59b,
+        0x99b03dbf, 0xb5dbc64b, 0x638dc0e6, 0x55819d99, 0xa197c81c,
+        0x4a012d6e, 0xc5884a28, 0xccc36f71,
+        0xb843c213, 0x6c0743f1, 0x8309893c, 0x0feddd5f, 0x2f7fe850,
+        0xd7c07f7e, 0x02507fbf, 0x5afb9a04,
+        0xa747d2d0, 0x1651192e, 0xaf70bf3e, 0x58c31380, 0x5f98302e,
+        0x727cc3c4, 0x0a0fb402, 0x0f7fef82,
+        0x8c96fdad, 0x5d2c2aae, 0x8ee99a49, 0x50da88b8, 0x8427f4a0,
+        0x1eac5790, 0x796fb449, 0x8252dc15,
+        0xefbd7d9b, 0xa672597d, 0xada840d8, 0x45f54504, 0xfa5d7403,
+        0xe83ec305, 0x4f91751a, 0x925669c2,
+        0x23efe941, 0xa903f12e, 0x60270df2, 0x0276e4b6, 0x94fd6574,
+        0x927985b2, 0x8276dbcb, 0x02778176,
+        0xf8af918d, 0x4e48f79e, 0x8f616ddf, 0xe29d840e, 0x842f7d83,
+        0x340ce5c8, 0x96bbb682, 0x93b4b148,
+        0xef303cab, 0x984faf28, 0x779faf9b, 0x92dc560d, 0x224d1e20,
+        0x8437aa88, 0x7d29dc96, 0x2756d3dc,
+        0x8b907cee, 0xb51fd240, 0xe7c07ce3, 0xe566b4a1, 0xc3e9615e,
+        0x3cf8209d, 0x6094d1e3, 0xcd9ca341,
+        0x5c76460e, 0x00ea983b, 0xd4d67881, 0xfd47572c, 0xf76cedd9,
+        0xbda8229c, 0x127dadaa, 0x438a074e,
+        0x1f97c090, 0x081bdb8a, 0x93a07ebe, 0xb938ca15, 0x97b03cff,
+        0x3dc2c0f8, 0x8d1ab2ec, 0x64380e51,
+        0x68cc7bfb, 0xd90f2788, 0x12490181, 0x5de5ffd4, 0xdd7ef86a,
+        0x76a2e214, 0xb9a40368, 0x925d958f,
+        0x4b39fffa, 0xba39aee9, 0xa4ffd30b, 0xfaf7933b, 0x6d498623,
+        0x193cbcfa, 0x27627545, 0x825cf47a,
+        0x61bd8ba0, 0xd11e42d1, 0xcead04f4, 0x127ea392, 0x10428db7,
+        0x8272a972, 0x9270c4a8, 0x127de50b,
+        0x285ba1c8, 0x3c62f44f, 0x35c0eaa5, 0xe805d231, 0x428929fb,
+        0xb4fcdf82, 0x4fb66a53, 0x0e7dc15b,
+        0x1f081fab, 0x108618ae, 0xfcfd086d, 0xf9ff2889, 0x694bcc11,
+        0x236a5cae, 0x12deca4d, 0x2c3f8cc5,
+        0xd2d02dfe, 0xf8ef5896, 0xe4cf52da, 0x95155b67, 0x494a488c,
+        0xb9b6a80c, 0x5c8f82bc, 0x89d36b45,
+        0x3a609437, 0xec00c9a9, 0x44715253, 0x0a874b49, 0xd773bc40,
+        0x7c34671c, 0x02717ef6, 0x4feb5536,
+        0xa2d02fff, 0xd2bf60c4, 0xd43f03c0, 0x50b4ef6d, 0x07478cd1,
+        0x006e1888, 0xa2e53f55, 0xb9e6d4bc,
+        0xa2048016, 0x97573833, 0xd7207d67, 0xde0f8f3d, 0x72f87b33,
+        0xabcc4f33, 0x7688c55d, 0x7b00a6b0,
+        0x947b0001, 0x570075d2, 0xf9bb88f8, 0x8942019e, 0x4264a5ff,
+        0x856302e0, 0x72dbd92b, 0xee971b69,
+        0x6ea22fde, 0x5f08ae2b, 0xaf7a616d, 0xe5c98767, 0xcf1febd2,
+        0x61efc8c2, 0xf1ac2571, 0xcc8239c2,
+        0x67214cb8, 0xb1e583d1, 0xb7dc3e62, 0x7f10bdce, 0xf90a5c38,
+        0x0ff0443d, 0x606e6dc6, 0x60543a49,
+        0x5727c148, 0x2be98a1d, 0x8ab41738, 0x20e1be24, 0xaf96da0f,
+        0x68458425, 0x99833be5, 0x600d457d,
+        0x282f9350, 0x8334b362, 0xd91d1120, 0x2b6d8da0, 0x642b1e31,
+        0x9c305a00, 0x52bce688, 0x1b03588a,
+        0xf7baefd5, 0x4142ed9c, 0xa4315c11, 0x83323ec5, 0xdfef4636,
+        0xa133c501, 0xe9d3531c, 0xee353783
+};
+static const u32 s4[256] = {
+        0x9db30420, 0x1fb6e9de, 0xa7be7bef, 0xd273a298, 0x4a4f7bdb,
+        0x64ad8c57, 0x85510443, 0xfa020ed1,
+        0x7e287aff, 0xe60fb663, 0x095f35a1, 0x79ebf120, 0xfd059d43,
+        0x6497b7b1, 0xf3641f63, 0x241e4adf,
+        0x28147f5f, 0x4fa2b8cd, 0xc9430040, 0x0cc32220, 0xfdd30b30,
+        0xc0a5374f, 0x1d2d00d9, 0x24147b15,
+        0xee4d111a, 0x0fca5167, 0x71ff904c, 0x2d195ffe, 0x1a05645f,
+        0x0c13fefe, 0x081b08ca, 0x05170121,
+        0x80530100, 0xe83e5efe, 0xac9af4f8, 0x7fe72701, 0xd2b8ee5f,
+        0x06df4261, 0xbb9e9b8a, 0x7293ea25,
+        0xce84ffdf, 0xf5718801, 0x3dd64b04, 0xa26f263b, 0x7ed48400,
+        0x547eebe6, 0x446d4ca0, 0x6cf3d6f5,
+        0x2649abdf, 0xaea0c7f5, 0x36338cc1, 0x503f7e93, 0xd3772061,
+        0x11b638e1, 0x72500e03, 0xf80eb2bb,
+        0xabe0502e, 0xec8d77de, 0x57971e81, 0xe14f6746, 0xc9335400,
+        0x6920318f, 0x081dbb99, 0xffc304a5,
+        0x4d351805, 0x7f3d5ce3, 0xa6c866c6, 0x5d5bcca9, 0xdaec6fea,
+        0x9f926f91, 0x9f46222f, 0x3991467d,
+        0xa5bf6d8e, 0x1143c44f, 0x43958302, 0xd0214eeb, 0x022083b8,
+        0x3fb6180c, 0x18f8931e, 0x281658e6,
+        0x26486e3e, 0x8bd78a70, 0x7477e4c1, 0xb506e07c, 0xf32d0a25,
+        0x79098b02, 0xe4eabb81, 0x28123b23,
+        0x69dead38, 0x1574ca16, 0xdf871b62, 0x211c40b7, 0xa51a9ef9,
+        0x0014377b, 0x041e8ac8, 0x09114003,
+        0xbd59e4d2, 0xe3d156d5, 0x4fe876d5, 0x2f91a340, 0x557be8de,
+        0x00eae4a7, 0x0ce5c2ec, 0x4db4bba6,
+        0xe756bdff, 0xdd3369ac, 0xec17b035, 0x06572327, 0x99afc8b0,
+        0x56c8c391, 0x6b65811c, 0x5e146119,
+        0x6e85cb75, 0xbe07c002, 0xc2325577, 0x893ff4ec, 0x5bbfc92d,
+        0xd0ec3b25, 0xb7801ab7, 0x8d6d3b24,
+        0x20c763ef, 0xc366a5fc, 0x9c382880, 0x0ace3205, 0xaac9548a,
+        0xeca1d7c7, 0x041afa32, 0x1d16625a,
+        0x6701902c, 0x9b757a54, 0x31d477f7, 0x9126b031, 0x36cc6fdb,
+        0xc70b8b46, 0xd9e66a48, 0x56e55a79,
+        0x026a4ceb, 0x52437eff, 0x2f8f76b4, 0x0df980a5, 0x8674cde3,
+        0xedda04eb, 0x17a9be04, 0x2c18f4df,
+        0xb7747f9d, 0xab2af7b4, 0xefc34d20, 0x2e096b7c, 0x1741a254,
+        0xe5b6a035, 0x213d42f6, 0x2c1c7c26,
+        0x61c2f50f, 0x6552daf9, 0xd2c231f8, 0x25130f69, 0xd8167fa2,
+        0x0418f2c8, 0x001a96a6, 0x0d1526ab,
+        0x63315c21, 0x5e0a72ec, 0x49bafefd, 0x187908d9, 0x8d0dbd86,
+        0x311170a7, 0x3e9b640c, 0xcc3e10d7,
+        0xd5cad3b6, 0x0caec388, 0xf73001e1, 0x6c728aff, 0x71eae2a1,
+        0x1f9af36e, 0xcfcbd12f, 0xc1de8417,
+        0xac07be6b, 0xcb44a1d8, 0x8b9b0f56, 0x013988c3, 0xb1c52fca,
+        0xb4be31cd, 0xd8782806, 0x12a3a4e2,
+        0x6f7de532, 0x58fd7eb6, 0xd01ee900, 0x24adffc2, 0xf4990fc5,
+        0x9711aac5, 0x001d7b95, 0x82e5e7d2,
+        0x109873f6, 0x00613096, 0xc32d9521, 0xada121ff, 0x29908415,
+        0x7fbb977f, 0xaf9eb3db, 0x29c9ed2a,
+        0x5ce2a465, 0xa730f32c, 0xd0aa3fe8, 0x8a5cc091, 0xd49e2ce7,
+        0x0ce454a9, 0xd60acd86, 0x015f1919,
+        0x77079103, 0xdea03af6, 0x78a8565e, 0xdee356df, 0x21f05cbe,
+        0x8b75e387, 0xb3c50651, 0xb8a5c3ef,
+        0xd8eeb6d2, 0xe523be77, 0xc2154529, 0x2f69efdf, 0xafe67afb,
+        0xf470c4b2, 0xf3e0eb5b, 0xd6cc9876,
+        0x39e4460c, 0x1fda8538, 0x1987832f, 0xca007367, 0xa99144f8,
+        0x296b299e, 0x492fc295, 0x9266beab,
+        0xb5676e69, 0x9bd3ddda, 0xdf7e052f, 0xdb25701c, 0x1b5e51ee,
+        0xf65324e6, 0x6afce36c, 0x0316cc04,
+        0x8644213e, 0xb7dc59d0, 0x7965291f, 0xccd6fd43, 0x41823979,
+        0x932bcdf6, 0xb657c34d, 0x4edfd282,
+        0x7ae5290c, 0x3cb9536b, 0x851e20fe, 0x9833557e, 0x13ecf0b0,
+        0xd3ffb372, 0x3f85c5c1, 0x0aef7ed2
+};
+static const u32 s5[256] = {
+        0x7ec90c04, 0x2c6e74b9, 0x9b0e66df, 0xa6337911, 0xb86a7fff,
+        0x1dd358f5, 0x44dd9d44, 0x1731167f,
+        0x08fbf1fa, 0xe7f511cc, 0xd2051b00, 0x735aba00, 0x2ab722d8,
+        0x386381cb, 0xacf6243a, 0x69befd7a,
+        0xe6a2e77f, 0xf0c720cd, 0xc4494816, 0xccf5c180, 0x38851640,
+        0x15b0a848, 0xe68b18cb, 0x4caadeff,
+        0x5f480a01, 0x0412b2aa, 0x259814fc, 0x41d0efe2, 0x4e40b48d,
+        0x248eb6fb, 0x8dba1cfe, 0x41a99b02,
+        0x1a550a04, 0xba8f65cb, 0x7251f4e7, 0x95a51725, 0xc106ecd7,
+        0x97a5980a, 0xc539b9aa, 0x4d79fe6a,
+        0xf2f3f763, 0x68af8040, 0xed0c9e56, 0x11b4958b, 0xe1eb5a88,
+        0x8709e6b0, 0xd7e07156, 0x4e29fea7,
+        0x6366e52d, 0x02d1c000, 0xc4ac8e05, 0x9377f571, 0x0c05372a,
+        0x578535f2, 0x2261be02, 0xd642a0c9,
+        0xdf13a280, 0x74b55bd2, 0x682199c0, 0xd421e5ec, 0x53fb3ce8,
+        0xc8adedb3, 0x28a87fc9, 0x3d959981,
+        0x5c1ff900, 0xfe38d399, 0x0c4eff0b, 0x062407ea, 0xaa2f4fb1,
+        0x4fb96976, 0x90c79505, 0xb0a8a774,
+        0xef55a1ff, 0xe59ca2c2, 0xa6b62d27, 0xe66a4263, 0xdf65001f,
+        0x0ec50966, 0xdfdd55bc, 0x29de0655,
+        0x911e739a, 0x17af8975, 0x32c7911c, 0x89f89468, 0x0d01e980,
+        0x524755f4, 0x03b63cc9, 0x0cc844b2,
+        0xbcf3f0aa, 0x87ac36e9, 0xe53a7426, 0x01b3d82b, 0x1a9e7449,
+        0x64ee2d7e, 0xcddbb1da, 0x01c94910,
+        0xb868bf80, 0x0d26f3fd, 0x9342ede7, 0x04a5c284, 0x636737b6,
+        0x50f5b616, 0xf24766e3, 0x8eca36c1,
+        0x136e05db, 0xfef18391, 0xfb887a37, 0xd6e7f7d4, 0xc7fb7dc9,
+        0x3063fcdf, 0xb6f589de, 0xec2941da,
+        0x26e46695, 0xb7566419, 0xf654efc5, 0xd08d58b7, 0x48925401,
+        0xc1bacb7f, 0xe5ff550f, 0xb6083049,
+        0x5bb5d0e8, 0x87d72e5a, 0xab6a6ee1, 0x223a66ce, 0xc62bf3cd,
+        0x9e0885f9, 0x68cb3e47, 0x086c010f,
+        0xa21de820, 0xd18b69de, 0xf3f65777, 0xfa02c3f6, 0x407edac3,
+        0xcbb3d550, 0x1793084d, 0xb0d70eba,
+        0x0ab378d5, 0xd951fb0c, 0xded7da56, 0x4124bbe4, 0x94ca0b56,
+        0x0f5755d1, 0xe0e1e56e, 0x6184b5be,
+        0x580a249f, 0x94f74bc0, 0xe327888e, 0x9f7b5561, 0xc3dc0280,
+        0x05687715, 0x646c6bd7, 0x44904db3,
+        0x66b4f0a3, 0xc0f1648a, 0x697ed5af, 0x49e92ff6, 0x309e374f,
+        0x2cb6356a, 0x85808573, 0x4991f840,
+        0x76f0ae02, 0x083be84d, 0x28421c9a, 0x44489406, 0x736e4cb8,
+        0xc1092910, 0x8bc95fc6, 0x7d869cf4,
+        0x134f616f, 0x2e77118d, 0xb31b2be1, 0xaa90b472, 0x3ca5d717,
+        0x7d161bba, 0x9cad9010, 0xaf462ba2,
+        0x9fe459d2, 0x45d34559, 0xd9f2da13, 0xdbc65487, 0xf3e4f94e,
+        0x176d486f, 0x097c13ea, 0x631da5c7,
+        0x445f7382, 0x175683f4, 0xcdc66a97, 0x70be0288, 0xb3cdcf72,
+        0x6e5dd2f3, 0x20936079, 0x459b80a5,
+        0xbe60e2db, 0xa9c23101, 0xeba5315c, 0x224e42f2, 0x1c5c1572,
+        0xf6721b2c, 0x1ad2fff3, 0x8c25404e,
+        0x324ed72f, 0x4067b7fd, 0x0523138e, 0x5ca3bc78, 0xdc0fd66e,
+        0x75922283, 0x784d6b17, 0x58ebb16e,
+        0x44094f85, 0x3f481d87, 0xfcfeae7b, 0x77b5ff76, 0x8c2302bf,
+        0xaaf47556, 0x5f46b02a, 0x2b092801,
+        0x3d38f5f7, 0x0ca81f36, 0x52af4a8a, 0x66d5e7c0, 0xdf3b0874,
+        0x95055110, 0x1b5ad7a8, 0xf61ed5ad,
+        0x6cf6e479, 0x20758184, 0xd0cefa65, 0x88f7be58, 0x4a046826,
+        0x0ff6f8f3, 0xa09c7f70, 0x5346aba0,
+        0x5ce96c28, 0xe176eda3, 0x6bac307f, 0x376829d2, 0x85360fa9,
+        0x17e3fe2a, 0x24b79767, 0xf5a96b20,
+        0xd6cd2595, 0x68ff1ebf, 0x7555442c, 0xf19f06be, 0xf9e0659a,
+        0xeeb9491d, 0x34010718, 0xbb30cab8,
+        0xe822fe15, 0x88570983, 0x750e6249, 0xda627e55, 0x5e76ffa8,
+        0xb1534546, 0x6d47de08, 0xefe9e7d4
+};
+static const u32 s6[256] = {
+        0xf6fa8f9d, 0x2cac6ce1, 0x4ca34867, 0xe2337f7c, 0x95db08e7,
+        0x016843b4, 0xeced5cbc, 0x325553ac,
+        0xbf9f0960, 0xdfa1e2ed, 0x83f0579d, 0x63ed86b9, 0x1ab6a6b8,
+        0xde5ebe39, 0xf38ff732, 0x8989b138,
+        0x33f14961, 0xc01937bd, 0xf506c6da, 0xe4625e7e, 0xa308ea99,
+        0x4e23e33c, 0x79cbd7cc, 0x48a14367,
+        0xa3149619, 0xfec94bd5, 0xa114174a, 0xeaa01866, 0xa084db2d,
+        0x09a8486f, 0xa888614a, 0x2900af98,
+        0x01665991, 0xe1992863, 0xc8f30c60, 0x2e78ef3c, 0xd0d51932,
+        0xcf0fec14, 0xf7ca07d2, 0xd0a82072,
+        0xfd41197e, 0x9305a6b0, 0xe86be3da, 0x74bed3cd, 0x372da53c,
+        0x4c7f4448, 0xdab5d440, 0x6dba0ec3,
+        0x083919a7, 0x9fbaeed9, 0x49dbcfb0, 0x4e670c53, 0x5c3d9c01,
+        0x64bdb941, 0x2c0e636a, 0xba7dd9cd,
+        0xea6f7388, 0xe70bc762, 0x35f29adb, 0x5c4cdd8d, 0xf0d48d8c,
+        0xb88153e2, 0x08a19866, 0x1ae2eac8,
+        0x284caf89, 0xaa928223, 0x9334be53, 0x3b3a21bf, 0x16434be3,
+        0x9aea3906, 0xefe8c36e, 0xf890cdd9,
+        0x80226dae, 0xc340a4a3, 0xdf7e9c09, 0xa694a807, 0x5b7c5ecc,
+        0x221db3a6, 0x9a69a02f, 0x68818a54,
+        0xceb2296f, 0x53c0843a, 0xfe893655, 0x25bfe68a, 0xb4628abc,
+        0xcf222ebf, 0x25ac6f48, 0xa9a99387,
+        0x53bddb65, 0xe76ffbe7, 0xe967fd78, 0x0ba93563, 0x8e342bc1,
+        0xe8a11be9, 0x4980740d, 0xc8087dfc,
+        0x8de4bf99, 0xa11101a0, 0x7fd37975, 0xda5a26c0, 0xe81f994f,
+        0x9528cd89, 0xfd339fed, 0xb87834bf,
+        0x5f04456d, 0x22258698, 0xc9c4c83b, 0x2dc156be, 0x4f628daa,
+        0x57f55ec5, 0xe2220abe, 0xd2916ebf,
+        0x4ec75b95, 0x24f2c3c0, 0x42d15d99, 0xcd0d7fa0, 0x7b6e27ff,
+        0xa8dc8af0, 0x7345c106, 0xf41e232f,
+        0x35162386, 0xe6ea8926, 0x3333b094, 0x157ec6f2, 0x372b74af,
+        0x692573e4, 0xe9a9d848, 0xf3160289,
+        0x3a62ef1d, 0xa787e238, 0xf3a5f676, 0x74364853, 0x20951063,
+        0x4576698d, 0xb6fad407, 0x592af950,
+        0x36f73523, 0x4cfb6e87, 0x7da4cec0, 0x6c152daa, 0xcb0396a8,
+        0xc50dfe5d, 0xfcd707ab, 0x0921c42f,
+        0x89dff0bb, 0x5fe2be78, 0x448f4f33, 0x754613c9, 0x2b05d08d,
+        0x48b9d585, 0xdc049441, 0xc8098f9b,
+        0x7dede786, 0xc39a3373, 0x42410005, 0x6a091751, 0x0ef3c8a6,
+        0x890072d6, 0x28207682, 0xa9a9f7be,
+        0xbf32679d, 0xd45b5b75, 0xb353fd00, 0xcbb0e358, 0x830f220a,
+        0x1f8fb214, 0xd372cf08, 0xcc3c4a13,
+        0x8cf63166, 0x061c87be, 0x88c98f88, 0x6062e397, 0x47cf8e7a,
+        0xb6c85283, 0x3cc2acfb, 0x3fc06976,
+        0x4e8f0252, 0x64d8314d, 0xda3870e3, 0x1e665459, 0xc10908f0,
+        0x513021a5, 0x6c5b68b7, 0x822f8aa0,
+        0x3007cd3e, 0x74719eef, 0xdc872681, 0x073340d4, 0x7e432fd9,
+        0x0c5ec241, 0x8809286c, 0xf592d891,
+        0x08a930f6, 0x957ef305, 0xb7fbffbd, 0xc266e96f, 0x6fe4ac98,
+        0xb173ecc0, 0xbc60b42a, 0x953498da,
+        0xfba1ae12, 0x2d4bd736, 0x0f25faab, 0xa4f3fceb, 0xe2969123,
+        0x257f0c3d, 0x9348af49, 0x361400bc,
+        0xe8816f4a, 0x3814f200, 0xa3f94043, 0x9c7a54c2, 0xbc704f57,
+        0xda41e7f9, 0xc25ad33a, 0x54f4a084,
+        0xb17f5505, 0x59357cbe, 0xedbd15c8, 0x7f97c5ab, 0xba5ac7b5,
+        0xb6f6deaf, 0x3a479c3a, 0x5302da25,
+        0x653d7e6a, 0x54268d49, 0x51a477ea, 0x5017d55b, 0xd7d25d88,
+        0x44136c76, 0x0404a8c8, 0xb8e5a121,
+        0xb81a928a, 0x60ed5869, 0x97c55b96, 0xeaec991b, 0x29935913,
+        0x01fdb7f1, 0x088e8dfa, 0x9ab6f6f5,
+        0x3b4cbf9f, 0x4a5de3ab, 0xe6051d35, 0xa0e1d855, 0xd36b4cf1,
+        0xf544edeb, 0xb0e93524, 0xbebb8fbd,
+        0xa2d762cf, 0x49c92f54, 0x38b5f331, 0x7128a454, 0x48392905,
+        0xa65b1db8, 0x851c97bd, 0xd675cf2f
+};
+static const u32 s7[256] = {
+        0x85e04019, 0x332bf567, 0x662dbfff, 0xcfc65693, 0x2a8d7f6f,
+        0xab9bc912, 0xde6008a1, 0x2028da1f,
+        0x0227bce7, 0x4d642916, 0x18fac300, 0x50f18b82, 0x2cb2cb11,
+        0xb232e75c, 0x4b3695f2, 0xb28707de,
+        0xa05fbcf6, 0xcd4181e9, 0xe150210c, 0xe24ef1bd, 0xb168c381,
+        0xfde4e789, 0x5c79b0d8, 0x1e8bfd43,
+        0x4d495001, 0x38be4341, 0x913cee1d, 0x92a79c3f, 0x089766be,
+        0xbaeeadf4, 0x1286becf, 0xb6eacb19,
+        0x2660c200, 0x7565bde4, 0x64241f7a, 0x8248dca9, 0xc3b3ad66,
+        0x28136086, 0x0bd8dfa8, 0x356d1cf2,
+        0x107789be, 0xb3b2e9ce, 0x0502aa8f, 0x0bc0351e, 0x166bf52a,
+        0xeb12ff82, 0xe3486911, 0xd34d7516,
+        0x4e7b3aff, 0x5f43671b, 0x9cf6e037, 0x4981ac83, 0x334266ce,
+        0x8c9341b7, 0xd0d854c0, 0xcb3a6c88,
+        0x47bc2829, 0x4725ba37, 0xa66ad22b, 0x7ad61f1e, 0x0c5cbafa,
+        0x4437f107, 0xb6e79962, 0x42d2d816,
+        0x0a961288, 0xe1a5c06e, 0x13749e67, 0x72fc081a, 0xb1d139f7,
+        0xf9583745, 0xcf19df58, 0xbec3f756,
+        0xc06eba30, 0x07211b24, 0x45c28829, 0xc95e317f, 0xbc8ec511,
+        0x38bc46e9, 0xc6e6fa14, 0xbae8584a,
+        0xad4ebc46, 0x468f508b, 0x7829435f, 0xf124183b, 0x821dba9f,
+        0xaff60ff4, 0xea2c4e6d, 0x16e39264,
+        0x92544a8b, 0x009b4fc3, 0xaba68ced, 0x9ac96f78, 0x06a5b79a,
+        0xb2856e6e, 0x1aec3ca9, 0xbe838688,
+        0x0e0804e9, 0x55f1be56, 0xe7e5363b, 0xb3a1f25d, 0xf7debb85,
+        0x61fe033c, 0x16746233, 0x3c034c28,
+        0xda6d0c74, 0x79aac56c, 0x3ce4e1ad, 0x51f0c802, 0x98f8f35a,
+        0x1626a49f, 0xeed82b29, 0x1d382fe3,
+        0x0c4fb99a, 0xbb325778, 0x3ec6d97b, 0x6e77a6a9, 0xcb658b5c,
+        0xd45230c7, 0x2bd1408b, 0x60c03eb7,
+        0xb9068d78, 0xa33754f4, 0xf430c87d, 0xc8a71302, 0xb96d8c32,
+        0xebd4e7be, 0xbe8b9d2d, 0x7979fb06,
+        0xe7225308, 0x8b75cf77, 0x11ef8da4, 0xe083c858, 0x8d6b786f,
+        0x5a6317a6, 0xfa5cf7a0, 0x5dda0033,
+        0xf28ebfb0, 0xf5b9c310, 0xa0eac280, 0x08b9767a, 0xa3d9d2b0,
+        0x79d34217, 0x021a718d, 0x9ac6336a,
+        0x2711fd60, 0x438050e3, 0x069908a8, 0x3d7fedc4, 0x826d2bef,
+        0x4eeb8476, 0x488dcf25, 0x36c9d566,
+        0x28e74e41, 0xc2610aca, 0x3d49a9cf, 0xbae3b9df, 0xb65f8de6,
+        0x92aeaf64, 0x3ac7d5e6, 0x9ea80509,
+        0xf22b017d, 0xa4173f70, 0xdd1e16c3, 0x15e0d7f9, 0x50b1b887,
+        0x2b9f4fd5, 0x625aba82, 0x6a017962,
+        0x2ec01b9c, 0x15488aa9, 0xd716e740, 0x40055a2c, 0x93d29a22,
+        0xe32dbf9a, 0x058745b9, 0x3453dc1e,
+        0xd699296e, 0x496cff6f, 0x1c9f4986, 0xdfe2ed07, 0xb87242d1,
+        0x19de7eae, 0x053e561a, 0x15ad6f8c,
+        0x66626c1c, 0x7154c24c, 0xea082b2a, 0x93eb2939, 0x17dcb0f0,
+        0x58d4f2ae, 0x9ea294fb, 0x52cf564c,
+        0x9883fe66, 0x2ec40581, 0x763953c3, 0x01d6692e, 0xd3a0c108,
+        0xa1e7160e, 0xe4f2dfa6, 0x693ed285,
+        0x74904698, 0x4c2b0edd, 0x4f757656, 0x5d393378, 0xa132234f,
+        0x3d321c5d, 0xc3f5e194, 0x4b269301,
+        0xc79f022f, 0x3c997e7e, 0x5e4f9504, 0x3ffafbbd, 0x76f7ad0e,
+        0x296693f4, 0x3d1fce6f, 0xc61e45be,
+        0xd3b5ab34, 0xf72bf9b7, 0x1b0434c0, 0x4e72b567, 0x5592a33d,
+        0xb5229301, 0xcfd2a87f, 0x60aeb767,
+        0x1814386b, 0x30bcc33d, 0x38a0c07d, 0xfd1606f2, 0xc363519b,
+        0x589dd390, 0x5479f8e6, 0x1cb8d647,
+        0x97fd61a9, 0xea7759f4, 0x2d57539d, 0x569a58cf, 0xe84e63ad,
+        0x462e1b78, 0x6580f87e, 0xf3817914,
+        0x91da55f4, 0x40a230f3, 0xd1988f35, 0xb6e318d2, 0x3ffa50bc,
+        0x3d40f021, 0xc3c0bdae, 0x4958c24c,
+        0x518f36b2, 0x84b1d370, 0x0fedce83, 0x878ddada, 0xf2a279c7,
+        0x94e01be8, 0x90716f4b, 0x954b8aa3
+};
+static const u32 sb8[256] = {
+        0xe216300d, 0xbbddfffc, 0xa7ebdabd, 0x35648095, 0x7789f8b7,
+        0xe6c1121b, 0x0e241600, 0x052ce8b5,
+        0x11a9cfb0, 0xe5952f11, 0xece7990a, 0x9386d174, 0x2a42931c,
+        0x76e38111, 0xb12def3a, 0x37ddddfc,
+        0xde9adeb1, 0x0a0cc32c, 0xbe197029, 0x84a00940, 0xbb243a0f,
+        0xb4d137cf, 0xb44e79f0, 0x049eedfd,
+        0x0b15a15d, 0x480d3168, 0x8bbbde5a, 0x669ded42, 0xc7ece831,
+        0x3f8f95e7, 0x72df191b, 0x7580330d,
+        0x94074251, 0x5c7dcdfa, 0xabbe6d63, 0xaa402164, 0xb301d40a,
+        0x02e7d1ca, 0x53571dae, 0x7a3182a2,
+        0x12a8ddec, 0xfdaa335d, 0x176f43e8, 0x71fb46d4, 0x38129022,
+        0xce949ad4, 0xb84769ad, 0x965bd862,
+        0x82f3d055, 0x66fb9767, 0x15b80b4e, 0x1d5b47a0, 0x4cfde06f,
+        0xc28ec4b8, 0x57e8726e, 0x647a78fc,
+        0x99865d44, 0x608bd593, 0x6c200e03, 0x39dc5ff6, 0x5d0b00a3,
+        0xae63aff2, 0x7e8bd632, 0x70108c0c,
+        0xbbd35049, 0x2998df04, 0x980cf42a, 0x9b6df491, 0x9e7edd53,
+        0x06918548, 0x58cb7e07, 0x3b74ef2e,
+        0x522fffb1, 0xd24708cc, 0x1c7e27cd, 0xa4eb215b, 0x3cf1d2e2,
+        0x19b47a38, 0x424f7618, 0x35856039,
+        0x9d17dee7, 0x27eb35e6, 0xc9aff67b, 0x36baf5b8, 0x09c467cd,
+        0xc18910b1, 0xe11dbf7b, 0x06cd1af8,
+        0x7170c608, 0x2d5e3354, 0xd4de495a, 0x64c6d006, 0xbcc0c62c,
+        0x3dd00db3, 0x708f8f34, 0x77d51b42,
+        0x264f620f, 0x24b8d2bf, 0x15c1b79e, 0x46a52564, 0xf8d7e54e,
+        0x3e378160, 0x7895cda5, 0x859c15a5,
+        0xe6459788, 0xc37bc75f, 0xdb07ba0c, 0x0676a3ab, 0x7f229b1e,
+        0x31842e7b, 0x24259fd7, 0xf8bef472,
+        0x835ffcb8, 0x6df4c1f2, 0x96f5b195, 0xfd0af0fc, 0xb0fe134c,
+        0xe2506d3d, 0x4f9b12ea, 0xf215f225,
+        0xa223736f, 0x9fb4c428, 0x25d04979, 0x34c713f8, 0xc4618187,
+        0xea7a6e98, 0x7cd16efc, 0x1436876c,
+        0xf1544107, 0xbedeee14, 0x56e9af27, 0xa04aa441, 0x3cf7c899,
+        0x92ecbae6, 0xdd67016d, 0x151682eb,
+        0xa842eedf, 0xfdba60b4, 0xf1907b75, 0x20e3030f, 0x24d8c29e,
+        0xe139673b, 0xefa63fb8, 0x71873054,
+        0xb6f2cf3b, 0x9f326442, 0xcb15a4cc, 0xb01a4504, 0xf1e47d8d,
+        0x844a1be5, 0xbae7dfdc, 0x42cbda70,
+        0xcd7dae0a, 0x57e85b7a, 0xd53f5af6, 0x20cf4d8c, 0xcea4d428,
+        0x79d130a4, 0x3486ebfb, 0x33d3cddc,
+        0x77853b53, 0x37effcb5, 0xc5068778, 0xe580b3e6, 0x4e68b8f4,
+        0xc5c8b37e, 0x0d809ea2, 0x398feb7c,
+        0x132a4f94, 0x43b7950e, 0x2fee7d1c, 0x223613bd, 0xdd06caa2,
+        0x37df932b, 0xc4248289, 0xacf3ebc3,
+        0x5715f6b7, 0xef3478dd, 0xf267616f, 0xc148cbe4, 0x9052815e,
+        0x5e410fab, 0xb48a2465, 0x2eda7fa4,
+        0xe87b40e4, 0xe98ea084, 0x5889e9e1, 0xefd390fc, 0xdd07d35b,
+        0xdb485694, 0x38d7e5b2, 0x57720101,
+        0x730edebc, 0x5b643113, 0x94917e4f, 0x503c2fba, 0x646f1282,
+        0x7523d24a, 0xe0779695, 0xf9c17a8f,
+        0x7a5b2121, 0xd187b896, 0x29263a4d, 0xba510cdf, 0x81f47c9f,
+        0xad1163ed, 0xea7b5965, 0x1a00726e,
+        0x11403092, 0x00da6d77, 0x4a0cdd61, 0xad1f4603, 0x605bdfb0,
+        0x9eedc364, 0x22ebe6a8, 0xcee7d28a,
+        0xa0e736a0, 0x5564a6b9, 0x10853209, 0xc7eb8f37, 0x2de705ca,
+        0x8951570f, 0xdf09822b, 0xbd691a6c,
+        0xaa12e4f2, 0x87451c0f, 0xe0f6a27a, 0x3ada4819, 0x4cf1764f,
+        0x0d771c2b, 0x67cdb156, 0x350d8384,
+        0x5938fa0f, 0x42399ef3, 0x36997b07, 0x0e84093d, 0x4aa93e61,
+        0x8360d87b, 0x1fa98b0c, 0x1149382c,
+        0xe97625a5, 0x0614d1b7, 0x0e25244b, 0x0c768347, 0x589e8d82,
+        0x0d2059d1, 0xa466bb1e, 0xf8da0a82,
+        0x04f19130, 0xba6e4ec0, 0x99265164, 0x1ee7230d, 0x50b2ad80,
+        0xeaee6801, 0x8db2a283, 0xea8bf59e
+};
+
+#define F1(D, m, r)  ((I = ((m) + (D))), (I = rol32(I, (r))),   \
+    (((s1[I >> 24] ^ s2[(I>>16)&0xff]) - s3[(I>>8)&0xff]) + s4[I&0xff]))
+#define F2(D, m, r)  ((I = ((m) ^ (D))), (I = rol32(I, (r))),   \
+    (((s1[I >> 24] - s2[(I>>16)&0xff]) + s3[(I>>8)&0xff]) ^ s4[I&0xff]))
+#define F3(D, m, r)  ((I = ((m) - (D))), (I = rol32(I, (r))),   \
+    (((s1[I >> 24] + s2[(I>>16)&0xff]) ^ s3[(I>>8)&0xff]) - s4[I&0xff]))
+
+
+static void cast5_encrypt(struct crypto_tfm *tfm, u8 *outbuf, const u8 *inbuf)
+{
+        struct cast5_ctx *c = crypto_tfm_ctx(tfm);
+        const __be32 *src = (const __be32 *)inbuf;
+        __be32 *dst = (__be32 *)outbuf;
+        u32 l, r, t;
+        u32 I;                  /* used by the Fx macros */
+        u32 *Km;
+        u8 *Kr;
+
+        Km = c->Km;
+        Kr = c->Kr;
+
+        /* (L0,R0) <-- (m1...m64).  (Split the plaintext into left and
+         * right 32-bit halves L0 = m1...m32 and R0 = m33...m64.)
+         */
+        l = be32_to_cpu(src[0]);
+        r = be32_to_cpu(src[1]);
+
+        /* (16 rounds) for i from 1 to 16, compute Li and Ri as follows:
+         *  Li = Ri-1;
+         *  Ri = Li-1 ^ f(Ri-1,Kmi,Kri), where f is defined in Section 2.2
+         * Rounds 1, 4, 7, 10, 13, and 16 use f function Type 1.
+         * Rounds 2, 5, 8, 11, and 14 use f function Type 2.
+         * Rounds 3, 6, 9, 12, and 15 use f function Type 3.
+         */
+
+        t = l; l = r; r = t ^ F1(r, Km[0], Kr[0]);
+        t = l; l = r; r = t ^ F2(r, Km[1], Kr[1]);
+        t = l; l = r; r = t ^ F3(r, Km[2], Kr[2]);
+        t = l; l = r; r = t ^ F1(r, Km[3], Kr[3]);
+        t = l; l = r; r = t ^ F2(r, Km[4], Kr[4]);
+        t = l; l = r; r = t ^ F3(r, Km[5], Kr[5]);
+        t = l; l = r; r = t ^ F1(r, Km[6], Kr[6]);
+        t = l; l = r; r = t ^ F2(r, Km[7], Kr[7]);
+        t = l; l = r; r = t ^ F3(r, Km[8], Kr[8]);
+        t = l; l = r; r = t ^ F1(r, Km[9], Kr[9]);
+        t = l; l = r; r = t ^ F2(r, Km[10], Kr[10]);
+        t = l; l = r; r = t ^ F3(r, Km[11], Kr[11]);
+        if (!(c->rr)) {
+                t = l; l = r; r = t ^ F1(r, Km[12], Kr[12]);
+                t = l; l = r; r = t ^ F2(r, Km[13], Kr[13]);
+                t = l; l = r; r = t ^ F3(r, Km[14], Kr[14]);
+                t = l; l = r; r = t ^ F1(r, Km[15], Kr[15]);
+        }
+
+        /* c1...c64 <-- (R16,L16).  (Exchange final blocks L16, R16 and
+         *  concatenate to form the ciphertext.) */
+        dst[0] = cpu_to_be32(r);
+        dst[1] = cpu_to_be32(l);
+}
+
+static void cast5_decrypt(struct crypto_tfm *tfm, u8 *outbuf, const u8 *inbuf)
+{
+        struct cast5_ctx *c = crypto_tfm_ctx(tfm);
+        const __be32 *src = (const __be32 *)inbuf;
+        __be32 *dst = (__be32 *)outbuf;
+        u32 l, r, t;
+        u32 I;
+        u32 *Km;
+        u8 *Kr;
+
+        Km = c->Km;
+        Kr = c->Kr;
+
+        l = be32_to_cpu(src[0]);
+        r = be32_to_cpu(src[1]);
+
+        if (!(c->rr)) {
+                t = l; l = r; r = t ^ F1(r, Km[15], Kr[15]);
+                t = l; l = r; r = t ^ F3(r, Km[14], Kr[14]);
+                t = l; l = r; r = t ^ F2(r, Km[13], Kr[13]);
+                t = l; l = r; r = t ^ F1(r, Km[12], Kr[12]);
+        }
+        t = l; l = r; r = t ^ F3(r, Km[11], Kr[11]);
+        t = l; l = r; r = t ^ F2(r, Km[10], Kr[10]);
+        t = l; l = r; r = t ^ F1(r, Km[9], Kr[9]);
+        t = l; l = r; r = t ^ F3(r, Km[8], Kr[8]);
+        t = l; l = r; r = t ^ F2(r, Km[7], Kr[7]);
+        t = l; l = r; r = t ^ F1(r, Km[6], Kr[6]);
+        t = l; l = r; r = t ^ F3(r, Km[5], Kr[5]);
+        t = l; l = r; r = t ^ F2(r, Km[4], Kr[4]);
+        t = l; l = r; r = t ^ F1(r, Km[3], Kr[3]);
+        t = l; l = r; r = t ^ F3(r, Km[2], Kr[2]);
+        t = l; l = r; r = t ^ F2(r, Km[1], Kr[1]);
+        t = l; l = r; r = t ^ F1(r, Km[0], Kr[0]);
+
+        dst[0] = cpu_to_be32(r);
+        dst[1] = cpu_to_be32(l);
+}
+
+static void key_schedule(u32 *x, u32 *z, u32 *k)
+{
+
+#define xi(i)   ((x[(i)/4] >> (8*(3-((i)%4)))) & 0xff)
+#define zi(i)   ((z[(i)/4] >> (8*(3-((i)%4)))) & 0xff)
+
+        z[0] = x[0] ^ s5[xi(13)] ^ s6[xi(15)] ^ s7[xi(12)] ^ sb8[xi(14)] ^
+            s7[xi(8)];
+        z[1] = x[2] ^ s5[zi(0)] ^ s6[zi(2)] ^ s7[zi(1)] ^ sb8[zi(3)] ^
+            sb8[xi(10)];
+        z[2] = x[3] ^ s5[zi(7)] ^ s6[zi(6)] ^ s7[zi(5)] ^ sb8[zi(4)] ^
+            s5[xi(9)];
+        z[3] = x[1] ^ s5[zi(10)] ^ s6[zi(9)] ^ s7[zi(11)] ^ sb8[zi(8)] ^
+            s6[xi(11)];
+        k[0] = s5[zi(8)] ^ s6[zi(9)] ^ s7[zi(7)] ^ sb8[zi(6)] ^ s5[zi(2)];
+        k[1] = s5[zi(10)] ^ s6[zi(11)] ^ s7[zi(5)] ^ sb8[zi(4)] ^
+            s6[zi(6)];
+        k[2] = s5[zi(12)] ^ s6[zi(13)] ^ s7[zi(3)] ^ sb8[zi(2)] ^
+            s7[zi(9)];
+        k[3] = s5[zi(14)] ^ s6[zi(15)] ^ s7[zi(1)] ^ sb8[zi(0)] ^
+            sb8[zi(12)];
+
+        x[0] = z[2] ^ s5[zi(5)] ^ s6[zi(7)] ^ s7[zi(4)] ^ sb8[zi(6)] ^
+            s7[zi(0)];
+        x[1] = z[0] ^ s5[xi(0)] ^ s6[xi(2)] ^ s7[xi(1)] ^ sb8[xi(3)] ^
+            sb8[zi(2)];
+        x[2] = z[1] ^ s5[xi(7)] ^ s6[xi(6)] ^ s7[xi(5)] ^ sb8[xi(4)] ^
+            s5[zi(1)];
+        x[3] = z[3] ^ s5[xi(10)] ^ s6[xi(9)] ^ s7[xi(11)] ^ sb8[xi(8)] ^
+            s6[zi(3)];
+        k[4] = s5[xi(3)] ^ s6[xi(2)] ^ s7[xi(12)] ^ sb8[xi(13)] ^
+            s5[xi(8)];
+        k[5] = s5[xi(1)] ^ s6[xi(0)] ^ s7[xi(14)] ^ sb8[xi(15)] ^
+            s6[xi(13)];
+        k[6] = s5[xi(7)] ^ s6[xi(6)] ^ s7[xi(8)] ^ sb8[xi(9)] ^ s7[xi(3)];
+        k[7] = s5[xi(5)] ^ s6[xi(4)] ^ s7[xi(10)] ^ sb8[xi(11)] ^
+            sb8[xi(7)];
+
+        z[0] = x[0] ^ s5[xi(13)] ^ s6[xi(15)] ^ s7[xi(12)] ^ sb8[xi(14)] ^
+            s7[xi(8)];
+        z[1] = x[2] ^ s5[zi(0)] ^ s6[zi(2)] ^ s7[zi(1)] ^ sb8[zi(3)] ^
+            sb8[xi(10)];
+        z[2] = x[3] ^ s5[zi(7)] ^ s6[zi(6)] ^ s7[zi(5)] ^ sb8[zi(4)] ^
+            s5[xi(9)];
+        z[3] = x[1] ^ s5[zi(10)] ^ s6[zi(9)] ^ s7[zi(11)] ^ sb8[zi(8)] ^
+            s6[xi(11)];
+        k[8] = s5[zi(3)] ^ s6[zi(2)] ^ s7[zi(12)] ^ sb8[zi(13)] ^
+            s5[zi(9)];
+        k[9] = s5[zi(1)] ^ s6[zi(0)] ^ s7[zi(14)] ^ sb8[zi(15)] ^
+            s6[zi(12)];
+        k[10] = s5[zi(7)] ^ s6[zi(6)] ^ s7[zi(8)] ^ sb8[zi(9)] ^ s7[zi(2)];
+        k[11] = s5[zi(5)] ^ s6[zi(4)] ^ s7[zi(10)] ^ sb8[zi(11)] ^
+            sb8[zi(6)];
+
+        x[0] = z[2] ^ s5[zi(5)] ^ s6[zi(7)] ^ s7[zi(4)] ^ sb8[zi(6)] ^
+            s7[zi(0)];
+        x[1] = z[0] ^ s5[xi(0)] ^ s6[xi(2)] ^ s7[xi(1)] ^ sb8[xi(3)] ^
+            sb8[zi(2)];
+        x[2] = z[1] ^ s5[xi(7)] ^ s6[xi(6)] ^ s7[xi(5)] ^ sb8[xi(4)] ^
+            s5[zi(1)];
+        x[3] = z[3] ^ s5[xi(10)] ^ s6[xi(9)] ^ s7[xi(11)] ^ sb8[xi(8)] ^
+            s6[zi(3)];
+        k[12] = s5[xi(8)] ^ s6[xi(9)] ^ s7[xi(7)] ^ sb8[xi(6)] ^ s5[xi(3)];
+        k[13] = s5[xi(10)] ^ s6[xi(11)] ^ s7[xi(5)] ^ sb8[xi(4)] ^
+            s6[xi(7)];
+        k[14] = s5[xi(12)] ^ s6[xi(13)] ^ s7[xi(3)] ^ sb8[xi(2)] ^
+            s7[xi(8)];
+        k[15] = s5[xi(14)] ^ s6[xi(15)] ^ s7[xi(1)] ^ sb8[xi(0)] ^
+            sb8[xi(13)];
+
+#undef xi
+#undef zi
+}
+
+
+static int cast5_setkey(struct crypto_tfm *tfm, const u8 *key, unsigned key_len)
+{
+        struct cast5_ctx *c = crypto_tfm_ctx(tfm);
+        int i;
+        u32 x[4];
+        u32 z[4];
+        u32 k[16];
+        __be32 p_key[4];
+
+        c->rr = key_len <= 10 ? 1 : 0;
+
+        memset(p_key, 0, 16);
+        memcpy(p_key, key, key_len);
+
+
+        x[0] = be32_to_cpu(p_key[0]);
+        x[1] = be32_to_cpu(p_key[1]);
+        x[2] = be32_to_cpu(p_key[2]);
+        x[3] = be32_to_cpu(p_key[3]);
+
+        key_schedule(x, z, k);
+        for (i = 0; i < 16; i++)
+                c->Km[i] = k[i];
+        key_schedule(x, z, k);
+        for (i = 0; i < 16; i++)
+                c->Kr[i] = k[i] & 0x1f;
+        return 0;
+}
+
+static struct crypto_alg alg = {
+        .cra_name       = "cast5",
+        .cra_flags      = CRYPTO_ALG_TYPE_CIPHER,
+        .cra_blocksize  = CAST5_BLOCK_SIZE,
+        .cra_ctxsize    = sizeof(struct cast5_ctx),
+        .cra_alignmask  = 3,
+        .cra_module     = THIS_MODULE,
+        .cra_list       = LIST_HEAD_INIT(alg.cra_list),
+        .cra_u          = {
+                .cipher = {
+                        .cia_min_keysize = CAST5_MIN_KEY_SIZE,
+                        .cia_max_keysize = CAST5_MAX_KEY_SIZE,
+                        .cia_setkey = cast5_setkey,
+                        .cia_encrypt = cast5_encrypt,
+                        .cia_decrypt = cast5_decrypt
+                }
+        }
+};
+
+static int __init cast5_mod_init(void)
+{
+        return crypto_register_alg(&alg);
+}
+
+static void __exit cast5_mod_fini(void)
+{
+        crypto_unregister_alg(&alg);
+}
+
+module_init(cast5_mod_init);
+module_exit(cast5_mod_fini);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Cast5 Cipher Algorithm");
+
diff --git a/crypto/cast6.c b/crypto/cast6.c
new file mode 100644
index 00000000000..e0c15a6c7c3
--- /dev/null
+++ b/crypto/cast6.c
@@ -0,0 +1,547 @@
+/* Kernel cryptographic api.
+ * cast6.c - Cast6 cipher algorithm [rfc2612].
+ *
+ * CAST-256 (*cast6*) is a DES like Substitution-Permutation Network (SPN)
+ * cryptosystem built upon the CAST-128 (*cast5*) [rfc2144] encryption
+ * algorithm.
+ *
+ * Copyright (C) 2003 Kartikey Mahendra Bhatt <kartik_me@hotmail.com>.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * 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
+ */
+
+
+#include <asm/byteorder.h>
+#include <linux/init.h>
+#include <linux/crypto.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/types.h>
+
+#define CAST6_BLOCK_SIZE 16
+#define CAST6_MIN_KEY_SIZE 16
+#define CAST6_MAX_KEY_SIZE 32
+
+struct cast6_ctx {
+        u32 Km[12][4];
+        u8 Kr[12][4];
+};
+
+#define F1(D, r, m)  ((I = ((m) + (D))), (I = rol32(I, (r))),   \
+    (((s1[I >> 24] ^ s2[(I>>16)&0xff]) - s3[(I>>8)&0xff]) + s4[I&0xff]))
+#define F2(D, r, m)  ((I = ((m) ^ (D))), (I = rol32(I, (r))),   \
+    (((s1[I >> 24] - s2[(I>>16)&0xff]) + s3[(I>>8)&0xff]) ^ s4[I&0xff]))
+#define F3(D, r, m)  ((I = ((m) - (D))), (I = rol32(I, (r))),   \
+    (((s1[I >> 24] + s2[(I>>16)&0xff]) ^ s3[(I>>8)&0xff]) - s4[I&0xff]))
+
+static const u32 s1[256] = {
+        0x30fb40d4, 0x9fa0ff0b, 0x6beccd2f, 0x3f258c7a, 0x1e213f2f,
+        0x9c004dd3, 0x6003e540, 0xcf9fc949,
+        0xbfd4af27, 0x88bbbdb5, 0xe2034090, 0x98d09675, 0x6e63a0e0,
+        0x15c361d2, 0xc2e7661d, 0x22d4ff8e,
+        0x28683b6f, 0xc07fd059, 0xff2379c8, 0x775f50e2, 0x43c340d3,
+        0xdf2f8656, 0x887ca41a, 0xa2d2bd2d,
+        0xa1c9e0d6, 0x346c4819, 0x61b76d87, 0x22540f2f, 0x2abe32e1,
+        0xaa54166b, 0x22568e3a, 0xa2d341d0,
+        0x66db40c8, 0xa784392f, 0x004dff2f, 0x2db9d2de, 0x97943fac,
+        0x4a97c1d8, 0x527644b7, 0xb5f437a7,
+        0xb82cbaef, 0xd751d159, 0x6ff7f0ed, 0x5a097a1f, 0x827b68d0,
+        0x90ecf52e, 0x22b0c054, 0xbc8e5935,
+        0x4b6d2f7f, 0x50bb64a2, 0xd2664910, 0xbee5812d, 0xb7332290,
+        0xe93b159f, 0xb48ee411, 0x4bff345d,
+        0xfd45c240, 0xad31973f, 0xc4f6d02e, 0x55fc8165, 0xd5b1caad,
+        0xa1ac2dae, 0xa2d4b76d, 0xc19b0c50,
+        0x882240f2, 0x0c6e4f38, 0xa4e4bfd7, 0x4f5ba272, 0x564c1d2f,
+        0xc59c5319, 0xb949e354, 0xb04669fe,
+        0xb1b6ab8a, 0xc71358dd, 0x6385c545, 0x110f935d, 0x57538ad5,
+        0x6a390493, 0xe63d37e0, 0x2a54f6b3,
+        0x3a787d5f, 0x6276a0b5, 0x19a6fcdf, 0x7a42206a, 0x29f9d4d5,
+        0xf61b1891, 0xbb72275e, 0xaa508167,
+        0x38901091, 0xc6b505eb, 0x84c7cb8c, 0x2ad75a0f, 0x874a1427,
+        0xa2d1936b, 0x2ad286af, 0xaa56d291,
+        0xd7894360, 0x425c750d, 0x93b39e26, 0x187184c9, 0x6c00b32d,
+        0x73e2bb14, 0xa0bebc3c, 0x54623779,
+        0x64459eab, 0x3f328b82, 0x7718cf82, 0x59a2cea6, 0x04ee002e,
+        0x89fe78e6, 0x3fab0950, 0x325ff6c2,
+        0x81383f05, 0x6963c5c8, 0x76cb5ad6, 0xd49974c9, 0xca180dcf,
+        0x380782d5, 0xc7fa5cf6, 0x8ac31511,
+        0x35e79e13, 0x47da91d0, 0xf40f9086, 0xa7e2419e, 0x31366241,
+        0x051ef495, 0xaa573b04, 0x4a805d8d,
+        0x548300d0, 0x00322a3c, 0xbf64cddf, 0xba57a68e, 0x75c6372b,
+        0x50afd341, 0xa7c13275, 0x915a0bf5,
+        0x6b54bfab, 0x2b0b1426, 0xab4cc9d7, 0x449ccd82, 0xf7fbf265,
+        0xab85c5f3, 0x1b55db94, 0xaad4e324,
+        0xcfa4bd3f, 0x2deaa3e2, 0x9e204d02, 0xc8bd25ac, 0xeadf55b3,
+        0xd5bd9e98, 0xe31231b2, 0x2ad5ad6c,
+        0x954329de, 0xadbe4528, 0xd8710f69, 0xaa51c90f, 0xaa786bf6,
+        0x22513f1e, 0xaa51a79b, 0x2ad344cc,
+        0x7b5a41f0, 0xd37cfbad, 0x1b069505, 0x41ece491, 0xb4c332e6,
+        0x032268d4, 0xc9600acc, 0xce387e6d,
+        0xbf6bb16c, 0x6a70fb78, 0x0d03d9c9, 0xd4df39de, 0xe01063da,
+        0x4736f464, 0x5ad328d8, 0xb347cc96,
+        0x75bb0fc3, 0x98511bfb, 0x4ffbcc35, 0xb58bcf6a, 0xe11f0abc,
+        0xbfc5fe4a, 0xa70aec10, 0xac39570a,
+        0x3f04442f, 0x6188b153, 0xe0397a2e, 0x5727cb79, 0x9ceb418f,
+        0x1cacd68d, 0x2ad37c96, 0x0175cb9d,
+        0xc69dff09, 0xc75b65f0, 0xd9db40d8, 0xec0e7779, 0x4744ead4,
+        0xb11c3274, 0xdd24cb9e, 0x7e1c54bd,
+        0xf01144f9, 0xd2240eb1, 0x9675b3fd, 0xa3ac3755, 0xd47c27af,
+        0x51c85f4d, 0x56907596, 0xa5bb15e6,
+        0x580304f0, 0xca042cf1, 0x011a37ea, 0x8dbfaadb, 0x35ba3e4a,
+        0x3526ffa0, 0xc37b4d09, 0xbc306ed9,
+        0x98a52666, 0x5648f725, 0xff5e569d, 0x0ced63d0, 0x7c63b2cf,
+        0x700b45e1, 0xd5ea50f1, 0x85a92872,
+        0xaf1fbda7, 0xd4234870, 0xa7870bf3, 0x2d3b4d79, 0x42e04198,
+        0x0cd0ede7, 0x26470db8, 0xf881814c,
+        0x474d6ad7, 0x7c0c5e5c, 0xd1231959, 0x381b7298, 0xf5d2f4db,
+        0xab838653, 0x6e2f1e23, 0x83719c9e,
+        0xbd91e046, 0x9a56456e, 0xdc39200c, 0x20c8c571, 0x962bda1c,
+        0xe1e696ff, 0xb141ab08, 0x7cca89b9,
+        0x1a69e783, 0x02cc4843, 0xa2f7c579, 0x429ef47d, 0x427b169c,
+        0x5ac9f049, 0xdd8f0f00, 0x5c8165bf
+};
+
+static const u32 s2[256] = {
+        0x1f201094, 0xef0ba75b, 0x69e3cf7e, 0x393f4380, 0xfe61cf7a,
+        0xeec5207a, 0x55889c94, 0x72fc0651,
+        0xada7ef79, 0x4e1d7235, 0xd55a63ce, 0xde0436ba, 0x99c430ef,
+        0x5f0c0794, 0x18dcdb7d, 0xa1d6eff3,
+        0xa0b52f7b, 0x59e83605, 0xee15b094, 0xe9ffd909, 0xdc440086,
+        0xef944459, 0xba83ccb3, 0xe0c3cdfb,
+        0xd1da4181, 0x3b092ab1, 0xf997f1c1, 0xa5e6cf7b, 0x01420ddb,
+        0xe4e7ef5b, 0x25a1ff41, 0xe180f806,
+        0x1fc41080, 0x179bee7a, 0xd37ac6a9, 0xfe5830a4, 0x98de8b7f,
+        0x77e83f4e, 0x79929269, 0x24fa9f7b,
+        0xe113c85b, 0xacc40083, 0xd7503525, 0xf7ea615f, 0x62143154,
+        0x0d554b63, 0x5d681121, 0xc866c359,
+        0x3d63cf73, 0xcee234c0, 0xd4d87e87, 0x5c672b21, 0x071f6181,
+        0x39f7627f, 0x361e3084, 0xe4eb573b,
+        0x602f64a4, 0xd63acd9c, 0x1bbc4635, 0x9e81032d, 0x2701f50c,
+        0x99847ab4, 0xa0e3df79, 0xba6cf38c,
+        0x10843094, 0x2537a95e, 0xf46f6ffe, 0xa1ff3b1f, 0x208cfb6a,
+        0x8f458c74, 0xd9e0a227, 0x4ec73a34,
+        0xfc884f69, 0x3e4de8df, 0xef0e0088, 0x3559648d, 0x8a45388c,
+        0x1d804366, 0x721d9bfd, 0xa58684bb,
+        0xe8256333, 0x844e8212, 0x128d8098, 0xfed33fb4, 0xce280ae1,
+        0x27e19ba5, 0xd5a6c252, 0xe49754bd,
+        0xc5d655dd, 0xeb667064, 0x77840b4d, 0xa1b6a801, 0x84db26a9,
+        0xe0b56714, 0x21f043b7, 0xe5d05860,
+        0x54f03084, 0x066ff472, 0xa31aa153, 0xdadc4755, 0xb5625dbf,
+        0x68561be6, 0x83ca6b94, 0x2d6ed23b,
+        0xeccf01db, 0xa6d3d0ba, 0xb6803d5c, 0xaf77a709, 0x33b4a34c,
+        0x397bc8d6, 0x5ee22b95, 0x5f0e5304,
+        0x81ed6f61, 0x20e74364, 0xb45e1378, 0xde18639b, 0x881ca122,
+        0xb96726d1, 0x8049a7e8, 0x22b7da7b,
+        0x5e552d25, 0x5272d237, 0x79d2951c, 0xc60d894c, 0x488cb402,
+        0x1ba4fe5b, 0xa4b09f6b, 0x1ca815cf,
+        0xa20c3005, 0x8871df63, 0xb9de2fcb, 0x0cc6c9e9, 0x0beeff53,
+        0xe3214517, 0xb4542835, 0x9f63293c,
+        0xee41e729, 0x6e1d2d7c, 0x50045286, 0x1e6685f3, 0xf33401c6,
+        0x30a22c95, 0x31a70850, 0x60930f13,
+        0x73f98417, 0xa1269859, 0xec645c44, 0x52c877a9, 0xcdff33a6,
+        0xa02b1741, 0x7cbad9a2, 0x2180036f,
+        0x50d99c08, 0xcb3f4861, 0xc26bd765, 0x64a3f6ab, 0x80342676,
+        0x25a75e7b, 0xe4e6d1fc, 0x20c710e6,
+        0xcdf0b680, 0x17844d3b, 0x31eef84d, 0x7e0824e4, 0x2ccb49eb,
+        0x846a3bae, 0x8ff77888, 0xee5d60f6,
+        0x7af75673, 0x2fdd5cdb, 0xa11631c1, 0x30f66f43, 0xb3faec54,
+        0x157fd7fa, 0xef8579cc, 0xd152de58,
+        0xdb2ffd5e, 0x8f32ce19, 0x306af97a, 0x02f03ef8, 0x99319ad5,
+        0xc242fa0f, 0xa7e3ebb0, 0xc68e4906,
+        0xb8da230c, 0x80823028, 0xdcdef3c8, 0xd35fb171, 0x088a1bc8,
+        0xbec0c560, 0x61a3c9e8, 0xbca8f54d,
+        0xc72feffa, 0x22822e99, 0x82c570b4, 0xd8d94e89, 0x8b1c34bc,
+        0x301e16e6, 0x273be979, 0xb0ffeaa6,
+        0x61d9b8c6, 0x00b24869, 0xb7ffce3f, 0x08dc283b, 0x43daf65a,
+        0xf7e19798, 0x7619b72f, 0x8f1c9ba4,
+        0xdc8637a0, 0x16a7d3b1, 0x9fc393b7, 0xa7136eeb, 0xc6bcc63e,
+        0x1a513742, 0xef6828bc, 0x520365d6,
+        0x2d6a77ab, 0x3527ed4b, 0x821fd216, 0x095c6e2e, 0xdb92f2fb,
+        0x5eea29cb, 0x145892f5, 0x91584f7f,
+        0x5483697b, 0x2667a8cc, 0x85196048, 0x8c4bacea, 0x833860d4,
+        0x0d23e0f9, 0x6c387e8a, 0x0ae6d249,
+        0xb284600c, 0xd835731d, 0xdcb1c647, 0xac4c56ea, 0x3ebd81b3,
+        0x230eabb0, 0x6438bc87, 0xf0b5b1fa,
+        0x8f5ea2b3, 0xfc184642, 0x0a036b7a, 0x4fb089bd, 0x649da589,
+        0xa345415e, 0x5c038323, 0x3e5d3bb9,
+        0x43d79572, 0x7e6dd07c, 0x06dfdf1e, 0x6c6cc4ef, 0x7160a539,
+        0x73bfbe70, 0x83877605, 0x4523ecf1
+};
+
+static const u32 s3[256] = {
+        0x8defc240, 0x25fa5d9f, 0xeb903dbf, 0xe810c907, 0x47607fff,
+        0x369fe44b, 0x8c1fc644, 0xaececa90,
+        0xbeb1f9bf, 0xeefbcaea, 0xe8cf1950, 0x51df07ae, 0x920e8806,
+        0xf0ad0548, 0xe13c8d83, 0x927010d5,
+        0x11107d9f, 0x07647db9, 0xb2e3e4d4, 0x3d4f285e, 0xb9afa820,
+        0xfade82e0, 0xa067268b, 0x8272792e,
+        0x553fb2c0, 0x489ae22b, 0xd4ef9794, 0x125e3fbc, 0x21fffcee,
+        0x825b1bfd, 0x9255c5ed, 0x1257a240,
+        0x4e1a8302, 0xbae07fff, 0x528246e7, 0x8e57140e, 0x3373f7bf,
+        0x8c9f8188, 0xa6fc4ee8, 0xc982b5a5,
+        0xa8c01db7, 0x579fc264, 0x67094f31, 0xf2bd3f5f, 0x40fff7c1,
+        0x1fb78dfc, 0x8e6bd2c1, 0x437be59b,
+        0x99b03dbf, 0xb5dbc64b, 0x638dc0e6, 0x55819d99, 0xa197c81c,
+        0x4a012d6e, 0xc5884a28, 0xccc36f71,
+        0xb843c213, 0x6c0743f1, 0x8309893c, 0x0feddd5f, 0x2f7fe850,
+        0xd7c07f7e, 0x02507fbf, 0x5afb9a04,
+        0xa747d2d0, 0x1651192e, 0xaf70bf3e, 0x58c31380, 0x5f98302e,
+        0x727cc3c4, 0x0a0fb402, 0x0f7fef82,
+        0x8c96fdad, 0x5d2c2aae, 0x8ee99a49, 0x50da88b8, 0x8427f4a0,
+        0x1eac5790, 0x796fb449, 0x8252dc15,
+        0xefbd7d9b, 0xa672597d, 0xada840d8, 0x45f54504, 0xfa5d7403,
+        0xe83ec305, 0x4f91751a, 0x925669c2,
+        0x23efe941, 0xa903f12e, 0x60270df2, 0x0276e4b6, 0x94fd6574,
+        0x927985b2, 0x8276dbcb, 0x02778176,
+        0xf8af918d, 0x4e48f79e, 0x8f616ddf, 0xe29d840e, 0x842f7d83,
+        0x340ce5c8, 0x96bbb682, 0x93b4b148,
+        0xef303cab, 0x984faf28, 0x779faf9b, 0x92dc560d, 0x224d1e20,
+        0x8437aa88, 0x7d29dc96, 0x2756d3dc,
+        0x8b907cee, 0xb51fd240, 0xe7c07ce3, 0xe566b4a1, 0xc3e9615e,
+        0x3cf8209d, 0x6094d1e3, 0xcd9ca341,
+        0x5c76460e, 0x00ea983b, 0xd4d67881, 0xfd47572c, 0xf76cedd9,
+        0xbda8229c, 0x127dadaa, 0x438a074e,
+        0x1f97c090, 0x081bdb8a, 0x93a07ebe, 0xb938ca15, 0x97b03cff,
+        0x3dc2c0f8, 0x8d1ab2ec, 0x64380e51,
+        0x68cc7bfb, 0xd90f2788, 0x12490181, 0x5de5ffd4, 0xdd7ef86a,
+        0x76a2e214, 0xb9a40368, 0x925d958f,
+        0x4b39fffa, 0xba39aee9, 0xa4ffd30b, 0xfaf7933b, 0x6d498623,
+        0x193cbcfa, 0x27627545, 0x825cf47a,
+        0x61bd8ba0, 0xd11e42d1, 0xcead04f4, 0x127ea392, 0x10428db7,
+        0x8272a972, 0x9270c4a8, 0x127de50b,
+        0x285ba1c8, 0x3c62f44f, 0x35c0eaa5, 0xe805d231, 0x428929fb,
+        0xb4fcdf82, 0x4fb66a53, 0x0e7dc15b,
+        0x1f081fab, 0x108618ae, 0xfcfd086d, 0xf9ff2889, 0x694bcc11,
+        0x236a5cae, 0x12deca4d, 0x2c3f8cc5,
+        0xd2d02dfe, 0xf8ef5896, 0xe4cf52da, 0x95155b67, 0x494a488c,
+        0xb9b6a80c, 0x5c8f82bc, 0x89d36b45,
+        0x3a609437, 0xec00c9a9, 0x44715253, 0x0a874b49, 0xd773bc40,
+        0x7c34671c, 0x02717ef6, 0x4feb5536,
+        0xa2d02fff, 0xd2bf60c4, 0xd43f03c0, 0x50b4ef6d, 0x07478cd1,
+        0x006e1888, 0xa2e53f55, 0xb9e6d4bc,
+        0xa2048016, 0x97573833, 0xd7207d67, 0xde0f8f3d, 0x72f87b33,
+        0xabcc4f33, 0x7688c55d, 0x7b00a6b0,
+        0x947b0001, 0x570075d2, 0xf9bb88f8, 0x8942019e, 0x4264a5ff,
+        0x856302e0, 0x72dbd92b, 0xee971b69,
+        0x6ea22fde, 0x5f08ae2b, 0xaf7a616d, 0xe5c98767, 0xcf1febd2,
+        0x61efc8c2, 0xf1ac2571, 0xcc8239c2,
+        0x67214cb8, 0xb1e583d1, 0xb7dc3e62, 0x7f10bdce, 0xf90a5c38,
+        0x0ff0443d, 0x606e6dc6, 0x60543a49,
+        0x5727c148, 0x2be98a1d, 0x8ab41738, 0x20e1be24, 0xaf96da0f,
+        0x68458425, 0x99833be5, 0x600d457d,
+        0x282f9350, 0x8334b362, 0xd91d1120, 0x2b6d8da0, 0x642b1e31,
+        0x9c305a00, 0x52bce688, 0x1b03588a,
+        0xf7baefd5, 0x4142ed9c, 0xa4315c11, 0x83323ec5, 0xdfef4636,
+        0xa133c501, 0xe9d3531c, 0xee353783
+};
+
+static const u32 s4[256] = {
+        0x9db30420, 0x1fb6e9de, 0xa7be7bef, 0xd273a298, 0x4a4f7bdb,
+        0x64ad8c57, 0x85510443, 0xfa020ed1,
+        0x7e287aff, 0xe60fb663, 0x095f35a1, 0x79ebf120, 0xfd059d43,
+        0x6497b7b1, 0xf3641f63, 0x241e4adf,
+        0x28147f5f, 0x4fa2b8cd, 0xc9430040, 0x0cc32220, 0xfdd30b30,
+        0xc0a5374f, 0x1d2d00d9, 0x24147b15,
+        0xee4d111a, 0x0fca5167, 0x71ff904c, 0x2d195ffe, 0x1a05645f,
+        0x0c13fefe, 0x081b08ca, 0x05170121,
+        0x80530100, 0xe83e5efe, 0xac9af4f8, 0x7fe72701, 0xd2b8ee5f,
+        0x06df4261, 0xbb9e9b8a, 0x7293ea25,
+        0xce84ffdf, 0xf5718801, 0x3dd64b04, 0xa26f263b, 0x7ed48400,
+        0x547eebe6, 0x446d4ca0, 0x6cf3d6f5,
+        0x2649abdf, 0xaea0c7f5, 0x36338cc1, 0x503f7e93, 0xd3772061,
+        0x11b638e1, 0x72500e03, 0xf80eb2bb,
+        0xabe0502e, 0xec8d77de, 0x57971e81, 0xe14f6746, 0xc9335400,
+        0x6920318f, 0x081dbb99, 0xffc304a5,
+        0x4d351805, 0x7f3d5ce3, 0xa6c866c6, 0x5d5bcca9, 0xdaec6fea,
+        0x9f926f91, 0x9f46222f, 0x3991467d,
+        0xa5bf6d8e, 0x1143c44f, 0x43958302, 0xd0214eeb, 0x022083b8,
+        0x3fb6180c, 0x18f8931e, 0x281658e6,
+        0x26486e3e, 0x8bd78a70, 0x7477e4c1, 0xb506e07c, 0xf32d0a25,
+        0x79098b02, 0xe4eabb81, 0x28123b23,
+        0x69dead38, 0x1574ca16, 0xdf871b62, 0x211c40b7, 0xa51a9ef9,
+        0x0014377b, 0x041e8ac8, 0x09114003,
+        0xbd59e4d2, 0xe3d156d5, 0x4fe876d5, 0x2f91a340, 0x557be8de,
+        0x00eae4a7, 0x0ce5c2ec, 0x4db4bba6,
+        0xe756bdff, 0xdd3369ac, 0xec17b035, 0x06572327, 0x99afc8b0,
+        0x56c8c391, 0x6b65811c, 0x5e146119,
+        0x6e85cb75, 0xbe07c002, 0xc2325577, 0x893ff4ec, 0x5bbfc92d,
+        0xd0ec3b25, 0xb7801ab7, 0x8d6d3b24,
+        0x20c763ef, 0xc366a5fc, 0x9c382880, 0x0ace3205, 0xaac9548a,
+        0xeca1d7c7, 0x041afa32, 0x1d16625a,
+        0x6701902c, 0x9b757a54, 0x31d477f7, 0x9126b031, 0x36cc6fdb,
+        0xc70b8b46, 0xd9e66a48, 0x56e55a79,
+        0x026a4ceb, 0x52437eff, 0x2f8f76b4, 0x0df980a5, 0x8674cde3,
+        0xedda04eb, 0x17a9be04, 0x2c18f4df,
+        0xb7747f9d, 0xab2af7b4, 0xefc34d20, 0x2e096b7c, 0x1741a254,
+        0xe5b6a035, 0x213d42f6, 0x2c1c7c26,
+        0x61c2f50f, 0x6552daf9, 0xd2c231f8, 0x25130f69, 0xd8167fa2,
+        0x0418f2c8, 0x001a96a6, 0x0d1526ab,
+        0x63315c21, 0x5e0a72ec, 0x49bafefd, 0x187908d9, 0x8d0dbd86,
+        0x311170a7, 0x3e9b640c, 0xcc3e10d7,
+        0xd5cad3b6, 0x0caec388, 0xf73001e1, 0x6c728aff, 0x71eae2a1,
+        0x1f9af36e, 0xcfcbd12f, 0xc1de8417,
+        0xac07be6b, 0xcb44a1d8, 0x8b9b0f56, 0x013988c3, 0xb1c52fca,
+        0xb4be31cd, 0xd8782806, 0x12a3a4e2,
+        0x6f7de532, 0x58fd7eb6, 0xd01ee900, 0x24adffc2, 0xf4990fc5,
+        0x9711aac5, 0x001d7b95, 0x82e5e7d2,
+        0x109873f6, 0x00613096, 0xc32d9521, 0xada121ff, 0x29908415,
+        0x7fbb977f, 0xaf9eb3db, 0x29c9ed2a,
+        0x5ce2a465, 0xa730f32c, 0xd0aa3fe8, 0x8a5cc091, 0xd49e2ce7,
+        0x0ce454a9, 0xd60acd86, 0x015f1919,
+        0x77079103, 0xdea03af6, 0x78a8565e, 0xdee356df, 0x21f05cbe,
+        0x8b75e387, 0xb3c50651, 0xb8a5c3ef,
+        0xd8eeb6d2, 0xe523be77, 0xc2154529, 0x2f69efdf, 0xafe67afb,
+        0xf470c4b2, 0xf3e0eb5b, 0xd6cc9876,
+        0x39e4460c, 0x1fda8538, 0x1987832f, 0xca007367, 0xa99144f8,
+        0x296b299e, 0x492fc295, 0x9266beab,
+        0xb5676e69, 0x9bd3ddda, 0xdf7e052f, 0xdb25701c, 0x1b5e51ee,
+        0xf65324e6, 0x6afce36c, 0x0316cc04,
+        0x8644213e, 0xb7dc59d0, 0x7965291f, 0xccd6fd43, 0x41823979,
+        0x932bcdf6, 0xb657c34d, 0x4edfd282,
+        0x7ae5290c, 0x3cb9536b, 0x851e20fe, 0x9833557e, 0x13ecf0b0,
+        0xd3ffb372, 0x3f85c5c1, 0x0aef7ed2
+};
+
+static const u32 Tm[24][8] = {
+        { 0x5a827999, 0xc95c653a, 0x383650db, 0xa7103c7c, 0x15ea281d,
+                0x84c413be, 0xf39dff5f, 0x6277eb00 } ,
+        { 0xd151d6a1, 0x402bc242, 0xaf05ade3, 0x1ddf9984, 0x8cb98525,
+                0xfb9370c6, 0x6a6d5c67, 0xd9474808 } ,
+        { 0x482133a9, 0xb6fb1f4a, 0x25d50aeb, 0x94aef68c, 0x0388e22d,
+                0x7262cdce, 0xe13cb96f, 0x5016a510 } ,
+        { 0xbef090b1, 0x2dca7c52, 0x9ca467f3, 0x0b7e5394, 0x7a583f35,
+                0xe9322ad6, 0x580c1677, 0xc6e60218 } ,
+        { 0x35bfedb9, 0xa499d95a, 0x1373c4fb, 0x824db09c, 0xf1279c3d,
+                0x600187de, 0xcedb737f, 0x3db55f20 } ,
+        { 0xac8f4ac1, 0x1b693662, 0x8a432203, 0xf91d0da4, 0x67f6f945,
+                0xd6d0e4e6, 0x45aad087, 0xb484bc28 } ,
+        { 0x235ea7c9, 0x9238936a, 0x01127f0b, 0x6fec6aac, 0xdec6564d,
+                0x4da041ee, 0xbc7a2d8f, 0x2b541930 } ,
+        { 0x9a2e04d1, 0x0907f072, 0x77e1dc13, 0xe6bbc7b4, 0x5595b355,
+                0xc46f9ef6, 0x33498a97, 0xa2237638 } ,
+        { 0x10fd61d9, 0x7fd74d7a, 0xeeb1391b, 0x5d8b24bc, 0xcc65105d,
+                0x3b3efbfe, 0xaa18e79f, 0x18f2d340 } ,
+        { 0x87ccbee1, 0xf6a6aa82, 0x65809623, 0xd45a81c4, 0x43346d65,
+                0xb20e5906, 0x20e844a7, 0x8fc23048 } ,
+        { 0xfe9c1be9, 0x6d76078a, 0xdc4ff32b, 0x4b29decc, 0xba03ca6d,
+                0x28ddb60e, 0x97b7a1af, 0x06918d50 } ,
+        { 0x756b78f1, 0xe4456492, 0x531f5033, 0xc1f93bd4, 0x30d32775,
+                0x9fad1316, 0x0e86feb7, 0x7d60ea58 } ,
+        { 0xec3ad5f9, 0x5b14c19a, 0xc9eead3b, 0x38c898dc, 0xa7a2847d,
+                0x167c701e, 0x85565bbf, 0xf4304760 } ,
+        { 0x630a3301, 0xd1e41ea2, 0x40be0a43, 0xaf97f5e4, 0x1e71e185,
+                0x8d4bcd26, 0xfc25b8c7, 0x6affa468 } ,
+        { 0xd9d99009, 0x48b37baa, 0xb78d674b, 0x266752ec, 0x95413e8d,
+                0x041b2a2e, 0x72f515cf, 0xe1cf0170 } ,
+        { 0x50a8ed11, 0xbf82d8b2, 0x2e5cc453, 0x9d36aff4, 0x0c109b95,
+                0x7aea8736, 0xe9c472d7, 0x589e5e78 } ,
+        { 0xc7784a19, 0x365235ba, 0xa52c215b, 0x14060cfc, 0x82dff89d,
+                0xf1b9e43e, 0x6093cfdf, 0xcf6dbb80 } ,
+        { 0x3e47a721, 0xad2192c2, 0x1bfb7e63, 0x8ad56a04, 0xf9af55a5,
+                0x68894146, 0xd7632ce7, 0x463d1888 } ,
+        { 0xb5170429, 0x23f0efca, 0x92cadb6b, 0x01a4c70c, 0x707eb2ad,
+                0xdf589e4e, 0x4e3289ef, 0xbd0c7590 } ,
+        { 0x2be66131, 0x9ac04cd2, 0x099a3873, 0x78742414, 0xe74e0fb5,
+                0x5627fb56, 0xc501e6f7, 0x33dbd298 } ,
+        { 0xa2b5be39, 0x118fa9da, 0x8069957b, 0xef43811c, 0x5e1d6cbd,
+                0xccf7585e, 0x3bd143ff, 0xaaab2fa0 } ,
+        { 0x19851b41, 0x885f06e2, 0xf738f283, 0x6612de24, 0xd4ecc9c5,
+                0x43c6b566, 0xb2a0a107, 0x217a8ca8 } ,
+        { 0x90547849, 0xff2e63ea, 0x6e084f8b, 0xdce23b2c, 0x4bbc26cd,
+                0xba96126e, 0x296ffe0f, 0x9849e9b0 } ,
+        { 0x0723d551, 0x75fdc0f2, 0xe4d7ac93, 0x53b19834, 0xc28b83d5,
+                0x31656f76, 0xa03f5b17, 0x0f1946b8 }
+};
+
+static const u8 Tr[4][8] = {
+        { 0x13, 0x04, 0x15, 0x06, 0x17, 0x08, 0x19, 0x0a } ,
+        { 0x1b, 0x0c, 0x1d, 0x0e, 0x1f, 0x10, 0x01, 0x12 } ,
+        { 0x03, 0x14, 0x05, 0x16, 0x07, 0x18, 0x09, 0x1a } ,
+        { 0x0b, 0x1c, 0x0d, 0x1e, 0x0f, 0x00, 0x11, 0x02 }
+};
+
+/* forward octave */
+static void W(u32 *key, unsigned int i)
+{
+        u32 I;
+        key[6] ^= F1(key[7], Tr[i % 4][0], Tm[i][0]);
+        key[5] ^= F2(key[6], Tr[i % 4][1], Tm[i][1]);
+        key[4] ^= F3(key[5], Tr[i % 4][2], Tm[i][2]);
+        key[3] ^= F1(key[4], Tr[i % 4][3], Tm[i][3]);
+        key[2] ^= F2(key[3], Tr[i % 4][4], Tm[i][4]);
+        key[1] ^= F3(key[2], Tr[i % 4][5], Tm[i][5]);
+        key[0] ^= F1(key[1], Tr[i % 4][6], Tm[i][6]);
+        key[7] ^= F2(key[0], Tr[i % 4][7], Tm[i][7]);
+}
+
+static int cast6_setkey(struct crypto_tfm *tfm, const u8 *in_key,
+                        unsigned key_len)
+{
+        int i;
+        u32 key[8];
+        __be32 p_key[8]; /* padded key */
+        struct cast6_ctx *c = crypto_tfm_ctx(tfm);
+        u32 *flags = &tfm->crt_flags;
+
+        if (key_len % 4 != 0) {
+                *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
+                return -EINVAL;
+        }
+
+        memset(p_key, 0, 32);
+        memcpy(p_key, in_key, key_len);
+
+        key[0] = be32_to_cpu(p_key[0]);         /* A */
+        key[1] = be32_to_cpu(p_key[1]);         /* B */
+        key[2] = be32_to_cpu(p_key[2]);         /* C */
+        key[3] = be32_to_cpu(p_key[3]);         /* D */
+        key[4] = be32_to_cpu(p_key[4]);         /* E */
+        key[5] = be32_to_cpu(p_key[5]);         /* F */
+        key[6] = be32_to_cpu(p_key[6]);         /* G */
+        key[7] = be32_to_cpu(p_key[7]);         /* H */
+
+        for (i = 0; i < 12; i++) {
+                W(key, 2 * i);
+                W(key, 2 * i + 1);
+
+                c->Kr[i][0] = key[0] & 0x1f;
+                c->Kr[i][1] = key[2] & 0x1f;
+                c->Kr[i][2] = key[4] & 0x1f;
+                c->Kr[i][3] = key[6] & 0x1f;
+
+                c->Km[i][0] = key[7];
+                c->Km[i][1] = key[5];
+                c->Km[i][2] = key[3];
+                c->Km[i][3] = key[1];
+        }
+
+        return 0;
+}
+
+/*forward quad round*/
+static void Q(u32 *block, u8 *Kr, u32 *Km)
+{
+        u32 I;
+        block[2] ^= F1(block[3], Kr[0], Km[0]);
+        block[1] ^= F2(block[2], Kr[1], Km[1]);
+        block[0] ^= F3(block[1], Kr[2], Km[2]);
+        block[3] ^= F1(block[0], Kr[3], Km[3]);
+}
+
+/*reverse quad round*/
+static void QBAR(u32 *block, u8 *Kr, u32 *Km)
+{
+        u32 I;
+        block[3] ^= F1(block[0], Kr[3], Km[3]);
+        block[0] ^= F3(block[1], Kr[2], Km[2]);
+        block[1] ^= F2(block[2], Kr[1], Km[1]);
+        block[2] ^= F1(block[3], Kr[0], Km[0]);
+}
+
+static void cast6_encrypt(struct crypto_tfm *tfm, u8 *outbuf, const u8 *inbuf)
+{
+        struct cast6_ctx *c = crypto_tfm_ctx(tfm);
+        const __be32 *src = (const __be32 *)inbuf;
+        __be32 *dst = (__be32 *)outbuf;
+        u32 block[4];
+        u32 *Km;
+        u8 *Kr;
+
+        block[0] = be32_to_cpu(src[0]);
+        block[1] = be32_to_cpu(src[1]);
+        block[2] = be32_to_cpu(src[2]);
+        block[3] = be32_to_cpu(src[3]);
+
+        Km = c->Km[0]; Kr = c->Kr[0]; Q(block, Kr, Km);
+        Km = c->Km[1]; Kr = c->Kr[1]; Q(block, Kr, Km);
+        Km = c->Km[2]; Kr = c->Kr[2]; Q(block, Kr, Km);
+        Km = c->Km[3]; Kr = c->Kr[3]; Q(block, Kr, Km);
+        Km = c->Km[4]; Kr = c->Kr[4]; Q(block, Kr, Km);
+        Km = c->Km[5]; Kr = c->Kr[5]; Q(block, Kr, Km);
+        Km = c->Km[6]; Kr = c->Kr[6]; QBAR(block, Kr, Km);
+        Km = c->Km[7]; Kr = c->Kr[7]; QBAR(block, Kr, Km);
+        Km = c->Km[8]; Kr = c->Kr[8]; QBAR(block, Kr, Km);
+        Km = c->Km[9]; Kr = c->Kr[9]; QBAR(block, Kr, Km);
+        Km = c->Km[10]; Kr = c->Kr[10]; QBAR(block, Kr, Km);
+        Km = c->Km[11]; Kr = c->Kr[11]; QBAR(block, Kr, Km);
+
+        dst[0] = cpu_to_be32(block[0]);
+        dst[1] = cpu_to_be32(block[1]);
+        dst[2] = cpu_to_be32(block[2]);
+        dst[3] = cpu_to_be32(block[3]);
+}
+
+static void cast6_decrypt(struct crypto_tfm *tfm, u8 *outbuf, const u8 *inbuf)
+{
+        struct cast6_ctx *c = crypto_tfm_ctx(tfm);
+        const __be32 *src = (const __be32 *)inbuf;
+        __be32 *dst = (__be32 *)outbuf;
+        u32 block[4];
+        u32 *Km;
+        u8 *Kr;
+
+        block[0] = be32_to_cpu(src[0]);
+        block[1] = be32_to_cpu(src[1]);
+        block[2] = be32_to_cpu(src[2]);
+        block[3] = be32_to_cpu(src[3]);
+
+        Km = c->Km[11]; Kr = c->Kr[11]; Q(block, Kr, Km);
+        Km = c->Km[10]; Kr = c->Kr[10]; Q(block, Kr, Km);
+        Km = c->Km[9]; Kr = c->Kr[9]; Q(block, Kr, Km);
+        Km = c->Km[8]; Kr = c->Kr[8]; Q(block, Kr, Km);
+        Km = c->Km[7]; Kr = c->Kr[7]; Q(block, Kr, Km);
+        Km = c->Km[6]; Kr = c->Kr[6]; Q(block, Kr, Km);
+        Km = c->Km[5]; Kr = c->Kr[5]; QBAR(block, Kr, Km);
+        Km = c->Km[4]; Kr = c->Kr[4]; QBAR(block, Kr, Km);
+        Km = c->Km[3]; Kr = c->Kr[3]; QBAR(block, Kr, Km);
+        Km = c->Km[2]; Kr = c->Kr[2]; QBAR(block, Kr, Km);
+        Km = c->Km[1]; Kr = c->Kr[1]; QBAR(block, Kr, Km);
+        Km = c->Km[0]; Kr = c->Kr[0]; QBAR(block, Kr, Km);
+
+        dst[0] = cpu_to_be32(block[0]);
+        dst[1] = cpu_to_be32(block[1]);
+        dst[2] = cpu_to_be32(block[2]);
+        dst[3] = cpu_to_be32(block[3]);
+}
+
+static struct crypto_alg alg = {
+        .cra_name = "cast6",
+        .cra_flags = CRYPTO_ALG_TYPE_CIPHER,
+        .cra_blocksize = CAST6_BLOCK_SIZE,
+        .cra_ctxsize = sizeof(struct cast6_ctx),
+        .cra_alignmask = 3,
+        .cra_module = THIS_MODULE,
+        .cra_list = LIST_HEAD_INIT(alg.cra_list),
+        .cra_u = {
+                  .cipher = {
+                             .cia_min_keysize = CAST6_MIN_KEY_SIZE,
+                             .cia_max_keysize = CAST6_MAX_KEY_SIZE,
+                             .cia_setkey = cast6_setkey,
+                             .cia_encrypt = cast6_encrypt,
+                             .cia_decrypt = cast6_decrypt}
+                  }
+};
+
+static int __init cast6_mod_init(void)
+{
+        return crypto_register_alg(&alg);
+}
+
+static void __exit cast6_mod_fini(void)
+{
+        crypto_unregister_alg(&alg);
+}
+
+module_init(cast6_mod_init);
+module_exit(cast6_mod_fini);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Cast6 Cipher Algorithm");
diff --git a/crypto/serpent.c b/crypto/serpent.c
new file mode 100644
index 00000000000..b651a55fa56
--- /dev/null
+++ b/crypto/serpent.c
@@ -0,0 +1,587 @@
+/*
+ * Cryptographic API.
+ *
+ * Serpent Cipher Algorithm.
+ *
+ * Copyright (C) 2002 Dag Arne Osvik <osvik@ii.uib.no>
+ *               2003 Herbert Valerio Riedel <hvr@gnu.org>
+ *
+ * Added tnepres support: Ruben Jesus Garcia Hernandez <ruben@ugr.es>, 18.10.2004
+ *               Based on code by hvr
+ *
+ * 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.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <asm/byteorder.h>
+#include <linux/crypto.h>
+#include <linux/types.h>
+
+/* Key is padded to the maximum of 256 bits before round key generation.
+ * Any key length <= 256 bits (32 bytes) is allowed by the algorithm.
+ */
+
+#define SERPENT_MIN_KEY_SIZE              0
+#define SERPENT_MAX_KEY_SIZE             32
+#define SERPENT_EXPKEY_WORDS            132
+#define SERPENT_BLOCK_SIZE               16
+
+#define PHI 0x9e3779b9UL
+
+#define keyiter(a,b,c,d,i,j) \
+        b ^= d; b ^= c; b ^= a; b ^= PHI ^ i; b = rol32(b,11); k[j] = b;
+
+#define loadkeys(x0,x1,x2,x3,i) \
+        x0=k[i]; x1=k[i+1]; x2=k[i+2]; x3=k[i+3];
+
+#define storekeys(x0,x1,x2,x3,i) \
+        k[i]=x0; k[i+1]=x1; k[i+2]=x2; k[i+3]=x3;
+
+#define K(x0,x1,x2,x3,i)                                \
+        x3 ^= k[4*(i)+3];        x2 ^= k[4*(i)+2];      \
+        x1 ^= k[4*(i)+1];        x0 ^= k[4*(i)+0];
+
+#define LK(x0,x1,x2,x3,x4,i)                            \
+                                        x0=rol32(x0,13);\
+        x2=rol32(x2,3); x1 ^= x0;       x4  = x0 << 3;  \
+        x3 ^= x2;       x1 ^= x2;                       \
+        x1=rol32(x1,1); x3 ^= x4;                       \
+        x3=rol32(x3,7); x4  = x1;                       \
+        x0 ^= x1;       x4 <<= 7;       x2 ^= x3;       \
+        x0 ^= x3;       x2 ^= x4;       x3 ^= k[4*i+3]; \
+        x1 ^= k[4*i+1]; x0=rol32(x0,5); x2=rol32(x2,22);\
+        x0 ^= k[4*i+0]; x2 ^= k[4*i+2];
+
+#define KL(x0,x1,x2,x3,x4,i)                            \
+        x0 ^= k[4*i+0]; x1 ^= k[4*i+1]; x2 ^= k[4*i+2]; \
+        x3 ^= k[4*i+3]; x0=ror32(x0,5); x2=ror32(x2,22);\
+        x4 =  x1;       x2 ^= x3;       x0 ^= x3;       \
+        x4 <<= 7;       x0 ^= x1;       x1=ror32(x1,1); \
+        x2 ^= x4;       x3=ror32(x3,7); x4 = x0 << 3;   \
+        x1 ^= x0;       x3 ^= x4;       x0=ror32(x0,13);\
+        x1 ^= x2;       x3 ^= x2;       x2=ror32(x2,3);
+
+#define S0(x0,x1,x2,x3,x4)                              \
+                                        x4  = x3;       \
+        x3 |= x0;       x0 ^= x4;       x4 ^= x2;       \
+        x4 =~ x4;       x3 ^= x1;       x1 &= x0;       \
+        x1 ^= x4;       x2 ^= x0;       x0 ^= x3;       \
+        x4 |= x0;       x0 ^= x2;       x2 &= x1;       \
+        x3 ^= x2;       x1 =~ x1;       x2 ^= x4;       \
+        x1 ^= x2;
+
+#define S1(x0,x1,x2,x3,x4)                              \
+                                        x4  = x1;       \
+        x1 ^= x0;       x0 ^= x3;       x3 =~ x3;       \
+        x4 &= x1;       x0 |= x1;       x3 ^= x2;       \
+        x0 ^= x3;       x1 ^= x3;       x3 ^= x4;       \
+        x1 |= x4;       x4 ^= x2;       x2 &= x0;       \
+        x2 ^= x1;       x1 |= x0;       x0 =~ x0;       \
+        x0 ^= x2;       x4 ^= x1;
+
+#define S2(x0,x1,x2,x3,x4)                              \
+                                        x3 =~ x3;       \
+        x1 ^= x0;       x4  = x0;       x0 &= x2;       \
+        x0 ^= x3;       x3 |= x4;       x2 ^= x1;       \
+        x3 ^= x1;       x1 &= x0;       x0 ^= x2;       \
+        x2 &= x3;       x3 |= x1;       x0 =~ x0;       \
+        x3 ^= x0;       x4 ^= x0;       x0 ^= x2;       \
+        x1 |= x2;
+
+#define S3(x0,x1,x2,x3,x4)                              \
+                                        x4  = x1;       \
+        x1 ^= x3;       x3 |= x0;       x4 &= x0;       \
+        x0 ^= x2;       x2 ^= x1;       x1 &= x3;       \
+        x2 ^= x3;       x0 |= x4;       x4 ^= x3;       \
+        x1 ^= x0;       x0 &= x3;       x3 &= x4;       \
+        x3 ^= x2;       x4 |= x1;       x2 &= x1;       \
+        x4 ^= x3;       x0 ^= x3;       x3 ^= x2;
+
+#define S4(x0,x1,x2,x3,x4)                              \
+                                        x4  = x3;       \
+        x3 &= x0;       x0 ^= x4;                       \
+        x3 ^= x2;       x2 |= x4;       x0 ^= x1;       \
+        x4 ^= x3;       x2 |= x0;                       \
+        x2 ^= x1;       x1 &= x0;                       \
+        x1 ^= x4;       x4 &= x2;       x2 ^= x3;       \
+        x4 ^= x0;       x3 |= x1;       x1 =~ x1;       \
+        x3 ^= x0;
+
+#define S5(x0,x1,x2,x3,x4)                              \
+        x4  = x1;       x1 |= x0;                       \
+        x2 ^= x1;       x3 =~ x3;       x4 ^= x0;       \
+        x0 ^= x2;       x1 &= x4;       x4 |= x3;       \
+        x4 ^= x0;       x0 &= x3;       x1 ^= x3;       \
+        x3 ^= x2;       x0 ^= x1;       x2 &= x4;       \
+        x1 ^= x2;       x2 &= x0;                       \
+        x3 ^= x2;
+
+#define S6(x0,x1,x2,x3,x4)                              \
+                                        x4  = x1;       \
+        x3 ^= x0;       x1 ^= x2;       x2 ^= x0;       \
+        x0 &= x3;       x1 |= x3;       x4 =~ x4;       \
+        x0 ^= x1;       x1 ^= x2;                       \
+        x3 ^= x4;       x4 ^= x0;       x2 &= x0;       \
+        x4 ^= x1;       x2 ^= x3;       x3 &= x1;       \
+        x3 ^= x0;       x1 ^= x2;
+
+#define S7(x0,x1,x2,x3,x4)                              \
+                                        x1 =~ x1;       \
+        x4  = x1;       x0 =~ x0;       x1 &= x2;       \
+        x1 ^= x3;       x3 |= x4;       x4 ^= x2;       \
+        x2 ^= x3;       x3 ^= x0;       x0 |= x1;       \
+        x2 &= x0;       x0 ^= x4;       x4 ^= x3;       \
+        x3 &= x0;       x4 ^= x1;                       \
+        x2 ^= x4;       x3 ^= x1;       x4 |= x0;       \
+        x4 ^= x1;
+
+#define SI0(x0,x1,x2,x3,x4)                             \
+                        x4  = x3;       x1 ^= x0;       \
+        x3 |= x1;       x4 ^= x1;       x0 =~ x0;       \
+        x2 ^= x3;       x3 ^= x0;       x0 &= x1;       \
+        x0 ^= x2;       x2 &= x3;       x3 ^= x4;       \
+        x2 ^= x3;       x1 ^= x3;       x3 &= x0;       \
+        x1 ^= x0;       x0 ^= x2;       x4 ^= x3;
+
+#define SI1(x0,x1,x2,x3,x4)                             \
+        x1 ^= x3;       x4  = x0;                       \
+        x0 ^= x2;       x2 =~ x2;       x4 |= x1;       \
+        x4 ^= x3;       x3 &= x1;       x1 ^= x2;       \
+        x2 &= x4;       x4 ^= x1;       x1 |= x3;       \
+        x3 ^= x0;       x2 ^= x0;       x0 |= x4;       \
+        x2 ^= x4;       x1 ^= x0;                       \
+        x4 ^= x1;
+
+#define SI2(x0,x1,x2,x3,x4)                             \
+        x2 ^= x1;       x4  = x3;       x3 =~ x3;       \
+        x3 |= x2;       x2 ^= x4;       x4 ^= x0;       \
+        x3 ^= x1;       x1 |= x2;       x2 ^= x0;       \
+        x1 ^= x4;       x4 |= x3;       x2 ^= x3;       \
+        x4 ^= x2;       x2 &= x1;                       \
+        x2 ^= x3;       x3 ^= x4;       x4 ^= x0;
+
+#define SI3(x0,x1,x2,x3,x4)                             \
+                                        x2 ^= x1;       \
+        x4  = x1;       x1 &= x2;                       \
+        x1 ^= x0;       x0 |= x4;       x4 ^= x3;       \
+        x0 ^= x3;       x3 |= x1;       x1 ^= x2;       \
+        x1 ^= x3;       x0 ^= x2;       x2 ^= x3;       \
+        x3 &= x1;       x1 ^= x0;       x0 &= x2;       \
+        x4 ^= x3;       x3 ^= x0;       x0 ^= x1;
+
+#define SI4(x0,x1,x2,x3,x4)                             \
+        x2 ^= x3;       x4  = x0;       x0 &= x1;       \
+        x0 ^= x2;       x2 |= x3;       x4 =~ x4;       \
+        x1 ^= x0;       x0 ^= x2;       x2 &= x4;       \
+        x2 ^= x0;       x0 |= x4;                       \
+        x0 ^= x3;       x3 &= x2;                       \
+        x4 ^= x3;       x3 ^= x1;       x1 &= x0;       \
+        x4 ^= x1;       x0 ^= x3;
+
+#define SI5(x0,x1,x2,x3,x4)                             \
+                        x4  = x1;       x1 |= x2;       \
+        x2 ^= x4;       x1 ^= x3;       x3 &= x4;       \
+        x2 ^= x3;       x3 |= x0;       x0 =~ x0;       \
+        x3 ^= x2;       x2 |= x0;       x4 ^= x1;       \
+        x2 ^= x4;       x4 &= x0;       x0 ^= x1;       \
+        x1 ^= x3;       x0 &= x2;       x2 ^= x3;       \
+        x0 ^= x2;       x2 ^= x4;       x4 ^= x3;
+
+#define SI6(x0,x1,x2,x3,x4)                             \
+                        x0 ^= x2;                       \
+        x4  = x0;       x0 &= x3;       x2 ^= x3;       \
+        x0 ^= x2;       x3 ^= x1;       x2 |= x4;       \
+        x2 ^= x3;       x3 &= x0;       x0 =~ x0;       \
+        x3 ^= x1;       x1 &= x2;       x4 ^= x0;       \
+        x3 ^= x4;       x4 ^= x2;       x0 ^= x1;       \
+        x2 ^= x0;
+
+#define SI7(x0,x1,x2,x3,x4)                             \
+        x4  = x3;       x3 &= x0;       x0 ^= x2;       \
+        x2 |= x4;       x4 ^= x1;       x0 =~ x0;       \
+        x1 |= x3;       x4 ^= x0;       x0 &= x2;       \
+        x0 ^= x1;       x1 &= x2;       x3 ^= x2;       \
+        x4 ^= x3;       x2 &= x3;       x3 |= x0;       \
+        x1 ^= x4;       x3 ^= x4;       x4 &= x0;       \
+        x4 ^= x2;
+
+struct serpent_ctx {
+        u32 expkey[SERPENT_EXPKEY_WORDS];
+};
+
+
+static int serpent_setkey(struct crypto_tfm *tfm, const u8 *key,
+                          unsigned int keylen)
+{
+        struct serpent_ctx *ctx = crypto_tfm_ctx(tfm);
+        u32 *k = ctx->expkey;
+        u8  *k8 = (u8 *)k;
+        u32 r0,r1,r2,r3,r4;
+        int i;
+
+        /* Copy key, add padding */
+
+        for (i = 0; i < keylen; ++i)
+                k8[i] = key[i];
+        if (i < SERPENT_MAX_KEY_SIZE)
+                k8[i++] = 1;
+        while (i < SERPENT_MAX_KEY_SIZE)
+                k8[i++] = 0;
+
+        /* Expand key using polynomial */
+
+        r0 = le32_to_cpu(k[3]);
+        r1 = le32_to_cpu(k[4]);
+        r2 = le32_to_cpu(k[5]);
+        r3 = le32_to_cpu(k[6]);
+        r4 = le32_to_cpu(k[7]);
+
+        keyiter(le32_to_cpu(k[0]),r0,r4,r2,0,0);
+        keyiter(le32_to_cpu(k[1]),r1,r0,r3,1,1);
+        keyiter(le32_to_cpu(k[2]),r2,r1,r4,2,2);
+        keyiter(le32_to_cpu(k[3]),r3,r2,r0,3,3);
+        keyiter(le32_to_cpu(k[4]),r4,r3,r1,4,4);
+        keyiter(le32_to_cpu(k[5]),r0,r4,r2,5,5);
+        keyiter(le32_to_cpu(k[6]),r1,r0,r3,6,6);
+        keyiter(le32_to_cpu(k[7]),r2,r1,r4,7,7);
+
+        keyiter(k[  0],r3,r2,r0,  8,  8); keyiter(k[  1],r4,r3,r1,  9,  9);
+        keyiter(k[  2],r0,r4,r2, 10, 10); keyiter(k[  3],r1,r0,r3, 11, 11);
+        keyiter(k[  4],r2,r1,r4, 12, 12); keyiter(k[  5],r3,r2,r0, 13, 13);
+        keyiter(k[  6],r4,r3,r1, 14, 14); keyiter(k[  7],r0,r4,r2, 15, 15);
+        keyiter(k[  8],r1,r0,r3, 16, 16); keyiter(k[  9],r2,r1,r4, 17, 17);
+        keyiter(k[ 10],r3,r2,r0, 18, 18); keyiter(k[ 11],r4,r3,r1, 19, 19);
+        keyiter(k[ 12],r0,r4,r2, 20, 20); keyiter(k[ 13],r1,r0,r3, 21, 21);
+        keyiter(k[ 14],r2,r1,r4, 22, 22); keyiter(k[ 15],r3,r2,r0, 23, 23);
+        keyiter(k[ 16],r4,r3,r1, 24, 24); keyiter(k[ 17],r0,r4,r2, 25, 25);
+        keyiter(k[ 18],r1,r0,r3, 26, 26); keyiter(k[ 19],r2,r1,r4, 27, 27);
+        keyiter(k[ 20],r3,r2,r0, 28, 28); keyiter(k[ 21],r4,r3,r1, 29, 29);
+        keyiter(k[ 22],r0,r4,r2, 30, 30); keyiter(k[ 23],r1,r0,r3, 31, 31);
+
+        k += 50;
+
+        keyiter(k[-26],r2,r1,r4, 32,-18); keyiter(k[-25],r3,r2,r0, 33,-17);
+        keyiter(k[-24],r4,r3,r1, 34,-16); keyiter(k[-23],r0,r4,r2, 35,-15);
+        keyiter(k[-22],r1,r0,r3, 36,-14); keyiter(k[-21],r2,r1,r4, 37,-13);
+        keyiter(k[-20],r3,r2,r0, 38,-12); keyiter(k[-19],r4,r3,r1, 39,-11);
+        keyiter(k[-18],r0,r4,r2, 40,-10); keyiter(k[-17],r1,r0,r3, 41, -9);
+        keyiter(k[-16],r2,r1,r4, 42, -8); keyiter(k[-15],r3,r2,r0, 43, -7);
+        keyiter(k[-14],r4,r3,r1, 44, -6); keyiter(k[-13],r0,r4,r2, 45, -5);
+        keyiter(k[-12],r1,r0,r3, 46, -4); keyiter(k[-11],r2,r1,r4, 47, -3);
+        keyiter(k[-10],r3,r2,r0, 48, -2); keyiter(k[ -9],r4,r3,r1, 49, -1);
+        keyiter(k[ -8],r0,r4,r2, 50,  0); keyiter(k[ -7],r1,r0,r3, 51,  1);
+        keyiter(k[ -6],r2,r1,r4, 52,  2); keyiter(k[ -5],r3,r2,r0, 53,  3);
+        keyiter(k[ -4],r4,r3,r1, 54,  4); keyiter(k[ -3],r0,r4,r2, 55,  5);
+        keyiter(k[ -2],r1,r0,r3, 56,  6); keyiter(k[ -1],r2,r1,r4, 57,  7);
+        keyiter(k[  0],r3,r2,r0, 58,  8); keyiter(k[  1],r4,r3,r1, 59,  9);
+        keyiter(k[  2],r0,r4,r2, 60, 10); keyiter(k[  3],r1,r0,r3, 61, 11);
+        keyiter(k[  4],r2,r1,r4, 62, 12); keyiter(k[  5],r3,r2,r0, 63, 13);
+        keyiter(k[  6],r4,r3,r1, 64, 14); keyiter(k[  7],r0,r4,r2, 65, 15);
+        keyiter(k[  8],r1,r0,r3, 66, 16); keyiter(k[  9],r2,r1,r4, 67, 17);
+        keyiter(k[ 10],r3,r2,r0, 68, 18); keyiter(k[ 11],r4,r3,r1, 69, 19);
+        keyiter(k[ 12],r0,r4,r2, 70, 20); keyiter(k[ 13],r1,r0,r3, 71, 21);
+        keyiter(k[ 14],r2,r1,r4, 72, 22); keyiter(k[ 15],r3,r2,r0, 73, 23);
+        keyiter(k[ 16],r4,r3,r1, 74, 24); keyiter(k[ 17],r0,r4,r2, 75, 25);
+        keyiter(k[ 18],r1,r0,r3, 76, 26); keyiter(k[ 19],r2,r1,r4, 77, 27);
+        keyiter(k[ 20],r3,r2,r0, 78, 28); keyiter(k[ 21],r4,r3,r1, 79, 29);
+        keyiter(k[ 22],r0,r4,r2, 80, 30); keyiter(k[ 23],r1,r0,r3, 81, 31);
+
+        k += 50;
+
+        keyiter(k[-26],r2,r1,r4, 82,-18); keyiter(k[-25],r3,r2,r0, 83,-17);
+        keyiter(k[-24],r4,r3,r1, 84,-16); keyiter(k[-23],r0,r4,r2, 85,-15);
+        keyiter(k[-22],r1,r0,r3, 86,-14); keyiter(k[-21],r2,r1,r4, 87,-13);
+        keyiter(k[-20],r3,r2,r0, 88,-12); keyiter(k[-19],r4,r3,r1, 89,-11);
+        keyiter(k[-18],r0,r4,r2, 90,-10); keyiter(k[-17],r1,r0,r3, 91, -9);
+        keyiter(k[-16],r2,r1,r4, 92, -8); keyiter(k[-15],r3,r2,r0, 93, -7);
+        keyiter(k[-14],r4,r3,r1, 94, -6); keyiter(k[-13],r0,r4,r2, 95, -5);
+        keyiter(k[-12],r1,r0,r3, 96, -4); keyiter(k[-11],r2,r1,r4, 97, -3);
+        keyiter(k[-10],r3,r2,r0, 98, -2); keyiter(k[ -9],r4,r3,r1, 99, -1);
+        keyiter(k[ -8],r0,r4,r2,100,  0); keyiter(k[ -7],r1,r0,r3,101,  1);
+        keyiter(k[ -6],r2,r1,r4,102,  2); keyiter(k[ -5],r3,r2,r0,103,  3);
+        keyiter(k[ -4],r4,r3,r1,104,  4); keyiter(k[ -3],r0,r4,r2,105,  5);
+        keyiter(k[ -2],r1,r0,r3,106,  6); keyiter(k[ -1],r2,r1,r4,107,  7);
+        keyiter(k[  0],r3,r2,r0,108,  8); keyiter(k[  1],r4,r3,r1,109,  9);
+        keyiter(k[  2],r0,r4,r2,110, 10); keyiter(k[  3],r1,r0,r3,111, 11);
+        keyiter(k[  4],r2,r1,r4,112, 12); keyiter(k[  5],r3,r2,r0,113, 13);
+        keyiter(k[  6],r4,r3,r1,114, 14); keyiter(k[  7],r0,r4,r2,115, 15);
+        keyiter(k[  8],r1,r0,r3,116, 16); keyiter(k[  9],r2,r1,r4,117, 17);
+        keyiter(k[ 10],r3,r2,r0,118, 18); keyiter(k[ 11],r4,r3,r1,119, 19);
+        keyiter(k[ 12],r0,r4,r2,120, 20); keyiter(k[ 13],r1,r0,r3,121, 21);
+        keyiter(k[ 14],r2,r1,r4,122, 22); keyiter(k[ 15],r3,r2,r0,123, 23);
+        keyiter(k[ 16],r4,r3,r1,124, 24); keyiter(k[ 17],r0,r4,r2,125, 25);
+        keyiter(k[ 18],r1,r0,r3,126, 26); keyiter(k[ 19],r2,r1,r4,127, 27);
+        keyiter(k[ 20],r3,r2,r0,128, 28); keyiter(k[ 21],r4,r3,r1,129, 29);
+        keyiter(k[ 22],r0,r4,r2,130, 30); keyiter(k[ 23],r1,r0,r3,131, 31);
+
+        /* Apply S-boxes */
+
+        S3(r3,r4,r0,r1,r2); storekeys(r1,r2,r4,r3, 28); loadkeys(r1,r2,r4,r3, 24);
+        S4(r1,r2,r4,r3,r0); storekeys(r2,r4,r3,r0, 24); loadkeys(r2,r4,r3,r0, 20);
+        S5(r2,r4,r3,r0,r1); storekeys(r1,r2,r4,r0, 20); loadkeys(r1,r2,r4,r0, 16);
+        S6(r1,r2,r4,r0,r3); storekeys(r4,r3,r2,r0, 16); loadkeys(r4,r3,r2,r0, 12);
+        S7(r4,r3,r2,r0,r1); storekeys(r1,r2,r0,r4, 12); loadkeys(r1,r2,r0,r4,  8);
+        S0(r1,r2,r0,r4,r3); storekeys(r0,r2,r4,r1,  8); loadkeys(r0,r2,r4,r1,  4);
+        S1(r0,r2,r4,r1,r3); storekeys(r3,r4,r1,r0,  4); loadkeys(r3,r4,r1,r0,  0);
+        S2(r3,r4,r1,r0,r2); storekeys(r2,r4,r3,r0,  0); loadkeys(r2,r4,r3,r0, -4);
+        S3(r2,r4,r3,r0,r1); storekeys(r0,r1,r4,r2, -4); loadkeys(r0,r1,r4,r2, -8);
+        S4(r0,r1,r4,r2,r3); storekeys(r1,r4,r2,r3, -8); loadkeys(r1,r4,r2,r3,-12);
+        S5(r1,r4,r2,r3,r0); storekeys(r0,r1,r4,r3,-12); loadkeys(r0,r1,r4,r3,-16);
+        S6(r0,r1,r4,r3,r2); storekeys(r4,r2,r1,r3,-16); loadkeys(r4,r2,r1,r3,-20);
+        S7(r4,r2,r1,r3,r0); storekeys(r0,r1,r3,r4,-20); loadkeys(r0,r1,r3,r4,-24);
+        S0(r0,r1,r3,r4,r2); storekeys(r3,r1,r4,r0,-24); loadkeys(r3,r1,r4,r0,-28);
+        k -= 50;
+        S1(r3,r1,r4,r0,r2); storekeys(r2,r4,r0,r3, 22); loadkeys(r2,r4,r0,r3, 18);
+        S2(r2,r4,r0,r3,r1); storekeys(r1,r4,r2,r3, 18); loadkeys(r1,r4,r2,r3, 14);
+        S3(r1,r4,r2,r3,r0); storekeys(r3,r0,r4,r1, 14); loadkeys(r3,r0,r4,r1, 10);
+        S4(r3,r0,r4,r1,r2); storekeys(r0,r4,r1,r2, 10); loadkeys(r0,r4,r1,r2,  6);
+        S5(r0,r4,r1,r2,r3); storekeys(r3,r0,r4,r2,  6); loadkeys(r3,r0,r4,r2,  2);
+        S6(r3,r0,r4,r2,r1); storekeys(r4,r1,r0,r2,  2); loadkeys(r4,r1,r0,r2, -2);
+        S7(r4,r1,r0,r2,r3); storekeys(r3,r0,r2,r4, -2); loadkeys(r3,r0,r2,r4, -6);
+        S0(r3,r0,r2,r4,r1); storekeys(r2,r0,r4,r3, -6); loadkeys(r2,r0,r4,r3,-10);
+        S1(r2,r0,r4,r3,r1); storekeys(r1,r4,r3,r2,-10); loadkeys(r1,r4,r3,r2,-14);
+        S2(r1,r4,r3,r2,r0); storekeys(r0,r4,r1,r2,-14); loadkeys(r0,r4,r1,r2,-18);
+        S3(r0,r4,r1,r2,r3); storekeys(r2,r3,r4,r0,-18); loadkeys(r2,r3,r4,r0,-22);
+        k -= 50;
+        S4(r2,r3,r4,r0,r1); storekeys(r3,r4,r0,r1, 28); loadkeys(r3,r4,r0,r1, 24);
+        S5(r3,r4,r0,r1,r2); storekeys(r2,r3,r4,r1, 24); loadkeys(r2,r3,r4,r1, 20);
+        S6(r2,r3,r4,r1,r0); storekeys(r4,r0,r3,r1, 20); loadkeys(r4,r0,r3,r1, 16);
+        S7(r4,r0,r3,r1,r2); storekeys(r2,r3,r1,r4, 16); loadkeys(r2,r3,r1,r4, 12);
+        S0(r2,r3,r1,r4,r0); storekeys(r1,r3,r4,r2, 12); loadkeys(r1,r3,r4,r2,  8);
+        S1(r1,r3,r4,r2,r0); storekeys(r0,r4,r2,r1,  8); loadkeys(r0,r4,r2,r1,  4);
+        S2(r0,r4,r2,r1,r3); storekeys(r3,r4,r0,r1,  4); loadkeys(r3,r4,r0,r1,  0);
+        S3(r3,r4,r0,r1,r2); storekeys(r1,r2,r4,r3,  0);
+
+        return 0;
+}
+
+static void serpent_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
+{
+        struct serpent_ctx *ctx = crypto_tfm_ctx(tfm);
+        const u32
+                *k = ctx->expkey;
+        const __le32 *s = (const __le32 *)src;
+        __le32  *d = (__le32 *)dst;
+        u32     r0, r1, r2, r3, r4;
+
+/*
+ * Note: The conversions between u8* and u32* might cause trouble
+ * on architectures with stricter alignment rules than x86
+ */
+
+        r0 = le32_to_cpu(s[0]);
+        r1 = le32_to_cpu(s[1]);
+        r2 = le32_to_cpu(s[2]);
+        r3 = le32_to_cpu(s[3]);
+
+                                 K(r0,r1,r2,r3,0);
+        S0(r0,r1,r2,r3,r4);     LK(r2,r1,r3,r0,r4,1);
+        S1(r2,r1,r3,r0,r4);     LK(r4,r3,r0,r2,r1,2);
+        S2(r4,r3,r0,r2,r1);     LK(r1,r3,r4,r2,r0,3);
+        S3(r1,r3,r4,r2,r0);     LK(r2,r0,r3,r1,r4,4);
+        S4(r2,r0,r3,r1,r4);     LK(r0,r3,r1,r4,r2,5);
+        S5(r0,r3,r1,r4,r2);     LK(r2,r0,r3,r4,r1,6);
+        S6(r2,r0,r3,r4,r1);     LK(r3,r1,r0,r4,r2,7);
+        S7(r3,r1,r0,r4,r2);     LK(r2,r0,r4,r3,r1,8);
+        S0(r2,r0,r4,r3,r1);     LK(r4,r0,r3,r2,r1,9);
+        S1(r4,r0,r3,r2,r1);     LK(r1,r3,r2,r4,r0,10);
+        S2(r1,r3,r2,r4,r0);     LK(r0,r3,r1,r4,r2,11);
+        S3(r0,r3,r1,r4,r2);     LK(r4,r2,r3,r0,r1,12);
+        S4(r4,r2,r3,r0,r1);     LK(r2,r3,r0,r1,r4,13);
+        S5(r2,r3,r0,r1,r4);     LK(r4,r2,r3,r1,r0,14);
+        S6(r4,r2,r3,r1,r0);     LK(r3,r0,r2,r1,r4,15);
+        S7(r3,r0,r2,r1,r4);     LK(r4,r2,r1,r3,r0,16);
+        S0(r4,r2,r1,r3,r0);     LK(r1,r2,r3,r4,r0,17);
+        S1(r1,r2,r3,r4,r0);     LK(r0,r3,r4,r1,r2,18);
+        S2(r0,r3,r4,r1,r2);     LK(r2,r3,r0,r1,r4,19);
+        S3(r2,r3,r0,r1,r4);     LK(r1,r4,r3,r2,r0,20);
+        S4(r1,r4,r3,r2,r0);     LK(r4,r3,r2,r0,r1,21);
+        S5(r4,r3,r2,r0,r1);     LK(r1,r4,r3,r0,r2,22);
+        S6(r1,r4,r3,r0,r2);     LK(r3,r2,r4,r0,r1,23);
+        S7(r3,r2,r4,r0,r1);     LK(r1,r4,r0,r3,r2,24);
+        S0(r1,r4,r0,r3,r2);     LK(r0,r4,r3,r1,r2,25);
+        S1(r0,r4,r3,r1,r2);     LK(r2,r3,r1,r0,r4,26);
+        S2(r2,r3,r1,r0,r4);     LK(r4,r3,r2,r0,r1,27);
+        S3(r4,r3,r2,r0,r1);     LK(r0,r1,r3,r4,r2,28);
+        S4(r0,r1,r3,r4,r2);     LK(r1,r3,r4,r2,r0,29);
+        S5(r1,r3,r4,r2,r0);     LK(r0,r1,r3,r2,r4,30);
+        S6(r0,r1,r3,r2,r4);     LK(r3,r4,r1,r2,r0,31);
+        S7(r3,r4,r1,r2,r0);      K(r0,r1,r2,r3,32);
+
+        d[0] = cpu_to_le32(r0);
+        d[1] = cpu_to_le32(r1);
+        d[2] = cpu_to_le32(r2);
+        d[3] = cpu_to_le32(r3);
+}
+
+static void serpent_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
+{
+        struct serpent_ctx *ctx = crypto_tfm_ctx(tfm);
+        const u32
+                *k = ((struct serpent_ctx *)ctx)->expkey;
+        const __le32 *s = (const __le32 *)src;
+        __le32  *d = (__le32 *)dst;
+        u32     r0, r1, r2, r3, r4;
+
+        r0 = le32_to_cpu(s[0]);
+        r1 = le32_to_cpu(s[1]);
+        r2 = le32_to_cpu(s[2]);
+        r3 = le32_to_cpu(s[3]);
+
+                                K(r0,r1,r2,r3,32);
+        SI7(r0,r1,r2,r3,r4);    KL(r1,r3,r0,r4,r2,31);
+        SI6(r1,r3,r0,r4,r2);    KL(r0,r2,r4,r1,r3,30);
+        SI5(r0,r2,r4,r1,r3);    KL(r2,r3,r0,r4,r1,29);
+        SI4(r2,r3,r0,r4,r1);    KL(r2,r0,r1,r4,r3,28);
+        SI3(r2,r0,r1,r4,r3);    KL(r1,r2,r3,r4,r0,27);
+        SI2(r1,r2,r3,r4,r0);    KL(r2,r0,r4,r3,r1,26);
+        SI1(r2,r0,r4,r3,r1);    KL(r1,r0,r4,r3,r2,25);
+        SI0(r1,r0,r4,r3,r2);    KL(r4,r2,r0,r1,r3,24);
+        SI7(r4,r2,r0,r1,r3);    KL(r2,r1,r4,r3,r0,23);
+        SI6(r2,r1,r4,r3,r0);    KL(r4,r0,r3,r2,r1,22);
+        SI5(r4,r0,r3,r2,r1);    KL(r0,r1,r4,r3,r2,21);
+        SI4(r0,r1,r4,r3,r2);    KL(r0,r4,r2,r3,r1,20);
+        SI3(r0,r4,r2,r3,r1);    KL(r2,r0,r1,r3,r4,19);
+        SI2(r2,r0,r1,r3,r4);    KL(r0,r4,r3,r1,r2,18);
+        SI1(r0,r4,r3,r1,r2);    KL(r2,r4,r3,r1,r0,17);
+        SI0(r2,r4,r3,r1,r0);    KL(r3,r0,r4,r2,r1,16);
+        SI7(r3,r0,r4,r2,r1);    KL(r0,r2,r3,r1,r4,15);
+        SI6(r0,r2,r3,r1,r4);    KL(r3,r4,r1,r0,r2,14);
+        SI5(r3,r4,r1,r0,r2);    KL(r4,r2,r3,r1,r0,13);
+        SI4(r4,r2,r3,r1,r0);    KL(r4,r3,r0,r1,r2,12);
+        SI3(r4,r3,r0,r1,r2);    KL(r0,r4,r2,r1,r3,11);
+        SI2(r0,r4,r2,r1,r3);    KL(r4,r3,r1,r2,r0,10);
+        SI1(r4,r3,r1,r2,r0);    KL(r0,r3,r1,r2,r4,9);
+        SI0(r0,r3,r1,r2,r4);    KL(r1,r4,r3,r0,r2,8);
+        SI7(r1,r4,r3,r0,r2);    KL(r4,r0,r1,r2,r3,7);
+        SI6(r4,r0,r1,r2,r3);    KL(r1,r3,r2,r4,r0,6);
+        SI5(r1,r3,r2,r4,r0);    KL(r3,r0,r1,r2,r4,5);
+        SI4(r3,r0,r1,r2,r4);    KL(r3,r1,r4,r2,r0,4);
+        SI3(r3,r1,r4,r2,r0);    KL(r4,r3,r0,r2,r1,3);
+        SI2(r4,r3,r0,r2,r1);    KL(r3,r1,r2,r0,r4,2);
+        SI1(r3,r1,r2,r0,r4);    KL(r4,r1,r2,r0,r3,1);
+        SI0(r4,r1,r2,r0,r3);    K(r2,r3,r1,r4,0);
+
+        d[0] = cpu_to_le32(r2);
+        d[1] = cpu_to_le32(r3);
+        d[2] = cpu_to_le32(r1);
+        d[3] = cpu_to_le32(r4);
+}
+
+static struct crypto_alg serpent_alg = {
+        .cra_name               =       "serpent",
+        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
+        .cra_blocksize          =       SERPENT_BLOCK_SIZE,
+        .cra_ctxsize            =       sizeof(struct serpent_ctx),
+        .cra_alignmask          =       3,
+        .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(serpent_alg.cra_list),
+        .cra_u                  =       { .cipher = {
+        .cia_min_keysize        =       SERPENT_MIN_KEY_SIZE,
+        .cia_max_keysize        =       SERPENT_MAX_KEY_SIZE,
+        .cia_setkey             =       serpent_setkey,
+        .cia_encrypt            =       serpent_encrypt,
+        .cia_decrypt            =       serpent_decrypt } }
+};
+
+static int tnepres_setkey(struct crypto_tfm *tfm, const u8 *key,
+                          unsigned int keylen)
+{
+        u8 rev_key[SERPENT_MAX_KEY_SIZE];
+        int i;
+
+        for (i = 0; i < keylen; ++i)
+                rev_key[keylen - i - 1] = key[i];
+ 
+        return serpent_setkey(tfm, rev_key, keylen);
+}
+
+static void tnepres_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
+{
+        const u32 * const s = (const u32 * const)src;
+        u32 * const d = (u32 * const)dst;
+
+        u32 rs[4], rd[4];
+
+        rs[0] = swab32(s[3]);
+        rs[1] = swab32(s[2]);
+        rs[2] = swab32(s[1]);
+        rs[3] = swab32(s[0]);
+
+        serpent_encrypt(tfm, (u8 *)rd, (u8 *)rs);
+
+        d[0] = swab32(rd[3]);
+        d[1] = swab32(rd[2]);
+        d[2] = swab32(rd[1]);
+        d[3] = swab32(rd[0]);
+}
+
+static void tnepres_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
+{
+        const u32 * const s = (const u32 * const)src;
+        u32 * const d = (u32 * const)dst;
+
+        u32 rs[4], rd[4];
+
+        rs[0] = swab32(s[3]);
+        rs[1] = swab32(s[2]);
+        rs[2] = swab32(s[1]);
+        rs[3] = swab32(s[0]);
+
+        serpent_decrypt(tfm, (u8 *)rd, (u8 *)rs);
+
+        d[0] = swab32(rd[3]);
+        d[1] = swab32(rd[2]);
+        d[2] = swab32(rd[1]);
+        d[3] = swab32(rd[0]);
+}
+
+static struct crypto_alg tnepres_alg = {
+        .cra_name               =       "tnepres",
+        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
+        .cra_blocksize          =       SERPENT_BLOCK_SIZE,
+        .cra_ctxsize            =       sizeof(struct serpent_ctx),
+        .cra_alignmask          =       3,
+        .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(serpent_alg.cra_list),
+        .cra_u                  =       { .cipher = {
+        .cia_min_keysize        =       SERPENT_MIN_KEY_SIZE,
+        .cia_max_keysize        =       SERPENT_MAX_KEY_SIZE,
+        .cia_setkey             =       tnepres_setkey,
+        .cia_encrypt            =       tnepres_encrypt,
+        .cia_decrypt            =       tnepres_decrypt } }
+};
+
+static int __init serpent_mod_init(void)
+{
+        int ret = crypto_register_alg(&serpent_alg);
+
+        if (ret)
+                return ret;
+
+        ret = crypto_register_alg(&tnepres_alg);
+
+        if (ret)
+                crypto_unregister_alg(&serpent_alg);
+
+        return ret;
+}
+
+static void __exit serpent_mod_fini(void)
+{
+        crypto_unregister_alg(&tnepres_alg);
+        crypto_unregister_alg(&serpent_alg);
+}
+
+module_init(serpent_mod_init);
+module_exit(serpent_mod_fini);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Serpent and tnepres (kerneli compatible serpent reversed) Cipher Algorithm");
+MODULE_AUTHOR("Dag Arne Osvik <osvik@ii.uib.no>");
+MODULE_ALIAS("tnepres");