Merge branch 'kbuild' of git://git.kernel.org/pub/scm/linux/kernel/git/mmarek/kbuild
[linux-2.6.git] / crypto / tcrypt.c
index 577a3af..8f147bf 100644 (file)
  *
  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
  * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
+ * Copyright (c) 2007 Nokia Siemens Networks
+ *
+ * Updated RFC4106 AES-GCM testing.
+ *    Authors: Aidan O'Mahony (aidan.o.mahony@intel.com)
+ *             Adrian Hoban <adrian.hoban@intel.com>
+ *             Gabriele Paoloni <gabriele.paoloni@intel.com>
+ *             Tadeusz Struk (tadeusz.struk@intel.com)
+ *             Copyright (c) 2010, Intel 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.
  *
- * 2004-08-09 Added cipher speed tests (Reyk Floeter <reyk@vantronix.net>)
- * 2003-09-14 Rewritten by Kartikey Mahendra Bhatt
- *
  */
 
+#include <crypto/hash.h>
+#include <linux/err.h>
 #include <linux/init.h>
+#include <linux/gfp.h>
 #include <linux/module.h>
-#include <linux/mm.h>
-#include <linux/slab.h>
 #include <linux/scatterlist.h>
 #include <linux/string.h>
-#include <linux/crypto.h>
-#include <linux/highmem.h>
 #include <linux/moduleparam.h>
 #include <linux/jiffies.h>
 #include <linux/timex.h>
 #include <linux/interrupt.h>
 #include "tcrypt.h"
+#include "internal.h"
 
 /*
- * Need to kmalloc() memory for testing kmap().
- */
-#define TVMEMSIZE      16384
-#define XBUFSIZE       32768
-
-/*
- * Indexes into the xbuf to simulate cross-page access.
+ * Need slab memory for testing (size in number of pages).
  */
-#define IDX1           37
-#define IDX2           32400
-#define IDX3           1
-#define IDX4           8193
-#define IDX5           22222
-#define IDX6           17101
-#define IDX7           27333
-#define IDX8           3000
+#define TVMEMSIZE      4
 
 /*
-* Used by test_cipher()
+* Used by test_cipher_speed()
 */
 #define ENCRYPT 1
 #define DECRYPT 0
-#define MODE_ECB 1
-#define MODE_CBC 0
-
-static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
 
 /*
  * Used by test_cipher_speed()
  */
 static unsigned int sec;
 
+static char *alg = NULL;
+static u32 type;
+static u32 mask;
 static int mode;
-static char *xbuf;
-static char *tvmem;
+static char *tvmem[TVMEMSIZE];
 
 static char *check[] = {
-       "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish",
-       "twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6",
-       "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
-       "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", NULL
+       "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
+       "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
+       "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
+       "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta",  "fcrypt",
+       "camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320",
+       "lzo", "cts", "zlib", NULL
 };
 
-static void hexdump(unsigned char *buf, unsigned int len)
+static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc,
+                              struct scatterlist *sg, int blen, int sec)
 {
-       while (len--)
-               printk("%02x", *buf++);
+       unsigned long start, end;
+       int bcount;
+       int ret;
+
+       for (start = jiffies, end = start + sec * HZ, bcount = 0;
+            time_before(jiffies, end); bcount++) {
+               if (enc)
+                       ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
+               else
+                       ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
+
+               if (ret)
+                       return ret;
+       }
 
-       printk("\n");
+       printk("%d operations in %d seconds (%ld bytes)\n",
+              bcount, sec, (long)bcount * blen);
+       return 0;
 }
 
