i2c: xlr: Fix module autoload for OF registration

[cascardo/linux.git] / drivers / crypto / omap-aes.c

diff --git a/drivers/crypto/omap-aes.c b/drivers/crypto/omap-aes.c
index f2aae4a..fe32dd9 100644 (file)
--- a/drivers/crypto/omap-aes.c
+++ b/drivers/crypto/omap-aes.c
@@ -35,8 +35,8 @@
 #include <linux/interrupt.h>
 #include <crypto/scatterwalk.h>
 #include <crypto/aes.h>
-#include <crypto/algapi.h>
 #include <crypto/engine.h>
+#include <crypto/internal/skcipher.h>
 
 #define DST_MAXBURST                   4
 #define DMA_MIN                                (DST_MAXBURST * sizeof(u32))
@@ -106,6 +106,7 @@ struct omap_aes_ctx {
        int             keylen;
        u32             key[AES_KEYSIZE_256 / sizeof(u32)];
        unsigned long   flags;
+       struct crypto_skcipher  *fallback;
 };
 
 struct omap_aes_reqctx {
@@ -330,20 +331,12 @@ static void omap_aes_dma_stop(struct omap_aes_dev *dd)
 
 static struct omap_aes_dev *omap_aes_find_dev(struct omap_aes_ctx *ctx)
 {
-       struct omap_aes_dev *dd = NULL, *tmp;
+       struct omap_aes_dev *dd;
 
        spin_lock_bh(&list_lock);
-       if (!ctx->dd) {
-               list_for_each_entry(tmp, &dev_list, list) {
-                       /* FIXME: take fist available aes core */
-                       dd = tmp;
-                       break;
-               }
-               ctx->dd = dd;
-       } else {
-               /* already found before */
-               dd = ctx->dd;
-       }
+       dd = list_first_entry(&dev_list, struct omap_aes_dev, list);
+       list_move_tail(&dd->list, &dev_list);
+       ctx->dd = dd;
        spin_unlock_bh(&list_lock);
 
        return dd;
@@ -616,7 +609,7 @@ static int omap_aes_prepare_req(struct crypto_engine *engine,
 {
        struct omap_aes_ctx *ctx = crypto_ablkcipher_ctx(
                        crypto_ablkcipher_reqtfm(req));
-       struct omap_aes_dev *dd = omap_aes_find_dev(ctx);
+       struct omap_aes_dev *dd = ctx->dd;
        struct omap_aes_reqctx *rctx;
 
        if (!dd)
@@ -662,7 +655,7 @@ static int omap_aes_crypt_req(struct crypto_engine *engine,
 {
        struct omap_aes_ctx *ctx = crypto_ablkcipher_ctx(
                        crypto_ablkcipher_reqtfm(req));
-       struct omap_aes_dev *dd = omap_aes_find_dev(ctx);
+       struct omap_aes_dev *dd = ctx->dd;
 
        if (!dd)
                return -ENODEV;
@@ -710,11 +703,29 @@ static int omap_aes_crypt(struct ablkcipher_request *req, unsigned long mode)
                        crypto_ablkcipher_reqtfm(req));
        struct omap_aes_reqctx *rctx = ablkcipher_request_ctx(req);
        struct omap_aes_dev *dd;
+       int ret;
 
        pr_debug("nbytes: %d, enc: %d, cbc: %d\n", req->nbytes,
                  !!(mode & FLAGS_ENCRYPT),
                  !!(mode & FLAGS_CBC));
 
+       if (req->nbytes < 200) {
+               SKCIPHER_REQUEST_ON_STACK(subreq, ctx->fallback);
+
+               skcipher_request_set_tfm(subreq, ctx->fallback);
+               skcipher_request_set_callback(subreq, req->base.flags, NULL,
+                                             NULL);
+               skcipher_request_set_crypt(subreq, req->src, req->dst,
+                                          req->nbytes, req->info);
+
+               if (mode & FLAGS_ENCRYPT)
+                       ret = crypto_skcipher_encrypt(subreq);
+               else
+                       ret = crypto_skcipher_decrypt(subreq);
+
+               skcipher_request_zero(subreq);
+               return ret;
+       }
        dd = omap_aes_find_dev(ctx);
        if (!dd)
                return -ENODEV;
@@ -730,6 +741,7 @@ static int omap_aes_setkey(struct crypto_ablkcipher *tfm, const u8 *key,
                           unsigned int keylen)
 {
        struct omap_aes_ctx *ctx = crypto_ablkcipher_ctx(tfm);
+       int ret;
 
        if (keylen != AES_KEYSIZE_128 && keylen != AES_KEYSIZE_192 &&
                   keylen != AES_KEYSIZE_256)
@@ -740,6 +752,14 @@ static int omap_aes_setkey(struct crypto_ablkcipher *tfm, const u8 *key,
        memcpy(ctx->key, key, keylen);
        ctx->keylen = keylen;
 
+       crypto_skcipher_clear_flags(ctx->fallback, CRYPTO_TFM_REQ_MASK);
+       crypto_skcipher_set_flags(ctx->fallback, tfm->base.crt_flags &
+                                                CRYPTO_TFM_REQ_MASK);
+
+       ret = crypto_skcipher_setkey(ctx->fallback, key, keylen);
+       if (!ret)
+               return 0;
+
        return 0;
 }
 
@@ -775,6 +795,17 @@ static int omap_aes_ctr_decrypt(struct ablkcipher_request *req)
 
 static int omap_aes_cra_init(struct crypto_tfm *tfm)
 {
+       const char *name = crypto_tfm_alg_name(tfm);
+       const u32 flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK;
+       struct omap_aes_ctx *ctx = crypto_tfm_ctx(tfm);
+       struct crypto_skcipher *blk;
+
+       blk = crypto_alloc_skcipher(name, 0, flags);
+       if (IS_ERR(blk))
+               return PTR_ERR(blk);
+
+       ctx->fallback = blk;
+
        tfm->crt_ablkcipher.reqsize = sizeof(struct omap_aes_reqctx);
 
        return 0;
@@ -782,6 +813,12 @@ static int omap_aes_cra_init(struct crypto_tfm *tfm)
 
 static void omap_aes_cra_exit(struct crypto_tfm *tfm)
 {
+       struct omap_aes_ctx *ctx = crypto_tfm_ctx(tfm);
+
+       if (ctx->fallback)
+               crypto_free_skcipher(ctx->fallback);
+
+       ctx->fallback = NULL;
 }
 
 /* ********************** ALGS ************************************ */
@@ -793,7 +830,7 @@ static struct crypto_alg algs_ecb_cbc[] = {
        .cra_priority           = 300,
        .cra_flags              = CRYPTO_ALG_TYPE_ABLKCIPHER |
                                  CRYPTO_ALG_KERN_DRIVER_ONLY |
-                                 CRYPTO_ALG_ASYNC,
+                                 CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
        .cra_blocksize          = AES_BLOCK_SIZE,
        .cra_ctxsize            = sizeof(struct omap_aes_ctx),
        .cra_alignmask          = 0,
@@ -815,7 +852,7 @@ static struct crypto_alg algs_ecb_cbc[] = {
        .cra_priority           = 300,
        .cra_flags              = CRYPTO_ALG_TYPE_ABLKCIPHER |
                                  CRYPTO_ALG_KERN_DRIVER_ONLY |
-                                 CRYPTO_ALG_ASYNC,
+                                 CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
        .cra_blocksize          = AES_BLOCK_SIZE,
        .cra_ctxsize            = sizeof(struct omap_aes_ctx),
        .cra_alignmask          = 0,
@@ -841,7 +878,7 @@ static struct crypto_alg algs_ctr[] = {
        .cra_priority           = 300,
        .cra_flags              = CRYPTO_ALG_TYPE_ABLKCIPHER |
                                  CRYPTO_ALG_KERN_DRIVER_ONLY |
-                                 CRYPTO_ALG_ASYNC,
+                                 CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
        .cra_blocksize          = AES_BLOCK_SIZE,
        .cra_ctxsize            = sizeof(struct omap_aes_ctx),
        .cra_alignmask          = 0,
@@ -1176,6 +1213,19 @@ static int omap_aes_probe(struct platform_device *pdev)
        list_add_tail(&dd->list, &dev_list);
        spin_unlock(&list_lock);
 
+       /* Initialize crypto engine */
+       dd->engine = crypto_engine_alloc_init(dev, 1);
+       if (!dd->engine) {
+               err = -ENOMEM;
+               goto err_engine;
+       }
+
+       dd->engine->prepare_cipher_request = omap_aes_prepare_req;
+       dd->engine->cipher_one_request = omap_aes_crypt_req;
+       err = crypto_engine_start(dd->engine);
+       if (err)
+               goto err_engine;
+
        for (i = 0; i < dd->pdata->algs_info_size; i++) {
                if (!dd->pdata->algs_info[i].registered) {
                        for (j = 0; j < dd->pdata->algs_info[i].size; j++) {
@@ -1193,26 +1243,17 @@ static int omap_aes_probe(struct platform_device *pdev)
                }
        }
 
-       /* Initialize crypto engine */
-       dd->engine = crypto_engine_alloc_init(dev, 1);
-       if (!dd->engine)
-               goto err_algs;
-
-       dd->engine->prepare_cipher_request = omap_aes_prepare_req;
-       dd->engine->cipher_one_request = omap_aes_crypt_req;
-       err = crypto_engine_start(dd->engine);
-       if (err)
-               goto err_engine;
-
        return 0;
-err_engine:
-       crypto_engine_exit(dd->engine);
 err_algs:
        for (i = dd->pdata->algs_info_size - 1; i >= 0; i--)
                for (j = dd->pdata->algs_info[i].registered - 1; j >= 0; j--)
                        crypto_unregister_alg(
                                        &dd->pdata->algs_info[i].algs_list[j]);
 
+err_engine:
+       if (dd->engine)
+               crypto_engine_exit(dd->engine);
+
        omap_aes_dma_cleanup(dd);
 err_irq:
        tasklet_kill(&dd->done_task);