caamalg.c (0ea8a56de21be24cb79abb03dee79aabcd60a316) caamalg.c (9d9b14dbe077c8704d8c3546e38820d35aff2d35)
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * caam - Freescale FSL CAAM support for crypto API
4 *
5 * Copyright 2008-2011 Freescale Semiconductor, Inc.
6 * Copyright 2016-2019 NXP
7 *
8 * Based on talitos crypto API driver.

--- 43 unchanged lines hidden (view full) ---

52#include "intern.h"
53#include "desc_constr.h"
54#include "jr.h"
55#include "error.h"
56#include "sg_sw_sec4.h"
57#include "key_gen.h"
58#include "caamalg_desc.h"
59#include <crypto/engine.h>
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * caam - Freescale FSL CAAM support for crypto API
4 *
5 * Copyright 2008-2011 Freescale Semiconductor, Inc.
6 * Copyright 2016-2019 NXP
7 *
8 * Based on talitos crypto API driver.

--- 43 unchanged lines hidden (view full) ---

52#include "intern.h"
53#include "desc_constr.h"
54#include "jr.h"
55#include "error.h"
56#include "sg_sw_sec4.h"
57#include "key_gen.h"
58#include "caamalg_desc.h"
59#include <crypto/engine.h>
60#include <asm/unaligned.h>
60
61/*
62 * crypto alg
63 */
64#define CAAM_CRA_PRIORITY 3000
65/* max key is sum of AES_MAX_KEY_SIZE, max split key size */
66#define CAAM_MAX_KEY_SIZE (AES_MAX_KEY_SIZE + \
67 CTR_RFC3686_NONCE_SIZE + \

--- 41 unchanged lines hidden (view full) ---

109 dma_addr_t sh_desc_enc_dma;
110 dma_addr_t sh_desc_dec_dma;
111 dma_addr_t key_dma;
112 enum dma_data_direction dir;
113 struct device *jrdev;
114 struct alginfo adata;
115 struct alginfo cdata;
116 unsigned int authsize;
61
62/*
63 * crypto alg
64 */
65#define CAAM_CRA_PRIORITY 3000
66/* max key is sum of AES_MAX_KEY_SIZE, max split key size */
67#define CAAM_MAX_KEY_SIZE (AES_MAX_KEY_SIZE + \
68 CTR_RFC3686_NONCE_SIZE + \

--- 41 unchanged lines hidden (view full) ---