-static void test_hash(char *algo, struct hash_testvec *template,
-                     unsigned int tcount)
+static int test_cipher_cycles(struct blkcipher_desc *desc, int enc,
+                             struct scatterlist *sg, int blen)
 {
-       unsigned int i, j, k, temp;
-       struct scatterlist sg[8];
-       char result[64];
-       struct crypto_tfm *tfm;
-       struct hash_testvec *hash_tv;
-       unsigned int tsize;
+       unsigned long cycles = 0;
+       int ret = 0;
+       int i;
 
-       printk("\ntesting %s\n", algo);
+       local_bh_disable();
+       local_irq_disable();
 
-       tsize = sizeof(struct hash_testvec);
-       tsize *= tcount;
+       /* Warm-up run. */
+       for (i = 0; i < 4; i++) {
+               if (enc)
+                       ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
+               else
+                       ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
 
-       if (tsize > TVMEMSIZE) {
-               printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE);
-               return;
+               if (ret)
+                       goto out;
        }
 
-       memcpy(tvmem, template, tsize);
-       hash_tv = (void *)tvmem;
-       tfm = crypto_alloc_tfm(algo, 0);
-       if (tfm == NULL) {
-               printk("failed to load transform for %s\n", algo);
-               return;
-       }
+       /* The real thing. */
+       for (i = 0; i < 8; i++) {
+               cycles_t start, end;
 
-       for (i = 0; i < tcount; i++) {
-               printk("test %u:\n", i + 1);
-               memset(result, 0, 64);
+               start = get_cycles();
+               if (enc)
+                       ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
+               else
+                       ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
+               end = get_cycles();
 
-               sg_set_buf(&sg[0], hash_tv[i].plaintext, hash_tv[i].psize);
+               if (ret)
+                       goto out;
 
-               crypto_digest_init(tfm);
-               if (tfm->crt_u.digest.dit_setkey) {
-                       crypto_digest_setkey(tfm, hash_tv[i].key,
-                                            hash_tv[i].ksize);
-               }
-               crypto_digest_update(tfm, sg, 1);
-               crypto_digest_final(tfm, result);
-
-               hexdump(result, crypto_tfm_alg_digestsize(tfm));
-               printk("%s\n",
-                      memcmp(result, hash_tv[i].digest,
-                             crypto_tfm_alg_digestsize(tfm)) ?
-                      "fail" : "pass");
+               cycles += end - start;
        }
 
-       printk("testing %s across pages\n", algo);
-
-       /* setup the dummy buffer first */
-       memset(xbuf, 0, XBUFSIZE);
-
-       j = 0;
-       for (i = 0; i < tcount; i++) {
-               if (hash_tv[i].np) {
-                       j++;
-                       printk("test %u:\n", j);
-                       memset(result, 0, 64);
-
-                       temp = 0;
-                       for (k = 0; k < hash_tv[i].np; k++) {
-                               memcpy(&xbuf[IDX[k]],
-                                      hash_tv[i].plaintext + temp,
-                                      hash_tv[i].tap[k]);
-                               temp += hash_tv[i].tap[k];
-                               sg_set_buf(&sg[k], &xbuf[IDX[k]],
-                                           hash_tv[i].tap[k]);
-                       }
-
-                       crypto_digest_digest(tfm, sg, hash_tv[i].np, result);
+out:
+       local_irq_enable();
+       local_bh_enable();
 
-                       hexdump(result, crypto_tfm_alg_digestsize(tfm));
-                       printk("%s\n",
-                              memcmp(result, hash_tv[i].digest,
-                                     crypto_tfm_alg_digestsize(tfm)) ?
-                              "fail" : "pass");
-               }
-       }
+       if (ret == 0)
+               printk("1 operation in %lu cycles (%d bytes)\n",
+                      (cycles + 4) / 8, blen);
 
-       crypto_free_tfm(tfm);
+       return ret;
 }
 
+static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
 
-#ifdef CONFIG_CRYPTO_HMAC
-
-static void test_hmac(char *algo, struct hmac_testvec *template,
-                     unsigned int tcount)
+static void test_cipher_speed(const char *algo, int enc, unsigned int sec,
+                             struct cipher_speed_template *template,
+                             unsigned int tcount, u8 *keysize)
 {
-       unsigned int i, j, k, temp;
-       struct scatterlist sg[8];
-       char result[64];
-       struct crypto_tfm *tfm;
-       struct hmac_testvec *hmac_tv;
-       unsigned int tsize, klen;
-
-       tfm = crypto_alloc_tfm(algo, 0);
-       if (tfm == NULL) {
-               printk("failed to load transform for %s\n", algo);
+       unsigned int ret, i, j, iv_len;
+       const char *key;
+       char iv[128];
+       struct crypto_blkcipher *tfm;
+       struct blkcipher_desc desc;
+       const char *e;
+       u32 *b_size;
+
+       if (enc == ENCRYPT)
+               e = "encryption";
+       else
+               e = "decryption";
+
+       printk("\ntesting speed of %s %s\n", algo, e);
+
+       tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
+
+       if (IS_ERR(tfm)) {
+               printk("failed to load transform for %s: %ld\n", algo,
+                      PTR_ERR(tfm));
                return;
        }
+       desc.tfm = tfm;
+       desc.flags = 0;
 
-       printk("\ntesting hmac_%s\n", algo);
+       i = 0;
+       do {
 
-       tsize = sizeof(struct hmac_testvec);
-       tsize *= tcount;
-       if (tsize > TVMEMSIZE) {
-               printk("template (%u) too big for tvmem (%u)\n", tsize,
-                      TVMEMSIZE);
-               goto out;
-       }
+               b_size = block_sizes;
+               do {
+                       struct scatterlist sg[TVMEMSIZE];
 
-       memcpy(tvmem, template, tsize);
-       hmac_tv = (void *)tvmem;
+                       if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
+                               printk("template (%u) too big for "
+                                      "tvmem (%lu)\n", *keysize + *b_size,
+                                      TVMEMSIZE * PAGE_SIZE);
+                               goto out;
+                       }
 
-       for (i = 0; i < tcount; i++) {
-               printk("test %u:\n", i + 1);
-               memset(result, 0, sizeof (result));
+                       printk("test %u (%d bit key, %d byte blocks): ", i,
+                                       *keysize * 8, *b_size);
 
-               klen = hmac_tv[i].ksize;
-               sg_set_buf(&sg[0], hmac_tv[i].plaintext, hmac_tv[i].psize);
+                       memset(tvmem[0], 0xff, PAGE_SIZE);
 
-               crypto_hmac(tfm, hmac_tv[i].key, &klen, sg, 1, result);
+                       /* set key, plain text and IV */
+                       key = tvmem[0];
+                       for (j = 0; j < tcount; j++) {
+                               if (template[j].klen == *keysize) {
+                                       key = template[j].key;
+                                       break;
+                               }
+                       }
 
-               hexdump(result, crypto_tfm_alg_digestsize(tfm));
-               printk("%s\n",
-                      memcmp(result, hmac_tv[i].digest,
-                             crypto_tfm_alg_digestsize(tfm)) ? "fail" :
-                      "pass");
-       }
+                       ret = crypto_blkcipher_setkey(tfm, key, *keysize);
+                       if (ret) {
+                               printk("setkey() failed flags=%x\n",
+                                               crypto_blkcipher_get_flags(tfm));
+                               goto out;
+                       }
 
-       printk("\ntesting hmac_%s across pages\n", algo);
-
-       memset(xbuf, 0, XBUFSIZE);
-
-       j = 0;
-       for (i = 0; i < tcount; i++) {
-               if (hmac_tv[i].np) {
-                       j++;
-                       printk("test %u:\n",j);
-                       memset(result, 0, 64);
-
-                       temp = 0;
-                       klen = hmac_tv[i].ksize;
-                       for (k = 0; k < hmac_tv[i].np; k++) {
-                               memcpy(&xbuf[IDX[k]],
-                                      hmac_tv[i].plaintext + temp,
-                                      hmac_tv[i].tap[k]);
-                               temp += hmac_tv[i].tap[k];
-                               sg_set_buf(&sg[k], &xbuf[IDX[k]],
-                                           hmac_tv[i].tap[k]);
+                       sg_init_table(sg, TVMEMSIZE);
+                       sg_set_buf(sg, tvmem[0] + *keysize,
+                                  PAGE_SIZE - *keysize);
+                       for (j = 1; j < TVMEMSIZE; j++) {
+                               sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
+                               memset (tvmem[j], 0xff, PAGE_SIZE);
                        }
 
-                       crypto_hmac(tfm, hmac_tv[i].key, &klen, sg,
-                                   hmac_tv[i].np, result);
-                       hexdump(result, crypto_tfm_alg_digestsize(tfm));
+                       iv_len = crypto_blkcipher_ivsize(tfm);
+                       if (iv_len) {
+                               memset(&iv, 0xff, iv_len);
+                               crypto_blkcipher_set_iv(tfm, iv, iv_len);
+                       }
+
+                       if (sec)
+                               ret = test_cipher_jiffies(&desc, enc, sg,
+                                                         *b_size, sec);
+                       else
+                               ret = test_cipher_cycles(&desc, enc, sg,
+                                                        *b_size);
+
+                       if (ret) {
+                               printk("%s() failed flags=%x\n", e, desc.flags);
+                               break;
+                       }
+                       b_size++;
+                       i++;
+               } while (*b_size);
+               keysize++;
+       } while (*keysize);
 
-                       printk("%s\n",
-                              memcmp(result, hmac_tv[i].digest,
-                                     crypto_tfm_alg_digestsize(tfm)) ?
-                              "fail" : "pass");
-               }
-       }
 out:
-       crypto_free_tfm(tfm);
+       crypto_free_blkcipher(tfm);
 }
 
-#endif /* CONFIG_CRYPTO_HMAC */
-
-static void test_cipher(char *algo, int mode, int enc,
-                       struct cipher_testvec *template, unsigned int tcount)
+static int test_hash_jiffies_digest(struct hash_desc *desc,
+                                   struct scatterlist *sg, int blen,
+                                   char *out, int sec)
 {
-       unsigned int ret, i, j, k, temp;
-       unsigned int tsize;
-       char *q;
-       struct crypto_tfm *tfm;
-       char *key;
-       struct cipher_testvec *cipher_tv;
-       struct scatterlist sg[8];
-       const char *e, *m;
+       unsigned long start, end;
+       int bcount;
+       int ret;
 
-       if (enc == ENCRYPT)
-               e = "encryption";
-       else
-               e = "decryption";
-       if (mode == MODE_ECB)
-               m = "ECB";
-       else
-               m = "CBC";
+       for (start = jiffies, end = start + sec * HZ, bcount = 0;
+            time_before(jiffies, end); bcount++) {
+               ret = crypto_hash_digest(desc, sg, blen, out);
+               if (ret)
+                       return ret;
+       }
 
-       printk("\ntesting %s %s %s\n", algo, m, e);
+       printk("%6u opers/sec, %9lu bytes/sec\n",
+              bcount / sec, ((long)bcount * blen) / sec);
 
-       tsize = sizeof (struct cipher_testvec);
-       tsize *= tcount;
+       return 0;
+}
 
-       if (tsize > TVMEMSIZE) {
-               printk("template (%u) too big for tvmem (%u)\n", tsize,
-                      TVMEMSIZE);
-               return;
+static int test_hash_jiffies(struct hash_desc *desc, struct scatterlist *sg,
+                            int blen, int plen, char *out, int sec)
+{
+       unsigned long start, end;
+       int bcount, pcount;
+       int ret;
+
+       if (plen == blen)
+               return test_hash_jiffies_digest(desc, sg, blen, out, sec);
+
+       for (start = jiffies, end = start + sec * HZ, bcount = 0;
+            time_before(jiffies, end); bcount++) {
+               ret = crypto_hash_init(desc);
+               if (ret)
+                       return ret;
+               for (pcount = 0; pcount < blen; pcount += plen) {
+                       ret = crypto_hash_update(desc, sg, plen);
+                       if (ret)
+                               return ret;
+               }
+               /* we assume there is enough space in 'out' for the result */
+               ret = crypto_hash_final(desc, out);
+               if (ret)
+                       return ret;
        }
 
-       memcpy(tvmem, template, tsize);
-       cipher_tv = (void *)tvmem;
+       printk("%6u opers/sec, %9lu bytes/sec\n",
+              bcount / sec, ((long)bcount * blen) / sec);
 
-       if (mode)
-               tfm = crypto_alloc_tfm(algo, 0);
-       else
-               tfm = crypto_alloc_tfm(algo, CRYPTO_TFM_MODE_CBC);
+       return 0;
+}
 
-       if (tfm == NULL) {
-               printk("failed to load transform for %s %s\n", algo, m);
-               return;
+static int test_hash_cycles_digest(struct hash_desc *desc,
+                                  struct scatterlist *sg, int blen, char *out)
+{
+       unsigned long cycles = 0;
+       int i;
+       int ret;
+
+       local_bh_disable();
+       local_irq_disable();
+
+       /* Warm-up run. */
+       for (i = 0; i < 4; i++) {
+               ret = crypto_hash_digest(desc, sg, blen, out);
+               if (ret)
+                       goto out;
        }
 
-       j = 0;
-       for (i = 0; i < tcount; i++) {
-               if (!(cipher_tv[i].np)) {
-                       j++;
-                       printk("test %u (%d bit key):\n",
-                       j, cipher_tv[i].klen * 8);
+       /* The real thing. */
+       for (i = 0; i < 8; i++) {
+               cycles_t start, end;
 
-                       tfm->crt_flags = 0;
-                       if (cipher_tv[i].wk)
-                               tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
-                       key = cipher_tv[i].key;
+               start = get_cycles();
 
-                       ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
-                       if (ret) {
-                               printk("setkey() failed flags=%x\n", tfm->crt_flags);
+               ret = crypto_hash_digest(desc, sg, blen, out);
+               if (ret)
+                       goto out;
 
-                               if (!cipher_tv[i].fail)
-                                       goto out;
-                       }
+               end = get_cycles();
 
-                       sg_set_buf(&sg[0], cipher_tv[i].input,
-                                  cipher_tv[i].ilen);
+               cycles += end - start;
+       }
 
-                       if (!mode) {
-                               crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
-                                       crypto_tfm_alg_ivsize(tfm));
-                       }
+out:
+       local_irq_enable();
+       local_bh_enable();
 
-                       if (enc)
-                               ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
-                       else
-                               ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
+       if (ret)
+               return ret;
 
+       printk("%6lu cycles/operation, %4lu cycles/byte\n",
+              cycles / 8, cycles / (8 * blen));
 
-                       if (ret) {
-                               printk("%s () failed flags=%x\n", e, tfm->crt_flags);
+       return 0;
+}
+
+static int test_hash_cycles(struct hash_desc *desc, struct scatterlist *sg,
+                           int blen, int plen, char *out)
+{
+       unsigned long cycles = 0;
+       int i, pcount;
+       int ret;
+
+       if (plen == blen)
+               return test_hash_cycles_digest(desc, sg, blen, out);
+
+       local_bh_disable();
+       local_irq_disable();
+
+       /* Warm-up run. */
+       for (i = 0; i < 4; i++) {
+               ret = crypto_hash_init(desc);
+               if (ret)
+                       goto out;
+               for (pcount = 0; pcount < blen; pcount += plen) {
+                       ret = crypto_hash_update(desc, sg, plen);
+                       if (ret)
                                goto out;
-                       }
+               }
+               ret = crypto_hash_final(desc, out);
+               if (ret)
+                       goto out;
+       }
+
+       /* The real thing. */
+       for (i = 0; i < 8; i++) {
+               cycles_t start, end;
 
-                       q = kmap(sg[0].page) + sg[0].offset;
-                       hexdump(q, cipher_tv[i].rlen);
+               start = get_cycles();
 
-                       printk("%s\n",
-                              memcmp(q, cipher_tv[i].result,
-                                     cipher_tv[i].rlen) ? "fail" : "pass");
+               ret = crypto_hash_init(desc);
+               if (ret)
+                       goto out;
+               for (pcount = 0; pcount < blen; pcount += plen) {
+                       ret = crypto_hash_update(desc, sg, plen);
+                       if (ret)
+                               goto out;
                }
+               ret = crypto_hash_final(desc, out);
+               if (ret)
+                       goto out;
+
+               end = get_cycles();
+
+               cycles += end - start;
        }
 
-       printk("\ntesting %s %s %s across pages (chunking)\n", algo, m, e);
-       memset(xbuf, 0, XBUFSIZE);
+out:
+       local_irq_enable();
+       local_bh_enable();
 
-       j = 0;
-       for (i = 0; i < tcount; i++) {
-               if (cipher_tv[i].np) {
-                       j++;
-                       printk("test %u (%d bit key):\n",
-                       j, cipher_tv[i].klen * 8);
+       if (ret)
+               return ret;
 
-                       tfm->crt_flags = 0;
-                       if (cipher_tv[i].wk)
-                               tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
-                       key = cipher_tv[i].key;
+       printk("%6lu cycles/operation, %4lu cycles/byte\n",
+              cycles / 8, cycles / (8 * blen));
 
-                       ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
-                       if (ret) {
-                               printk("setkey() failed flags=%x\n", tfm->crt_flags);
+       return 0;
+}
 
-                               if (!cipher_tv[i].fail)
-                                       goto out;
-                       }
+static void test_hash_sg_init(struct scatterlist *sg)
+{
+       int i;
 
-                       temp = 0;
-                       for (k = 0; k < cipher_tv[i].np; k++) {
-                               memcpy(&xbuf[IDX[k]],
-                                      cipher_tv[i].input + temp,
-                                      cipher_tv[i].tap[k]);
-                               temp += cipher_tv[i].tap[k];
-                               sg_set_buf(&sg[k], &xbuf[IDX[k]],
-                                          cipher_tv[i].tap[k]);
-                       }
+       sg_init_table(sg, TVMEMSIZE);
+       for (i = 0; i < TVMEMSIZE; i++) {
+               sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
+               memset(tvmem[i], 0xff, PAGE_SIZE);
+       }
+}
 
-                       if (!mode) {
-                               crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
-                                               crypto_tfm_alg_ivsize(tfm));
-                       }
+static void test_hash_speed(const char *algo, unsigned int sec,
+                           struct hash_speed *speed)
+{
+       struct scatterlist sg[TVMEMSIZE];
+       struct crypto_hash *tfm;
+       struct hash_desc desc;
+       static char output[1024];
+       int i;
+       int ret;
 
-                       if (enc)
-                               ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
-                       else
-                               ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
+       printk(KERN_INFO "\ntesting speed of %s\n", algo);
 
-                       if (ret) {
-                               printk("%s () failed flags=%x\n", e, tfm->crt_flags);
-                               goto out;
-                       }
+       tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
 
-                       temp = 0;
-                       for (k = 0; k < cipher_tv[i].np; k++) {
-                               printk("page %u\n", k);
-                               q = kmap(sg[k].page) + sg[k].offset;
-                               hexdump(q, cipher_tv[i].tap[k]);
-                               printk("%s\n",
-                                       memcmp(q, cipher_tv[i].result + temp,
-                                               cipher_tv[i].tap[k]) ? "fail" :
-                                       "pass");
-                               temp += cipher_tv[i].tap[k];
-                       }
+       if (IS_ERR(tfm)) {
+               printk(KERN_ERR "failed to load transform for %s: %ld\n", algo,
+                      PTR_ERR(tfm));
+               return;
+       }
+
+       desc.tfm = tfm;
+       desc.flags = 0;
+
+       if (crypto_hash_digestsize(tfm) > sizeof(output)) {
+               printk(KERN_ERR "digestsize(%u) > outputbuffer(%zu)\n",
+                      crypto_hash_digestsize(tfm), sizeof(output));
+               goto out;
+       }
+
+       test_hash_sg_init(sg);
+       for (i = 0; speed[i].blen != 0; i++) {
+               if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
+                       printk(KERN_ERR
+                              "template (%u) too big for tvmem (%lu)\n",
+                              speed[i].blen, TVMEMSIZE * PAGE_SIZE);
+                       goto out;
+               }
+
+               if (speed[i].klen)
+                       crypto_hash_setkey(tfm, tvmem[0], speed[i].klen);
+
+               printk(KERN_INFO "test%3u "
+                      "(%5u byte blocks,%5u bytes per update,%4u updates): ",
+                      i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
+
+               if (sec)
+                       ret = test_hash_jiffies(&desc, sg, speed[i].blen,
+                                               speed[i].plen, output, sec);
+               else
+                       ret = test_hash_cycles(&desc, sg, speed[i].blen,
+                                              speed[i].plen, output);
+
+               if (ret) {
+                       printk(KERN_ERR "hashing failed ret=%d\n", ret);
+                       break;
                }
        }
 
 out:
-       crypto_free_tfm(tfm);
+       crypto_free_hash(tfm);
+}
+
+struct tcrypt_result {
+       struct completion completion;
+       int err;
+};
+
+static void tcrypt_complete(struct crypto_async_request *req, int err)
+{
+       struct tcrypt_result *res = req->data;
+
+       if (err == -EINPROGRESS)
+               return;
+
+       res->err = err;
+       complete(&res->completion);
 }
 
-static int test_cipher_jiffies(struct crypto_tfm *tfm, int enc, char *p,
-                              int blen, int sec)
+static inline int do_one_ahash_op(struct ahash_request *req, int ret)
+{
+       if (ret == -EINPROGRESS || ret == -EBUSY) {
+               struct tcrypt_result *tr = req->base.data;
+
+               ret = wait_for_completion_interruptible(&tr->completion);
+               if (!ret)
+                       ret = tr->err;
+               INIT_COMPLETION(tr->completion);
+       }
+       return ret;
+}
+
+static int test_ahash_jiffies_digest(struct ahash_request *req, int blen,
+                                    char *out, int sec)
 {
-       struct scatterlist sg[8];
        unsigned long start, end;
        int bcount;
        int ret;
 
-       sg_set_buf(&sg[0], p, blen);
-
        for (start = jiffies, end = start + sec * HZ, bcount = 0;
             time_before(jiffies, end); bcount++) {
-               if (enc)
-                       ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
-               else
-                       ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
-
+               ret = do_one_ahash_op(req, crypto_ahash_digest(req));
                if (ret)
                        return ret;
        }
 
-       printk("%d operations in %d seconds (%ld bytes)\n",
-              bcount, sec, (long)bcount * blen);
+       printk("%6u opers/sec, %9lu bytes/sec\n",
+              bcount / sec, ((long)bcount * blen) / sec);
+
        return 0;
 }
 
-static int test_cipher_cycles(struct crypto_tfm *tfm, int enc, char *p,
-                             int blen)
+static int test_ahash_jiffies(struct ahash_request *req, int blen,
+                             int plen, char *out, int sec)
 {
-       struct scatterlist sg[8];
-       unsigned long cycles = 0;
-       int ret = 0;
-       int i;
+       unsigned long start, end;
+       int bcount, pcount;
+       int ret;
 
-       sg_set_buf(&sg[0], p, blen);
+       if (plen == blen)
+               return test_ahash_jiffies_digest(req, blen, out, sec);
 
-       local_bh_disable();
-       local_irq_disable();
+       for (start = jiffies, end = start + sec * HZ, bcount = 0;
+            time_before(jiffies, end); bcount++) {
+               ret = crypto_ahash_init(req);
+               if (ret)
+                       return ret;
+               for (pcount = 0; pcount < blen; pcount += plen) {
+                       ret = do_one_ahash_op(req, crypto_ahash_update(req));
+                       if (ret)
+                               return ret;
+               }
+               /* we assume there is enough space in 'out' for the result */
+               ret = do_one_ahash_op(req, crypto_ahash_final(req));
+               if (ret)
+                       return ret;
+       }
+
+       pr_cont("%6u opers/sec, %9lu bytes/sec\n",
+               bcount / sec, ((long)bcount * blen) / sec);
+
+       return 0;
+}
+
+static int test_ahash_cycles_digest(struct ahash_request *req, int blen,
+                                   char *out)
+{
+       unsigned long cycles = 0;
+       int ret, i;
 
        /* Warm-up run. */
        for (i = 0; i < 4; i++) {
-               if (enc)
-                       ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
-               else
-                       ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
-
+               ret = do_one_ahash_op(req, crypto_ahash_digest(req));
                if (ret)
                        goto out;
        }
@@ -467,284 +574,350 @@ static int test_cipher_cycles(struct crypto_tfm *tfm, int enc, char *p,
                cycles_t start, end;
 
                start = get_cycles();
-               if (enc)
-                       ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
-               else
-                       ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
-               end = get_cycles();
 
+               ret = do_one_ahash_op(req, crypto_ahash_digest(req));
                if (ret)
                        goto out;
 
+               end = get_cycles();
+
                cycles += end - start;
        }
 
 out:
-       local_irq_enable();
-       local_bh_enable();
+       if (ret)
+               return ret;
 
-       if (ret == 0)
-               printk("1 operation in %lu cycles (%d bytes)\n",
-                      (cycles + 4) / 8, blen);
+       pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
+               cycles / 8, cycles / (8 * blen));
 
-       return ret;
+       return 0;
 }
 
-static void test_cipher_speed(char *algo, int mode, int enc, unsigned int sec,
-                             struct cipher_testvec *template,
-                             unsigned int tcount, struct cipher_speed *speed)
+static int test_ahash_cycles(struct ahash_request *req, int blen,
+                            int plen, char *out)
 {
-       unsigned int ret, i, j, iv_len;
-       unsigned char *key, *p, iv[128];
-       struct crypto_tfm *tfm;
-       const char *e, *m;
+       unsigned long cycles = 0;
+       int i, pcount, ret;
 
-       if (enc == ENCRYPT)
-               e = "encryption";
-       else
-               e = "decryption";
-       if (mode == MODE_ECB)
-               m = "ECB";
-       else
-               m = "CBC";
+       if (plen == blen)
+               return test_ahash_cycles_digest(req, blen, out);
 
-       printk("\ntesting speed of %s %s %s\n", algo, m, e);
+       /* Warm-up run. */
+       for (i = 0; i < 4; i++) {
+               ret = crypto_ahash_init(req);
+               if (ret)
+                       goto out;
+               for (pcount = 0; pcount < blen; pcount += plen) {
+                       ret = do_one_ahash_op(req, crypto_ahash_update(req));
+                       if (ret)
+                               goto out;
+               }
+               ret = do_one_ahash_op(req, crypto_ahash_final(req));
+               if (ret)
+                       goto out;
+       }
 
-       if (mode)
-               tfm = crypto_alloc_tfm(algo, 0);
-       else
-               tfm = crypto_alloc_tfm(algo, CRYPTO_TFM_MODE_CBC);
+       /* The real thing. */
+       for (i = 0; i < 8; i++) {
+               cycles_t start, end;
 
-       if (tfm == NULL) {
-               printk("failed to load transform for %s %s\n", algo, m);
-               return;
-       }
+               start = get_cycles();
 
-       for (i = 0; speed[i].klen != 0; i++) {
-               if ((speed[i].blen + speed[i].klen) > TVMEMSIZE) {
-                       printk("template (%u) too big for tvmem (%u)\n",
-                              speed[i].blen + speed[i].klen, TVMEMSIZE);
+               ret = crypto_ahash_init(req);
+               if (ret)
                        goto out;
+               for (pcount = 0; pcount < blen; pcount += plen) {
+                       ret = do_one_ahash_op(req, crypto_ahash_update(req));
+                       if (ret)
+                               goto out;
                }
+               ret = do_one_ahash_op(req, crypto_ahash_final(req));
+               if (ret)
+                       goto out;
+
+               end = get_cycles();
 
-               printk("test %u (%d bit key, %d byte blocks): ", i,
-                      speed[i].klen * 8, speed[i].blen);
+               cycles += end - start;
+       }
 
-               memset(tvmem, 0xff, speed[i].klen + speed[i].blen);
+out:
+       if (ret)
+               return ret;
 
-               /* set key, plain text and IV */
-               key = (unsigned char *)tvmem;
-               for (j = 0; j < tcount; j++) {
-                       if (template[j].klen == speed[i].klen) {
-                               key = template[j].key;
-                               break;
-                       }
-               }
-               p = (unsigned char *)tvmem + speed[i].klen;
+       pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
+               cycles / 8, cycles / (8 * blen));
 
-               ret = crypto_cipher_setkey(tfm, key, speed[i].klen);
-               if (ret) {
-                       printk("setkey() failed flags=%x\n", tfm->crt_flags);
-                       goto out;
-               }
+       return 0;
+}
+
+static void test_ahash_speed(const char *algo, unsigned int sec,
+                            struct hash_speed *speed)
+{
+       struct scatterlist sg[TVMEMSIZE];
+       struct tcrypt_result tresult;
+       struct ahash_request *req;
+       struct crypto_ahash *tfm;
+       static char output[1024];
+       int i, ret;
+
+       printk(KERN_INFO "\ntesting speed of async %s\n", algo);
+
+       tfm = crypto_alloc_ahash(algo, 0, 0);
+       if (IS_ERR(tfm)) {
+               pr_err("failed to load transform for %s: %ld\n",
+                      algo, PTR_ERR(tfm));
+               return;
+       }
+
+       if (crypto_ahash_digestsize(tfm) > sizeof(output)) {
+               pr_err("digestsize(%u) > outputbuffer(%zu)\n",
+                      crypto_ahash_digestsize(tfm), sizeof(output));
+               goto out;
+       }
+
+       test_hash_sg_init(sg);
+       req = ahash_request_alloc(tfm, GFP_KERNEL);
+       if (!req) {
+               pr_err("ahash request allocation failure\n");
+               goto out;
+       }
+
+       init_completion(&tresult.completion);
+       ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
+                                  tcrypt_complete, &tresult);
 
-               if (!mode) {
-                       iv_len = crypto_tfm_alg_ivsize(tfm);
-                       memset(&iv, 0xff, iv_len);
-                       crypto_cipher_set_iv(tfm, iv, iv_len);
+       for (i = 0; speed[i].blen != 0; i++) {
+               if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
+                       pr_err("template (%u) too big for tvmem (%lu)\n",
+                              speed[i].blen, TVMEMSIZE * PAGE_SIZE);
+                       break;
                }
 
+               pr_info("test%3u "
+                       "(%5u byte blocks,%5u bytes per update,%4u updates): ",
+                       i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
+
+               ahash_request_set_crypt(req, sg, output, speed[i].plen);
+
                if (sec)
-                       ret = test_cipher_jiffies(tfm, enc, p, speed[i].blen,
-                                                 sec);
+                       ret = test_ahash_jiffies(req, speed[i].blen,
+                                                speed[i].plen, output, sec);
                else
-                       ret = test_cipher_cycles(tfm, enc, p, speed[i].blen);
+                       ret = test_ahash_cycles(req, speed[i].blen,
+                                               speed[i].plen, output);
 
                if (ret) {
-                       printk("%s() failed flags=%x\n", e, tfm->crt_flags);
+                       pr_err("hashing failed ret=%d\n", ret);
                        break;
                }
        }
 
+       ahash_request_free(req);
+
 out:
-       crypto_free_tfm(tfm);
+       crypto_free_ahash(tfm);
 }
 
-static void test_deflate(void)
+static inline int do_one_acipher_op(struct ablkcipher_request *req, int ret)
 {
-       unsigned int i;
-       char result[COMP_BUF_SIZE];
-       struct crypto_tfm *tfm;
-       struct comp_testvec *tv;
-       unsigned int tsize;
-
-       printk("\ntesting deflate compression\n");
-
-       tsize = sizeof (deflate_comp_tv_template);
-       if (tsize > TVMEMSIZE) {
-               printk("template (%u) too big for tvmem (%u)\n", tsize,
-                      TVMEMSIZE);
-               return;
-       }
+       if (ret == -EINPROGRESS || ret == -EBUSY) {
+               struct tcrypt_result *tr = req->base.data;
 
-       memcpy(tvmem, deflate_comp_tv_template, tsize);
-       tv = (void *)tvmem;
-
-       tfm = crypto_alloc_tfm("deflate", 0);
-       if (tfm == NULL) {
-               printk("failed to load transform for deflate\n");
-               return;
+               ret = wait_for_completion_interruptible(&tr->completion);
+               if (!ret)
+                       ret = tr->err;
+               INIT_COMPLETION(tr->completion);
        }
 
-       for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) {
-               int ilen, ret, dlen = COMP_BUF_SIZE;
+       return ret;
+}
+
+static int test_acipher_jiffies(struct ablkcipher_request *req, int enc,
+                               int blen, int sec)
+{
+       unsigned long start, end;
+       int bcount;
+       int ret;
 
-               printk("test %u:\n", i + 1);
-               memset(result, 0, sizeof (result));
+       for (start = jiffies, end = start + sec * HZ, bcount = 0;
+            time_before(jiffies, end); bcount++) {
+               if (enc)
+                       ret = do_one_acipher_op(req,
+                                               crypto_ablkcipher_encrypt(req));
+               else
+                       ret = do_one_acipher_op(req,
+                                               crypto_ablkcipher_decrypt(req));
 
-               ilen = tv[i].inlen;
-               ret = crypto_comp_compress(tfm, tv[i].input,
-                                          ilen, result, &dlen);
-               if (ret) {
-                       printk("fail: ret=%d\n", ret);
-                       continue;
-               }
-               hexdump(result, dlen);
-               printk("%s (ratio %d:%d)\n",
-                      memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
-                      ilen, dlen);
+               if (ret)
+                       return ret;
        }
 
-       printk("\ntesting deflate decompression\n");
+       pr_cont("%d operations in %d seconds (%ld bytes)\n",
+               bcount, sec, (long)bcount * blen);
+       return 0;
+}
 
-       tsize = sizeof (deflate_decomp_tv_template);
-       if (tsize > TVMEMSIZE) {
-               printk("template (%u) too big for tvmem (%u)\n", tsize,
-                      TVMEMSIZE);
-               goto out;
+static int test_acipher_cycles(struct ablkcipher_request *req, int enc,
+                              int blen)
+{
+       unsigned long cycles = 0;
+       int ret = 0;
+       int i;
+
+       /* Warm-up run. */
+       for (i = 0; i < 4; i++) {
+               if (enc)
+                       ret = do_one_acipher_op(req,
+                                               crypto_ablkcipher_encrypt(req));
+               else
+                       ret = do_one_acipher_op(req,
+                                               crypto_ablkcipher_decrypt(req));
+
+               if (ret)
+                       goto out;
        }
 
-       memcpy(tvmem, deflate_decomp_tv_template, tsize);
-       tv = (void *)tvmem;
+       /* The real thing. */
+       for (i = 0; i < 8; i++) {
+               cycles_t start, end;
 
-       for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) {
-               int ilen, ret, dlen = COMP_BUF_SIZE;
+               start = get_cycles();
+               if (enc)
+                       ret = do_one_acipher_op(req,
+                                               crypto_ablkcipher_encrypt(req));
+               else
+                       ret = do_one_acipher_op(req,
+                                               crypto_ablkcipher_decrypt(req));
+               end = get_cycles();
 
-               printk("test %u:\n", i + 1);
-               memset(result, 0, sizeof (result));
+               if (ret)
+                       goto out;
 
-               ilen = tv[i].inlen;
-               ret = crypto_comp_decompress(tfm, tv[i].input,
-                                            ilen, result, &dlen);
-               if (ret) {
-                       printk("fail: ret=%d\n", ret);
-                       continue;
-               }
-               hexdump(result, dlen);
-               printk("%s (ratio %d:%d)\n",
-                      memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
-                      ilen, dlen);
+               cycles += end - start;
        }
+
 out:
-       crypto_free_tfm(tfm);
+       if (ret == 0)
+               pr_cont("1 operation in %lu cycles (%d bytes)\n",
+                       (cycles + 4) / 8, blen);
+
+       return ret;
 }
 
-static void test_crc32c(void)
+static void test_acipher_speed(const char *algo, int enc, unsigned int sec,
+                              struct cipher_speed_template *template,
+                              unsigned int tcount, u8 *keysize)
 {
-#define NUMVEC 6
-#define VECSIZE 40
-
-       int i, j, pass;
-       u32 crc;
-       u8 b, test_vec[NUMVEC][VECSIZE];
-       static u32 vec_results[NUMVEC] = {
-               0x0e2c157f, 0xe980ebf6, 0xde74bded,
-               0xd579c862, 0xba979ad0, 0x2b29d913
-       };
-       static u32 tot_vec_results = 0x24c5d375;
-
-       struct scatterlist sg[NUMVEC];
-       struct crypto_tfm *tfm;
-       char *fmtdata = "testing crc32c initialized to %08x: %s\n";
-#define SEEDTESTVAL 0xedcba987
-       u32 seed;
-
-       printk("\ntesting crc32c\n");
-
-       tfm = crypto_alloc_tfm("crc32c", 0);
-       if (tfm == NULL) {
-               printk("failed to load transform for crc32c\n");
-               return;
-       }
+       unsigned int ret, i, j, iv_len;
+       struct tcrypt_result tresult;
+       const char *key;
+       char iv[128];
+       struct ablkcipher_request *req;
+       struct crypto_ablkcipher *tfm;
+       const char *e;
+       u32 *b_size;
 
-       crypto_digest_init(tfm);
-       crypto_digest_final(tfm, (u8*)&crc);
-       printk(fmtdata, crc, (crc == 0) ? "pass" : "ERROR");
+       if (enc == ENCRYPT)
+               e = "encryption";
+       else
+               e = "decryption";
 
-       /*
-        * stuff test_vec with known values, simple incrementing
-        * byte values.
-        */
-       b = 0;
-       for (i = 0; i < NUMVEC; i++) {
-               for (j = 0; j < VECSIZE; j++)
-                       test_vec[i][j] = ++b;
-               sg_set_buf(&sg[i], test_vec[i], VECSIZE);
-       }
+       pr_info("\ntesting speed of async %s %s\n", algo, e);
 
-       seed = SEEDTESTVAL;
-       (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
-       crypto_digest_final(tfm, (u8*)&crc);
-       printk("testing crc32c setkey returns %08x : %s\n", crc, (crc == (SEEDTESTVAL ^ ~(u32)0)) ?
-              "pass" : "ERROR");
-
-       printk("testing crc32c using update/final:\n");
-
-       pass = 1;                   /* assume all is well */
-
-       for (i = 0; i < NUMVEC; i++) {
-               seed = ~(u32)0;
-               (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
-               crypto_digest_update(tfm, &sg[i], 1);
-               crypto_digest_final(tfm, (u8*)&crc);
-               if (crc == vec_results[i]) {
-                       printk(" %08x:OK", crc);
-               } else {
-                       printk(" %08x:BAD, wanted %08x\n", crc, vec_results[i]);
-                       pass = 0;
-               }
-       }
+       init_completion(&tresult.completion);
 
-       printk("\ntesting crc32c using incremental accumulator:\n");
-       crc = 0;
-       for (i = 0; i < NUMVEC; i++) {
-               seed = (crc ^ ~(u32)0);
-               (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
-               crypto_digest_update(tfm, &sg[i], 1);
-               crypto_digest_final(tfm, (u8*)&crc);
-       }
-       if (crc == tot_vec_results) {
-               printk(" %08x:OK", crc);
-       } else {
-               printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results);
-               pass = 0;
+       tfm = crypto_alloc_ablkcipher(algo, 0, 0);
+
+       if (IS_ERR(tfm)) {
+               pr_err("failed to load transform for %s: %ld\n", algo,
+                      PTR_ERR(tfm));
+               return;
        }
 
-       printk("\ntesting crc32c using digest:\n");
-       seed = ~(u32)0;
-       (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
-       crypto_digest_digest(tfm, sg, NUMVEC, (u8*)&crc);
-       if (crc == tot_vec_results) {
-               printk(" %08x:OK", crc);
-       } else {
-               printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results);
-               pass = 0;
+       req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
+       if (!req) {
+               pr_err("tcrypt: skcipher: Failed to allocate request for %s\n",
+                      algo);
+               goto out;
        }
 
-       printk("\n%s\n", pass ? "pass" : "ERROR");
+       ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
+                                       tcrypt_complete, &tresult);
+
+       i = 0;
+       do {
+               b_size = block_sizes;
+
+               do {
+                       struct scatterlist sg[TVMEMSIZE];
+
+                       if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
+                               pr_err("template (%u) too big for "
+                                      "tvmem (%lu)\n", *keysize + *b_size,
+                                      TVMEMSIZE * PAGE_SIZE);
+                               goto out_free_req;
+                       }
+
+                       pr_info("test %u (%d bit key, %d byte blocks): ", i,
+                               *keysize * 8, *b_size);
+
+                       memset(tvmem[0], 0xff, PAGE_SIZE);
+
+                       /* set key, plain text and IV */
+                       key = tvmem[0];
+                       for (j = 0; j < tcount; j++) {
+                               if (template[j].klen == *keysize) {
+                                       key = template[j].key;
+                                       break;
+                               }
+                       }
+
+                       crypto_ablkcipher_clear_flags(tfm, ~0);
+
+                       ret = crypto_ablkcipher_setkey(tfm, key, *keysize);
+                       if (ret) {
+                               pr_err("setkey() failed flags=%x\n",
+                                       crypto_ablkcipher_get_flags(tfm));
+                               goto out_free_req;
+                       }
+
+                       sg_init_table(sg, TVMEMSIZE);
+                       sg_set_buf(sg, tvmem[0] + *keysize,
+                                  PAGE_SIZE - *keysize);
+                       for (j = 1; j < TVMEMSIZE; j++) {
+                               sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
+                               memset(tvmem[j], 0xff, PAGE_SIZE);
+                       }
+
+                       iv_len = crypto_ablkcipher_ivsize(tfm);
+                       if (iv_len)
+                               memset(&iv, 0xff, iv_len);
 
-       crypto_free_tfm(tfm);
-       printk("crc32c test complete\n");
+                       ablkcipher_request_set_crypt(req, sg, sg, *b_size, iv);
+
+                       if (sec)
+                               ret = test_acipher_jiffies(req, enc,
+                                                          *b_size, sec);
+                       else
+                               ret = test_acipher_cycles(req, enc,
+                                                         *b_size);
+
+                       if (ret) {
+                               pr_err("%s() failed flags=%x\n", e,
+                                       crypto_ablkcipher_get_flags(tfm));
+                               break;
+                       }
+                       b_size++;
+                       i++;
+               } while (*b_size);
+               keysize++;
+       } while (*keysize);
+
+out_free_req:
+       ablkcipher_request_free(req);
+out:
+       crypto_free_ablkcipher(tfm);
 }
 
 static void test_available(void)
@@ -753,374 +926,707 @@ static void test_available(void)
 
        while (*name) {
                printk("alg %s ", *name);
-               printk((crypto_alg_available(*name, 0)) ?
-                       "found\n" : "not found\n");
+               printk(crypto_has_alg(*name, 0, 0) ?
+                      "found\n" : "not found\n");
                name++;
        }
 }
 
-static void do_test(void)
+static inline int tcrypt_test(const char *alg)
+{
+       int ret;
+
+       ret = alg_test(alg, alg, 0, 0);
+       /* non-fips algs return -EINVAL in fips mode */
+       if (fips_enabled && ret == -EINVAL)
+               ret = 0;
+       return ret;
+}
+
+static int do_test(int m)
 {
-       switch (mode) {
+       int i;
+       int ret = 0;
 
+       switch (m) {
        case 0:
-               test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
-
-               test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
-
-               //DES
-               test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS);
-               test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
-               test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
-               test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
-
-               //DES3_EDE
-               test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
-               test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
-
-               test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
-
-               test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
-
-               //BLOWFISH
-               test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
-               test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
-               test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS);
-               test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS);
-
-               //TWOFISH
-               test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS);
-               test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS);
-               test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
-               test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
-
-               //SERPENT
-               test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
-               test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
-
-               //TNEPRES
-               test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS);
-               test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS);
-
-               //AES
-               test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS);
-               test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);
-
-               //CAST5
-               test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS);
-               test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS);
-
-               //CAST6
-               test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS);
-               test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS);
-
-               //ARC4
-               test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS);
-               test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS);
-
-               //TEA
-               test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS);
-               test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS);
-
-
-               //XTEA
-               test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS);
-               test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS);
-
-               //KHAZAD
-               test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS);
-               test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS);
-
-               //ANUBIS
-               test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS);
-               test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS);
-               test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
-               test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
-
-               //XETA
-               test_cipher ("xeta", MODE_ECB, ENCRYPT, xeta_enc_tv_template, XETA_ENC_TEST_VECTORS);
-               test_cipher ("xeta", MODE_ECB, DECRYPT, xeta_dec_tv_template, XETA_DEC_TEST_VECTORS);
-
-               test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
-               test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
-               test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
-               test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
-               test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
-               test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
-               test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
-               test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
-               test_deflate();
-               test_crc32c();
-#ifdef CONFIG_CRYPTO_HMAC
-               test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
-               test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
-               test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
-#endif
-
-               test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
+               for (i = 1; i < 200; i++)
+                       ret += do_test(i);
                break;
 
        case 1:
-               test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
+               ret += tcrypt_test("md5");
                break;
 
        case 2:
-               test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
+               ret += tcrypt_test("sha1");
                break;
 
        case 3:
-               test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS);
-               test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
-               test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
-               test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
+               ret += tcrypt_test("ecb(des)");
+               ret += tcrypt_test("cbc(des)");
                break;
 
        case 4:
-               test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
-               test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
+               ret += tcrypt_test("ecb(des3_ede)");
+               ret += tcrypt_test("cbc(des3_ede)");
                break;
 
        case 5:
-               test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
+               ret += tcrypt_test("md4");
                break;
 
        case 6:
-               test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
+               ret += tcrypt_test("sha256");
                break;
 
        case 7:
-               test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
-               test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
-               test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS);
-               test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS);
+               ret += tcrypt_test("ecb(blowfish)");
+               ret += tcrypt_test("cbc(blowfish)");
+               ret += tcrypt_test("ctr(blowfish)");
                break;
 
        case 8:
-               test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS);
-               test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS);
-               test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
-               test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
+               ret += tcrypt_test("ecb(twofish)");
+               ret += tcrypt_test("cbc(twofish)");
+               ret += tcrypt_test("ctr(twofish)");
+               ret += tcrypt_test("lrw(twofish)");
+               ret += tcrypt_test("xts(twofish)");
                break;
 
        case 9:
-               test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
-               test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
+               ret += tcrypt_test("ecb(serpent)");
+               ret += tcrypt_test("cbc(serpent)");
+               ret += tcrypt_test("ctr(serpent)");
+               ret += tcrypt_test("lrw(serpent)");
+               ret += tcrypt_test("xts(serpent)");
                break;
 
        case 10:
-               test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS);
-               test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);
+               ret += tcrypt_test("ecb(aes)");
+               ret += tcrypt_test("cbc(aes)");
+               ret += tcrypt_test("lrw(aes)");
+               ret += tcrypt_test("xts(aes)");
+               ret += tcrypt_test("ctr(aes)");
+               ret += tcrypt_test("rfc3686(ctr(aes))");
                break;
 
        case 11:
-               test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
+               ret += tcrypt_test("sha384");
                break;
 
        case 12:
-               test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
+               ret += tcrypt_test("sha512");
                break;
 
        case 13:
-               test_deflate();
+               ret += tcrypt_test("deflate");
                break;
 
        case 14:
-               test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS);
-               test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS);
+               ret += tcrypt_test("ecb(cast5)");
                break;
 
        case 15:
-               test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS);
-               test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS);
+               ret += tcrypt_test("ecb(cast6)");
                break;
 
        case 16:
-               test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS);
-               test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS);
+               ret += tcrypt_test("ecb(arc4)");
                break;
 
        case 17:
