Merge git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6: (46 commits)
  random: simplify fips mode
  crypto: authenc - Fix cryptlen calculation
  crypto: talitos - add support for sha224
  crypto: talitos - add hash algorithms
  crypto: talitos - second prepare step for adding ahash algorithms
  crypto: talitos - prepare for adding ahash algorithms
  crypto: n2 - Add Niagara2 crypto driver
  crypto: skcipher - Add ablkcipher_walk interfaces
  crypto: testmgr - Add testing for async hashing and update/final
  crypto: tcrypt - Add speed tests for async hashing
  crypto: scatterwalk - Fix scatterwalk_done() test
  crypto: hifn_795x - Rename ablkcipher_walk to hifn_cipher_walk
  padata: Use get_online_cpus/put_online_cpus in padata_free
  padata: Add some code comments
  padata: Flush the padata queues actively
  padata: Use a timer to handle remaining objects in the reorder queues
  crypto: shash - Remove usage of CRYPTO_MINALIGN
  crypto: mv_cesa - Use resource_size
  crypto: omap - OMAP macros corrected
  padata: Use get_online_cpus/put_online_cpus
  ...

Fix up conflicts in arch/arm/mach-omap2/devices.c

1 files changed, 48 insertions, 18 deletions

diff --git a/crypto/testmgr.c b/crypto/testmgr.c
index c494d7610be1..5c8aaa0cb0b9 100644
--- a/crypto/testmgr.c
+++ b/crypto/testmgr.c
@@ -153,8 +153,21 @@ static void testmgr_free_buf(char *buf[XBUFSIZE])
                 free_page((unsigned long)buf[i]);
 }
 
+static int do_one_async_hash_op(struct ahash_request *req,
+                                struct tcrypt_result *tr,
+                                int ret)
+{
+        if (ret == -EINPROGRESS || ret == -EBUSY) {
+                ret = wait_for_completion_interruptible(&tr->completion);
+                if (!ret)
+                        ret = tr->err;
+                INIT_COMPLETION(tr->completion);
+        }
+        return ret;
+}
+
 static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
-                     unsigned int tcount)
+                     unsigned int tcount, bool use_digest)
 {
         const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
         unsigned int i, j, k, temp;
@@ -206,23 +219,36 @@ static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
                 }
 
                 ahash_request_set_crypt(req, sg, result, template[i].psize);
-                ret = crypto_ahash_digest(req);
-                switch (ret) {
-                case 0:
-                        break;
-                case -EINPROGRESS:
-                case -EBUSY:
-                        ret = wait_for_completion_interruptible(
-                                &tresult.completion);
-                        if (!ret && !(ret = tresult.err)) {
-                                INIT_COMPLETION(tresult.completion);
-                                break;
+                if (use_digest) {
+                        ret = do_one_async_hash_op(req, &tresult,
+                                                   crypto_ahash_digest(req));
+                        if (ret) {
+                                pr_err("alg: hash: digest failed on test %d "
+                                       "for %s: ret=%d\n", j, algo, -ret);
+                                goto out;
+                        }
+                } else {
+                        ret = do_one_async_hash_op(req, &tresult,
+                                                   crypto_ahash_init(req));
+                        if (ret) {
+                                pr_err("alt: hash: init failed on test %d "
+                                       "for %s: ret=%d\n", j, algo, -ret);
+                                goto out;
+                        }
+                        ret = do_one_async_hash_op(req, &tresult,
+                                                   crypto_ahash_update(req));
+                        if (ret) {
+                                pr_err("alt: hash: update failed on test %d "
+                                       "for %s: ret=%d\n", j, algo, -ret);
+                                goto out;
+                        }
+                        ret = do_one_async_hash_op(req, &tresult,
+                                                   crypto_ahash_final(req));
+                        if (ret) {
+                                pr_err("alt: hash: final failed on test %d "
+                                       "for %s: ret=%d\n", j, algo, -ret);
+                                goto out;
                         }
-                        /* fall through */
-                default:
-                        printk(KERN_ERR "alg: hash: digest failed on test %d "
-                               "for %s: ret=%d\n", j, algo, -ret);
-                        goto out;
                 }
 
                 if (memcmp(result, template[i].digest,
@@ -1402,7 +1428,11 @@ static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
                 return PTR_ERR(tfm);
         }
 
-        err = test_hash(tfm, desc->suite.hash.vecs, desc->suite.hash.count);
+        err = test_hash(tfm, desc->suite.hash.vecs,
+                        desc->suite.hash.count, true);
+        if (!err)
+                err = test_hash(tfm, desc->suite.hash.vecs,
+                                desc->suite.hash.count, false);
 
         crypto_free_ahash(tfm);
         return err;