110 dma_addr_t sh_desc_enc_dma;
111 dma_addr_t sh_desc_dec_dma;
112 dma_addr_t key_dma;
113 enum dma_data_direction dir;
114 struct device *jrdev;
115 struct alginfo adata;
116 struct alginfo cdata;
117 unsigned int authsize;
118 struct crypto_skcipher *fallback;
117};
118
119struct caam_skcipher_req_ctx {
120 struct skcipher_edesc *edesc;
119};
120
121struct caam_skcipher_req_ctx {
122 struct skcipher_edesc *edesc;
123 struct skcipher_request fallback_req;
121};
122
123struct caam_aead_req_ctx {
124 struct aead_edesc *edesc;
125};
126
127static int aead_null_set_sh_desc(struct crypto_aead *aead)
128{

--- 696 unchanged lines hidden (view full) ---

825}
826
827static int xts_skcipher_setkey(struct crypto_skcipher *skcipher, const u8 *key,
828 unsigned int keylen)
829{
830 struct caam_ctx *ctx = crypto_skcipher_ctx(skcipher);
831 struct device *jrdev = ctx->jrdev;
832 u32 *desc;
124};
125
126struct caam_aead_req_ctx {
127 struct aead_edesc *edesc;
128};
129
130static int aead_null_set_sh_desc(struct crypto_aead *aead)
131{

--- 696 unchanged lines hidden (view full) ---

828}
829
830static int xts_skcipher_setkey(struct crypto_skcipher *skcipher, const u8 *key,
831 unsigned int keylen)
832{
833 struct caam_ctx *ctx = crypto_skcipher_ctx(skcipher);
834 struct device *jrdev = ctx->jrdev;
835 u32 *desc;
836 int err;
833
834 if (keylen != 2 * AES_MIN_KEY_SIZE && keylen != 2 * AES_MAX_KEY_SIZE) {
835 dev_dbg(jrdev, "key size mismatch\n");
836 return -EINVAL;
837 }
838
837
838 if (keylen != 2 * AES_MIN_KEY_SIZE && keylen != 2 * AES_MAX_KEY_SIZE) {
839 dev_dbg(jrdev, "key size mismatch\n");
840 return -EINVAL;
841 }
842
843 err = crypto_skcipher_setkey(ctx->fallback, key, keylen);
844 if (err)
845 return err;
846
839 ctx->cdata.keylen = keylen;
840 ctx->cdata.key_virt = key;
841 ctx->cdata.key_inline = true;
842
843 /* xts_skcipher_encrypt shared descriptor */
844 desc = ctx->sh_desc_enc;
845 cnstr_shdsc_xts_skcipher_encap(desc, &ctx->cdata);
846 dma_sync_single_for_device(jrdev, ctx->sh_desc_enc_dma,

--- 903 unchanged lines hidden (view full) ---

1750 kfree(rctx->edesc);
1751 } else {
1752 ret = 0;
1753 }
1754
1755 return ret;
1756}
1757
847 ctx->cdata.keylen = keylen;
848 ctx->cdata.key_virt = key;
849 ctx->cdata.key_inline = true;
850
851 /* xts_skcipher_encrypt shared descriptor */
852 desc = ctx->sh_desc_enc;
853 cnstr_shdsc_xts_skcipher_encap(desc, &ctx->cdata);
854 dma_sync_single_for_device(jrdev, ctx->sh_desc_enc_dma,

--- 903 unchanged lines hidden (view full) ---

1758 kfree(rctx->edesc);
1759 } else {
1760 ret = 0;
1761 }
1762
1763 return ret;
1764}
1765
1766static inline bool xts_skcipher_ivsize(struct skcipher_request *req)
1767{
1768 struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(req);
1769 unsigned int ivsize = crypto_skcipher_ivsize(skcipher);
1770
1771 return !!get_unaligned((u64 *)(req->iv + (ivsize / 2)));
1772}
1773
1758static inline int skcipher_crypt(struct skcipher_request *req, bool encrypt)
1759{
1760 struct skcipher_edesc *edesc;
1761 struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(req);
1762 struct caam_ctx *ctx = crypto_skcipher_ctx(skcipher);
1763 struct device *jrdev = ctx->jrdev;
1764 struct caam_drv_private_jr *jrpriv = dev_get_drvdata(jrdev);
1765 u32 *desc;
1766 int ret = 0;
1767
1768 if (!req->cryptlen)
1769 return 0;
1770
1774static inline int skcipher_crypt(struct skcipher_request *req, bool encrypt)
1775{
1776 struct skcipher_edesc *edesc;
1777 struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(req);
1778 struct caam_ctx *ctx = crypto_skcipher_ctx(skcipher);
1779 struct device *jrdev = ctx->jrdev;
1780 struct caam_drv_private_jr *jrpriv = dev_get_drvdata(jrdev);
1781 u32 *desc;
1782 int ret = 0;
1783
1784 if (!req->cryptlen)
1785 return 0;
1786
1787 if (ctx->fallback && xts_skcipher_ivsize(req)) {
1788 struct caam_skcipher_req_ctx *rctx = skcipher_request_ctx(req);
1789
1790 skcipher_request_set_tfm(&rctx->fallback_req, ctx->fallback);
1791 skcipher_request_set_callback(&rctx->fallback_req,
1792 req->base.flags,
1793 req->base.complete,
1794 req->base.data);
1795 skcipher_request_set_crypt(&rctx->fallback_req, req->src,
1796 req->dst, req->cryptlen, req->iv);
1797
1798 return encrypt ? crypto_skcipher_encrypt(&rctx->fallback_req) :
1799 crypto_skcipher_decrypt(&rctx->fallback_req);
1800 }
1801
1771 /* allocate extended descriptor */
1772 edesc = skcipher_edesc_alloc(req, DESC_JOB_IO_LEN * CAAM_CMD_SZ);
1773 if (IS_ERR(edesc))
1774 return PTR_ERR(edesc);
1775
1776 /* Create and submit job descriptor*/
1777 init_skcipher_job(req, edesc, encrypt);
1778

--- 121 unchanged lines hidden (view full) ---

1900 .rfc3686 = true,
1901 },
1902 },
1903 {
1904 .skcipher = {
1905 .base = {
1906 .cra_name = "xts(aes)",
1907 .cra_driver_name = "xts-aes-caam",
1802 /* allocate extended descriptor */
1803 edesc = skcipher_edesc_alloc(req, DESC_JOB_IO_LEN * CAAM_CMD_SZ);
1804 if (IS_ERR(edesc))
1805 return PTR_ERR(edesc);
1806
1807 /* Create and submit job descriptor*/
1808 init_skcipher_job(req, edesc, encrypt);
1809

--- 121 unchanged lines hidden (view full) ---

1931 .rfc3686 = true,
1932 },
1933 },
1934 {
1935 .skcipher = {
1936 .base = {
1937 .cra_name = "xts(aes)",
1938 .cra_driver_name = "xts-aes-caam",
1939 .cra_flags = CRYPTO_ALG_NEED_FALLBACK,
1908 .cra_blocksize = AES_BLOCK_SIZE,
1909 },
1910 .setkey = xts_skcipher_setkey,
1911 .encrypt = skcipher_encrypt,
1912 .decrypt = skcipher_decrypt,
1913 .min_keysize = 2 * AES_MIN_KEY_SIZE,
1914 .max_keysize = 2 * AES_MAX_KEY_SIZE,
1915 .ivsize = AES_BLOCK_SIZE,

--- 1423 unchanged lines hidden (view full) ---

3339}
3340
3341static int caam_cra_init(struct crypto_skcipher *tfm)
3342{
3343 struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
3344 struct caam_skcipher_alg *caam_alg =
3345 container_of(alg, typeof(*caam_alg), skcipher);
3346 struct caam_ctx *ctx = crypto_skcipher_ctx(tfm);
1940 .cra_blocksize = AES_BLOCK_SIZE,
1941 },
1942 .setkey = xts_skcipher_setkey,
1943 .encrypt = skcipher_encrypt,
1944 .decrypt = skcipher_decrypt,
1945 .min_keysize = 2 * AES_MIN_KEY_SIZE,
1946 .max_keysize = 2 * AES_MAX_KEY_SIZE,
1947 .ivsize = AES_BLOCK_SIZE,

--- 1423 unchanged lines hidden (view full) ---

3371}
3372
3373static int caam_cra_init(struct crypto_skcipher *tfm)
3374{
3375 struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
3376 struct caam_skcipher_alg *caam_alg =
3377 container_of(alg, typeof(*caam_alg), skcipher);
3378 struct caam_ctx *ctx = crypto_skcipher_ctx(tfm);
3379 u32 alg_aai = caam_alg->caam.class1_alg_type & OP_ALG_AAI_MASK;
3380 int ret = 0;
3347
3381
3348 crypto_skcipher_set_reqsize(tfm, sizeof(struct caam_skcipher_req_ctx));
3349
3350 ctx->enginectx.op.do_one_request = skcipher_do_one_req;
3351
3382 ctx->enginectx.op.do_one_request = skcipher_do_one_req;
3383
3352 return caam_init_common(crypto_skcipher_ctx(tfm), &caam_alg->caam,
3353 false);
3384 if (alg_aai == OP_ALG_AAI_XTS) {
3385 const char *tfm_name = crypto_tfm_alg_name(&tfm->base);
3386 struct crypto_skcipher *fallback;
3387
3388 fallback = crypto_alloc_skcipher(tfm_name, 0,
3389 CRYPTO_ALG_NEED_FALLBACK);
3390 if (IS_ERR(fallback)) {
3391 dev_err(ctx->jrdev, "Failed to allocate %s fallback: %ld\n",
3392 tfm_name, PTR_ERR(fallback));
3393 return PTR_ERR(fallback);
3394 }
3395
3396 ctx->fallback = fallback;
3397 crypto_skcipher_set_reqsize(tfm, sizeof(struct caam_skcipher_req_ctx) +
3398 crypto_skcipher_reqsize(fallback));
3399 } else {
3400 crypto_skcipher_set_reqsize(tfm, sizeof(struct caam_skcipher_req_ctx));
3401 }
3402
3403 ret = caam_init_common(ctx, &caam_alg->caam, false);
3404 if (ret && ctx->fallback)
3405 crypto_free_skcipher(ctx->fallback);
3406
3407 return ret;
3354}
3355
3356static int caam_aead_init(struct crypto_aead *tfm)
3357{
3358 struct aead_alg *alg = crypto_aead_alg(tfm);
3359 struct caam_aead_alg *caam_alg =
3360 container_of(alg, struct caam_aead_alg, aead);
3361 struct caam_ctx *ctx = crypto_aead_ctx(tfm);

--- 11 unchanged lines hidden (view full) ---

3373 offsetof(struct caam_ctx, sh_desc_enc_dma) -
3374 offsetof(struct caam_ctx, sh_desc_enc),
3375 ctx->dir, DMA_ATTR_SKIP_CPU_SYNC);
3376 caam_jr_free(ctx->jrdev);
3377}
3378
3379static void caam_cra_exit(struct crypto_skcipher *tfm)
3380{
3408}
3409
3410static int caam_aead_init(struct crypto_aead *tfm)
3411{
3412 struct aead_alg *alg = crypto_aead_alg(tfm);
3413 struct caam_aead_alg *caam_alg =
3414 container_of(alg, struct caam_aead_alg, aead);
3415 struct caam_ctx *ctx = crypto_aead_ctx(tfm);

--- 11 unchanged lines hidden (view full) ---

3427 offsetof(struct caam_ctx, sh_desc_enc_dma) -
3428 offsetof(struct caam_ctx, sh_desc_enc),
3429 ctx->dir, DMA_ATTR_SKIP_CPU_SYNC);
3430 caam_jr_free(ctx->jrdev);
3431}
3432
3433static void caam_cra_exit(struct crypto_skcipher *tfm)
3434{
3381 caam_exit_common(crypto_skcipher_ctx(tfm));
3435 struct caam_ctx *ctx = crypto_skcipher_ctx(tfm);
3436
3437 if (ctx->fallback)
3438 crypto_free_skcipher(ctx->fallback);
3439 caam_exit_common(ctx);
3382}
3383
3384static void caam_aead_exit(struct crypto_aead *tfm)
3385{
3386 caam_exit_common(crypto_aead_ctx(tfm));
3387}
3388
3389void caam_algapi_exit(void)