-               test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
+               ret += tcrypt_test("michael_mic");
                break;
 
        case 18:
-               test_crc32c();
+               ret += tcrypt_test("crc32c");
                break;
 
        case 19:
-               test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS);
-               test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS);
+               ret += tcrypt_test("ecb(tea)");
                break;
 
        case 20:
-               test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS);
-               test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS);
+               ret += tcrypt_test("ecb(xtea)");
                break;
 
        case 21:
-               test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS);
-               test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS);
+               ret += tcrypt_test("ecb(khazad)");
                break;
 
        case 22:
-               test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
+               ret += tcrypt_test("wp512");
                break;
 
        case 23:
-               test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
+               ret += tcrypt_test("wp384");
                break;
 
        case 24:
-               test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
+               ret += tcrypt_test("wp256");
                break;
 
        case 25:
-               test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS);
-               test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS);
+               ret += tcrypt_test("ecb(tnepres)");
                break;
 
        case 26:
-               test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS);
-               test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS);
-               test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
-               test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
+               ret += tcrypt_test("ecb(anubis)");
+               ret += tcrypt_test("cbc(anubis)");
                break;
 
        case 27:
-               test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
+               ret += tcrypt_test("tgr192");
                break;
 
        case 28:
 
-               test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
+               ret += tcrypt_test("tgr160");
                break;
 
        case 29:
-               test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
+               ret += tcrypt_test("tgr128");
                break;
-               
+
        case 30:
-               test_cipher ("xeta", MODE_ECB, ENCRYPT, xeta_enc_tv_template, XETA_ENC_TEST_VECTORS);
-               test_cipher ("xeta", MODE_ECB, DECRYPT, xeta_dec_tv_template, XETA_DEC_TEST_VECTORS);
+               ret += tcrypt_test("ecb(xeta)");
+               break;
+
+       case 31:
+               ret += tcrypt_test("pcbc(fcrypt)");
+               break;
+
+       case 32:
+               ret += tcrypt_test("ecb(camellia)");
+               ret += tcrypt_test("cbc(camellia)");
+               break;
+       case 33:
+               ret += tcrypt_test("sha224");
+               break;
+
+       case 34:
+               ret += tcrypt_test("salsa20");
+               break;
+
+       case 35:
+               ret += tcrypt_test("gcm(aes)");
+               break;
+
+       case 36:
+               ret += tcrypt_test("lzo");
+               break;
+
+       case 37:
+               ret += tcrypt_test("ccm(aes)");
+               break;
+
+       case 38:
+               ret += tcrypt_test("cts(cbc(aes))");
+               break;
+
+        case 39:
+               ret += tcrypt_test("rmd128");
+               break;
+
+        case 40:
+               ret += tcrypt_test("rmd160");
+               break;
+
+       case 41:
+               ret += tcrypt_test("rmd256");
+               break;
+
+       case 42:
+               ret += tcrypt_test("rmd320");
+               break;
+
+       case 43:
+               ret += tcrypt_test("ecb(seed)");
+               break;
+
+       case 44:
+               ret += tcrypt_test("zlib");
+               break;
+
+       case 45:
+               ret += tcrypt_test("rfc4309(ccm(aes))");
                break;
 