--- 17 unchanged lines hidden (view full) ---

3407
3408static void caam_skcipher_alg_init(struct caam_skcipher_alg *t_alg)
3409{
3410 struct skcipher_alg *alg = &t_alg->skcipher;
3411
3412 alg->base.cra_module = THIS_MODULE;
3413 alg->base.cra_priority = CAAM_CRA_PRIORITY;
3414 alg->base.cra_ctxsize = sizeof(struct caam_ctx);
3440}
3441
3442static void caam_aead_exit(struct crypto_aead *tfm)
3443{
3444 caam_exit_common(crypto_aead_ctx(tfm));
3445}
3446
3447void caam_algapi_exit(void)

--- 17 unchanged lines hidden (view full) ---

3465
3466static void caam_skcipher_alg_init(struct caam_skcipher_alg *t_alg)
3467{
3468 struct skcipher_alg *alg = &t_alg->skcipher;
3469
3470 alg->base.cra_module = THIS_MODULE;
3471 alg->base.cra_priority = CAAM_CRA_PRIORITY;
3472 alg->base.cra_ctxsize = sizeof(struct caam_ctx);
3415 alg->base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY |
3416 CRYPTO_ALG_KERN_DRIVER_ONLY;
3473 alg->base.cra_flags |= (CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY |
3474 CRYPTO_ALG_KERN_DRIVER_ONLY);
3417
3418 alg->init = caam_cra_init;
3419 alg->exit = caam_cra_exit;
3420}
3421
3422static void caam_aead_alg_init(struct caam_aead_alg *t_alg)
3423{
3424 struct aead_alg *alg = &t_alg->aead;

--- 156 unchanged lines hidden --- 		3475
3476 alg->init = caam_cra_init;
3477 alg->exit = caam_cra_exit;
3478}
3479
3480static void caam_aead_alg_init(struct caam_aead_alg *t_alg)
3481{
3482 struct aead_alg *alg = &t_alg->aead;

--- 156 unchanged lines hidden ---