-#ifdef CONFIG_CRYPTO_HMAC
        case 100:
-               test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
+               ret += tcrypt_test("hmac(md5)");
                break;
 
        case 101:
-               test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
+               ret += tcrypt_test("hmac(sha1)");
                break;
 
        case 102:
-               test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
+               ret += tcrypt_test("hmac(sha256)");
+               break;
+
+       case 103:
+               ret += tcrypt_test("hmac(sha384)");
+               break;
+
+       case 104:
+               ret += tcrypt_test("hmac(sha512)");
                break;
 
-#endif
+       case 105:
+               ret += tcrypt_test("hmac(sha224)");
+               break;
+
+       case 106:
+               ret += tcrypt_test("xcbc(aes)");
+               break;
+
+       case 107:
+               ret += tcrypt_test("hmac(rmd128)");
+               break;
+
+       case 108:
+               ret += tcrypt_test("hmac(rmd160)");
+               break;
+
+       case 109:
+               ret += tcrypt_test("vmac(aes)");
+               break;
+
+       case 150:
+               ret += tcrypt_test("ansi_cprng");
+               break;
+
+       case 151:
+               ret += tcrypt_test("rfc4106(gcm(aes))");
+               break;
 
        case 200:
-               test_cipher_speed("aes", MODE_ECB, ENCRYPT, sec, NULL, 0,
-                                 aes_speed_template);
-               test_cipher_speed("aes", MODE_ECB, DECRYPT, sec, NULL, 0,
-                                 aes_speed_template);
-               test_cipher_speed("aes", MODE_CBC, ENCRYPT, sec, NULL, 0,
-                                 aes_speed_template);
-               test_cipher_speed("aes", MODE_CBC, DECRYPT, sec, NULL, 0,
-                                 aes_speed_template);
+               test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
+               test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
+               test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
+               test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
+               test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
+                               speed_template_32_40_48);
+               test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
+                               speed_template_32_40_48);
+               test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
+                               speed_template_32_48_64);
+               test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
+                               speed_template_32_48_64);
+               test_cipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
+               test_cipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
                break;
 
        case 201:
-               test_cipher_speed("des3_ede", MODE_ECB, ENCRYPT, sec,
-                                 des3_ede_enc_tv_template,
-                                 DES3_EDE_ENC_TEST_VECTORS,
-                                 des3_ede_speed_template);
-               test_cipher_speed("des3_ede", MODE_ECB, DECRYPT, sec,
-                                 des3_ede_dec_tv_template,
-                                 DES3_EDE_DEC_TEST_VECTORS,
-                                 des3_ede_speed_template);
-               test_cipher_speed("des3_ede", MODE_CBC, ENCRYPT, sec,
-                                 des3_ede_enc_tv_template,
-                                 DES3_EDE_ENC_TEST_VECTORS,
-                                 des3_ede_speed_template);
-               test_cipher_speed("des3_ede", MODE_CBC, DECRYPT, sec,
-                                 des3_ede_dec_tv_template,
-                                 DES3_EDE_DEC_TEST_VECTORS,
-                                 des3_ede_speed_template);
+               test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
+                               des3_speed_template, DES3_SPEED_VECTORS,
+                               speed_template_24);
+               test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
+                               des3_speed_template, DES3_SPEED_VECTORS,
+                               speed_template_24);
+               test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
+                               des3_speed_template, DES3_SPEED_VECTORS,
+                               speed_template_24);
+               test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
+                               des3_speed_template, DES3_SPEED_VECTORS,
+                               speed_template_24);
                break;
 
        case 202:
-               test_cipher_speed("twofish", MODE_ECB, ENCRYPT, sec, NULL, 0,
-                                 twofish_speed_template);
-               test_cipher_speed("twofish", MODE_ECB, DECRYPT, sec, NULL, 0,
-                                 twofish_speed_template);
-               test_cipher_speed("twofish", MODE_CBC, ENCRYPT, sec, NULL, 0,
-                                 twofish_speed_template);
-               test_cipher_speed("twofish", MODE_CBC, DECRYPT, sec, NULL, 0,
-                                 twofish_speed_template);
+               test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
+               test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
+               test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
+               test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
+               test_cipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
+               test_cipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
+               test_cipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
+                               speed_template_32_40_48);
+               test_cipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
+                               speed_template_32_40_48);
+               test_cipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
+                               speed_template_32_48_64);
+               test_cipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
+                               speed_template_32_48_64);
                break;
 
        case 203:
-               test_cipher_speed("blowfish", MODE_ECB, ENCRYPT, sec, NULL, 0,
-                                 blowfish_speed_template);
-               test_cipher_speed("blowfish", MODE_ECB, DECRYPT, sec, NULL, 0,
-                                 blowfish_speed_template);
-               test_cipher_speed("blowfish", MODE_CBC, ENCRYPT, sec, NULL, 0,
-                                 blowfish_speed_template);
-               test_cipher_speed("blowfish", MODE_CBC, DECRYPT, sec, NULL, 0,
-                                 blowfish_speed_template);
+               test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_8_32);
+               test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
+                                 speed_template_8_32);
+               test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_8_32);
+               test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
+                                 speed_template_8_32);
+               test_cipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_8_32);
+               test_cipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
+                                 speed_template_8_32);
                break;
 
        case 204:
-               test_cipher_speed("des", MODE_ECB, ENCRYPT, sec, NULL, 0,
-                                 des_speed_template);
-               test_cipher_speed("des", MODE_ECB, DECRYPT, sec, NULL, 0,
-                                 des_speed_template);
-               test_cipher_speed("des", MODE_CBC, ENCRYPT, sec, NULL, 0,
-                                 des_speed_template);
-               test_cipher_speed("des", MODE_CBC, DECRYPT, sec, NULL, 0,
-                                 des_speed_template);
+               test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_8);
+               test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
+                                 speed_template_8);
+               test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_8);
+               test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
+                                 speed_template_8);
                break;
 
-       case 1000:
-               test_available();
+       case 205:
+               test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
+               test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
+               test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
+               test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
+               test_cipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
+               test_cipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
+               test_cipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
+                               speed_template_32_40_48);
+               test_cipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
+                               speed_template_32_40_48);
+               test_cipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
+                               speed_template_32_48_64);
+               test_cipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
+                               speed_template_32_48_64);
+               break;
+
+       case 206:
+               test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
+                                 speed_template_16_32);
+               break;
+
+       case 207:
+               test_cipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_16_32);
+               test_cipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
+                                 speed_template_16_32);
+               test_cipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_16_32);
+               test_cipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
+                                 speed_template_16_32);
+               test_cipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_16_32);
+               test_cipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
+                                 speed_template_16_32);
+               test_cipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_32_48);
+               test_cipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
+                                 speed_template_32_48);
+               test_cipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_32_64);
+               test_cipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
+                                 speed_template_32_64);
+               break;
+
+       case 300:
+               /* fall through */
+
+       case 301:
+               test_hash_speed("md4", sec, generic_hash_speed_template);
+               if (mode > 300 && mode < 400) break;
+
+       case 302:
+               test_hash_speed("md5", sec, generic_hash_speed_template);
+               if (mode > 300 && mode < 400) break;
+
+       case 303:
+               test_hash_speed("sha1", sec, generic_hash_speed_template);
+               if (mode > 300 && mode < 400) break;
+
+       case 304:
+               test_hash_speed("sha256", sec, generic_hash_speed_template);
+               if (mode > 300 && mode < 400) break;
+
+       case 305:
+               test_hash_speed("sha384", sec, generic_hash_speed_template);
+               if (mode > 300 && mode < 400) break;
+
+       case 306:
+               test_hash_speed("sha512", sec, generic_hash_speed_template);
+               if (mode > 300 && mode < 400) break;
+
+       case 307:
+               test_hash_speed("wp256", sec, generic_hash_speed_template);
+               if (mode > 300 && mode < 400) break;
+
+       case 308:
+               test_hash_speed("wp384", sec, generic_hash_speed_template);
+               if (mode > 300 && mode < 400) break;
+
+       case 309:
+               test_hash_speed("wp512", sec, generic_hash_speed_template);
+               if (mode > 300 && mode < 400) break;
+
+       case 310:
+               test_hash_speed("tgr128", sec, generic_hash_speed_template);
+               if (mode > 300 && mode < 400) break;
+
+       case 311:
+               test_hash_speed("tgr160", sec, generic_hash_speed_template);
+               if (mode > 300 && mode < 400) break;
+
+       case 312:
+               test_hash_speed("tgr192", sec, generic_hash_speed_template);
+               if (mode > 300 && mode < 400) break;
+
+       case 313:
+               test_hash_speed("sha224", sec, generic_hash_speed_template);
+               if (mode > 300 && mode < 400) break;
+
+       case 314:
+               test_hash_speed("rmd128", sec, generic_hash_speed_template);
+               if (mode > 300 && mode < 400) break;
+
+       case 315:
+               test_hash_speed("rmd160", sec, generic_hash_speed_template);
+               if (mode > 300 && mode < 400) break;
+
+       case 316:
+               test_hash_speed("rmd256", sec, generic_hash_speed_template);
+               if (mode > 300 && mode < 400) break;
+
+       case 317:
+               test_hash_speed("rmd320", sec, generic_hash_speed_template);
+               if (mode > 300 && mode < 400) break;
+
+       case 318:
+               test_hash_speed("ghash-generic", sec, hash_speed_template_16);
+               if (mode > 300 && mode < 400) break;
+
+       case 399:
+               break;
+
+       case 400:
+               /* fall through */
+
+       case 401:
+               test_ahash_speed("md4", sec, generic_hash_speed_template);
+               if (mode > 400 && mode < 500) break;
+
+       case 402:
+               test_ahash_speed("md5", sec, generic_hash_speed_template);
+               if (mode > 400 && mode < 500) break;
+
+       case 403:
+               test_ahash_speed("sha1", sec, generic_hash_speed_template);
+               if (mode > 400 && mode < 500) break;
+
+       case 404:
+               test_ahash_speed("sha256", sec, generic_hash_speed_template);
+               if (mode > 400 && mode < 500) break;
+
+       case 405:
+               test_ahash_speed("sha384", sec, generic_hash_speed_template);
+               if (mode > 400 && mode < 500) break;
+
+       case 406:
+               test_ahash_speed("sha512", sec, generic_hash_speed_template);
+               if (mode > 400 && mode < 500) break;
+
+       case 407:
+               test_ahash_speed("wp256", sec, generic_hash_speed_template);
+               if (mode > 400 && mode < 500) break;
+
+       case 408:
+               test_ahash_speed("wp384", sec, generic_hash_speed_template);
+               if (mode > 400 && mode < 500) break;
+
+       case 409:
+               test_ahash_speed("wp512", sec, generic_hash_speed_template);
+               if (mode > 400 && mode < 500) break;
+
+       case 410:
+               test_ahash_speed("tgr128", sec, generic_hash_speed_template);
+               if (mode > 400 && mode < 500) break;
+
+       case 411:
+               test_ahash_speed("tgr160", sec, generic_hash_speed_template);
+               if (mode > 400 && mode < 500) break;
+
+       case 412:
+               test_ahash_speed("tgr192", sec, generic_hash_speed_template);
+               if (mode > 400 && mode < 500) break;
+
+       case 413:
+               test_ahash_speed("sha224", sec, generic_hash_speed_template);
+               if (mode > 400 && mode < 500) break;
+
+       case 414:
+               test_ahash_speed("rmd128", sec, generic_hash_speed_template);
+               if (mode > 400 && mode < 500) break;
+
+       case 415:
+               test_ahash_speed("rmd160", sec, generic_hash_speed_template);
+               if (mode > 400 && mode < 500) break;
+
+       case 416:
+               test_ahash_speed("rmd256", sec, generic_hash_speed_template);
+               if (mode > 400 && mode < 500) break;
+
+       case 417:
+               test_ahash_speed("rmd320", sec, generic_hash_speed_template);
+               if (mode > 400 && mode < 500) break;
+
+       case 499:
+               break;
+
+       case 500:
+               test_acipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_32_40_48);
+               test_acipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
+                                  speed_template_32_40_48);
+               test_acipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_32_48_64);
+               test_acipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
+                                  speed_template_32_48_64);
+               test_acipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               break;
+
+       case 501:
+               test_acipher_speed("ecb(des3_ede)", ENCRYPT, sec,
+                                  des3_speed_template, DES3_SPEED_VECTORS,
+                                  speed_template_24);
+               test_acipher_speed("ecb(des3_ede)", DECRYPT, sec,
+                                  des3_speed_template, DES3_SPEED_VECTORS,
+                                  speed_template_24);
+               test_acipher_speed("cbc(des3_ede)", ENCRYPT, sec,
+                                  des3_speed_template, DES3_SPEED_VECTORS,
+                                  speed_template_24);
+               test_acipher_speed("cbc(des3_ede)", DECRYPT, sec,
+                                  des3_speed_template, DES3_SPEED_VECTORS,
+                                  speed_template_24);
+               break;
+
+       case 502:
+               test_acipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_8);
+               test_acipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
+                                  speed_template_8);
+               test_acipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_8);
+               test_acipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
+                                  speed_template_8);
+               break;
+
+       case 503:
+               test_acipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_32);
+               test_acipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_32);
+               test_acipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_32);
+               test_acipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_32);
+               test_acipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_32);
+               test_acipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_32);
+               test_acipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_32_48);
+               test_acipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
+                                  speed_template_32_48);
+               test_acipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_32_64);
+               test_acipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
+                                  speed_template_32_64);
                break;
 
-       default:
-               /* useful for debugging */
-               printk("not testing anything\n");
+       case 1000:
+               test_available();
                break;
        }
+
+       return ret;
 }
 
-static int __init init(void)
+static int do_alg_test(const char *alg, u32 type, u32 mask)
 {
-       tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
-       if (tvmem == NULL)
-               return -ENOMEM;
-
-       xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
-       if (xbuf == NULL) {
-               kfree(tvmem);
-               return -ENOMEM;
+       return crypto_has_alg(alg, type, mask ?: CRYPTO_ALG_TYPE_MASK) ?
+              0 : -ENOENT;
+}
+
+static int __init tcrypt_mod_init(void)
+{
+       int err = -ENOMEM;
+       int i;
+
+       for (i = 0; i < TVMEMSIZE; i++) {
+               tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
+               if (!tvmem[i])
+                       goto err_free_tv;
        }
 
-       do_test();
+       if (alg)
+               err = do_alg_test(alg, type, mask);
+       else
+               err = do_test(mode);
 
-       kfree(xbuf);
-       kfree(tvmem);
-       return 0;
+       if (err) {
+               printk(KERN_ERR "tcrypt: one or more tests failed!\n");
+               goto err_free_tv;
+       }
+
+       /* We intentionaly return -EAGAIN to prevent keeping the module,
+        * unless we're running in fips mode. It does all its work from
+        * init() and doesn't offer any runtime functionality, but in
+        * the fips case, checking for a successful load is helpful.
+        * => we don't need it in the memory, do we?
+        *                                        -- mludvig
+        */
+       if (!fips_enabled)
+               err = -EAGAIN;
+
+err_free_tv:
+       for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
+               free_page((unsigned long)tvmem[i]);
+
+       return err;
 }
 
 /*
  * If an init function is provided, an exit function must also be provided
  * to allow module unload.
  */
-static void __exit fini(void) { }
+static void __exit tcrypt_mod_fini(void) { }
 
-module_init(init);
-module_exit(fini);
+module_init(tcrypt_mod_init);
+module_exit(tcrypt_mod_fini);
 
+module_param(alg, charp, 0);
+module_param(type, uint, 0);
+module_param(mask, uint, 0);
 module_param(mode, int, 0);
 module_param(sec, uint, 0);
 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "