crypto: convert h/w accelerator drivers to skcipher API
Subsystems (19)
v4 cover crypto: convert h/w accelerator drivers to skcipher API
This series converts all drivers for h/w accelerators that produce the ablkcipher API to the skcipher API, so that we can finally retire the long deprecated ablkcipher code.
Changes since v3:
- add acks from Tudor, Gilad and Eric
- incorporate updated version of the QAT patch from Giovanni
- rebased onto latest cryptodev/master
- updated wording in commit logs to refer to ablkcipher not blkcipher [which has already been removed]
Changes since v2:
- added a patch that removes the ablkcipher support code itself
- fix an issue in the talitos code
- add tero's ack to patch #5
- add stanimir's ack to patch #20
Changes since v1:
- remove some more [cosmetic] references to [a]blkcipher (#26-#27)
- add back missing IV for cbc(aes) in the omap driver, fixing a crash
- add Gary's ack to #4
- add Linus's ack to #6 and #15
- add Kamil's and Krzysztof's acks to #7
- fixed a bug in the Atmel patch (#8)
- add Horia's tested-by to #16
- add Dave's ack to #22
Patches #1, #2 are fixes for the virtio driver, which need to be applied first so that they can be backported
Patches #3 and #4 have been tested by me on actual 'hardware' (given the virtual nature of the virtio driver). Patch #5 was tested by Tero. Patch #7 was tested successfully in kernelci. Patches #8 and #9 were tested by Tudor. Patch #16 was tested by Horia. Patch #25 was updated with changes proposed by Giovanni, so I assume he tested them as well. Patch #24 was fixed in v2 in response to a test failure report.
All other patches have been build tested *only*, and should preferably be tested on actual hardware before being merged. Note that patches can be merged piecemeal (with the exception of #1 .. #3 which should be taken as a set, and #28 which removes the ablkcipher support code) since there are no dependencies between them. However, deferring this series indefinitely until everyone has chimed in doesn't seem like a useful approach either, so I am leaving it up to the maintainers to decide when we have reached critical mass and the whole series can be taken.
Ard Biesheuvel (29):
crypto: virtio - implement missing support for output IVs
crypto: virtio - deal with unsupported input sizes
crypto: virtio - switch to skcipher API
crypto: ccp - switch from ablkcipher to skcipher
crypto: omap - switch to skcipher API
crypto: ux500 - switch to skcipher API
crypto: s5p - switch to skcipher API
crypto: atmel-aes - switch to skcipher API
crypto: atmel-tdes - switch to skcipher API
crypto: bcm-spu - switch to skcipher API
crypto: nitrox - remove cra_type reference to ablkcipher
crypto: cavium/cpt - switch to skcipher API
crypto: chelsio - switch to skcipher API
crypto: hifn - switch to skcipher API
crypto: ixp4xx - switch to skcipher API
crypto: mxs - switch to skcipher API
crypto: mediatek - switch to skcipher API
crypto: sahara - switch to skcipher API
crypto: picoxcell - switch to skcipher API
crypto: qce - switch to skcipher API
crypto: stm32 - switch to skcipher API
crypto: niagara2 - switch to skcipher API
crypto: rockchip - switch to skcipher API
crypto: talitos - switch to skcipher API
crypto: qat - switch to skcipher API
crypto: marvell/cesa - rename blkcipher to skcipher
crypto: nx - remove stale comment referring to the blkcipher walk API
crypto: remove deprecated and unused ablkcipher support
crypto: ccree - update a stale reference to ablkcipher
Documentation/crypto/api-skcipher.rst | 20 +-
Documentation/crypto/architecture.rst | 2 -
Documentation/crypto/crypto_engine.rst | 4 -
crypto/Makefile | 4 +-
crypto/ablkcipher.c | 407 -------------
crypto/algapi.c | 26 -
crypto/crypto_engine.c | 29 -
crypto/skcipher.c | 106 ----
drivers/crypto/Kconfig | 2 +-
drivers/crypto/atmel-aes.c | 509 ++++++++--------
drivers/crypto/atmel-tdes.c | 433 +++++++-------
drivers/crypto/bcm/cipher.c | 373 ++++++------
drivers/crypto/bcm/cipher.h | 10 +-
drivers/crypto/bcm/spu2.c | 6 +-
drivers/crypto/cavium/cpt/cptvf_algs.c | 292 +++++----
.../crypto/cavium/nitrox/nitrox_skcipher.c | 1 -
drivers/crypto/ccp/ccp-crypto-aes-galois.c | 7 +-
drivers/crypto/ccp/ccp-crypto-aes-xts.c | 94 +--
drivers/crypto/ccp/ccp-crypto-aes.c | 169 +++---
drivers/crypto/ccp/ccp-crypto-des3.c | 100 ++--
drivers/crypto/ccp/ccp-crypto-main.c | 14 +-
drivers/crypto/ccp/ccp-crypto.h | 13 +-
drivers/crypto/ccree/cc_cipher.c | 4 +-
drivers/crypto/chelsio/chcr_algo.c | 334 ++++++-----
drivers/crypto/chelsio/chcr_algo.h | 2 +-
drivers/crypto/chelsio/chcr_crypto.h | 16 +-
drivers/crypto/hifn_795x.c | 183 +++---
drivers/crypto/ixp4xx_crypto.c | 228 ++++---
drivers/crypto/marvell/cesa.h | 6 +-
drivers/crypto/marvell/cipher.c | 14 +-
drivers/crypto/mediatek/mtk-aes.c | 248 ++++----
drivers/crypto/mxs-dcp.c | 140 ++---
drivers/crypto/n2_core.c | 194 +++---
drivers/crypto/nx/nx-aes-ccm.c | 5 -
drivers/crypto/nx/nx-aes-gcm.c | 5 -
drivers/crypto/omap-aes.c | 209 ++++---
drivers/crypto/omap-aes.h | 4 +-
drivers/crypto/omap-des.c | 232 ++++----
drivers/crypto/picoxcell_crypto.c | 386 ++++++------
drivers/crypto/qat/qat_common/qat_algs.c | 304 +++++-----
drivers/crypto/qat/qat_common/qat_crypto.h | 4 +-
drivers/crypto/qce/Makefile | 2 +-
drivers/crypto/qce/cipher.h | 8 +-
drivers/crypto/qce/common.c | 12 +-
drivers/crypto/qce/common.h | 3 +-
drivers/crypto/qce/core.c | 2 +-
.../crypto/qce/{ablkcipher.c => skcipher.c} | 172 +++---
drivers/crypto/rockchip/Makefile | 2 +-
drivers/crypto/rockchip/rk3288_crypto.c | 8 +-
drivers/crypto/rockchip/rk3288_crypto.h | 3 +-
.../rockchip/rk3288_crypto_ablkcipher.c | 556 ------------------
.../crypto/rockchip/rk3288_crypto_skcipher.c | 538 +++++++++++++++++
drivers/crypto/s5p-sss.c | 187 +++---
drivers/crypto/sahara.c | 156 +++--
drivers/crypto/stm32/stm32-cryp.c | 338 +++++------
drivers/crypto/talitos.c | 308 +++++-----
drivers/crypto/ux500/cryp/cryp_core.c | 371 +++++-------
drivers/crypto/virtio/virtio_crypto_algs.c | 192 +++---
drivers/crypto/virtio/virtio_crypto_common.h | 2 +-
include/crypto/aead.h | 2 +-
include/crypto/algapi.h | 75 ---
include/crypto/engine.h | 4 -
include/crypto/hash.h | 2 +-
include/crypto/internal/des.h | 12 -
include/crypto/internal/skcipher.h | 20 -
include/crypto/skcipher.h | 6 -
include/linux/crypto.h | 435 --------------
67 files changed, 3531 insertions(+), 5024 deletions(-)
delete mode 100644 crypto/ablkcipher.c
rename drivers/crypto/qce/{ablkcipher.c => skcipher.c} (61%)
delete mode 100644 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c
create mode 100644 drivers/crypto/rockchip/rk3288_crypto_skcipher.cSignature · 1 line
2.17.1
PATCH v4 1/29 crypto: virtio - implement missing support for output IVs
In order to allow for CBC to be chained, which is something that the CTS template relies upon, implementations of CBC need to pass the IV to be used for subsequent invocations via the IV buffer. This was not implemented yet for virtio-crypto so implement it now.
--- drivers/crypto/virtio/virtio_crypto_algs.c | 9 +++++++++ 1 file changed, 9 insertions(+)
drivers/crypto/virtio/virtio_crypto_algs.c +9 -0
@@ -437,6 +437,11 @@ __virtio_crypto_ablkcipher_do_req(struct virtio_crypto_sym_request *vc_sym_req, goto free; }memcpy (iv, req->info, ivsize); +if (!vc_sym_req->encrypt) +scatterwalk_map_and_copy (req->info, req->src, + req->nbytes -AES_BLOCK_SIZE , +AES_BLOCK_SIZE ,0 ); +sg_init_one (&iv_sg, iv, ivsize); sgs[num_out++] = &iv_sg; vc_sym_req->iv = iv;
@@ -563,6 +568,10 @@ static void virtio_crypto_ablkcipher_finalize_req( struct ablkcipher_request *req, int err) { +if (vc_sym_req->encrypt) +scatterwalk_map_and_copy (req->info, req->dst, + req->nbytes -AES_BLOCK_SIZE , +AES_BLOCK_SIZE ,0 );crypto_finalize_ablkcipher_request (vc_sym_req->base.dataq->engine, req, err);kzfree (vc_sym_req->iv);
Signature · 1 line
2.17.1
PATCH v4 2/29 crypto: virtio - deal with unsupported input sizes
In reply to Ard BiesheuvelReturn -EINVAL for input sizes that are not a multiple of the AES block size, since they are not supported by our CBC chaining mode.
While at it, remove the pr_err() that reports unsupported key sizes being used: we shouldn't spam the kernel log with that.
--- drivers/crypto/virtio/virtio_crypto_algs.c | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-)
drivers/crypto/virtio/virtio_crypto_algs.c +10 -2
@@ -105,8 +105,6 @@ virtio_crypto_alg_validate_key(int key_len, uint32_t *alg) *alg =VIRTIO_CRYPTO_CIPHER_AES_CBC ;break ;default : -pr_err ("virtio_crypto: Unsupported key length: %d\n" , - key_len);return -EINVAL ; }return 0 ;
@@ -489,6 +487,11 @@ static int virtio_crypto_ablkcipher_encrypt(struct ablkcipher_request *req)/* Use the first data virtqueue as default */ struct data_queue *data_vq = &vcrypto->data_vq[0 ]; +if (!req->nbytes) +return 0 ; +if (req->nbytes %AES_BLOCK_SIZE ) +return -EINVAL ; + vc_req->dataq = data_vq; vc_req->alg_cb = virtio_crypto_dataq_sym_callback; vc_sym_req->ablkcipher_ctx = ctx;
@@ -509,6 +512,11 @@ static int virtio_crypto_ablkcipher_decrypt(struct ablkcipher_request *req)/* Use the first data virtqueue as default */ struct data_queue *data_vq = &vcrypto->data_vq[0 ]; +if (!req->nbytes) +return 0 ; +if (req->nbytes %AES_BLOCK_SIZE ) +return -EINVAL ; + vc_req->dataq = data_vq; vc_req->alg_cb = virtio_crypto_dataq_sym_callback; vc_sym_req->ablkcipher_ctx = ctx;
Signature · 1 line
2.17.1
PATCH v4 3/29 crypto: virtio - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/virtio/virtio_crypto_algs.c | 187 ++++++++++---------- drivers/crypto/virtio/virtio_crypto_common.h | 2 +- 2 files changed, 92 insertions(+), 97 deletions(-)
drivers/crypto/virtio/virtio_crypto_algs.c +91 -96
@@ -8,6 +8,7 @@#include <linux/scatterlist.h> #include <crypto/algapi.h> +#include <crypto/internal/skcipher.h> #include <linux/err.h> #include <crypto/scatterwalk.h> #include <linux/atomic.h>
@@ -16,10 +17,10 @@#include "virtio_crypto_common.h" -struct virtio_crypto_ablkcipher_ctx { +struct virtio_crypto_skcipher_ctx {struct crypto_engine_ctx enginectx;struct virtio_crypto *vcrypto; -struct crypto_tfm *tfm; +struct crypto_skcipher *tfm;struct virtio_crypto_sym_session_info enc_sess_info;struct virtio_crypto_sym_session_info dec_sess_info;
@@ -30,8 +31,8 @@ struct virtio_crypto_sym_request {/* Cipher or aead */ uint32_t type; -struct virtio_crypto_ablkcipher_ctx *ablkcipher_ctx; -struct ablkcipher_request *ablkcipher_req; +struct virtio_crypto_skcipher_ctx *skcipher_ctx; +struct skcipher_request *skcipher_req;uint8_t *iv;/* Encryption? */ bool encrypt;
@@ -41,7 +42,7 @@ struct virtio_crypto_algo {uint32_t algonum;uint32_t service;unsigned int active_devs; -struct crypto_alg algo; +struct skcipher_alg algo; };/*
@@ -49,9 +50,9 @@ struct virtio_crypto_algo {* and crypto algorithms registion. */ static DEFINE_MUTEX (algs_lock); -static void virtio_crypto_ablkcipher_finalize_req ( +static void virtio_crypto_skcipher_finalize_req (struct virtio_crypto_sym_request *vc_sym_req, -struct ablkcipher_request *req, +struct skcipher_request *req,int err);static void virtio_crypto_dataq_sym_callback
@@ -59,7 +60,7 @@ static void virtio_crypto_dataq_sym_callback {struct virtio_crypto_sym_request *vc_sym_req = container_of(vc_req, struct virtio_crypto_sym_request, base); -struct ablkcipher_request *ablk_req; +struct skcipher_request *ablk_req;int error;/* Finish the encrypt or decrypt process */
@@ -79,8 +80,8 @@ static void virtio_crypto_dataq_sym_callback error = -EIO ;break ; } - ablk_req = vc_sym_req->ablkcipher_req; -virtio_crypto_ablkcipher_finalize_req (vc_sym_req, + ablk_req = vc_sym_req->skcipher_req; +virtio_crypto_skcipher_finalize_req (vc_sym_req, ablk_req, error); } }
@@ -110,8 +111,8 @@ virtio_crypto_alg_validate_key(int key_len, uint32_t *alg)return 0 ; } -static int virtio_crypto_alg_ablkcipher_init_session ( -struct virtio_crypto_ablkcipher_ctx *ctx, +static int virtio_crypto_alg_skcipher_init_session ( +struct virtio_crypto_skcipher_ctx *ctx,uint32_t alg,const uint8_t *key,unsigned int keylen,int encrypt)
@@ -200,8 +201,8 @@ static int virtio_crypto_alg_ablkcipher_init_session(return 0 ; } -static int virtio_crypto_alg_ablkcipher_close_session ( -struct virtio_crypto_ablkcipher_ctx *ctx, +static int virtio_crypto_alg_skcipher_close_session ( +struct virtio_crypto_skcipher_ctx *ctx,int encrypt) {struct scatterlist outhdr, status_sg, *sgs[2 ];
@@ -261,8 +262,8 @@ static int virtio_crypto_alg_ablkcipher_close_session(return 0 ; } -static int virtio_crypto_alg_ablkcipher_init_sessions ( -struct virtio_crypto_ablkcipher_ctx *ctx, +static int virtio_crypto_alg_skcipher_init_sessions ( +struct virtio_crypto_skcipher_ctx *ctx,const uint8_t *key,unsigned int keylen) {uint32_t alg;
@@ -278,30 +279,30 @@ static int virtio_crypto_alg_ablkcipher_init_sessions( goto bad_key;/* Create encryption session */ - ret =virtio_crypto_alg_ablkcipher_init_session (ctx, + ret =virtio_crypto_alg_skcipher_init_session (ctx, alg, key, keylen,1 );if (ret)return ret;/* Create decryption session */ - ret =virtio_crypto_alg_ablkcipher_init_session (ctx, + ret =virtio_crypto_alg_skcipher_init_session (ctx, alg, key, keylen,0 );if (ret) { -virtio_crypto_alg_ablkcipher_close_session (ctx,1 ); +virtio_crypto_alg_skcipher_close_session (ctx,1 );return ret; }return 0 ; bad_key: -crypto_tfm_set_flags (ctx->tfm,CRYPTO_TFM_RES_BAD_KEY_LEN ); +crypto_skcipher_set_flags (ctx->tfm,CRYPTO_TFM_RES_BAD_KEY_LEN );return -EINVAL ; }/* Note: kernel crypto API realization */ -static int virtio_crypto_ablkcipher_setkey (struct crypto_ablkcipher *tfm, +static int virtio_crypto_skcipher_setkey (struct crypto_skcipher *tfm,const uint8_t *key,unsigned int keylen) { -struct virtio_crypto_ablkcipher_ctx *ctx =crypto_ablkcipher_ctx (tfm); +struct virtio_crypto_skcipher_ctx *ctx =crypto_skcipher_ctx (tfm);uint32_t alg;int ret;
@@ -323,11 +324,11 @@ static int virtio_crypto_ablkcipher_setkey(struct crypto_ablkcipher *tfm, ctx->vcrypto = vcrypto; }else {/* Rekeying, we should close the created sessions previously */ -virtio_crypto_alg_ablkcipher_close_session (ctx,1 ); -virtio_crypto_alg_ablkcipher_close_session (ctx,0 ); +virtio_crypto_alg_skcipher_close_session (ctx,1 ); +virtio_crypto_alg_skcipher_close_session (ctx,0 ); } - ret =virtio_crypto_alg_ablkcipher_init_sessions (ctx, key, keylen); + ret =virtio_crypto_alg_skcipher_init_sessions (ctx, key, keylen);if (ret) {virtcrypto_dev_put (ctx->vcrypto); ctx->vcrypto =NULL ;
@@ -339,14 +340,14 @@ static int virtio_crypto_ablkcipher_setkey(struct crypto_ablkcipher *tfm, }static int -__virtio_crypto_ablkcipher_do_req (struct virtio_crypto_sym_request *vc_sym_req, -struct ablkcipher_request *req, +__virtio_crypto_skcipher_do_req (struct virtio_crypto_sym_request *vc_sym_req, +struct skcipher_request *req,struct data_queue *data_vq) { -struct crypto_ablkcipher *tfm =crypto_ablkcipher_reqtfm (req); -struct virtio_crypto_ablkcipher_ctx *ctx = vc_sym_req->ablkcipher_ctx; +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req); +struct virtio_crypto_skcipher_ctx *ctx = vc_sym_req->skcipher_ctx;struct virtio_crypto_request *vc_req = &vc_sym_req->base; -unsigned int ivsize =crypto_ablkcipher_ivsize (tfm); +unsigned int ivsize =crypto_skcipher_ivsize (tfm);struct virtio_crypto *vcrypto = ctx->vcrypto;struct virtio_crypto_op_data_req *req_data;int src_nents, dst_nents;
@@ -359,7 +360,7 @@ __virtio_crypto_ablkcipher_do_req(struct virtio_crypto_sym_request *vc_sym_req,int sg_total;uint8_t *iv; - src_nents =sg_nents_for_len (req->src, req->nbytes); + src_nents =sg_nents_for_len (req->src, req->cryptlen); dst_nents =sg_nents (req->dst); pr_debug("virtio_crypto: Number of sgs (src_nents: %d, dst_nents: %d)\n",
@@ -396,7 +397,7 @@ __virtio_crypto_ablkcipher_do_req(struct virtio_crypto_sym_request *vc_sym_req, req_data->u.sym_req.op_type =cpu_to_le32 (VIRTIO_CRYPTO_SYM_OP_CIPHER ); req_data->u.sym_req.u.cipher.para.iv_len =cpu_to_le32 (ivsize); req_data->u.sym_req.u.cipher.para.src_data_len = -cpu_to_le32 (req->nbytes); +cpu_to_le32 (req->cryptlen); dst_len =virtio_crypto_alg_sg_nents_length (req->dst);if (unlikely (dst_len >U32_MAX )) {
@@ -406,9 +407,9 @@ __virtio_crypto_ablkcipher_do_req(struct virtio_crypto_sym_request *vc_sym_req, }pr_debug ("virtio_crypto: src_len: %u, dst_len: %llu\n" , - req->nbytes, dst_len); + req->cryptlen, dst_len); -if (unlikely (req->nbytes + dst_len + ivsize + +if (unlikely (req->cryptlen + dst_len + ivsize +sizeof (vc_req->status) > vcrypto->max_size)) {pr_err ("virtio_crypto: The length is too big\n" ); err = -EINVAL ;
@@ -434,10 +435,10 @@ __virtio_crypto_ablkcipher_do_req(struct virtio_crypto_sym_request *vc_sym_req, err = -ENOMEM ; goto free; } -memcpy (iv, req->info, ivsize); +memcpy (iv, req->iv, ivsize);if (!vc_sym_req->encrypt) -scatterwalk_map_and_copy (req->info, req->src, - req->nbytes -AES_BLOCK_SIZE , +scatterwalk_map_and_copy (req->iv, req->src, + req->cryptlen -AES_BLOCK_SIZE ,AES_BLOCK_SIZE ,0 );sg_init_one (&iv_sg, iv, ivsize);
@@ -476,93 +477,93 @@ __virtio_crypto_ablkcipher_do_req(struct virtio_crypto_sym_request *vc_sym_req,return err; } -static int virtio_crypto_ablkcipher_encrypt (struct ablkcipher_request *req) +static int virtio_crypto_skcipher_encrypt (struct skcipher_request *req) { -struct crypto_ablkcipher *atfm =crypto_ablkcipher_reqtfm (req); -struct virtio_crypto_ablkcipher_ctx *ctx =crypto_ablkcipher_ctx (atfm); +struct crypto_skcipher *atfm =crypto_skcipher_reqtfm (req); +struct virtio_crypto_skcipher_ctx *ctx =crypto_skcipher_ctx (atfm);struct virtio_crypto_sym_request *vc_sym_req = -ablkcipher_request_ctx (req); +skcipher_request_ctx (req);struct virtio_crypto_request *vc_req = &vc_sym_req->base;struct virtio_crypto *vcrypto = ctx->vcrypto;/* Use the first data virtqueue as default */ struct data_queue *data_vq = &vcrypto->data_vq[0 ]; -if (!req->nbytes) +if (!req->cryptlen)return 0 ; -if (req->nbytes %AES_BLOCK_SIZE ) +if (req->cryptlen %AES_BLOCK_SIZE )return -EINVAL ; vc_req->dataq = data_vq; vc_req->alg_cb = virtio_crypto_dataq_sym_callback; - vc_sym_req->ablkcipher_ctx = ctx; - vc_sym_req->ablkcipher_req = req; + vc_sym_req->skcipher_ctx = ctx; + vc_sym_req->skcipher_req = req; vc_sym_req->encrypt = true; -return crypto_transfer_ablkcipher_request_to_engine (data_vq->engine, req); +return crypto_transfer_skcipher_request_to_engine (data_vq->engine, req); } -static int virtio_crypto_ablkcipher_decrypt (struct ablkcipher_request *req) +static int virtio_crypto_skcipher_decrypt (struct skcipher_request *req) { -struct crypto_ablkcipher *atfm =crypto_ablkcipher_reqtfm (req); -struct virtio_crypto_ablkcipher_ctx *ctx =crypto_ablkcipher_ctx (atfm); +struct crypto_skcipher *atfm =crypto_skcipher_reqtfm (req); +struct virtio_crypto_skcipher_ctx *ctx =crypto_skcipher_ctx (atfm);struct virtio_crypto_sym_request *vc_sym_req = -ablkcipher_request_ctx (req); +skcipher_request_ctx (req);struct virtio_crypto_request *vc_req = &vc_sym_req->base;struct virtio_crypto *vcrypto = ctx->vcrypto;/* Use the first data virtqueue as default */ struct data_queue *data_vq = &vcrypto->data_vq[0 ]; -if (!req->nbytes) +if (!req->cryptlen)return 0 ; -if (req->nbytes %AES_BLOCK_SIZE ) +if (req->cryptlen %AES_BLOCK_SIZE )return -EINVAL ; vc_req->dataq = data_vq; vc_req->alg_cb = virtio_crypto_dataq_sym_callback; - vc_sym_req->ablkcipher_ctx = ctx; - vc_sym_req->ablkcipher_req = req; + vc_sym_req->skcipher_ctx = ctx; + vc_sym_req->skcipher_req = req; vc_sym_req->encrypt = false; -return crypto_transfer_ablkcipher_request_to_engine (data_vq->engine, req); +return crypto_transfer_skcipher_request_to_engine (data_vq->engine, req); } -static int virtio_crypto_ablkcipher_init (struct crypto_tfm *tfm) +static int virtio_crypto_skcipher_init (struct crypto_skcipher *tfm) { -struct virtio_crypto_ablkcipher_ctx *ctx =crypto_tfm_ctx (tfm); +struct virtio_crypto_skcipher_ctx *ctx =crypto_skcipher_ctx (tfm); - tfm->crt_ablkcipher.reqsize =sizeof (struct virtio_crypto_sym_request ); +crypto_skcipher_set_reqsize (tfm,sizeof (struct virtio_crypto_sym_request )); ctx->tfm = tfm; - ctx->enginectx.op.do_one_request = virtio_crypto_ablkcipher_crypt_req; + ctx->enginectx.op.do_one_request = virtio_crypto_skcipher_crypt_req; ctx->enginectx.op.prepare_request =NULL ; ctx->enginectx.op.unprepare_request =NULL ;return 0 ; } -static void virtio_crypto_ablkcipher_exit (struct crypto_tfm *tfm) +static void virtio_crypto_skcipher_exit (struct crypto_skcipher *tfm) { -struct virtio_crypto_ablkcipher_ctx *ctx =crypto_tfm_ctx (tfm); +struct virtio_crypto_skcipher_ctx *ctx =crypto_skcipher_ctx (tfm);if (!ctx->vcrypto)return ; -virtio_crypto_alg_ablkcipher_close_session (ctx,1 ); -virtio_crypto_alg_ablkcipher_close_session (ctx,0 ); +virtio_crypto_alg_skcipher_close_session (ctx,1 ); +virtio_crypto_alg_skcipher_close_session (ctx,0 );virtcrypto_dev_put (ctx->vcrypto); ctx->vcrypto =NULL ; } -int virtio_crypto_ablkcipher_crypt_req ( +int virtio_crypto_skcipher_crypt_req (struct crypto_engine *engine,void *vreq) { - struct ablkcipher_request *req = container_of(vreq, struct ablkcipher_request, base); + struct skcipher_request *req = container_of(vreq, struct skcipher_request, base);struct virtio_crypto_sym_request *vc_sym_req = -ablkcipher_request_ctx (req); +skcipher_request_ctx (req);struct virtio_crypto_request *vc_req = &vc_sym_req->base;struct data_queue *data_vq = vc_req->dataq;int ret; - ret =__virtio_crypto_ablkcipher_do_req (vc_sym_req, req, data_vq); + ret =__virtio_crypto_skcipher_do_req (vc_sym_req, req, data_vq);if (ret <0 )return ret;
@@ -571,16 +572,16 @@ int virtio_crypto_ablkcipher_crypt_req(return 0 ; } -static void virtio_crypto_ablkcipher_finalize_req ( +static void virtio_crypto_skcipher_finalize_req (struct virtio_crypto_sym_request *vc_sym_req, -struct ablkcipher_request *req, +struct skcipher_request *req,int err) {if (vc_sym_req->encrypt) -scatterwalk_map_and_copy (req->info, req->dst, - req->nbytes -AES_BLOCK_SIZE , +scatterwalk_map_and_copy (req->iv, req->dst, + req->cryptlen -AES_BLOCK_SIZE ,AES_BLOCK_SIZE ,0 ); -crypto_finalize_ablkcipher_request (vc_sym_req->base.dataq->engine, +crypto_finalize_skcipher_request (vc_sym_req->base.dataq->engine, req, err);kzfree (vc_sym_req->iv);virtcrypto_clear_request (&vc_sym_req->base);
@@ -590,27 +591,21 @@ static struct virtio_crypto_algo virtio_crypto_algs[] = { { .algonum = VIRTIO_CRYPTO_CIPHER_AES_CBC, .service = VIRTIO_CRYPTO_SERVICE_CIPHER, .algo = { - .cra_name = "cbc(aes)", - .cra_driver_name = "virtio_crypto_aes_cbc", - .cra_priority = 150, - .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, - .cra_blocksize = AES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct virtio_crypto_ablkcipher_ctx), - .cra_alignmask = 0, - .cra_module = THIS_MODULE, - .cra_type = &crypto_ablkcipher_type, - .cra_init = virtio_crypto_ablkcipher_init, - .cra_exit = virtio_crypto_ablkcipher_exit, - .cra_u = { - .ablkcipher = { - .setkey = virtio_crypto_ablkcipher_setkey, - .decrypt = virtio_crypto_ablkcipher_decrypt, - .encrypt = virtio_crypto_ablkcipher_encrypt, - .min_keysize = AES_MIN_KEY_SIZE, - .max_keysize = AES_MAX_KEY_SIZE, - .ivsize = AES_BLOCK_SIZE, - }, - }, + .base.cra_name = "cbc(aes)", + .base.cra_driver_name = "virtio_crypto_aes_cbc", + .base.cra_priority = 150, + .base.cra_flags = CRYPTO_ALG_ASYNC, + .base.cra_blocksize = AES_BLOCK_SIZE, + .base.cra_ctxsize = sizeof(struct virtio_crypto_skcipher_ctx), + .base.cra_module = THIS_MODULE, + .init = virtio_crypto_skcipher_init, + .exit = virtio_crypto_skcipher_exit, + .setkey = virtio_crypto_skcipher_setkey, + .decrypt = virtio_crypto_skcipher_decrypt, + .encrypt = virtio_crypto_skcipher_encrypt, + .min_keysize = AES_MIN_KEY_SIZE, + .max_keysize = AES_MAX_KEY_SIZE, + .ivsize = AES_BLOCK_SIZE, }, } };
@@ -630,14 +625,14 @@ int virtio_crypto_algs_register(struct virtio_crypto *vcrypto)continue ;if (virtio_crypto_algs[i].active_devs ==0 ) { - ret =crypto_register_alg (&virtio_crypto_algs[i].algo); + ret =crypto_register_skcipher (&virtio_crypto_algs[i].algo);if (ret) goto unlock; } virtio_crypto_algs[i].active_devs++;dev_info (&vcrypto->vdev->dev,"Registered algo %s\n" , - virtio_crypto_algs[i].algo.cra_name); + virtio_crypto_algs[i].algo.base.cra_name); } unlock:
@@ -661,7 +656,7 @@ void virtio_crypto_algs_unregister(struct virtio_crypto *vcrypto)continue ;if (virtio_crypto_algs[i].active_devs ==1 ) -crypto_unregister_alg (&virtio_crypto_algs[i].algo); +crypto_unregister_skcipher (&virtio_crypto_algs[i].algo); virtio_crypto_algs[i].active_devs--; }
drivers/crypto/virtio/virtio_crypto_common.h +1 -1
@@ -112,7 +112,7 @@ struct virtio_crypto *virtcrypto_get_dev_node(int node, uint32_t algo);int virtcrypto_dev_start (struct virtio_crypto *vcrypto);void virtcrypto_dev_stop (struct virtio_crypto *vcrypto); -int virtio_crypto_ablkcipher_crypt_req ( +int virtio_crypto_skcipher_crypt_req (struct crypto_engine *engine,void *vreq);void
Signature · 1 line
2.17.1
PATCH v4 4/29 crypto: ccp - switch from ablkcipher to skcipher
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/ccp/ccp-crypto-aes-galois.c | 7 +- drivers/crypto/ccp/ccp-crypto-aes-xts.c | 94 +++++------ drivers/crypto/ccp/ccp-crypto-aes.c | 169 +++++++++----------- drivers/crypto/ccp/ccp-crypto-des3.c | 100 ++++++------ drivers/crypto/ccp/ccp-crypto-main.c | 14 +- drivers/crypto/ccp/ccp-crypto.h | 13 +- 6 files changed, 186 insertions(+), 211 deletions(-)
drivers/crypto/ccp/ccp-crypto-aes-galois.c +2 -5
@@ -172,14 +172,12 @@ static struct aead_alg ccp_aes_gcm_defaults = { .ivsize = GCM_AES_IV_SIZE, .maxauthsize = AES_BLOCK_SIZE, .base = { - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC | + .cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_KERN_DRIVER_ONLY | CRYPTO_ALG_NEED_FALLBACK, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct ccp_ctx), .cra_priority = CCP_CRA_PRIORITY, - .cra_type = &crypto_ablkcipher_type, .cra_exit = ccp_aes_gcm_cra_exit, .cra_module = THIS_MODULE, },
@@ -229,11 +227,10 @@ static int ccp_register_aes_aead(struct list_head *head,snprintf (alg->base.cra_driver_name,CRYPTO_MAX_ALG_NAME ,"%s" , def->driver_name); alg->base.cra_blocksize = def->blocksize; - alg->base.cra_ablkcipher.ivsize = def->ivsize; ret =crypto_register_aead (alg);if (ret) { -pr_err ("%s ablkcipher algorithm registration error (%d)\n" , +pr_err ("%s aead algorithm registration error (%d)\n" , alg->base.cra_name, ret);kfree (ccp_aead);return ret;
drivers/crypto/ccp/ccp-crypto-aes-xts.c +47 -47
197 lines not on this page · raw message
drivers/crypto/ccp/ccp-crypto-aes.c +77 -92
313 lines not on this page · raw message
drivers/crypto/ccp/ccp-crypto-des3.c +46 -54
190 lines not on this page · raw message
drivers/crypto/ccp/ccp-crypto-main.c +7 -7
@@ -41,7 +41,7 @@ MODULE_PARM_DESC(rsa_disable, "Disable use of RSA - any non-zero value");/* List heads for the supported algorithms */ static LIST_HEAD (hash_algs); -static LIST_HEAD (cipher_algs); +static LIST_HEAD (skcipher_algs);static LIST_HEAD (aead_algs);static LIST_HEAD (akcipher_algs);
@@ -330,7 +330,7 @@ static int ccp_register_algs(void)int ret;if (!aes_disable) { - ret =ccp_register_aes_algs (&cipher_algs); + ret =ccp_register_aes_algs (&skcipher_algs);if (ret)return ret;
@@ -338,7 +338,7 @@ static int ccp_register_algs(void)if (ret)return ret; - ret =ccp_register_aes_xts_algs (&cipher_algs); + ret =ccp_register_aes_xts_algs (&skcipher_algs);if (ret)return ret;
@@ -348,7 +348,7 @@ static int ccp_register_algs(void) }if (!des3_disable) { - ret =ccp_register_des3_algs (&cipher_algs); + ret =ccp_register_des3_algs (&skcipher_algs);if (ret)return ret; }
@@ -371,7 +371,7 @@ static int ccp_register_algs(void)static void ccp_unregister_algs (void ) {struct ccp_crypto_ahash_alg *ahash_alg, *ahash_tmp; -struct ccp_crypto_ablkcipher_alg *ablk_alg, *ablk_tmp; +struct ccp_crypto_skcipher_alg *ablk_alg, *ablk_tmp;struct ccp_crypto_aead *aead_alg, *aead_tmp;struct ccp_crypto_akcipher_alg *akc_alg, *akc_tmp;
@@ -381,8 +381,8 @@ static void ccp_unregister_algs(void)kfree (ahash_alg); } -list_for_each_entry_safe (ablk_alg, ablk_tmp, &cipher_algs, entry) { -crypto_unregister_alg (&ablk_alg->alg); +list_for_each_entry_safe (ablk_alg, ablk_tmp, &skcipher_algs, entry) { +crypto_unregister_skcipher (&ablk_alg->alg);list_del (&ablk_alg->entry);kfree (ablk_alg); }
drivers/crypto/ccp/ccp-crypto.h +7 -6
@@ -21,6 +21,7 @@#include <crypto/hash.h> #include <crypto/sha.h> #include <crypto/akcipher.h> +#include <crypto/skcipher.h> #include <crypto/internal/rsa.h> /* We want the module name in front of our messages */
@@ -31,12 +32,12 @@#define CCP_CRA_PRIORITY 300 -struct ccp_crypto_ablkcipher_alg { +struct ccp_crypto_skcipher_alg {struct list_head entry;u32 mode; -struct crypto_alg alg; +struct skcipher_alg alg; };struct ccp_crypto_aead {
@@ -66,12 +67,12 @@ struct ccp_crypto_akcipher_alg {struct akcipher_alg alg; }; -static inline struct ccp_crypto_ablkcipher_alg * -ccp_crypto_ablkcipher_alg (struct crypto_tfm *tfm) +static inline struct ccp_crypto_skcipher_alg * +ccp_crypto_skcipher_alg (struct crypto_skcipher *tfm) { -struct crypto_alg *alg = tfm->__crt_alg; +struct skcipher_alg *alg =crypto_skcipher_alg (tfm); - return container_of(alg, struct ccp_crypto_ablkcipher_alg, alg); + return container_of(alg, struct ccp_crypto_skcipher_alg, alg); } static inline struct ccp_crypto_ahash_alg *
Signature · 1 line
2.17.1
PATCH v4 5/29 crypto: omap - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/omap-aes.c | 209 +++++++++--------- drivers/crypto/omap-aes.h | 4 +- drivers/crypto/omap-des.c | 232 +++++++++----------- 3 files changed, 207 insertions(+), 238 deletions(-)
drivers/crypto/omap-aes.c +101 -108
@@ -142,8 +142,8 @@ int omap_aes_write_ctrl(struct omap_aes_dev *dd) __le32_to_cpu(dd->ctx->key[i])); } -if ((dd->flags & (FLAGS_CBC |FLAGS_CTR )) && dd->req->info) -omap_aes_write_n (dd,AES_REG_IV (dd,0 ), dd->req->info,4 ); +if ((dd->flags & (FLAGS_CBC |FLAGS_CTR )) && dd->req->iv) +omap_aes_write_n (dd,AES_REG_IV (dd,0 ), (void *)dd->req->iv,4 );if ((dd->flags & (FLAGS_GCM )) && dd->aead_req->iv) { rctx =aead_request_ctx (dd->aead_req);
@@ -382,11 +382,11 @@ int omap_aes_crypt_dma_start(struct omap_aes_dev *dd)static void omap_aes_finish_req (struct omap_aes_dev *dd,int err) { -struct ablkcipher_request *req = dd->req; +struct skcipher_request *req = dd->req;pr_debug ("err: %d\n" , err); -crypto_finalize_ablkcipher_request (dd->engine, req, err); +crypto_finalize_skcipher_request (dd->engine, req, err);pm_runtime_mark_last_busy (dd->dev);pm_runtime_put_autosuspend (dd->dev);
@@ -403,10 +403,10 @@ int omap_aes_crypt_dma_stop(struct omap_aes_dev *dd) }static int omap_aes_handle_queue (struct omap_aes_dev *dd, -struct ablkcipher_request *req) +struct skcipher_request *req) {if (req) -return crypto_transfer_ablkcipher_request_to_engine (dd->engine, req); +return crypto_transfer_skcipher_request_to_engine (dd->engine, req);return 0 ; }
@@ -414,10 +414,10 @@ static int omap_aes_handle_queue(struct omap_aes_dev *dd,static int omap_aes_prepare_req (struct crypto_engine *engine,void *areq) { - struct ablkcipher_request *req = container_of(areq, struct ablkcipher_request, base); -struct omap_aes_ctx *ctx =crypto_ablkcipher_ctx ( -crypto_ablkcipher_reqtfm (req)); -struct omap_aes_reqctx *rctx =ablkcipher_request_ctx (req); + struct skcipher_request *req = container_of(areq, struct skcipher_request, base); +struct omap_aes_ctx *ctx =crypto_skcipher_ctx ( +crypto_skcipher_reqtfm (req)); +struct omap_aes_reqctx *rctx =skcipher_request_ctx (req);struct omap_aes_dev *dd = rctx->dd;int ret;u16 flags;
@@ -427,8 +427,8 @@ static int omap_aes_prepare_req(struct crypto_engine *engine,/* assign new request to device */ dd->req = req; - dd->total = req->nbytes; - dd->total_save = req->nbytes; + dd->total = req->cryptlen; + dd->total_save = req->cryptlen; dd->in_sg = req->src; dd->out_sg = req->dst; dd->orig_out = req->dst;
@@ -469,8 +469,8 @@ static int omap_aes_prepare_req(struct crypto_engine *engine,static int omap_aes_crypt_req (struct crypto_engine *engine,void *areq) { - struct ablkcipher_request *req = container_of(areq, struct ablkcipher_request, base); -struct omap_aes_reqctx *rctx =ablkcipher_request_ctx (req); + struct skcipher_request *req = container_of(areq, struct skcipher_request, base); +struct omap_aes_reqctx *rctx =skcipher_request_ctx (req);struct omap_aes_dev *dd = rctx->dd;if (!dd)
@@ -505,26 +505,26 @@ static void omap_aes_done_task(unsigned long data)pr_debug ("exit\n" ); } -static int omap_aes_crypt (struct ablkcipher_request *req,unsigned long mode) +static int omap_aes_crypt (struct skcipher_request *req,unsigned long mode) { -struct omap_aes_ctx *ctx =crypto_ablkcipher_ctx ( -crypto_ablkcipher_reqtfm (req)); -struct omap_aes_reqctx *rctx =ablkcipher_request_ctx (req); +struct omap_aes_ctx *ctx =crypto_skcipher_ctx ( +crypto_skcipher_reqtfm (req)); +struct omap_aes_reqctx *rctx =skcipher_request_ctx (req);struct omap_aes_dev *dd;int ret; -pr_debug ("nbytes: %d, enc: %d, cbc: %d\n" , req->nbytes, +pr_debug ("nbytes: %d, enc: %d, cbc: %d\n" , req->cryptlen, !!(mode &FLAGS_ENCRYPT ), !!(mode &FLAGS_CBC )); -if (req->nbytes < aes_fallback_sz) { +if (req->cryptlen < aes_fallback_sz) {SYNC_SKCIPHER_REQUEST_ON_STACK (subreq, ctx->fallback);skcipher_request_set_sync_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); + req->cryptlen, req->iv);if (mode &FLAGS_ENCRYPT ) ret =crypto_skcipher_encrypt (subreq);
@@ -545,10 +545,10 @@ static int omap_aes_crypt(struct ablkcipher_request *req, unsigned long mode)/* ********************** ALG API ************************************ */ -static int omap_aes_setkey (struct crypto_ablkcipher *tfm,const u8 *key, +static int omap_aes_setkey (struct crypto_skcipher *tfm,const u8 *key,unsigned int keylen) { -struct omap_aes_ctx *ctx =crypto_ablkcipher_ctx (tfm); +struct omap_aes_ctx *ctx =crypto_skcipher_ctx (tfm);int ret; if (keylen != AES_KEYSIZE_128 && keylen != AES_KEYSIZE_192 &&
@@ -571,32 +571,32 @@ static int omap_aes_setkey(struct crypto_ablkcipher *tfm, const u8 *key,return 0 ; } -static int omap_aes_ecb_encrypt (struct ablkcipher_request *req) +static int omap_aes_ecb_encrypt (struct skcipher_request *req) {return omap_aes_crypt (req,FLAGS_ENCRYPT ); } -static int omap_aes_ecb_decrypt (struct ablkcipher_request *req) +static int omap_aes_ecb_decrypt (struct skcipher_request *req) {return omap_aes_crypt (req,0 ); } -static int omap_aes_cbc_encrypt (struct ablkcipher_request *req) +static int omap_aes_cbc_encrypt (struct skcipher_request *req) {return omap_aes_crypt (req,FLAGS_ENCRYPT |FLAGS_CBC ); } -static int omap_aes_cbc_decrypt (struct ablkcipher_request *req) +static int omap_aes_cbc_decrypt (struct skcipher_request *req) {return omap_aes_crypt (req,FLAGS_CBC ); } -static int omap_aes_ctr_encrypt (struct ablkcipher_request *req) +static int omap_aes_ctr_encrypt (struct skcipher_request *req) {return omap_aes_crypt (req,FLAGS_ENCRYPT |FLAGS_CTR ); } -static int omap_aes_ctr_decrypt (struct ablkcipher_request *req) +static int omap_aes_ctr_decrypt (struct skcipher_request *req) {return omap_aes_crypt (req,FLAGS_CTR ); }
@@ -606,10 +606,10 @@ static int omap_aes_prepare_req(struct crypto_engine *engine,static int omap_aes_crypt_req (struct crypto_engine *engine,void *req); -static int omap_aes_cra_init (struct crypto_tfm *tfm) +static int omap_aes_init_tfm (struct crypto_skcipher *tfm) { -const char *name =crypto_tfm_alg_name (tfm); -struct omap_aes_ctx *ctx =crypto_tfm_ctx (tfm); +const char *name =crypto_tfm_alg_name (&tfm->base); +struct omap_aes_ctx *ctx =crypto_skcipher_ctx (tfm);struct crypto_sync_skcipher *blk; blk =crypto_alloc_sync_skcipher (name,0 ,CRYPTO_ALG_NEED_FALLBACK );
@@ -618,7 +618,7 @@ static int omap_aes_cra_init(struct crypto_tfm *tfm) ctx->fallback = blk; - tfm->crt_ablkcipher.reqsize =sizeof (struct omap_aes_reqctx ); +crypto_skcipher_set_reqsize (tfm,sizeof (struct omap_aes_reqctx )); ctx->enginectx.op.prepare_request = omap_aes_prepare_req; ctx->enginectx.op.unprepare_request =NULL ;
@@ -657,9 +657,9 @@ static int omap_aes_gcm_cra_init(struct crypto_aead *tfm)return 0 ; } -static void omap_aes_cra_exit (struct crypto_tfm *tfm) +static void omap_aes_exit_tfm (struct crypto_skcipher *tfm) { -struct omap_aes_ctx *ctx =crypto_tfm_ctx (tfm); +struct omap_aes_ctx *ctx =crypto_skcipher_ctx (tfm);if (ctx->fallback)crypto_free_sync_skcipher (ctx->fallback);
@@ -671,7 +671,10 @@ static void omap_aes_gcm_cra_exit(struct crypto_aead *tfm) {struct omap_aes_ctx *ctx =crypto_aead_ctx (tfm); -omap_aes_cra_exit (crypto_aead_tfm (tfm)); +if (ctx->fallback) +crypto_free_sync_skcipher (ctx->fallback); + + ctx->fallback =NULL ;if (ctx->ctr)crypto_free_skcipher (ctx->ctr);
@@ -679,78 +682,69 @@ static void omap_aes_gcm_cra_exit(struct crypto_aead *tfm)/* ********************** ALGS ************************************ */ -static struct crypto_alg algs_ecb_cbc[] = { +static struct skcipher_alg algs_ecb_cbc[] = { { - .cra_name ="ecb(aes)" , - .cra_driver_name ="ecb-aes-omap" , - .cra_priority =300 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_KERN_DRIVER_ONLY | -CRYPTO_ALG_ASYNC |CRYPTO_ALG_NEED_FALLBACK , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct omap_aes_ctx ), - .cra_alignmask =0 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = omap_aes_cra_init, - .cra_exit = omap_aes_cra_exit, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .setkey = omap_aes_setkey, - .encrypt = omap_aes_ecb_encrypt, - .decrypt = omap_aes_ecb_decrypt, - } + .base.cra_name ="ecb(aes)" , + .base.cra_driver_name ="ecb-aes-omap" , + .base.cra_priority =300 , + .base.cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY | +CRYPTO_ALG_ASYNC | +CRYPTO_ALG_NEED_FALLBACK , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct omap_aes_ctx ), + .base.cra_module =THIS_MODULE , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = omap_aes_setkey, + .encrypt = omap_aes_ecb_encrypt, + .decrypt = omap_aes_ecb_decrypt, + .init = omap_aes_init_tfm, + .exit = omap_aes_exit_tfm, }, { - .cra_name ="cbc(aes)" , - .cra_driver_name ="cbc-aes-omap" , - .cra_priority =300 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_KERN_DRIVER_ONLY | -CRYPTO_ALG_ASYNC |CRYPTO_ALG_NEED_FALLBACK , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct omap_aes_ctx ), - .cra_alignmask =0 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = omap_aes_cra_init, - .cra_exit = omap_aes_cra_exit, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = omap_aes_setkey, - .encrypt = omap_aes_cbc_encrypt, - .decrypt = omap_aes_cbc_decrypt, - } + .base.cra_name ="cbc(aes)" , + .base.cra_driver_name ="cbc-aes-omap" , + .base.cra_priority =300 , + .base.cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY | +CRYPTO_ALG_ASYNC | +CRYPTO_ALG_NEED_FALLBACK , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct omap_aes_ctx ), + .base.cra_module =THIS_MODULE , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , + .setkey = omap_aes_setkey, + .encrypt = omap_aes_cbc_encrypt, + .decrypt = omap_aes_cbc_decrypt, + .init = omap_aes_init_tfm, + .exit = omap_aes_exit_tfm, } }; -static struct crypto_alg algs_ctr[] = { +static struct skcipher_alg algs_ctr[] = { { - .cra_name ="ctr(aes)" , - .cra_driver_name ="ctr-aes-omap" , - .cra_priority =300 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_KERN_DRIVER_ONLY | -CRYPTO_ALG_ASYNC |CRYPTO_ALG_NEED_FALLBACK , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct omap_aes_ctx ), - .cra_alignmask =0 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = omap_aes_cra_init, - .cra_exit = omap_aes_cra_exit, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = omap_aes_setkey, - .encrypt = omap_aes_ctr_encrypt, - .decrypt = omap_aes_ctr_decrypt, - } -} , + .base.cra_name ="ctr(aes)" , + .base.cra_driver_name ="ctr-aes-omap" , + .base.cra_priority =300 , + .base.cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY | +CRYPTO_ALG_ASYNC | +CRYPTO_ALG_NEED_FALLBACK , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct omap_aes_ctx ), + .base.cra_module =THIS_MODULE , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , + .setkey = omap_aes_setkey, + .encrypt = omap_aes_ctr_encrypt, + .decrypt = omap_aes_ctr_decrypt, + .init = omap_aes_init_tfm, + .exit = omap_aes_exit_tfm, +} };static struct omap_aes_algs_info omap_aes_algs_info_ecb_cbc[] = {
@@ -1121,7 +1115,7 @@ static int omap_aes_probe(struct platform_device *pdev) {struct device *dev = &pdev->dev;struct omap_aes_dev *dd; -struct crypto_alg *algp; +struct skcipher_alg *algp;struct aead_alg *aalg;struct resource res;int err = -ENOMEM , i, j, irq =-1 ;
@@ -1215,9 +1209,9 @@ static int omap_aes_probe(struct platform_device *pdev)for (j =0 ; j < dd->pdata->algs_info[i].size; j++) { algp = &dd->pdata->algs_info[i].algs_list[j]; -pr_debug ("reg alg: %s\n" , algp->cra_name); +pr_debug ("reg alg: %s\n" , algp->base.cra_name); - err =crypto_register_alg (algp); + err =crypto_register_skcipher (algp);if (err) goto err_algs;
@@ -1230,9 +1224,8 @@ static int omap_aes_probe(struct platform_device *pdev) !dd->pdata->aead_algs_info->registered) {for (i =0 ; i < dd->pdata->aead_algs_info->size; i++) { aalg = &dd->pdata->aead_algs_info->algs_list[i]; - algp = &aalg->base; -pr_debug ("reg alg: %s\n" , algp->cra_name); +pr_debug ("reg alg: %s\n" , aalg->base.cra_name); err =crypto_register_aead (aalg);if (err)
@@ -1257,7 +1250,7 @@ static int omap_aes_probe(struct platform_device *pdev) 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 ( +crypto_unregister_skcipher ( &dd->pdata->algs_info[i].algs_list[j]); err_engine:
@@ -1290,7 +1283,7 @@ static int omap_aes_remove(struct platform_device *pdev)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 ( +crypto_unregister_skcipher ( &dd->pdata->algs_info[i].algs_list[j]);for (i = dd->pdata->aead_algs_info->size -1 ; i >=0 ; i--) {
drivers/crypto/omap-aes.h +2 -2
@@ -112,7 +112,7 @@ struct omap_aes_reqctx {#define OMAP_AES_CACHE_SIZE 0struct omap_aes_algs_info { -struct crypto_alg *algs_list; +struct skcipher_alg *algs_list;unsigned int size;unsigned int registered; };
@@ -162,7 +162,7 @@ struct omap_aes_dev {struct aead_queue aead_queue;spinlock_t lock; -struct ablkcipher_request *req; +struct skcipher_request *req;struct aead_request *aead_req;struct crypto_engine *engine;
drivers/crypto/omap-des.c +104 -128
411 lines not on this page · raw message
Signature · 1 line
2.17.1
PATCH v4 6/29 crypto: ux500 - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/ux500/cryp/cryp_core.c | 371 ++++++++------------ 1 file changed, 156 insertions(+), 215 deletions(-)
drivers/crypto/ux500/cryp/cryp_core.c +156 -215
@@ -30,6 +30,7 @@#include <crypto/algapi.h> #include <crypto/ctr.h> #include <crypto/internal/des.h> +#include <crypto/internal/skcipher.h> #include <crypto/scatterwalk.h> #include <linux/platform_data/crypto-ux500.h>
@@ -828,10 +829,10 @@ static int get_nents(struct scatterlist *sg, int nbytes)return nents; } -static int ablk_dma_crypt (struct ablkcipher_request *areq) +static int ablk_dma_crypt (struct skcipher_request *areq) { -struct crypto_ablkcipher *cipher =crypto_ablkcipher_reqtfm (areq); -struct cryp_ctx *ctx =crypto_ablkcipher_ctx (cipher); +struct crypto_skcipher *cipher =crypto_skcipher_reqtfm (areq); +struct cryp_ctx *ctx =crypto_skcipher_ctx (cipher);struct cryp_device_data *device_data;int bytes_written =0 ;
@@ -840,8 +841,8 @@ static int ablk_dma_crypt(struct ablkcipher_request *areq)pr_debug (DEV_DBG_NAME " [%s]" , __func__); - ctx->datalen = areq->nbytes; - ctx->outlen = areq->nbytes; + ctx->datalen = areq->cryptlen; + ctx->outlen = areq->cryptlen; ret =cryp_get_device_data (ctx, &device_data);if (ret)
@@ -885,11 +886,11 @@ static int ablk_dma_crypt(struct ablkcipher_request *areq)return 0 ; } -static int ablk_crypt (struct ablkcipher_request *areq) +static int ablk_crypt (struct skcipher_request *areq) { -struct ablkcipher_walk walk; -struct crypto_ablkcipher *cipher =crypto_ablkcipher_reqtfm (areq); -struct cryp_ctx *ctx =crypto_ablkcipher_ctx (cipher); +struct skcipher_walk walk; +struct crypto_skcipher *cipher =crypto_skcipher_reqtfm (areq); +struct cryp_ctx *ctx =crypto_skcipher_ctx (cipher);struct cryp_device_data *device_data;unsigned long src_paddr;unsigned long dst_paddr;
@@ -902,21 +903,20 @@ static int ablk_crypt(struct ablkcipher_request *areq)if (ret) goto out; -ablkcipher_walk_init (&walk, areq->dst, areq->src, areq->nbytes); - ret =ablkcipher_walk_phys (areq, &walk); + ret =skcipher_walk_async (&walk, areq);if (ret) { -pr_err (DEV_DBG_NAME "[%s]: ablkcipher_walk_phys() failed!" , +pr_err (DEV_DBG_NAME "[%s]: skcipher_walk_async() failed!" , __func__); goto out; }while ((nbytes = walk.nbytes) >0 ) { ctx->iv = walk.iv; - src_paddr = (page_to_phys (walk.src.page) + walk.src.offset); + src_paddr = (page_to_phys (walk.src.phys.page) + walk.src.phys.offset); ctx->indata =phys_to_virt (src_paddr); - dst_paddr = (page_to_phys (walk.dst.page) + walk.dst.offset); + dst_paddr = (page_to_phys (walk.dst.phys.page) + walk.dst.phys.offset); ctx->outdata =phys_to_virt (dst_paddr); ctx->datalen = nbytes - (nbytes % ctx->blocksize);
@@ -926,11 +926,10 @@ static int ablk_crypt(struct ablkcipher_request *areq) goto out; nbytes -= ctx->datalen; - ret =ablkcipher_walk_done (areq, &walk, nbytes); + ret =skcipher_walk_done (&walk, nbytes);if (ret) goto out; } -ablkcipher_walk_complete (&walk); out:/* Release the device */
@@ -948,10 +947,10 @@ static int ablk_crypt(struct ablkcipher_request *areq)return ret; } -static int aes_ablkcipher_setkey (struct crypto_ablkcipher *cipher, +static int aes_skcipher_setkey (struct crypto_skcipher *cipher,const u8 *key,unsigned int keylen) { -struct cryp_ctx *ctx =crypto_ablkcipher_ctx (cipher); +struct cryp_ctx *ctx =crypto_skcipher_ctx (cipher);u32 *flags = &cipher->base.crt_flags;pr_debug (DEV_DBG_NAME " [%s]" , __func__);
@@ -983,15 +982,15 @@ static int aes_ablkcipher_setkey(struct crypto_ablkcipher *cipher,return 0 ; } -static int des_ablkcipher_setkey (struct crypto_ablkcipher *cipher, +static int des_skcipher_setkey (struct crypto_skcipher *cipher,const u8 *key,unsigned int keylen) { -struct cryp_ctx *ctx =crypto_ablkcipher_ctx (cipher); +struct cryp_ctx *ctx =crypto_skcipher_ctx (cipher);int err;pr_debug (DEV_DBG_NAME " [%s]" , __func__); - err =verify_ablkcipher_des_key (cipher, key); + err =verify_skcipher_des_key (cipher, key);if (err)return err;
@@ -1002,15 +1001,15 @@ static int des_ablkcipher_setkey(struct crypto_ablkcipher *cipher,return 0 ; } -static int des3_ablkcipher_setkey (struct crypto_ablkcipher *cipher, +static int des3_skcipher_setkey (struct crypto_skcipher *cipher,const u8 *key,unsigned int keylen) { -struct cryp_ctx *ctx =crypto_ablkcipher_ctx (cipher); +struct cryp_ctx *ctx =crypto_skcipher_ctx (cipher);int err;pr_debug (DEV_DBG_NAME " [%s]" , __func__); - err =verify_ablkcipher_des3_key (cipher, key); + err =verify_skcipher_des3_key (cipher, key);if (err)return err;
@@ -1021,10 +1020,10 @@ static int des3_ablkcipher_setkey(struct crypto_ablkcipher *cipher,return 0 ; } -static int cryp_blk_encrypt (struct ablkcipher_request *areq) +static int cryp_blk_encrypt (struct skcipher_request *areq) { -struct crypto_ablkcipher *cipher =crypto_ablkcipher_reqtfm (areq); -struct cryp_ctx *ctx =crypto_ablkcipher_ctx (cipher); +struct crypto_skcipher *cipher =crypto_skcipher_reqtfm (areq); +struct cryp_ctx *ctx =crypto_skcipher_ctx (cipher);pr_debug (DEV_DBG_NAME " [%s]" , __func__);
@@ -1039,10 +1038,10 @@ static int cryp_blk_encrypt(struct ablkcipher_request *areq)return ablk_crypt (areq); } -static int cryp_blk_decrypt (struct ablkcipher_request *areq) +static int cryp_blk_decrypt (struct skcipher_request *areq) { -struct crypto_ablkcipher *cipher =crypto_ablkcipher_reqtfm (areq); -struct cryp_ctx *ctx =crypto_ablkcipher_ctx (cipher); +struct crypto_skcipher *cipher =crypto_skcipher_reqtfm (areq); +struct cryp_ctx *ctx =crypto_skcipher_ctx (cipher);pr_debug (DEV_DBG_NAME " [%s]" , __func__);
@@ -1058,19 +1057,19 @@ static int cryp_blk_decrypt(struct ablkcipher_request *areq)struct cryp_algo_template {enum cryp_algo_mode algomode; -struct crypto_alg crypto; +struct skcipher_alg skcipher; }; -static int cryp_cra_init (struct crypto_tfm *tfm) +static int cryp_init_tfm (struct crypto_skcipher *tfm) { -struct cryp_ctx *ctx =crypto_tfm_ctx (tfm); -struct crypto_alg *alg = tfm->__crt_alg; +struct cryp_ctx *ctx =crypto_skcipher_ctx (tfm); +struct skcipher_alg *alg =crypto_skcipher_alg (tfm);struct cryp_algo_template *cryp_alg =container_of (alg, struct cryp_algo_template, - crypto); + skcipher); ctx->config.algomode = cryp_alg->algomode; - ctx->blocksize =crypto_tfm_alg_blocksize (tfm); + ctx->blocksize =crypto_skcipher_blocksize (tfm);return 0 ; }
@@ -1078,205 +1077,147 @@ static int cryp_cra_init(struct crypto_tfm *tfm)static struct cryp_algo_template cryp_algs[] = { { .algomode =CRYP_ALGO_AES_ECB , - .crypto = { - .cra_name ="aes" , - .cra_driver_name ="aes-ux500" , - .cra_priority =300 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct cryp_ctx ), - .cra_alignmask =3 , - .cra_type = &crypto_ablkcipher_type, - .cra_init = cryp_cra_init, - .cra_module =THIS_MODULE , - .cra_u = { - .ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .setkey = aes_ablkcipher_setkey, - .encrypt = cryp_blk_encrypt, - .decrypt = cryp_blk_decrypt - } - } - } - }, - { - .algomode =CRYP_ALGO_AES_ECB , - .crypto = { - .cra_name ="ecb(aes)" , - .cra_driver_name ="ecb-aes-ux500" , - .cra_priority =300 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct cryp_ctx ), - .cra_alignmask =3 , - .cra_type = &crypto_ablkcipher_type, - .cra_init = cryp_cra_init, - .cra_module =THIS_MODULE , - .cra_u = { - .ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .setkey = aes_ablkcipher_setkey, - .encrypt = cryp_blk_encrypt, - .decrypt = cryp_blk_decrypt, - } - } + .skcipher = { + .base.cra_name ="ecb(aes)" , + .base.cra_driver_name ="ecb-aes-ux500" , + .base.cra_priority =300 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct cryp_ctx ), + .base.cra_alignmask =3 , + .base.cra_module =THIS_MODULE , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = aes_skcipher_setkey, + .encrypt = cryp_blk_encrypt, + .decrypt = cryp_blk_decrypt, + .init = cryp_init_tfm, } }, { .algomode =CRYP_ALGO_AES_CBC , - .crypto = { - .cra_name ="cbc(aes)" , - .cra_driver_name ="cbc-aes-ux500" , - .cra_priority =300 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct cryp_ctx ), - .cra_alignmask =3 , - .cra_type = &crypto_ablkcipher_type, - .cra_init = cryp_cra_init, - .cra_module =THIS_MODULE , - .cra_u = { - .ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .setkey = aes_ablkcipher_setkey, - .encrypt = cryp_blk_encrypt, - .decrypt = cryp_blk_decrypt, - .ivsize =AES_BLOCK_SIZE , - } - } + .skcipher = { + .base.cra_name ="cbc(aes)" , + .base.cra_driver_name ="cbc-aes-ux500" , + .base.cra_priority =300 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct cryp_ctx ), + .base.cra_alignmask =3 , + .base.cra_module =THIS_MODULE , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = aes_skcipher_setkey, + .encrypt = cryp_blk_encrypt, + .decrypt = cryp_blk_decrypt, + .init = cryp_init_tfm, + .ivsize =AES_BLOCK_SIZE , } }, { .algomode =CRYP_ALGO_AES_CTR , - .crypto = { - .cra_name ="ctr(aes)" , - .cra_driver_name ="ctr-aes-ux500" , - .cra_priority =300 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct cryp_ctx ), - .cra_alignmask =3 , - .cra_type = &crypto_ablkcipher_type, - .cra_init = cryp_cra_init, - .cra_module =THIS_MODULE , - .cra_u = { - .ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .setkey = aes_ablkcipher_setkey, - .encrypt = cryp_blk_encrypt, - .decrypt = cryp_blk_decrypt, - .ivsize =AES_BLOCK_SIZE , - } - } + .skcipher = { + .base.cra_name ="ctr(aes)" , + .base.cra_driver_name ="ctr-aes-ux500" , + .base.cra_priority =300 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =1 , + .base.cra_ctxsize =sizeof (struct cryp_ctx ), + .base.cra_alignmask =3 , + .base.cra_module =THIS_MODULE , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = aes_skcipher_setkey, + .encrypt = cryp_blk_encrypt, + .decrypt = cryp_blk_decrypt, + .init = cryp_init_tfm, + .ivsize =AES_BLOCK_SIZE , + .chunksize =AES_BLOCK_SIZE , } }, { .algomode =CRYP_ALGO_DES_ECB , - .crypto = { - .cra_name ="ecb(des)" , - .cra_driver_name ="ecb-des-ux500" , - .cra_priority =300 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_blocksize =DES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct cryp_ctx ), - .cra_alignmask =3 , - .cra_type = &crypto_ablkcipher_type, - .cra_init = cryp_cra_init, - .cra_module =THIS_MODULE , - .cra_u = { - .ablkcipher = { - .min_keysize =DES_KEY_SIZE , - .max_keysize =DES_KEY_SIZE , - .setkey = des_ablkcipher_setkey, - .encrypt = cryp_blk_encrypt, - .decrypt = cryp_blk_decrypt, - } - } + .skcipher = { + .base.cra_name ="ecb(des)" , + .base.cra_driver_name ="ecb-des-ux500" , + .base.cra_priority =300 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =DES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct cryp_ctx ), + .base.cra_alignmask =3 , + .base.cra_module =THIS_MODULE , + + .min_keysize =DES_KEY_SIZE , + .max_keysize =DES_KEY_SIZE , + .setkey = des_skcipher_setkey, + .encrypt = cryp_blk_encrypt, + .decrypt = cryp_blk_decrypt, + .init = cryp_init_tfm, } }, { .algomode =CRYP_ALGO_TDES_ECB , - .crypto = { - .cra_name ="ecb(des3_ede)" , - .cra_driver_name ="ecb-des3_ede-ux500" , - .cra_priority =300 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_blocksize =DES3_EDE_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct cryp_ctx ), - .cra_alignmask =3 , - .cra_type = &crypto_ablkcipher_type, - .cra_init = cryp_cra_init, - .cra_module =THIS_MODULE , - .cra_u = { - .ablkcipher = { - .min_keysize =DES3_EDE_KEY_SIZE , - .max_keysize =DES3_EDE_KEY_SIZE , - .setkey = des3_ablkcipher_setkey, - .encrypt = cryp_blk_encrypt, - .decrypt = cryp_blk_decrypt, - } - } + .skcipher = { + .base.cra_name ="ecb(des3_ede)" , + .base.cra_driver_name ="ecb-des3_ede-ux500" , + .base.cra_priority =300 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =DES3_EDE_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct cryp_ctx ), + .base.cra_alignmask =3 , + .base.cra_module =THIS_MODULE , + + .min_keysize =DES3_EDE_KEY_SIZE , + .max_keysize =DES3_EDE_KEY_SIZE , + .setkey = des3_skcipher_setkey, + .encrypt = cryp_blk_encrypt, + .decrypt = cryp_blk_decrypt, + .init = cryp_init_tfm, } }, { .algomode =CRYP_ALGO_DES_CBC , - .crypto = { - .cra_name ="cbc(des)" , - .cra_driver_name ="cbc-des-ux500" , - .cra_priority =300 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_blocksize =DES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct cryp_ctx ), - .cra_alignmask =3 , - .cra_type = &crypto_ablkcipher_type, - .cra_init = cryp_cra_init, - .cra_module =THIS_MODULE , - .cra_u = { - .ablkcipher = { - .min_keysize =DES_KEY_SIZE , - .max_keysize =DES_KEY_SIZE , - .setkey = des_ablkcipher_setkey, - .encrypt = cryp_blk_encrypt, - .decrypt = cryp_blk_decrypt, - } - } + .skcipher = { + .base.cra_name ="cbc(des)" , + .base.cra_driver_name ="cbc-des-ux500" , + .base.cra_priority =300 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =DES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct cryp_ctx ), + .base.cra_alignmask =3 , + .base.cra_module =THIS_MODULE , + + .min_keysize =DES_KEY_SIZE , + .max_keysize =DES_KEY_SIZE , + .setkey = des_skcipher_setkey, + .encrypt = cryp_blk_encrypt, + .decrypt = cryp_blk_decrypt, + .ivsize =DES_BLOCK_SIZE , + .init = cryp_init_tfm, } }, { .algomode =CRYP_ALGO_TDES_CBC , - .crypto = { - .cra_name ="cbc(des3_ede)" , - .cra_driver_name ="cbc-des3_ede-ux500" , - .cra_priority =300 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_blocksize =DES3_EDE_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct cryp_ctx ), - .cra_alignmask =3 , - .cra_type = &crypto_ablkcipher_type, - .cra_init = cryp_cra_init, - .cra_module =THIS_MODULE , - .cra_u = { - .ablkcipher = { - .min_keysize =DES3_EDE_KEY_SIZE , - .max_keysize =DES3_EDE_KEY_SIZE , - .setkey = des3_ablkcipher_setkey, - .encrypt = cryp_blk_encrypt, - .decrypt = cryp_blk_decrypt, - .ivsize =DES3_EDE_BLOCK_SIZE , - } - } + .skcipher = { + .base.cra_name ="cbc(des3_ede)" , + .base.cra_driver_name ="cbc-des3_ede-ux500" , + .base.cra_priority =300 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =DES3_EDE_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct cryp_ctx ), + .base.cra_alignmask =3 , + .base.cra_module =THIS_MODULE , + + .min_keysize =DES3_EDE_KEY_SIZE , + .max_keysize =DES3_EDE_KEY_SIZE , + .setkey = des3_skcipher_setkey, + .encrypt = cryp_blk_encrypt, + .decrypt = cryp_blk_decrypt, + .ivsize =DES3_EDE_BLOCK_SIZE , + .init = cryp_init_tfm, } } };
@@ -1293,18 +1234,18 @@ static int cryp_algs_register_all(void)pr_debug ("[%s]" , __func__);for (i =0 ; i <ARRAY_SIZE (cryp_algs); i++) { - ret =crypto_register_alg (&cryp_algs[i].crypto); + ret =crypto_register_skcipher (&cryp_algs[i].skcipher);if (ret) { count = i;pr_err ("[%s] alg registration failed" , - cryp_algs[i].crypto.cra_driver_name); + cryp_algs[i].skcipher.base.cra_driver_name); goto unreg; } }return 0 ; unreg:for (i =0 ; i < count; i++) -crypto_unregister_alg (&cryp_algs[i].crypto); +crypto_unregister_skcipher (&cryp_algs[i].skcipher);return ret; }
@@ -1318,7 +1259,7 @@ static void cryp_algs_unregister_all(void)pr_debug (DEV_DBG_NAME " [%s]" , __func__);for (i =0 ; i <ARRAY_SIZE (cryp_algs); i++) -crypto_unregister_alg (&cryp_algs[i].crypto); +crypto_unregister_skcipher (&cryp_algs[i].skcipher); }static int ux500_cryp_probe (struct platform_device *pdev)
Signature · 1 line
2.17.1
PATCH v4 7/29 crypto: s5p - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/s5p-sss.c | 187 ++++++++++---------- 1 file changed, 89 insertions(+), 98 deletions(-)
drivers/crypto/s5p-sss.c +89 -98
@@ -303,7 +303,7 @@ struct s5p_aes_dev {void __iomem *aes_ioaddr;int irq_fc; -struct ablkcipher_request *req; +struct skcipher_request *req;struct s5p_aes_ctx *ctx;struct scatterlist *sg_src;struct scatterlist *sg_dst;
@@ -456,7 +456,7 @@ static void s5p_free_sg_cpy(struct s5p_aes_dev *dev, struct scatterlist **sg)if (!*sg)return ; - len =ALIGN (dev->req->nbytes,AES_BLOCK_SIZE ); + len =ALIGN (dev->req->cryptlen,AES_BLOCK_SIZE );free_pages ((unsigned long )sg_virt (*sg),get_order (len));kfree (*sg);
@@ -478,27 +478,27 @@ static void s5p_sg_copy_buf(void *buf, struct scatterlist *sg,static void s5p_sg_done (struct s5p_aes_dev *dev) { -struct ablkcipher_request *req = dev->req; -struct s5p_aes_reqctx *reqctx =ablkcipher_request_ctx (req); +struct skcipher_request *req = dev->req; +struct s5p_aes_reqctx *reqctx =skcipher_request_ctx (req);if (dev->sg_dst_cpy) {dev_dbg (dev->dev,"Copying %d bytes of output data back to original place\n" , - dev->req->nbytes); + dev->req->cryptlen);s5p_sg_copy_buf (sg_virt (dev->sg_dst_cpy), dev->req->dst, - dev->req->nbytes,1 ); + dev->req->cryptlen,1 ); }s5p_free_sg_cpy (dev, &dev->sg_src_cpy);s5p_free_sg_cpy (dev, &dev->sg_dst_cpy);if (reqctx->mode &FLAGS_AES_CBC ) -memcpy_fromio (req->info, dev->aes_ioaddr +SSS_REG_AES_IV_DATA (0 ),AES_BLOCK_SIZE ); +memcpy_fromio (req->iv, dev->aes_ioaddr +SSS_REG_AES_IV_DATA (0 ),AES_BLOCK_SIZE );else if (reqctx->mode &FLAGS_AES_CTR ) -memcpy_fromio (req->info, dev->aes_ioaddr +SSS_REG_AES_CNT_DATA (0 ),AES_BLOCK_SIZE ); +memcpy_fromio (req->iv, dev->aes_ioaddr +SSS_REG_AES_CNT_DATA (0 ),AES_BLOCK_SIZE ); }/* Calls the completion. Cannot be called with dev->lock hold. */ -static void s5p_aes_complete (struct ablkcipher_request *req,int err) +static void s5p_aes_complete (struct skcipher_request *req,int err) { req->base.complete (&req->base, err); }
@@ -523,7 +523,7 @@ static int s5p_make_sg_cpy(struct s5p_aes_dev *dev, struct scatterlist *src,if (!*dst)return -ENOMEM ; - len =ALIGN (dev->req->nbytes,AES_BLOCK_SIZE ); + len =ALIGN (dev->req->cryptlen,AES_BLOCK_SIZE ); pages = (void *)__get_free_pages (GFP_ATOMIC ,get_order (len));if (!pages) {kfree (*dst);
@@ -531,7 +531,7 @@ static int s5p_make_sg_cpy(struct s5p_aes_dev *dev, struct scatterlist *src,return -ENOMEM ; } -s5p_sg_copy_buf (pages, src, dev->req->nbytes,0 ); +s5p_sg_copy_buf (pages, src, dev->req->cryptlen,0 );sg_init_table (*dst,1 );sg_set_buf (*dst, pages, len);
@@ -660,7 +660,7 @@ static irqreturn_t s5p_aes_interrupt(int irq, void *dev_id) {struct platform_device *pdev = dev_id;struct s5p_aes_dev *dev =platform_get_drvdata (pdev); -struct ablkcipher_request *req; +struct skcipher_request *req;int err_dma_tx =0 ;int err_dma_rx =0 ;int err_dma_hx =0 ;
@@ -1870,7 +1870,7 @@ static bool s5p_is_sg_aligned(struct scatterlist *sg) }static int s5p_set_indata_start (struct s5p_aes_dev *dev, -struct ablkcipher_request *req) +struct skcipher_request *req) {struct scatterlist *sg;int err;
@@ -1897,7 +1897,7 @@ static int s5p_set_indata_start(struct s5p_aes_dev *dev, }static int s5p_set_outdata_start (struct s5p_aes_dev *dev, -struct ablkcipher_request *req) +struct skcipher_request *req) {struct scatterlist *sg;int err;
@@ -1925,7 +1925,7 @@ static int s5p_set_outdata_start(struct s5p_aes_dev *dev,static void s5p_aes_crypt_start (struct s5p_aes_dev *dev,unsigned long mode) { -struct ablkcipher_request *req = dev->req; +struct skcipher_request *req = dev->req;u32 aes_control;unsigned long flags;int err;
@@ -1938,12 +1938,12 @@ static void s5p_aes_crypt_start(struct s5p_aes_dev *dev, unsigned long mode)if ((mode &FLAGS_AES_MODE_MASK ) ==FLAGS_AES_CBC ) { aes_control |=SSS_AES_CHAIN_MODE_CBC ; - iv = req->info; + iv = req->iv; ctr =NULL ; }else if ((mode &FLAGS_AES_MODE_MASK ) ==FLAGS_AES_CTR ) { aes_control |=SSS_AES_CHAIN_MODE_CTR ; iv =NULL ; - ctr = req->info; + ctr = req->iv; }else { iv =NULL ;/* AES_ECB */ ctr =NULL ;
@@ -2021,21 +2021,21 @@ static void s5p_tasklet_cb(unsigned long data)if (backlog) backlog->complete (backlog, -EINPROGRESS ); - dev->req =ablkcipher_request_cast (async_req); + dev->req =skcipher_request_cast (async_req); dev->ctx =crypto_tfm_ctx (dev->req->base.tfm); - reqctx =ablkcipher_request_ctx (dev->req); + reqctx =skcipher_request_ctx (dev->req);s5p_aes_crypt_start (dev, reqctx->mode); }static int s5p_aes_handle_req (struct s5p_aes_dev *dev, -struct ablkcipher_request *req) +struct skcipher_request *req) {unsigned long flags;int err;spin_lock_irqsave (&dev->lock, flags); - err =ablkcipher_enqueue_request (&dev->queue, req); + err =crypto_enqueue_request (&dev->queue, &req->base);if (dev->busy) {spin_unlock_irqrestore (&dev->lock, flags);return err;
@@ -2049,17 +2049,17 @@ static int s5p_aes_handle_req(struct s5p_aes_dev *dev,return err; } -static int s5p_aes_crypt (struct ablkcipher_request *req,unsigned long mode) +static int s5p_aes_crypt (struct skcipher_request *req,unsigned long mode) { -struct crypto_ablkcipher *tfm =crypto_ablkcipher_reqtfm (req); -struct s5p_aes_reqctx *reqctx =ablkcipher_request_ctx (req); -struct s5p_aes_ctx *ctx =crypto_ablkcipher_ctx (tfm); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req); +struct s5p_aes_reqctx *reqctx =skcipher_request_ctx (req); +struct s5p_aes_ctx *ctx =crypto_skcipher_ctx (tfm);struct s5p_aes_dev *dev = ctx->dev; -if (!req->nbytes) +if (!req->cryptlen)return 0 ; -if (!IS_ALIGNED (req->nbytes,AES_BLOCK_SIZE ) && +if (!IS_ALIGNED (req->cryptlen,AES_BLOCK_SIZE ) && ((mode &FLAGS_AES_MODE_MASK ) !=FLAGS_AES_CTR )) {dev_dbg (dev->dev,"request size is not exact amount of AES blocks\n" );return -EINVAL ;
@@ -2070,10 +2070,10 @@ static int s5p_aes_crypt(struct ablkcipher_request *req, unsigned long mode)return s5p_aes_handle_req (dev, req); } -static int s5p_aes_setkey (struct crypto_ablkcipher *cipher, +static int s5p_aes_setkey (struct crypto_skcipher *cipher,const u8 *key,unsigned int keylen) { -struct crypto_tfm *tfm =crypto_ablkcipher_tfm (cipher); +struct crypto_tfm *tfm =crypto_skcipher_tfm (cipher);struct s5p_aes_ctx *ctx =crypto_tfm_ctx (tfm); if (keylen != AES_KEYSIZE_128 &&
@@ -2087,106 +2087,97 @@ static int s5p_aes_setkey(struct crypto_ablkcipher *cipher,return 0 ; } -static int s5p_aes_ecb_encrypt (struct ablkcipher_request *req) +static int s5p_aes_ecb_encrypt (struct skcipher_request *req) {return s5p_aes_crypt (req,0 ); } -static int s5p_aes_ecb_decrypt (struct ablkcipher_request *req) +static int s5p_aes_ecb_decrypt (struct skcipher_request *req) {return s5p_aes_crypt (req,FLAGS_AES_DECRYPT ); } -static int s5p_aes_cbc_encrypt (struct ablkcipher_request *req) +static int s5p_aes_cbc_encrypt (struct skcipher_request *req) {return s5p_aes_crypt (req,FLAGS_AES_CBC ); } -static int s5p_aes_cbc_decrypt (struct ablkcipher_request *req) +static int s5p_aes_cbc_decrypt (struct skcipher_request *req) {return s5p_aes_crypt (req,FLAGS_AES_DECRYPT |FLAGS_AES_CBC ); } -static int s5p_aes_ctr_crypt (struct ablkcipher_request *req) +static int s5p_aes_ctr_crypt (struct skcipher_request *req) {return s5p_aes_crypt (req,FLAGS_AES_CTR ); } -static int s5p_aes_cra_init (struct crypto_tfm *tfm) +static int s5p_aes_init_tfm (struct crypto_skcipher *tfm) { -struct s5p_aes_ctx *ctx =crypto_tfm_ctx (tfm); +struct s5p_aes_ctx *ctx =crypto_skcipher_ctx (tfm); ctx->dev = s5p_dev; - tfm->crt_ablkcipher.reqsize =sizeof (struct s5p_aes_reqctx ); +crypto_skcipher_set_reqsize (tfm,sizeof (struct s5p_aes_reqctx ));return 0 ; } -static struct crypto_alg algs[] = { +static struct skcipher_alg algs[] = { { - .cra_name ="ecb(aes)" , - .cra_driver_name ="ecb-aes-s5p" , - .cra_priority =100 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC | + .base.cra_name ="ecb(aes)" , + .base.cra_driver_name ="ecb-aes-s5p" , + .base.cra_priority =100 , + .base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_KERN_DRIVER_ONLY , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct s5p_aes_ctx ), - .cra_alignmask =0x0f , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = s5p_aes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .setkey = s5p_aes_setkey, - .encrypt = s5p_aes_ecb_encrypt, - .decrypt = s5p_aes_ecb_decrypt, - } + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct s5p_aes_ctx ), + .base.cra_alignmask =0x0f , + .base.cra_module =THIS_MODULE , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = s5p_aes_setkey, + .encrypt = s5p_aes_ecb_encrypt, + .decrypt = s5p_aes_ecb_decrypt, + .init = s5p_aes_init_tfm, }, { - .cra_name ="cbc(aes)" , - .cra_driver_name ="cbc-aes-s5p" , - .cra_priority =100 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC | + .base.cra_name ="cbc(aes)" , + .base.cra_driver_name ="cbc-aes-s5p" , + .base.cra_priority =100 , + .base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_KERN_DRIVER_ONLY , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct s5p_aes_ctx ), - .cra_alignmask =0x0f , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = s5p_aes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = s5p_aes_setkey, - .encrypt = s5p_aes_cbc_encrypt, - .decrypt = s5p_aes_cbc_decrypt, - } + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct s5p_aes_ctx ), + .base.cra_alignmask =0x0f , + .base.cra_module =THIS_MODULE , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , + .setkey = s5p_aes_setkey, + .encrypt = s5p_aes_cbc_encrypt, + .decrypt = s5p_aes_cbc_decrypt, + .init = s5p_aes_init_tfm, }, { - .cra_name ="ctr(aes)" , - .cra_driver_name ="ctr-aes-s5p" , - .cra_priority =100 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC | + .base.cra_name ="ctr(aes)" , + .base.cra_driver_name ="ctr-aes-s5p" , + .base.cra_priority =100 , + .base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_KERN_DRIVER_ONLY , - .cra_blocksize =1 , - .cra_ctxsize =sizeof (struct s5p_aes_ctx ), - .cra_alignmask =0x0f , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = s5p_aes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = s5p_aes_setkey, - .encrypt = s5p_aes_ctr_crypt, - .decrypt = s5p_aes_ctr_crypt, - } + .base.cra_blocksize =1 , + .base.cra_ctxsize =sizeof (struct s5p_aes_ctx ), + .base.cra_alignmask =0x0f , + .base.cra_module =THIS_MODULE , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , + .setkey = s5p_aes_setkey, + .encrypt = s5p_aes_ctr_crypt, + .decrypt = s5p_aes_ctr_crypt, + .init = s5p_aes_init_tfm, }, };
@@ -2297,7 +2288,7 @@ static int s5p_aes_probe(struct platform_device *pdev)crypto_init_queue (&pdata->queue,CRYPTO_QUEUE_LEN );for (i =0 ; i <ARRAY_SIZE (algs); i++) { - err =crypto_register_alg (&algs[i]); + err =crypto_register_skcipher (&algs[i]);if (err) goto err_algs; }
@@ -2334,11 +2325,11 @@ static int s5p_aes_probe(struct platform_device *pdev) err_algs:if (i <ARRAY_SIZE (algs)) -dev_err (dev,"can't register '%s': %d\n" , algs[i].cra_name, +dev_err (dev,"can't register '%s': %d\n" , algs[i].base.cra_name, err);for (j =0 ; j < i; j++) -crypto_unregister_alg (&algs[j]); +crypto_unregister_skcipher (&algs[j]);tasklet_kill (&pdata->tasklet);
@@ -2362,7 +2353,7 @@ static int s5p_aes_remove(struct platform_device *pdev)return -ENODEV ;for (i =0 ; i <ARRAY_SIZE (algs); i++) -crypto_unregister_alg (&algs[i]); +crypto_unregister_skcipher (&algs[i]);tasklet_kill (&pdata->tasklet);if (pdata->use_hash) {
Signature · 1 line
2.17.1
PATCH v4 8/29 crypto: atmel-aes - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/atmel-aes.c | 509 ++++++++++---------- 1 file changed, 245 insertions(+), 264 deletions(-)
drivers/crypto/atmel-aes.c +245 -264
@@ -36,6 +36,7 @@#include <crypto/gcm.h> #include <crypto/xts.h> #include <crypto/internal/aead.h> +#include <crypto/internal/skcipher.h> #include <linux/platform_data/crypto-atmel.h> #include <dt-bindings/dma/at91.h> #include "atmel-aes-regs.h"
@@ -492,23 +493,23 @@ static void atmel_aes_authenc_complete(struct atmel_aes_dev *dd, int err);static void atmel_aes_set_iv_as_last_ciphertext_block (struct atmel_aes_dev *dd) { -struct ablkcipher_request *req =ablkcipher_request_cast (dd->areq); -struct atmel_aes_reqctx *rctx =ablkcipher_request_ctx (req); -struct crypto_ablkcipher *ablkcipher =crypto_ablkcipher_reqtfm (req); -unsigned int ivsize =crypto_ablkcipher_ivsize (ablkcipher); +struct skcipher_request *req =skcipher_request_cast (dd->areq); +struct atmel_aes_reqctx *rctx =skcipher_request_ctx (req); +struct crypto_skcipher *skcipher =crypto_skcipher_reqtfm (req); +unsigned int ivsize =crypto_skcipher_ivsize (skcipher); -if (req->nbytes < ivsize) +if (req->cryptlen < ivsize)return ;if (rctx->mode &AES_FLAGS_ENCRYPT ) { -scatterwalk_map_and_copy (req->info, req->dst, - req->nbytes - ivsize, ivsize,0 ); +scatterwalk_map_and_copy (req->iv, req->dst, + req->cryptlen - ivsize, ivsize,0 ); }else {if (req->src == req->dst) -memcpy (req->info, rctx->lastc, ivsize); +memcpy (req->iv, rctx->lastc, ivsize);else -scatterwalk_map_and_copy (req->info, req->src, - req->nbytes - ivsize, +scatterwalk_map_and_copy (req->iv, req->src, + req->cryptlen - ivsize, ivsize,0 ); } }
@@ -981,9 +982,9 @@ static int atmel_aes_transfer_complete(struct atmel_aes_dev *dd)static int atmel_aes_start (struct atmel_aes_dev *dd) { -struct ablkcipher_request *req =ablkcipher_request_cast (dd->areq); -struct atmel_aes_reqctx *rctx =ablkcipher_request_ctx (req); -bool use_dma = (req->nbytes >=ATMEL_AES_DMA_THRESHOLD || +struct skcipher_request *req =skcipher_request_cast (dd->areq); +struct atmel_aes_reqctx *rctx =skcipher_request_ctx (req); +bool use_dma = (req->cryptlen >=ATMEL_AES_DMA_THRESHOLD || dd->ctx->block_size !=AES_BLOCK_SIZE );int err;
@@ -993,12 +994,12 @@ static int atmel_aes_start(struct atmel_aes_dev *dd)if (err)return atmel_aes_complete (dd, err); -atmel_aes_write_ctrl (dd, use_dma, req->info); +atmel_aes_write_ctrl (dd, use_dma, (void *)req->iv);if (use_dma) -return atmel_aes_dma_start (dd, req->src, req->dst, req->nbytes, +return atmel_aes_dma_start (dd, req->src, req->dst, req->cryptlen, atmel_aes_transfer_complete); -return atmel_aes_cpu_start (dd, req->src, req->dst, req->nbytes, +return atmel_aes_cpu_start (dd, req->src, req->dst, req->cryptlen, atmel_aes_transfer_complete); }
@@ -1011,7 +1012,7 @@ atmel_aes_ctr_ctx_cast(struct atmel_aes_base_ctx *ctx)static int atmel_aes_ctr_transfer (struct atmel_aes_dev *dd) {struct atmel_aes_ctr_ctx *ctx =atmel_aes_ctr_ctx_cast (dd->ctx); -struct ablkcipher_request *req =ablkcipher_request_cast (dd->areq); +struct skcipher_request *req =skcipher_request_cast (dd->areq);struct scatterlist *src, *dst;u32 ctr, blocks;size_t datalen;
@@ -1019,11 +1020,11 @@ static int atmel_aes_ctr_transfer(struct atmel_aes_dev *dd)/* Check for transfer completion. */ ctx->offset += dd->total; -if (ctx->offset >= req->nbytes) +if (ctx->offset >= req->cryptlen)return atmel_aes_transfer_complete (dd);/* Compute data length. */ - datalen = req->nbytes - ctx->offset; + datalen = req->cryptlen - ctx->offset; blocks =DIV_ROUND_UP (datalen,AES_BLOCK_SIZE ); ctr =be32_to_cpu (ctx->iv[3 ]);if (dd->caps.has_ctr32) {
@@ -1076,8 +1077,8 @@ static int atmel_aes_ctr_transfer(struct atmel_aes_dev *dd)static int atmel_aes_ctr_start (struct atmel_aes_dev *dd) {struct atmel_aes_ctr_ctx *ctx =atmel_aes_ctr_ctx_cast (dd->ctx); -struct ablkcipher_request *req =ablkcipher_request_cast (dd->areq); -struct atmel_aes_reqctx *rctx =ablkcipher_request_ctx (req); +struct skcipher_request *req =skcipher_request_cast (dd->areq); +struct atmel_aes_reqctx *rctx =skcipher_request_ctx (req);int err;atmel_aes_set_mode (dd, rctx);
@@ -1086,16 +1087,16 @@ static int atmel_aes_ctr_start(struct atmel_aes_dev *dd)if (err)return atmel_aes_complete (dd, err); -memcpy (ctx->iv, req->info,AES_BLOCK_SIZE ); +memcpy (ctx->iv, req->iv,AES_BLOCK_SIZE ); ctx->offset =0 ; dd->total =0 ;return atmel_aes_ctr_transfer (dd); } -static int atmel_aes_crypt (struct ablkcipher_request *req,unsigned long mode) +static int atmel_aes_crypt (struct skcipher_request *req,unsigned long mode) { -struct crypto_ablkcipher *ablkcipher =crypto_ablkcipher_reqtfm (req); -struct atmel_aes_base_ctx *ctx =crypto_ablkcipher_ctx (ablkcipher); +struct crypto_skcipher *skcipher =crypto_skcipher_reqtfm (req); +struct atmel_aes_base_ctx *ctx =crypto_skcipher_ctx (skcipher);struct atmel_aes_reqctx *rctx;struct atmel_aes_dev *dd;
@@ -1126,30 +1127,30 @@ static int atmel_aes_crypt(struct ablkcipher_request *req, unsigned long mode)if (!dd)return -ENODEV ; - rctx =ablkcipher_request_ctx (req); + rctx =skcipher_request_ctx (req); rctx->mode = mode;if (!(mode &AES_FLAGS_ENCRYPT ) && (req->src == req->dst)) { -unsigned int ivsize =crypto_ablkcipher_ivsize (ablkcipher); +unsigned int ivsize =crypto_skcipher_ivsize (skcipher); -if (req->nbytes >= ivsize) +if (req->cryptlen >= ivsize)scatterwalk_map_and_copy (rctx->lastc, req->src, - req->nbytes - ivsize, + req->cryptlen - ivsize, ivsize,0 ); }return atmel_aes_handle_queue (dd, &req->base); } -static int atmel_aes_setkey (struct crypto_ablkcipher *tfm,const u8 *key, +static int atmel_aes_setkey (struct crypto_skcipher *tfm,const u8 *key,unsigned int keylen) { -struct atmel_aes_base_ctx *ctx =crypto_ablkcipher_ctx (tfm); +struct atmel_aes_base_ctx *ctx =crypto_skcipher_ctx (tfm);if (keylen !=AES_KEYSIZE_128 && keylen !=AES_KEYSIZE_192 && keylen !=AES_KEYSIZE_256 ) { -crypto_ablkcipher_set_flags (tfm,CRYPTO_TFM_RES_BAD_KEY_LEN ); +crypto_skcipher_set_flags (tfm,CRYPTO_TFM_RES_BAD_KEY_LEN );return -EINVAL ; }
@@ -1159,297 +1160,279 @@ static int atmel_aes_setkey(struct crypto_ablkcipher *tfm, const u8 *key,return 0 ; } -static int atmel_aes_ecb_encrypt (struct ablkcipher_request *req) +static int atmel_aes_ecb_encrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_ECB |AES_FLAGS_ENCRYPT ); } -static int atmel_aes_ecb_decrypt (struct ablkcipher_request *req) +static int atmel_aes_ecb_decrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_ECB ); } -static int atmel_aes_cbc_encrypt (struct ablkcipher_request *req) +static int atmel_aes_cbc_encrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_CBC |AES_FLAGS_ENCRYPT ); } -static int atmel_aes_cbc_decrypt (struct ablkcipher_request *req) +static int atmel_aes_cbc_decrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_CBC ); } -static int atmel_aes_ofb_encrypt (struct ablkcipher_request *req) +static int atmel_aes_ofb_encrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_OFB |AES_FLAGS_ENCRYPT ); } -static int atmel_aes_ofb_decrypt (struct ablkcipher_request *req) +static int atmel_aes_ofb_decrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_OFB ); } -static int atmel_aes_cfb_encrypt (struct ablkcipher_request *req) +static int atmel_aes_cfb_encrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_CFB128 |AES_FLAGS_ENCRYPT ); } -static int atmel_aes_cfb_decrypt (struct ablkcipher_request *req) +static int atmel_aes_cfb_decrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_CFB128 ); } -static int atmel_aes_cfb64_encrypt (struct ablkcipher_request *req) +static int atmel_aes_cfb64_encrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_CFB64 |AES_FLAGS_ENCRYPT ); } -static int atmel_aes_cfb64_decrypt (struct ablkcipher_request *req) +static int atmel_aes_cfb64_decrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_CFB64 ); } -static int atmel_aes_cfb32_encrypt (struct ablkcipher_request *req) +static int atmel_aes_cfb32_encrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_CFB32 |AES_FLAGS_ENCRYPT ); } -static int atmel_aes_cfb32_decrypt (struct ablkcipher_request *req) +static int atmel_aes_cfb32_decrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_CFB32 ); } -static int atmel_aes_cfb16_encrypt (struct ablkcipher_request *req) +static int atmel_aes_cfb16_encrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_CFB16 |AES_FLAGS_ENCRYPT ); } -static int atmel_aes_cfb16_decrypt (struct ablkcipher_request *req) +static int atmel_aes_cfb16_decrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_CFB16 ); } -static int atmel_aes_cfb8_encrypt (struct ablkcipher_request *req) +static int atmel_aes_cfb8_encrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_CFB8 |AES_FLAGS_ENCRYPT ); } -static int atmel_aes_cfb8_decrypt (struct ablkcipher_request *req) +static int atmel_aes_cfb8_decrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_CFB8 ); } -static int atmel_aes_ctr_encrypt (struct ablkcipher_request *req) +static int atmel_aes_ctr_encrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_CTR |AES_FLAGS_ENCRYPT ); } -static int atmel_aes_ctr_decrypt (struct ablkcipher_request *req) +static int atmel_aes_ctr_decrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_CTR ); } -static int atmel_aes_cra_init (struct crypto_tfm *tfm) +static int atmel_aes_init_tfm (struct crypto_skcipher *tfm) { -struct atmel_aes_ctx *ctx =crypto_tfm_ctx (tfm); +struct atmel_aes_ctx *ctx =crypto_skcipher_ctx (tfm); - tfm->crt_ablkcipher.reqsize =sizeof (struct atmel_aes_reqctx ); +crypto_skcipher_set_reqsize (tfm,sizeof (struct atmel_aes_reqctx )); ctx->base.start = atmel_aes_start;return 0 ; } -static int atmel_aes_ctr_cra_init (struct crypto_tfm *tfm) +static int atmel_aes_ctr_init_tfm (struct crypto_skcipher *tfm) { -struct atmel_aes_ctx *ctx =crypto_tfm_ctx (tfm); +struct atmel_aes_ctx *ctx =crypto_skcipher_ctx (tfm); - tfm->crt_ablkcipher.reqsize =sizeof (struct atmel_aes_reqctx ); +crypto_skcipher_set_reqsize (tfm,sizeof (struct atmel_aes_reqctx )); ctx->base.start = atmel_aes_ctr_start;return 0 ; } -static struct crypto_alg aes_algs[] = { -{ - .cra_name ="ecb(aes)" , - .cra_driver_name ="atmel-ecb-aes" , - .cra_priority =ATMEL_AES_PRIORITY , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct atmel_aes_ctx ), - .cra_alignmask =0xf , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_aes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .setkey = atmel_aes_setkey, - .encrypt = atmel_aes_ecb_encrypt, - .decrypt = atmel_aes_ecb_decrypt, - } +static struct skcipher_alg aes_algs[] = { +{ + .base.cra_name ="ecb(aes)" , + .base.cra_driver_name ="atmel-ecb-aes" , + .base.cra_priority =ATMEL_AES_PRIORITY , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct atmel_aes_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .init = atmel_aes_init_tfm, + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = atmel_aes_setkey, + .encrypt = atmel_aes_ecb_encrypt, + .decrypt = atmel_aes_ecb_decrypt, }, { - .cra_name ="cbc(aes)" , - .cra_driver_name ="atmel-cbc-aes" , - .cra_priority =ATMEL_AES_PRIORITY , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct atmel_aes_ctx ), - .cra_alignmask =0xf , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_aes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = atmel_aes_setkey, - .encrypt = atmel_aes_cbc_encrypt, - .decrypt = atmel_aes_cbc_decrypt, - } + .base.cra_name ="cbc(aes)" , + .base.cra_driver_name ="atmel-cbc-aes" , + .base.cra_priority =ATMEL_AES_PRIORITY , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct atmel_aes_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .init = atmel_aes_init_tfm, + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = atmel_aes_setkey, + .encrypt = atmel_aes_cbc_encrypt, + .decrypt = atmel_aes_cbc_decrypt, + .ivsize =AES_BLOCK_SIZE , }, { - .cra_name ="ofb(aes)" , - .cra_driver_name ="atmel-ofb-aes" , - .cra_priority =ATMEL_AES_PRIORITY , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct atmel_aes_ctx ), - .cra_alignmask =0xf , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_aes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = atmel_aes_setkey, - .encrypt = atmel_aes_ofb_encrypt, - .decrypt = atmel_aes_ofb_decrypt, - } + .base.cra_name ="ofb(aes)" , + .base.cra_driver_name ="atmel-ofb-aes" , + .base.cra_priority =ATMEL_AES_PRIORITY , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct atmel_aes_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .init = atmel_aes_init_tfm, + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = atmel_aes_setkey, + .encrypt = atmel_aes_ofb_encrypt, + .decrypt = atmel_aes_ofb_decrypt, + .ivsize =AES_BLOCK_SIZE , }, { - .cra_name ="cfb(aes)" , - .cra_driver_name ="atmel-cfb-aes" , - .cra_priority =ATMEL_AES_PRIORITY , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct atmel_aes_ctx ), - .cra_alignmask =0xf , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_aes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = atmel_aes_setkey, - .encrypt = atmel_aes_cfb_encrypt, - .decrypt = atmel_aes_cfb_decrypt, - } + .base.cra_name ="cfb(aes)" , + .base.cra_driver_name ="atmel-cfb-aes" , + .base.cra_priority =ATMEL_AES_PRIORITY , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct atmel_aes_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .init = atmel_aes_init_tfm, + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = atmel_aes_setkey, + .encrypt = atmel_aes_cfb_encrypt, + .decrypt = atmel_aes_cfb_decrypt, + .ivsize =AES_BLOCK_SIZE , }, { - .cra_name ="cfb32(aes)" , - .cra_driver_name ="atmel-cfb32-aes" , - .cra_priority =ATMEL_AES_PRIORITY , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =CFB32_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct atmel_aes_ctx ), - .cra_alignmask =0x3 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_aes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = atmel_aes_setkey, - .encrypt = atmel_aes_cfb32_encrypt, - .decrypt = atmel_aes_cfb32_decrypt, - } + .base.cra_name ="cfb32(aes)" , + .base.cra_driver_name ="atmel-cfb32-aes" , + .base.cra_priority =ATMEL_AES_PRIORITY , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =CFB32_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct atmel_aes_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .init = atmel_aes_init_tfm, + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = atmel_aes_setkey, + .encrypt = atmel_aes_cfb32_encrypt, + .decrypt = atmel_aes_cfb32_decrypt, + .ivsize =AES_BLOCK_SIZE , }, { - .cra_name ="cfb16(aes)" , - .cra_driver_name ="atmel-cfb16-aes" , - .cra_priority =ATMEL_AES_PRIORITY , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =CFB16_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct atmel_aes_ctx ), - .cra_alignmask =0x1 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_aes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = atmel_aes_setkey, - .encrypt = atmel_aes_cfb16_encrypt, - .decrypt = atmel_aes_cfb16_decrypt, - } + .base.cra_name ="cfb16(aes)" , + .base.cra_driver_name ="atmel-cfb16-aes" , + .base.cra_priority =ATMEL_AES_PRIORITY , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =CFB16_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct atmel_aes_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .init = atmel_aes_init_tfm, + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = atmel_aes_setkey, + .encrypt = atmel_aes_cfb16_encrypt, + .decrypt = atmel_aes_cfb16_decrypt, + .ivsize =AES_BLOCK_SIZE , }, { - .cra_name ="cfb8(aes)" , - .cra_driver_name ="atmel-cfb8-aes" , - .cra_priority =ATMEL_AES_PRIORITY , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =CFB8_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct atmel_aes_ctx ), - .cra_alignmask =0x0 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_aes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = atmel_aes_setkey, - .encrypt = atmel_aes_cfb8_encrypt, - .decrypt = atmel_aes_cfb8_decrypt, - } + .base.cra_name ="cfb8(aes)" , + .base.cra_driver_name ="atmel-cfb8-aes" , + .base.cra_priority =ATMEL_AES_PRIORITY , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =CFB8_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct atmel_aes_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .init = atmel_aes_init_tfm, + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = atmel_aes_setkey, + .encrypt = atmel_aes_cfb8_encrypt, + .decrypt = atmel_aes_cfb8_decrypt, + .ivsize =AES_BLOCK_SIZE , }, { - .cra_name ="ctr(aes)" , - .cra_driver_name ="atmel-ctr-aes" , - .cra_priority =ATMEL_AES_PRIORITY , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =1 , - .cra_ctxsize =sizeof (struct atmel_aes_ctr_ctx ), - .cra_alignmask =0xf , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_aes_ctr_cra_init, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = atmel_aes_setkey, - .encrypt = atmel_aes_ctr_encrypt, - .decrypt = atmel_aes_ctr_decrypt, - } + .base.cra_name ="ctr(aes)" , + .base.cra_driver_name ="atmel-ctr-aes" , + .base.cra_priority =ATMEL_AES_PRIORITY , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =1 , + .base.cra_ctxsize =sizeof (struct atmel_aes_ctr_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .init = atmel_aes_ctr_init_tfm, + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = atmel_aes_setkey, + .encrypt = atmel_aes_ctr_encrypt, + .decrypt = atmel_aes_ctr_decrypt, + .ivsize =AES_BLOCK_SIZE , }, }; -static struct crypto_alg aes_cfb64_alg = { - .cra_name ="cfb64(aes)" , - .cra_driver_name ="atmel-cfb64-aes" , - .cra_priority =ATMEL_AES_PRIORITY , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =CFB64_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct atmel_aes_ctx ), - .cra_alignmask =0x7 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_aes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = atmel_aes_setkey, - .encrypt = atmel_aes_cfb64_encrypt, - .decrypt = atmel_aes_cfb64_decrypt, - } +static struct skcipher_alg aes_cfb64_alg = { + .base.cra_name ="cfb64(aes)" , + .base.cra_driver_name ="atmel-cfb64-aes" , + .base.cra_priority =ATMEL_AES_PRIORITY , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =CFB64_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct atmel_aes_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .init = atmel_aes_init_tfm, + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = atmel_aes_setkey, + .encrypt = atmel_aes_cfb64_encrypt, + .decrypt = atmel_aes_cfb64_decrypt, + .ivsize =AES_BLOCK_SIZE , };
@@ -1864,8 +1847,8 @@ static int atmel_aes_xts_process_data(struct atmel_aes_dev *dd);static int atmel_aes_xts_start (struct atmel_aes_dev *dd) {struct atmel_aes_xts_ctx *ctx =atmel_aes_xts_ctx_cast (dd->ctx); -struct ablkcipher_request *req =ablkcipher_request_cast (dd->areq); -struct atmel_aes_reqctx *rctx =ablkcipher_request_ctx (req); +struct skcipher_request *req =skcipher_request_cast (dd->areq); +struct atmel_aes_reqctx *rctx =skcipher_request_ctx (req);unsigned long flags;int err;
@@ -1875,7 +1858,7 @@ static int atmel_aes_xts_start(struct atmel_aes_dev *dd)if (err)return atmel_aes_complete (dd, err); -/* Compute the tweak value from req->info with ecb(aes). */ +/* Compute the tweak value from req->iv with ecb(aes). */ flags = dd->flags; dd->flags &= ~AES_FLAGS_MODE_MASK ; dd->flags |= (AES_FLAGS_ECB |AES_FLAGS_ENCRYPT );
@@ -1883,14 +1866,14 @@ static int atmel_aes_xts_start(struct atmel_aes_dev *dd) ctx->key2, ctx->base.keylen); dd->flags = flags; -atmel_aes_write_block (dd,AES_IDATAR (0 ), req->info); +atmel_aes_write_block (dd,AES_IDATAR (0 ), (void *)req->iv);return atmel_aes_wait_for_data_ready (dd, atmel_aes_xts_process_data); }static int atmel_aes_xts_process_data (struct atmel_aes_dev *dd) { -struct ablkcipher_request *req =ablkcipher_request_cast (dd->areq); -bool use_dma = (req->nbytes >=ATMEL_AES_DMA_THRESHOLD ); +struct skcipher_request *req =skcipher_request_cast (dd->areq); +bool use_dma = (req->cryptlen >=ATMEL_AES_DMA_THRESHOLD );u32 tweak[AES_BLOCK_SIZE /sizeof (u32)];static const __le32 one[AES_BLOCK_SIZE /sizeof (u32)] = {cpu_to_le32 (1 ), };u8 *tweak_bytes = (u8 *)tweak;
@@ -1915,20 +1898,20 @@ static int atmel_aes_xts_process_data(struct atmel_aes_dev *dd)atmel_aes_write_block (dd,AES_TWR (0 ), tweak);atmel_aes_write_block (dd,AES_ALPHAR (0 ), one);if (use_dma) -return atmel_aes_dma_start (dd, req->src, req->dst, req->nbytes, +return atmel_aes_dma_start (dd, req->src, req->dst, req->cryptlen, atmel_aes_transfer_complete); -return atmel_aes_cpu_start (dd, req->src, req->dst, req->nbytes, +return atmel_aes_cpu_start (dd, req->src, req->dst, req->cryptlen, atmel_aes_transfer_complete); } -static int atmel_aes_xts_setkey (struct crypto_ablkcipher *tfm,const u8 *key, +static int atmel_aes_xts_setkey (struct crypto_skcipher *tfm,const u8 *key,unsigned int keylen) { -struct atmel_aes_xts_ctx *ctx =crypto_ablkcipher_ctx (tfm); +struct atmel_aes_xts_ctx *ctx =crypto_skcipher_ctx (tfm);int err; - err =xts_check_key (crypto_ablkcipher_tfm (tfm), key, keylen); + err =xts_check_key (crypto_skcipher_tfm (tfm), key, keylen);if (err)return err;
@@ -1939,45 +1922,43 @@ static int atmel_aes_xts_setkey(struct crypto_ablkcipher *tfm, const u8 *key,return 0 ; } -static int atmel_aes_xts_encrypt (struct ablkcipher_request *req) +static int atmel_aes_xts_encrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_XTS |AES_FLAGS_ENCRYPT ); } -static int atmel_aes_xts_decrypt (struct ablkcipher_request *req) +static int atmel_aes_xts_decrypt (struct skcipher_request *req) {return atmel_aes_crypt (req,AES_FLAGS_XTS ); } -static int atmel_aes_xts_cra_init (struct crypto_tfm *tfm) +static int atmel_aes_xts_init_tfm (struct crypto_skcipher *tfm) { -struct atmel_aes_xts_ctx *ctx =crypto_tfm_ctx (tfm); +struct atmel_aes_xts_ctx *ctx =crypto_skcipher_ctx (tfm); - tfm->crt_ablkcipher.reqsize =sizeof (struct atmel_aes_reqctx ); +crypto_skcipher_set_reqsize (tfm,sizeof (struct atmel_aes_reqctx )); ctx->base.start = atmel_aes_xts_start;return 0 ; } -static struct crypto_alg aes_xts_alg = { - .cra_name ="xts(aes)" , - .cra_driver_name ="atmel-xts-aes" , - .cra_priority =ATMEL_AES_PRIORITY , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct atmel_aes_xts_ctx ), - .cra_alignmask =0xf , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_aes_xts_cra_init, - .cra_u.ablkcipher = { - .min_keysize =2 *AES_MIN_KEY_SIZE , - .max_keysize =2 *AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = atmel_aes_xts_setkey, - .encrypt = atmel_aes_xts_encrypt, - .decrypt = atmel_aes_xts_decrypt, - } +static struct skcipher_alg aes_xts_alg = { + .base.cra_name ="xts(aes)" , + .base.cra_driver_name ="atmel-xts-aes" , + .base.cra_priority =ATMEL_AES_PRIORITY , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct atmel_aes_xts_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .min_keysize =2 *AES_MIN_KEY_SIZE , + .max_keysize =2 *AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , + .setkey = atmel_aes_xts_setkey, + .encrypt = atmel_aes_xts_encrypt, + .decrypt = atmel_aes_xts_decrypt, + .init = atmel_aes_xts_init_tfm, };#if IS_ENABLED (CONFIG_CRYPTO_DEV_ATMEL_AUTHENC )
@@ -2474,16 +2455,16 @@ static void atmel_aes_unregister_algs(struct atmel_aes_dev *dd)#endif if (dd->caps.has_xts) -crypto_unregister_alg (&aes_xts_alg); +crypto_unregister_skcipher (&aes_xts_alg);if (dd->caps.has_gcm)crypto_unregister_aead (&aes_gcm_alg);if (dd->caps.has_cfb64) -crypto_unregister_alg (&aes_cfb64_alg); +crypto_unregister_skcipher (&aes_cfb64_alg);for (i =0 ; i <ARRAY_SIZE (aes_algs); i++) -crypto_unregister_alg (&aes_algs[i]); +crypto_unregister_skcipher (&aes_algs[i]); }static int atmel_aes_register_algs (struct atmel_aes_dev *dd)
@@ -2491,13 +2472,13 @@ static int atmel_aes_register_algs(struct atmel_aes_dev *dd)int err, i, j;for (i =0 ; i <ARRAY_SIZE (aes_algs); i++) { - err =crypto_register_alg (&aes_algs[i]); + err =crypto_register_skcipher (&aes_algs[i]);if (err) goto err_aes_algs; }if (dd->caps.has_cfb64) { - err =crypto_register_alg (&aes_cfb64_alg); + err =crypto_register_skcipher (&aes_cfb64_alg);if (err) goto err_aes_cfb64_alg; }
@@ -2509,7 +2490,7 @@ static int atmel_aes_register_algs(struct atmel_aes_dev *dd) }if (dd->caps.has_xts) { - err =crypto_register_alg (&aes_xts_alg); + err =crypto_register_skcipher (&aes_xts_alg);if (err) goto err_aes_xts_alg; }
@@ -2531,17 +2512,17 @@ static int atmel_aes_register_algs(struct atmel_aes_dev *dd) err_aes_authenc_alg:for (j =0 ; j < i; j++)crypto_unregister_aead (&aes_authenc_algs[j]); -crypto_unregister_alg (&aes_xts_alg); +crypto_unregister_skcipher (&aes_xts_alg);#endif err_aes_xts_alg:crypto_unregister_aead (&aes_gcm_alg); err_aes_gcm_alg: -crypto_unregister_alg (&aes_cfb64_alg); +crypto_unregister_skcipher (&aes_cfb64_alg); err_aes_cfb64_alg: i =ARRAY_SIZE (aes_algs); err_aes_algs:for (j =0 ; j < i; j++) -crypto_unregister_alg (&aes_algs[j]); +crypto_unregister_skcipher (&aes_algs[j]);return err; }
Signature · 1 line
2.17.1
Re: [PATCH v4 08/29] crypto: atmel-aes - switch to skcipher API
Quoted 10 lines · Ard Biesheuvel
drivers/crypto/atmel-aes.c +1
-1@@ -1875,7 +1858,7 @@ static int atmel_aes_xts_start(struct atmel_aes_dev *dd)if (err)return atmel_aes_complete (dd, err); -/* Compute the tweak value from req->info with ecb(aes). */ +/* Compute the tweak value from req->iv with ecb(aes). */ flags = dd->flags; dd->flags &= ~AES_FLAGS_MODE_MASK ; dd->flags |= (AES_FLAGS_ECB |AES_FLAGS_ENCRYPT );
drivers/crypto/atmel-aes.c static int atmel_aes_xts_start(struct atmel_aes_dev *dd) · line 1869
Quoted 5 lines
drivers/crypto/atmel-aes.c +1
-1@@ -1883,14 +1866,14 @@ static int atmel_aes_xts_start(struct atmel_aes_dev *dd) ctx->key2, ctx->base.keylen); dd->flags = flags; -atmel_aes_write_block (dd,AES_IDATAR (0 ), req->info); +atmel_aes_write_block (dd,AES_IDATAR (0 ), (void *)req->iv);
I think we can get rid of this explicit cast.
And there are two checkpatch warnings introduced by this patch:
WARNING: line over 80 characters
#152: FILE: drivers/crypto/atmel-aes.c:999:
+ return atmel_aes_dma_start(dd, req->src, req->dst, req->cryptlen,
WARNING: line over 80 characters
#764: FILE: drivers/crypto/atmel-aes.c:1901:
+ return atmel_aes_dma_start(dd, req->src, req->dst, req->cryptlen,
With these fixed one can add
Thanks again, Ard,
ta
PATCH v4 9/29 crypto: atmel-tdes - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/atmel-tdes.c | 433 ++++++++++---------- 1 file changed, 207 insertions(+), 226 deletions(-)
drivers/crypto/atmel-tdes.c +207 -226
@@ -36,6 +36,7 @@#include <crypto/internal/des.h> #include <crypto/hash.h> #include <crypto/internal/hash.h> +#include <crypto/internal/skcipher.h> #include <linux/platform_data/crypto-atmel.h> #include "atmel-tdes-regs.h"
@@ -72,7 +73,7 @@ struct atmel_tdes_ctx {struct atmel_tdes_dev *dd;int keylen; -u32 key[3 *DES_KEY_SIZE /sizeof (u32)]; +u32 key[DES3_EDE_KEY_SIZE /sizeof (u32)];unsigned long flags;u16 block_size;
@@ -106,7 +107,7 @@ struct atmel_tdes_dev {struct tasklet_struct done_task;struct tasklet_struct queue_task; -struct ablkcipher_request *req; +struct skcipher_request *req;size_t total;struct scatterlist *in_sg;
@@ -307,8 +308,8 @@ static int atmel_tdes_write_ctrl(struct atmel_tdes_dev *dd) dd->ctx->keylen >> 2);if (((dd->flags &TDES_FLAGS_CBC ) || (dd->flags &TDES_FLAGS_CFB ) || - (dd->flags &TDES_FLAGS_OFB )) && dd->req->info) { -atmel_tdes_write_n (dd,TDES_IV1R , dd->req->info,2 ); + (dd->flags &TDES_FLAGS_OFB )) && dd->req->iv) { +atmel_tdes_write_n (dd,TDES_IV1R , (void *)dd->req->iv,2 ); }return 0 ;
@@ -502,8 +503,8 @@ static int atmel_tdes_crypt_dma(struct crypto_tfm *tfm, dma_addr_t dma_addr_in,static int atmel_tdes_crypt_start (struct atmel_tdes_dev *dd) { -struct crypto_tfm *tfm =crypto_ablkcipher_tfm ( -crypto_ablkcipher_reqtfm (dd->req)); +struct crypto_tfm *tfm =crypto_skcipher_tfm ( +crypto_skcipher_reqtfm (dd->req));int err, fast =0 , in, out;size_t count;dma_addr_t addr_in, addr_out;
@@ -573,7 +574,7 @@ static int atmel_tdes_crypt_start(struct atmel_tdes_dev *dd)static void atmel_tdes_finish_req (struct atmel_tdes_dev *dd,int err) { -struct ablkcipher_request *req = dd->req; +struct skcipher_request *req = dd->req;clk_disable_unprepare (dd->iclk);
@@ -583,7 +584,7 @@ static void atmel_tdes_finish_req(struct atmel_tdes_dev *dd, int err) }static int atmel_tdes_handle_queue (struct atmel_tdes_dev *dd, -struct ablkcipher_request *req) +struct skcipher_request *req) {struct crypto_async_request *async_req, *backlog;struct atmel_tdes_ctx *ctx;
@@ -593,7 +594,7 @@ static int atmel_tdes_handle_queue(struct atmel_tdes_dev *dd,spin_lock_irqsave (&dd->lock, flags);if (req) - ret =ablkcipher_enqueue_request (&dd->queue, req); + ret =crypto_enqueue_request (&dd->queue, &req->base);if (dd->flags &TDES_FLAGS_BUSY ) {spin_unlock_irqrestore (&dd->lock, flags);return ret;
@@ -610,18 +611,18 @@ static int atmel_tdes_handle_queue(struct atmel_tdes_dev *dd,if (backlog) backlog->complete (backlog, -EINPROGRESS ); - req =ablkcipher_request_cast (async_req); + req =skcipher_request_cast (async_req);/* assign new request to device */ dd->req = req; - dd->total = req->nbytes; + dd->total = req->cryptlen; dd->in_offset =0 ; dd->in_sg = req->src; dd->out_offset =0 ; dd->out_sg = req->dst; - rctx =ablkcipher_request_ctx (req); - ctx =crypto_ablkcipher_ctx (crypto_ablkcipher_reqtfm (req)); + rctx =skcipher_request_ctx (req); + ctx =crypto_skcipher_ctx (crypto_skcipher_reqtfm (req)); rctx->mode &=TDES_FLAGS_MODE_MASK ; dd->flags = (dd->flags & ~TDES_FLAGS_MODE_MASK ) | rctx->mode; dd->ctx = ctx;
@@ -665,32 +666,32 @@ static int atmel_tdes_crypt_dma_stop(struct atmel_tdes_dev *dd)return err; } -static int atmel_tdes_crypt (struct ablkcipher_request *req,unsigned long mode) +static int atmel_tdes_crypt (struct skcipher_request *req,unsigned long mode) { -struct atmel_tdes_ctx *ctx =crypto_ablkcipher_ctx ( -crypto_ablkcipher_reqtfm (req)); -struct atmel_tdes_reqctx *rctx =ablkcipher_request_ctx (req); +struct atmel_tdes_ctx *ctx =crypto_skcipher_ctx ( +crypto_skcipher_reqtfm (req)); +struct atmel_tdes_reqctx *rctx =skcipher_request_ctx (req);if (mode &TDES_FLAGS_CFB8 ) { -if (!IS_ALIGNED (req->nbytes,CFB8_BLOCK_SIZE )) { +if (!IS_ALIGNED (req->cryptlen,CFB8_BLOCK_SIZE )) {pr_err ("request size is not exact amount of CFB8 blocks\n" );return -EINVAL ; } ctx->block_size =CFB8_BLOCK_SIZE ; }else if (mode &TDES_FLAGS_CFB16 ) { -if (!IS_ALIGNED (req->nbytes,CFB16_BLOCK_SIZE )) { +if (!IS_ALIGNED (req->cryptlen,CFB16_BLOCK_SIZE )) {pr_err ("request size is not exact amount of CFB16 blocks\n" );return -EINVAL ; } ctx->block_size =CFB16_BLOCK_SIZE ; }else if (mode &TDES_FLAGS_CFB32 ) { -if (!IS_ALIGNED (req->nbytes,CFB32_BLOCK_SIZE )) { +if (!IS_ALIGNED (req->cryptlen,CFB32_BLOCK_SIZE )) {pr_err ("request size is not exact amount of CFB32 blocks\n" );return -EINVAL ; } ctx->block_size =CFB32_BLOCK_SIZE ; }else { -if (!IS_ALIGNED (req->nbytes,DES_BLOCK_SIZE )) { +if (!IS_ALIGNED (req->cryptlen,DES_BLOCK_SIZE )) {pr_err ("request size is not exact amount of DES blocks\n" );return -EINVAL ; }
@@ -770,13 +771,13 @@ static void atmel_tdes_dma_cleanup(struct atmel_tdes_dev *dd)dma_release_channel (dd->dma_lch_out.chan); } -static int atmel_des_setkey (struct crypto_ablkcipher *tfm,const u8 *key, +static int atmel_des_setkey (struct crypto_skcipher *tfm,const u8 *key,unsigned int keylen) { -struct atmel_tdes_ctx *ctx =crypto_ablkcipher_ctx (tfm); +struct atmel_tdes_ctx *ctx =crypto_skcipher_ctx (tfm);int err; - err =verify_ablkcipher_des_key (tfm, key); + err =verify_skcipher_des_key (tfm, key);if (err)return err;
@@ -786,13 +787,13 @@ static int atmel_des_setkey(struct crypto_ablkcipher *tfm, const u8 *key,return 0 ; } -static int atmel_tdes_setkey (struct crypto_ablkcipher *tfm,const u8 *key, +static int atmel_tdes_setkey (struct crypto_skcipher *tfm,const u8 *key,unsigned int keylen) { -struct atmel_tdes_ctx *ctx =crypto_ablkcipher_ctx (tfm); +struct atmel_tdes_ctx *ctx =crypto_skcipher_ctx (tfm);int err; - err =verify_ablkcipher_des3_key (tfm, key); + err =verify_skcipher_des3_key (tfm, key);if (err)return err;
@@ -802,84 +803,84 @@ static int atmel_tdes_setkey(struct crypto_ablkcipher *tfm, const u8 *key,return 0 ; } -static int atmel_tdes_ecb_encrypt (struct ablkcipher_request *req) +static int atmel_tdes_ecb_encrypt (struct skcipher_request *req) {return atmel_tdes_crypt (req,TDES_FLAGS_ENCRYPT ); } -static int atmel_tdes_ecb_decrypt (struct ablkcipher_request *req) +static int atmel_tdes_ecb_decrypt (struct skcipher_request *req) {return atmel_tdes_crypt (req,0 ); } -static int atmel_tdes_cbc_encrypt (struct ablkcipher_request *req) +static int atmel_tdes_cbc_encrypt (struct skcipher_request *req) {return atmel_tdes_crypt (req,TDES_FLAGS_ENCRYPT |TDES_FLAGS_CBC ); } -static int atmel_tdes_cbc_decrypt (struct ablkcipher_request *req) +static int atmel_tdes_cbc_decrypt (struct skcipher_request *req) {return atmel_tdes_crypt (req,TDES_FLAGS_CBC ); } -static int atmel_tdes_cfb_encrypt (struct ablkcipher_request *req) +static int atmel_tdes_cfb_encrypt (struct skcipher_request *req) {return atmel_tdes_crypt (req,TDES_FLAGS_ENCRYPT |TDES_FLAGS_CFB ); } -static int atmel_tdes_cfb_decrypt (struct ablkcipher_request *req) +static int atmel_tdes_cfb_decrypt (struct skcipher_request *req) {return atmel_tdes_crypt (req,TDES_FLAGS_CFB ); } -static int atmel_tdes_cfb8_encrypt (struct ablkcipher_request *req) +static int atmel_tdes_cfb8_encrypt (struct skcipher_request *req) {return atmel_tdes_crypt (req,TDES_FLAGS_ENCRYPT |TDES_FLAGS_CFB |TDES_FLAGS_CFB8 ); } -static int atmel_tdes_cfb8_decrypt (struct ablkcipher_request *req) +static int atmel_tdes_cfb8_decrypt (struct skcipher_request *req) {return atmel_tdes_crypt (req,TDES_FLAGS_CFB |TDES_FLAGS_CFB8 ); } -static int atmel_tdes_cfb16_encrypt (struct ablkcipher_request *req) +static int atmel_tdes_cfb16_encrypt (struct skcipher_request *req) {return atmel_tdes_crypt (req,TDES_FLAGS_ENCRYPT |TDES_FLAGS_CFB |TDES_FLAGS_CFB16 ); } -static int atmel_tdes_cfb16_decrypt (struct ablkcipher_request *req) +static int atmel_tdes_cfb16_decrypt (struct skcipher_request *req) {return atmel_tdes_crypt (req,TDES_FLAGS_CFB |TDES_FLAGS_CFB16 ); } -static int atmel_tdes_cfb32_encrypt (struct ablkcipher_request *req) +static int atmel_tdes_cfb32_encrypt (struct skcipher_request *req) {return atmel_tdes_crypt (req,TDES_FLAGS_ENCRYPT |TDES_FLAGS_CFB |TDES_FLAGS_CFB32 ); } -static int atmel_tdes_cfb32_decrypt (struct ablkcipher_request *req) +static int atmel_tdes_cfb32_decrypt (struct skcipher_request *req) {return atmel_tdes_crypt (req,TDES_FLAGS_CFB |TDES_FLAGS_CFB32 ); } -static int atmel_tdes_ofb_encrypt (struct ablkcipher_request *req) +static int atmel_tdes_ofb_encrypt (struct skcipher_request *req) {return atmel_tdes_crypt (req,TDES_FLAGS_ENCRYPT |TDES_FLAGS_OFB ); } -static int atmel_tdes_ofb_decrypt (struct ablkcipher_request *req) +static int atmel_tdes_ofb_decrypt (struct skcipher_request *req) {return atmel_tdes_crypt (req,TDES_FLAGS_OFB ); } -static int atmel_tdes_cra_init (struct crypto_tfm *tfm) +static int atmel_tdes_init_tfm (struct crypto_skcipher *tfm) { -struct atmel_tdes_ctx *ctx =crypto_tfm_ctx (tfm); +struct atmel_tdes_ctx *ctx =crypto_skcipher_ctx (tfm);struct atmel_tdes_dev *dd; - tfm->crt_ablkcipher.reqsize =sizeof (struct atmel_tdes_reqctx ); +crypto_skcipher_set_reqsize (tfm,sizeof (struct atmel_tdes_reqctx )); dd =atmel_tdes_find_dev (ctx);if (!dd)
@@ -888,204 +889,184 @@ static int atmel_tdes_cra_init(struct crypto_tfm *tfm)return 0 ; } -static struct crypto_alg tdes_algs[] = { +static struct skcipher_alg tdes_algs[] = { { - .cra_name ="ecb(des)" , - .cra_driver_name ="atmel-ecb-des" , - .cra_priority =100 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =DES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct atmel_tdes_ctx ), - .cra_alignmask =0x7 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_tdes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =DES_KEY_SIZE , - .max_keysize =DES_KEY_SIZE , - .setkey = atmel_des_setkey, - .encrypt = atmel_tdes_ecb_encrypt, - .decrypt = atmel_tdes_ecb_decrypt, - } + .base.cra_name ="ecb(des)" , + .base.cra_driver_name ="atmel-ecb-des" , + .base.cra_priority =100 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =DES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct atmel_tdes_ctx ), + .base.cra_alignmask =0x7 , + .base.cra_module =THIS_MODULE , + + .init = atmel_tdes_init_tfm, + .min_keysize =DES_KEY_SIZE , + .max_keysize =DES_KEY_SIZE , + .setkey = atmel_des_setkey, + .encrypt = atmel_tdes_ecb_encrypt, + .decrypt = atmel_tdes_ecb_decrypt, }, { - .cra_name ="cbc(des)" , - .cra_driver_name ="atmel-cbc-des" , - .cra_priority =100 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =DES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct atmel_tdes_ctx ), - .cra_alignmask =0x7 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_tdes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =DES_KEY_SIZE , - .max_keysize =DES_KEY_SIZE , - .ivsize =DES_BLOCK_SIZE , - .setkey = atmel_des_setkey, - .encrypt = atmel_tdes_cbc_encrypt, - .decrypt = atmel_tdes_cbc_decrypt, - } + .base.cra_name ="cbc(des)" , + .base.cra_driver_name ="atmel-cbc-des" , + .base.cra_priority =100 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =DES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct atmel_tdes_ctx ), + .base.cra_alignmask =0x7 , + .base.cra_module =THIS_MODULE , + + .init = atmel_tdes_init_tfm, + .min_keysize =DES_KEY_SIZE , + .max_keysize =DES_KEY_SIZE , + .ivsize =DES_BLOCK_SIZE , + .setkey = atmel_des_setkey, + .encrypt = atmel_tdes_cbc_encrypt, + .decrypt = atmel_tdes_cbc_decrypt, }, { - .cra_name ="cfb(des)" , - .cra_driver_name ="atmel-cfb-des" , - .cra_priority =100 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =DES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct atmel_tdes_ctx ), - .cra_alignmask =0x7 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_tdes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =DES_KEY_SIZE , - .max_keysize =DES_KEY_SIZE , - .ivsize =DES_BLOCK_SIZE , - .setkey = atmel_des_setkey, - .encrypt = atmel_tdes_cfb_encrypt, - .decrypt = atmel_tdes_cfb_decrypt, - } + .base.cra_name ="cfb(des)" , + .base.cra_driver_name ="atmel-cfb-des" , + .base.cra_priority =100 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =DES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct atmel_tdes_ctx ), + .base.cra_alignmask =0x7 , + .base.cra_module =THIS_MODULE , + + .init = atmel_tdes_init_tfm, + .min_keysize =DES_KEY_SIZE , + .max_keysize =DES_KEY_SIZE , + .ivsize =DES_BLOCK_SIZE , + .setkey = atmel_des_setkey, + .encrypt = atmel_tdes_cfb_encrypt, + .decrypt = atmel_tdes_cfb_decrypt, }, { - .cra_name ="cfb8(des)" , - .cra_driver_name ="atmel-cfb8-des" , - .cra_priority =100 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =CFB8_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct atmel_tdes_ctx ), - .cra_alignmask =0 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_tdes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =DES_KEY_SIZE , - .max_keysize =DES_KEY_SIZE , - .ivsize =DES_BLOCK_SIZE , - .setkey = atmel_des_setkey, - .encrypt = atmel_tdes_cfb8_encrypt, - .decrypt = atmel_tdes_cfb8_decrypt, - } + .base.cra_name ="cfb8(des)" , + .base.cra_driver_name ="atmel-cfb8-des" , + .base.cra_priority =100 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =CFB8_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct atmel_tdes_ctx ), + .base.cra_alignmask =0 , + .base.cra_module =THIS_MODULE , + + .init = atmel_tdes_init_tfm, + .min_keysize =DES_KEY_SIZE , + .max_keysize =DES_KEY_SIZE , + .ivsize =DES_BLOCK_SIZE , + .setkey = atmel_des_setkey, + .encrypt = atmel_tdes_cfb8_encrypt, + .decrypt = atmel_tdes_cfb8_decrypt, }, { - .cra_name ="cfb16(des)" , - .cra_driver_name ="atmel-cfb16-des" , - .cra_priority =100 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =CFB16_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct atmel_tdes_ctx ), - .cra_alignmask =0x1 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_tdes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =DES_KEY_SIZE , - .max_keysize =DES_KEY_SIZE , - .ivsize =DES_BLOCK_SIZE , - .setkey = atmel_des_setkey, - .encrypt = atmel_tdes_cfb16_encrypt, - .decrypt = atmel_tdes_cfb16_decrypt, - } + .base.cra_name ="cfb16(des)" , + .base.cra_driver_name ="atmel-cfb16-des" , + .base.cra_priority =100 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =CFB16_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct atmel_tdes_ctx ), + .base.cra_alignmask =0x1 , + .base.cra_module =THIS_MODULE , + + .init = atmel_tdes_init_tfm, + .min_keysize =DES_KEY_SIZE , + .max_keysize =DES_KEY_SIZE , + .ivsize =DES_BLOCK_SIZE , + .setkey = atmel_des_setkey, + .encrypt = atmel_tdes_cfb16_encrypt, + .decrypt = atmel_tdes_cfb16_decrypt, }, { - .cra_name ="cfb32(des)" , - .cra_driver_name ="atmel-cfb32-des" , - .cra_priority =100 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =CFB32_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct atmel_tdes_ctx ), - .cra_alignmask =0x3 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_tdes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =DES_KEY_SIZE , - .max_keysize =DES_KEY_SIZE , - .ivsize =DES_BLOCK_SIZE , - .setkey = atmel_des_setkey, - .encrypt = atmel_tdes_cfb32_encrypt, - .decrypt = atmel_tdes_cfb32_decrypt, - } + .base.cra_name ="cfb32(des)" , + .base.cra_driver_name ="atmel-cfb32-des" , + .base.cra_priority =100 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =CFB32_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct atmel_tdes_ctx ), + .base.cra_alignmask =0x3 , + .base.cra_module =THIS_MODULE , + + .init = atmel_tdes_init_tfm, + .min_keysize =DES_KEY_SIZE , + .max_keysize =DES_KEY_SIZE , + .ivsize =DES_BLOCK_SIZE , + .setkey = atmel_des_setkey, + .encrypt = atmel_tdes_cfb32_encrypt, + .decrypt = atmel_tdes_cfb32_decrypt, }, { - .cra_name ="ofb(des)" , - .cra_driver_name ="atmel-ofb-des" , - .cra_priority =100 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =DES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct atmel_tdes_ctx ), - .cra_alignmask =0x7 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_tdes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =DES_KEY_SIZE , - .max_keysize =DES_KEY_SIZE , - .ivsize =DES_BLOCK_SIZE , - .setkey = atmel_des_setkey, - .encrypt = atmel_tdes_ofb_encrypt, - .decrypt = atmel_tdes_ofb_decrypt, - } + .base.cra_name ="ofb(des)" , + .base.cra_driver_name ="atmel-ofb-des" , + .base.cra_priority =100 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =DES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct atmel_tdes_ctx ), + .base.cra_alignmask =0x7 , + .base.cra_module =THIS_MODULE , + + .init = atmel_tdes_init_tfm, + .min_keysize =DES_KEY_SIZE , + .max_keysize =DES_KEY_SIZE , + .ivsize =DES_BLOCK_SIZE , + .setkey = atmel_des_setkey, + .encrypt = atmel_tdes_ofb_encrypt, + .decrypt = atmel_tdes_ofb_decrypt, }, { - .cra_name ="ecb(des3_ede)" , - .cra_driver_name ="atmel-ecb-tdes" , - .cra_priority =100 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =DES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct atmel_tdes_ctx ), - .cra_alignmask =0x7 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_tdes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =3 *DES_KEY_SIZE , - .max_keysize =3 *DES_KEY_SIZE , - .setkey = atmel_tdes_setkey, - .encrypt = atmel_tdes_ecb_encrypt, - .decrypt = atmel_tdes_ecb_decrypt, - } + .base.cra_name ="ecb(des3_ede)" , + .base.cra_driver_name ="atmel-ecb-tdes" , + .base.cra_priority =100 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =DES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct atmel_tdes_ctx ), + .base.cra_alignmask =0x7 , + .base.cra_module =THIS_MODULE , + + .init = atmel_tdes_init_tfm, + .min_keysize =DES3_EDE_KEY_SIZE , + .max_keysize =DES3_EDE_KEY_SIZE , + .setkey = atmel_tdes_setkey, + .encrypt = atmel_tdes_ecb_encrypt, + .decrypt = atmel_tdes_ecb_decrypt, }, { - .cra_name ="cbc(des3_ede)" , - .cra_driver_name ="atmel-cbc-tdes" , - .cra_priority =100 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =DES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct atmel_tdes_ctx ), - .cra_alignmask =0x7 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_tdes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =3 *DES_KEY_SIZE , - .max_keysize =3 *DES_KEY_SIZE , - .ivsize =DES_BLOCK_SIZE , - .setkey = atmel_tdes_setkey, - .encrypt = atmel_tdes_cbc_encrypt, - .decrypt = atmel_tdes_cbc_decrypt, - } + .base.cra_name ="cbc(des3_ede)" , + .base.cra_driver_name ="atmel-cbc-tdes" , + .base.cra_priority =100 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =DES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct atmel_tdes_ctx ), + .base.cra_alignmask =0x7 , + .base.cra_module =THIS_MODULE , + + .init = atmel_tdes_init_tfm, + .min_keysize =DES3_EDE_KEY_SIZE , + .max_keysize =DES3_EDE_KEY_SIZE , + .setkey = atmel_tdes_setkey, + .encrypt = atmel_tdes_cbc_encrypt, + .decrypt = atmel_tdes_cbc_decrypt, + .ivsize =DES_BLOCK_SIZE , }, { - .cra_name ="ofb(des3_ede)" , - .cra_driver_name ="atmel-ofb-tdes" , - .cra_priority =100 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =DES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct atmel_tdes_ctx ), - .cra_alignmask =0x7 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = atmel_tdes_cra_init, - .cra_u.ablkcipher = { - .min_keysize =3 *DES_KEY_SIZE , - .max_keysize =3 *DES_KEY_SIZE , - .ivsize =DES_BLOCK_SIZE , - .setkey = atmel_tdes_setkey, - .encrypt = atmel_tdes_ofb_encrypt, - .decrypt = atmel_tdes_ofb_decrypt, - } + .base.cra_name ="ofb(des3_ede)" , + .base.cra_driver_name ="atmel-ofb-tdes" , + .base.cra_priority =100 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =DES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct atmel_tdes_ctx ), + .base.cra_alignmask =0x7 , + .base.cra_module =THIS_MODULE , + + .init = atmel_tdes_init_tfm, + .min_keysize =DES3_EDE_KEY_SIZE , + .max_keysize =DES3_EDE_KEY_SIZE , + .setkey = atmel_tdes_setkey, + .encrypt = atmel_tdes_ofb_encrypt, + .decrypt = atmel_tdes_ofb_decrypt, + .ivsize =DES_BLOCK_SIZE , }, };
@@ -1148,7 +1129,7 @@ static void atmel_tdes_unregister_algs(struct atmel_tdes_dev *dd)int i;for (i =0 ; i <ARRAY_SIZE (tdes_algs); i++) -crypto_unregister_alg (&tdes_algs[i]); +crypto_unregister_skcipher (&tdes_algs[i]); }static int atmel_tdes_register_algs (struct atmel_tdes_dev *dd)
@@ -1156,7 +1137,7 @@ static int atmel_tdes_register_algs(struct atmel_tdes_dev *dd)int err, i, j;for (i =0 ; i <ARRAY_SIZE (tdes_algs); i++) { - err =crypto_register_alg (&tdes_algs[i]); + err =crypto_register_skcipher (&tdes_algs[i]);if (err) goto err_tdes_algs; }
@@ -1165,7 +1146,7 @@ static int atmel_tdes_register_algs(struct atmel_tdes_dev *dd) err_tdes_algs:for (j =0 ; j < i; j++) -crypto_unregister_alg (&tdes_algs[j]); +crypto_unregister_skcipher (&tdes_algs[j]);return err; }
Signature · 1 line
2.17.1
Re: [PATCH v4 09/29] crypto: atmel-tdes - switch to skcipher API
Quoted 7 lines · Ard Biesheuvel
Commit
7a7ffe65c8c5("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
Quoted 8 lines
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
Cc Nicolas Ferre <[email protected]>Cc Alexandre Belloni <[email protected]>Cc Ludovic Desroches <[email protected]>Tested-by Tudor Ambarus <[email protected]>Signed-off-by Ard Biesheuvel <[email protected]>
PATCH v4 10/29 crypto: bcm-spu - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/Kconfig | 2 +- drivers/crypto/bcm/cipher.c | 373 +++++++++----------- drivers/crypto/bcm/cipher.h | 10 +- drivers/crypto/bcm/spu2.c | 6 +- 4 files changed, 186 insertions(+), 205 deletions(-)
drivers/crypto/Kconfig +1 -1
@@ -708,7 +708,7 @@ config CRYPTO_DEV_BCM_SPU select CRYPTO_SHA512 help This driver provides support for Broadcom crypto acceleration using the - Secure Processing Unit (SPU). The SPU driver registers ablkcipher, + Secure Processing Unit (SPU). The SPU driver registers skcipher, ahash, and aead algorithms with the kernel cryptographic API. source "drivers/crypto/stm32/Kconfig"
drivers/crypto/bcm/cipher.c +176 -197
682 lines not on this page · raw message
drivers/crypto/bcm/cipher.h +6 -4
@@ -1,3 +1,4 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ /* * Copyright 2016 Broadcom
@@ -11,6 +12,7 @@#include <linux/mailbox_client.h> #include <crypto/aes.h> #include <crypto/internal/hash.h> +#include <crypto/internal/skcipher.h> #include <crypto/aead.h> #include <crypto/arc4.h> #include <crypto/gcm.h>
@@ -102,7 +104,7 @@ struct auth_op {struct iproc_alg_s {u32 type;union { -struct crypto_alg crypto; +struct skcipher_alg skcipher;struct ahash_alg hash;struct aead_alg aead; } alg;
@@ -149,7 +151,7 @@ struct spu_msg_buf {u8 rx_stat[ALIGN (SPU_RX_STATUS_LEN ,SPU_MSG_ALIGN )];union { -/* Buffers only used for ablkcipher */ +/* Buffers only used for skcipher */ struct {/* * Field used for either SUPDT when RC4 is used
@@ -214,7 +216,7 @@ struct iproc_ctx_s {/* * Buffer to hold SPU message header template. Template is created at -* setkey time for ablkcipher requests, since most of the fields in the +* setkey time for skcipher requests, since most of the fields in the * header are known at that time. At request time, just fill in a few * missing pieces related to length of data in the request and IVs, etc. */
@@ -256,7 +258,7 @@ struct iproc_reqctx_s {/* total todo, rx'd, and sent for this request */ unsigned int total_todo; -unsigned int total_received;/* only valid for ablkcipher */ +unsigned int total_received;/* only valid for skcipher */ unsigned int total_sent;/*
drivers/crypto/bcm/spu2.c +3 -3
@@ -542,7 +542,7 @@ void spu2_dump_msg_hdr(u8 *buf, unsigned int buf_len)/** * spu2_fmd_init() - At setkey time, initialize the fixed meta data for -* subsequent ablkcipher requests for this context. +* subsequent skcipher requests for this context. * @spu2_cipher_type: Cipher algorithm * @spu2_mode: Cipher mode * @cipher_key_len: Length of cipher key, in bytes
@@ -1107,13 +1107,13 @@ u32 spu2_create_request(u8 *spu_hdr, }/** -* spu_cipher_req_init() - Build an ablkcipher SPU2 request message header, +* spu_cipher_req_init() - Build an skcipher SPU2 request message header, * including FMD and OMD. * @spu_hdr: Location of start of SPU request (FMD field) * @cipher_parms: Parameters describing cipher request * * Called at setkey time to initialize a msg header that can be reused for all -* subsequent ablkcipher requests. Construct the message starting at spu_hdr. +* subsequent skcipher requests. Construct the message starting at spu_hdr. * Caller should allocate this buffer in DMA-able memory at least * SPU_HEADER_ALLOC_LEN bytes long. *
Signature · 1 line
2.17.1
PATCH v4 11/29 crypto: nitrox - remove cra_type reference to ablkcipher
In reply to Ard BiesheuvelSetting the cra_type field is not necessary for skciphers, and ablkcipher will be removed, so drop the assignment from the nitrox driver.
--- drivers/crypto/cavium/nitrox/nitrox_skcipher.c | 1 - 1 file changed, 1 deletion(-)
drivers/crypto/cavium/nitrox/nitrox_skcipher.c +0 -1
@@ -493,7 +493,6 @@ static struct skcipher_alg nitrox_skciphers[] = { { .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct nitrox_crypto_ctx), .cra_alignmask = 0, - .cra_type = &crypto_ablkcipher_type, .cra_module = THIS_MODULE, }, .min_keysize = AES_MIN_KEY_SIZE,
Signature · 1 line
2.17.1
PATCH v4 12/29 crypto: cavium/cpt - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/cavium/cpt/cptvf_algs.c | 292 +++++++++----------- 1 file changed, 134 insertions(+), 158 deletions(-)
drivers/crypto/cavium/cpt/cptvf_algs.c +134 -158
@@ -92,15 +92,15 @@ static inline void update_output_data(struct cpt_request_info *req_info, } } -static inline u32 create_ctx_hdr (struct ablkcipher_request *req,u32 enc, +static inline u32 create_ctx_hdr (struct skcipher_request *req,u32 enc,u32 *argcnt) { -struct crypto_ablkcipher *tfm =crypto_ablkcipher_reqtfm (req); -struct cvm_enc_ctx *ctx =crypto_ablkcipher_ctx (tfm); -struct cvm_req_ctx *rctx =ablkcipher_request_ctx (req); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req); +struct cvm_enc_ctx *ctx =crypto_skcipher_ctx (tfm); +struct cvm_req_ctx *rctx =skcipher_request_ctx (req);struct fc_context *fctx = &rctx->fctx;u64 *offset_control = &rctx->control_word; -u32 enc_iv_len =crypto_ablkcipher_ivsize (tfm); +u32 enc_iv_len =crypto_skcipher_ivsize (tfm);struct cpt_request_info *req_info = &rctx->cpt_req;u64 *ctrl_flags =NULL ;
@@ -115,7 +115,7 @@ static inline u32 create_ctx_hdr(struct ablkcipher_request *req, u32 enc,else req_info->req.opcode.s.minor =3 ; - req_info->req.param1 = req->nbytes;/* Encryption Data length */ + req_info->req.param1 = req->cryptlen;/* Encryption Data length */ req_info->req.param2 =0 ;/*Auth data length */ fctx->enc.enc_ctrl.e.enc_cipher = ctx->cipher_type;
@@ -147,32 +147,32 @@ static inline u32 create_ctx_hdr(struct ablkcipher_request *req, u32 enc,return 0 ; } -static inline u32 create_input_list (struct ablkcipher_request *req,u32 enc, +static inline u32 create_input_list (struct skcipher_request *req,u32 enc,u32 enc_iv_len) { -struct cvm_req_ctx *rctx =ablkcipher_request_ctx (req); +struct cvm_req_ctx *rctx =skcipher_request_ctx (req);struct cpt_request_info *req_info = &rctx->cpt_req;u32 argcnt =0 ;create_ctx_hdr (req, enc, &argcnt); -update_input_iv (req_info, req->info, enc_iv_len, &argcnt); -update_input_data (req_info, req->src, req->nbytes, &argcnt); +update_input_iv (req_info, req->iv, enc_iv_len, &argcnt); +update_input_data (req_info, req->src, req->cryptlen, &argcnt); req_info->incnt = argcnt;return 0 ; } -static inline void store_cb_info (struct ablkcipher_request *req, +static inline void store_cb_info (struct skcipher_request *req,struct cpt_request_info *req_info) { req_info->callback = (void *)cvm_callback; req_info->callback_arg = (void *)&req->base; } -static inline void create_output_list (struct ablkcipher_request *req, +static inline void create_output_list (struct skcipher_request *req,u32 enc_iv_len) { -struct cvm_req_ctx *rctx =ablkcipher_request_ctx (req); +struct cvm_req_ctx *rctx =skcipher_request_ctx (req);struct cpt_request_info *req_info = &rctx->cpt_req;u32 argcnt =0 ;
@@ -184,16 +184,16 @@ static inline void create_output_list(struct ablkcipher_request *req,* [ 16 Bytes/ [ Request Enc/Dec/ DATA Len AES CBC ] */ /* Reading IV information */ -update_output_iv (req_info, req->info, enc_iv_len, &argcnt); -update_output_data (req_info, req->dst, req->nbytes, &argcnt); +update_output_iv (req_info, req->iv, enc_iv_len, &argcnt); +update_output_data (req_info, req->dst, req->cryptlen, &argcnt); req_info->outcnt = argcnt; } -static inline int cvm_enc_dec (struct ablkcipher_request *req,u32 enc) +static inline int cvm_enc_dec (struct skcipher_request *req,u32 enc) { -struct crypto_ablkcipher *tfm =crypto_ablkcipher_reqtfm (req); -struct cvm_req_ctx *rctx =ablkcipher_request_ctx (req); -u32 enc_iv_len =crypto_ablkcipher_ivsize (tfm); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req); +struct cvm_req_ctx *rctx =skcipher_request_ctx (req); +u32 enc_iv_len =crypto_skcipher_ivsize (tfm);struct fc_context *fctx = &rctx->fctx;struct cpt_request_info *req_info = &rctx->cpt_req;void *cdev =NULL ;
@@ -217,20 +217,20 @@ static inline int cvm_enc_dec(struct ablkcipher_request *req, u32 enc)return -EINPROGRESS ; } -static int cvm_encrypt (struct ablkcipher_request *req) +static int cvm_encrypt (struct skcipher_request *req) {return cvm_enc_dec (req, true); } -static int cvm_decrypt (struct ablkcipher_request *req) +static int cvm_decrypt (struct skcipher_request *req) {return cvm_enc_dec (req, false); } -static int cvm_xts_setkey (struct crypto_ablkcipher *cipher,const u8 *key, +static int cvm_xts_setkey (struct crypto_skcipher *cipher,const u8 *key,u32 keylen) { -struct crypto_tfm *tfm =crypto_ablkcipher_tfm (cipher); +struct crypto_tfm *tfm =crypto_skcipher_tfm (cipher);struct cvm_enc_ctx *ctx =crypto_tfm_ctx (tfm);int err;const u8 *key1 = key;
@@ -284,10 +284,10 @@ static int cvm_validate_keylen(struct cvm_enc_ctx *ctx, u32 keylen)return -EINVAL ; } -static int cvm_setkey (struct crypto_ablkcipher *cipher,const u8 *key, +static int cvm_setkey (struct crypto_skcipher *cipher,const u8 *key,u32 keylen,u8 cipher_type) { -struct crypto_tfm *tfm =crypto_ablkcipher_tfm (cipher); +struct crypto_tfm *tfm =crypto_skcipher_tfm (cipher);struct cvm_enc_ctx *ctx =crypto_tfm_ctx (tfm); ctx->cipher_type = cipher_type;
@@ -295,183 +295,159 @@ static int cvm_setkey(struct crypto_ablkcipher *cipher, const u8 *key,memcpy (ctx->enc_key, key, keylen);return 0 ; }else { -crypto_ablkcipher_set_flags (cipher, +crypto_skcipher_set_flags (cipher,CRYPTO_TFM_RES_BAD_KEY_LEN );return -EINVAL ; } } -static int cvm_cbc_aes_setkey (struct crypto_ablkcipher *cipher,const u8 *key, +static int cvm_cbc_aes_setkey (struct crypto_skcipher *cipher,const u8 *key,u32 keylen) {return cvm_setkey (cipher, key, keylen,AES_CBC ); } -static int cvm_ecb_aes_setkey (struct crypto_ablkcipher *cipher,const u8 *key, +static int cvm_ecb_aes_setkey (struct crypto_skcipher *cipher,const u8 *key,u32 keylen) {return cvm_setkey (cipher, key, keylen,AES_ECB ); } -static int cvm_cfb_aes_setkey (struct crypto_ablkcipher *cipher,const u8 *key, +static int cvm_cfb_aes_setkey (struct crypto_skcipher *cipher,const u8 *key,u32 keylen) {return cvm_setkey (cipher, key, keylen,AES_CFB ); } -static int cvm_cbc_des3_setkey (struct crypto_ablkcipher *cipher,const u8 *key, +static int cvm_cbc_des3_setkey (struct crypto_skcipher *cipher,const u8 *key,u32 keylen) { -return verify_ablkcipher_des3_key (cipher, key) ?: +return verify_skcipher_des3_key (cipher, key) ?:cvm_setkey (cipher, key, keylen,DES3_CBC ); } -static int cvm_ecb_des3_setkey (struct crypto_ablkcipher *cipher,const u8 *key, +static int cvm_ecb_des3_setkey (struct crypto_skcipher *cipher,const u8 *key,u32 keylen) { -return verify_ablkcipher_des3_key (cipher, key) ?: +return verify_skcipher_des3_key (cipher, key) ?:cvm_setkey (cipher, key, keylen,DES3_ECB ); } -static int cvm_enc_dec_init (struct crypto_tfm *tfm) +static int cvm_enc_dec_init (struct crypto_skcipher *tfm) { - tfm->crt_ablkcipher.reqsize =sizeof (struct cvm_req_ctx ); +crypto_skcipher_set_reqsize (tfm,sizeof (struct cvm_req_ctx )); +return 0 ; } -static struct crypto_alg algs[] = { { - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct cvm_enc_ctx ), - .cra_alignmask =7 , - .cra_priority =4001 , - .cra_name ="xts(aes)" , - .cra_driver_name ="cavium-xts-aes" , - .cra_type = &crypto_ablkcipher_type, - .cra_u = { - .ablkcipher = { - .ivsize =AES_BLOCK_SIZE , - .min_keysize =2 *AES_MIN_KEY_SIZE , - .max_keysize =2 *AES_MAX_KEY_SIZE , - .setkey = cvm_xts_setkey, - .encrypt = cvm_encrypt, - .decrypt = cvm_decrypt, - }, - }, - .cra_init = cvm_enc_dec_init, - .cra_module =THIS_MODULE , +static struct skcipher_alg algs[] = { { + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct cvm_enc_ctx ), + .base.cra_alignmask =7 , + .base.cra_priority =4001 , + .base.cra_name ="xts(aes)" , + .base.cra_driver_name ="cavium-xts-aes" , + .base.cra_module =THIS_MODULE , + + .ivsize =AES_BLOCK_SIZE , + .min_keysize =2 *AES_MIN_KEY_SIZE , + .max_keysize =2 *AES_MAX_KEY_SIZE , + .setkey = cvm_xts_setkey, + .encrypt = cvm_encrypt, + .decrypt = cvm_decrypt, + .init = cvm_enc_dec_init, }, { - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct cvm_enc_ctx ), - .cra_alignmask =7 , - .cra_priority =4001 , - .cra_name ="cbc(aes)" , - .cra_driver_name ="cavium-cbc-aes" , - .cra_type = &crypto_ablkcipher_type, - .cra_u = { - .ablkcipher = { - .ivsize =AES_BLOCK_SIZE , - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .setkey = cvm_cbc_aes_setkey, - .encrypt = cvm_encrypt, - .decrypt = cvm_decrypt, - }, - }, - .cra_init = cvm_enc_dec_init, - .cra_module =THIS_MODULE , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct cvm_enc_ctx ), + .base.cra_alignmask =7 , + .base.cra_priority =4001 , + .base.cra_name ="cbc(aes)" , + .base.cra_driver_name ="cavium-cbc-aes" , + .base.cra_module =THIS_MODULE , + + .ivsize =AES_BLOCK_SIZE , + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = cvm_cbc_aes_setkey, + .encrypt = cvm_encrypt, + .decrypt = cvm_decrypt, + .init = cvm_enc_dec_init, }, { - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct cvm_enc_ctx ), - .cra_alignmask =7 , - .cra_priority =4001 , - .cra_name ="ecb(aes)" , - .cra_driver_name ="cavium-ecb-aes" , - .cra_type = &crypto_ablkcipher_type, - .cra_u = { - .ablkcipher = { - .ivsize =AES_BLOCK_SIZE , - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .setkey = cvm_ecb_aes_setkey, - .encrypt = cvm_encrypt, - .decrypt = cvm_decrypt, - }, - }, - .cra_init = cvm_enc_dec_init, - .cra_module =THIS_MODULE , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct cvm_enc_ctx ), + .base.cra_alignmask =7 , + .base.cra_priority =4001 , + .base.cra_name ="ecb(aes)" , + .base.cra_driver_name ="cavium-ecb-aes" , + .base.cra_module =THIS_MODULE , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = cvm_ecb_aes_setkey, + .encrypt = cvm_encrypt, + .decrypt = cvm_decrypt, + .init = cvm_enc_dec_init, }, { - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct cvm_enc_ctx ), - .cra_alignmask =7 , - .cra_priority =4001 , - .cra_name ="cfb(aes)" , - .cra_driver_name ="cavium-cfb-aes" , - .cra_type = &crypto_ablkcipher_type, - .cra_u = { - .ablkcipher = { - .ivsize =AES_BLOCK_SIZE , - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .setkey = cvm_cfb_aes_setkey, - .encrypt = cvm_encrypt, - .decrypt = cvm_decrypt, - }, - }, - .cra_init = cvm_enc_dec_init, - .cra_module =THIS_MODULE , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct cvm_enc_ctx ), + .base.cra_alignmask =7 , + .base.cra_priority =4001 , + .base.cra_name ="cfb(aes)" , + .base.cra_driver_name ="cavium-cfb-aes" , + .base.cra_module =THIS_MODULE , + + .ivsize =AES_BLOCK_SIZE , + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = cvm_cfb_aes_setkey, + .encrypt = cvm_encrypt, + .decrypt = cvm_decrypt, + .init = cvm_enc_dec_init, }, { - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =DES3_EDE_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct cvm_des3_ctx ), - .cra_alignmask =7 , - .cra_priority =4001 , - .cra_name ="cbc(des3_ede)" , - .cra_driver_name ="cavium-cbc-des3_ede" , - .cra_type = &crypto_ablkcipher_type, - .cra_u = { - .ablkcipher = { - .min_keysize =DES3_EDE_KEY_SIZE , - .max_keysize =DES3_EDE_KEY_SIZE , - .ivsize =DES_BLOCK_SIZE , - .setkey = cvm_cbc_des3_setkey, - .encrypt = cvm_encrypt, - .decrypt = cvm_decrypt, - }, - }, - .cra_init = cvm_enc_dec_init, - .cra_module =THIS_MODULE , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =DES3_EDE_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct cvm_des3_ctx ), + .base.cra_alignmask =7 , + .base.cra_priority =4001 , + .base.cra_name ="cbc(des3_ede)" , + .base.cra_driver_name ="cavium-cbc-des3_ede" , + .base.cra_module =THIS_MODULE , + + .min_keysize =DES3_EDE_KEY_SIZE , + .max_keysize =DES3_EDE_KEY_SIZE , + .ivsize =DES_BLOCK_SIZE , + .setkey = cvm_cbc_des3_setkey, + .encrypt = cvm_encrypt, + .decrypt = cvm_decrypt, + .init = cvm_enc_dec_init, }, { - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =DES3_EDE_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct cvm_des3_ctx ), - .cra_alignmask =7 , - .cra_priority =4001 , - .cra_name ="ecb(des3_ede)" , - .cra_driver_name ="cavium-ecb-des3_ede" , - .cra_type = &crypto_ablkcipher_type, - .cra_u = { - .ablkcipher = { - .min_keysize =DES3_EDE_KEY_SIZE , - .max_keysize =DES3_EDE_KEY_SIZE , - .ivsize =DES_BLOCK_SIZE , - .setkey = cvm_ecb_des3_setkey, - .encrypt = cvm_encrypt, - .decrypt = cvm_decrypt, - }, - }, - .cra_init = cvm_enc_dec_init, - .cra_module =THIS_MODULE , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =DES3_EDE_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct cvm_des3_ctx ), + .base.cra_alignmask =7 , + .base.cra_priority =4001 , + .base.cra_name ="ecb(des3_ede)" , + .base.cra_driver_name ="cavium-ecb-des3_ede" , + .base.cra_module =THIS_MODULE , + + .min_keysize =DES3_EDE_KEY_SIZE , + .max_keysize =DES3_EDE_KEY_SIZE , + .ivsize =DES_BLOCK_SIZE , + .setkey = cvm_ecb_des3_setkey, + .encrypt = cvm_encrypt, + .decrypt = cvm_decrypt, + .init = cvm_enc_dec_init, } };static inline int cav_register_algs (void ) {int err =0 ; - err =crypto_register_algs (algs,ARRAY_SIZE (algs)); + err =crypto_register_skciphers (algs,ARRAY_SIZE (algs));if (err)return err;
@@ -480,7 +456,7 @@ static inline int cav_register_algs(void)static inline void cav_unregister_algs (void ) { -crypto_unregister_algs (algs,ARRAY_SIZE (algs)); +crypto_unregister_skciphers (algs,ARRAY_SIZE (algs)); }int cvm_crypto_init (struct cpt_vf *cptvf)
Signature · 1 line
2.17.1
PATCH v4 13/29 crypto: chelsio - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/chelsio/chcr_algo.c | 334 ++++++++++---------- drivers/crypto/chelsio/chcr_algo.h | 2 +- drivers/crypto/chelsio/chcr_crypto.h | 16 +- 3 files changed, 173 insertions(+), 179 deletions(-)
drivers/crypto/chelsio/chcr_algo.c +164 -170
@@ -93,7 +93,7 @@ static u32 round_constant[11] = { 0x1B000000, 0x36000000, 0x6C000000 }; -static int chcr_handle_cipher_resp (struct ablkcipher_request *req, +static int chcr_handle_cipher_resp (struct skcipher_request *req,unsigned char *input,int err);static inline struct chcr_aead_ctx *AEAD_CTX (struct chcr_context *ctx)
@@ -568,11 +568,11 @@ static void ulptx_walk_add_sg(struct ulptx_walk *walk, } } -static inline int get_cryptoalg_subtype (struct crypto_tfm *tfm) +static inline int get_cryptoalg_subtype (struct crypto_skcipher *tfm) { -struct crypto_alg *alg = tfm->__crt_alg; +struct skcipher_alg *alg =crypto_skcipher_alg (tfm);struct chcr_alg_template *chcr_crypto_alg = - container_of(alg, struct chcr_alg_template, alg.crypto); + container_of(alg, struct chcr_alg_template, alg.skcipher);return chcr_crypto_alg->type &CRYPTO_ALG_SUB_TYPE_MASK ; }
@@ -757,14 +757,14 @@ static inline void create_wreq(struct chcr_context *ctx,*/ static struct sk_buff *create_cipher_wr (struct cipher_wr_param *wrparam) { -struct crypto_ablkcipher *tfm =crypto_ablkcipher_reqtfm (wrparam->req); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (wrparam->req);struct ablk_ctx *ablkctx =ABLK_CTX (c_ctx (tfm));struct sk_buff *skb =NULL ;struct chcr_wr *chcr_req;struct cpl_rx_phys_dsgl *phys_cpl;struct ulptx_sgl *ulptx; -struct chcr_blkcipher_req_ctx *reqctx = -ablkcipher_request_ctx (wrparam->req); +struct chcr_skcipher_req_ctx *reqctx = +skcipher_request_ctx (wrparam->req);unsigned int temp =0 , transhdr_len, dst_size;int error;int nents;
@@ -807,9 +807,9 @@ static struct sk_buff *create_cipher_wr(struct cipher_wr_param *wrparam) chcr_req->key_ctx.ctx_hdr = ablkctx->key_ctx_hdr;if ((reqctx->op ==CHCR_DECRYPT_OP ) && - (!(get_cryptoalg_subtype (crypto_ablkcipher_tfm (tfm)) == + (!(get_cryptoalg_subtype (tfm) ==CRYPTO_ALG_SUB_TYPE_CTR )) && - (!(get_cryptoalg_subtype (crypto_ablkcipher_tfm (tfm)) == + (!(get_cryptoalg_subtype (tfm) ==CRYPTO_ALG_SUB_TYPE_CTR_RFC3686 ))) {generate_copy_rrkey (ablkctx, &chcr_req->key_ctx); }else {
@@ -843,7 +843,7 @@ static struct sk_buff *create_cipher_wr(struct cipher_wr_param *wrparam)if (reqctx->op && (ablkctx->ciph_mode ==CHCR_SCMD_CIPHER_MODE_AES_CBC ))sg_pcopy_to_buffer (wrparam->req->src, -sg_nents (wrparam->req->src), wrparam->req->info,16 , +sg_nents (wrparam->req->src), wrparam->req->iv,16 , reqctx->processed + wrparam->bytes -AES_BLOCK_SIZE );return skb;
@@ -866,11 +866,11 @@ static inline int chcr_keyctx_ck_size(unsigned int keylen)return ck_size; } -static int chcr_cipher_fallback_setkey (struct crypto_ablkcipher *cipher, +static int chcr_cipher_fallback_setkey (struct crypto_skcipher *cipher,const u8 *key,unsigned int keylen) { -struct crypto_tfm *tfm =crypto_ablkcipher_tfm (cipher); +struct crypto_tfm *tfm =crypto_skcipher_tfm (cipher);struct ablk_ctx *ablkctx =ABLK_CTX (c_ctx (cipher));int err =0 ;
@@ -886,7 +886,7 @@ static int chcr_cipher_fallback_setkey(struct crypto_ablkcipher *cipher,return err; } -static int chcr_aes_cbc_setkey (struct crypto_ablkcipher *cipher, +static int chcr_aes_cbc_setkey (struct crypto_skcipher *cipher,const u8 *key,unsigned int keylen) {
@@ -912,13 +912,13 @@ static int chcr_aes_cbc_setkey(struct crypto_ablkcipher *cipher, ablkctx->ciph_mode =CHCR_SCMD_CIPHER_MODE_AES_CBC ;return 0 ; badkey_err: -crypto_ablkcipher_set_flags (cipher,CRYPTO_TFM_RES_BAD_KEY_LEN ); +crypto_skcipher_set_flags (cipher,CRYPTO_TFM_RES_BAD_KEY_LEN ); ablkctx->enckey_len =0 ;return err; } -static int chcr_aes_ctr_setkey (struct crypto_ablkcipher *cipher, +static int chcr_aes_ctr_setkey (struct crypto_skcipher *cipher,const u8 *key,unsigned int keylen) {
@@ -943,13 +943,13 @@ static int chcr_aes_ctr_setkey(struct crypto_ablkcipher *cipher,return 0 ; badkey_err: -crypto_ablkcipher_set_flags (cipher,CRYPTO_TFM_RES_BAD_KEY_LEN ); +crypto_skcipher_set_flags (cipher,CRYPTO_TFM_RES_BAD_KEY_LEN ); ablkctx->enckey_len =0 ;return err; } -static int chcr_aes_rfc3686_setkey (struct crypto_ablkcipher *cipher, +static int chcr_aes_rfc3686_setkey (struct crypto_skcipher *cipher,const u8 *key,unsigned int keylen) {
@@ -981,7 +981,7 @@ static int chcr_aes_rfc3686_setkey(struct crypto_ablkcipher *cipher,return 0 ; badkey_err: -crypto_ablkcipher_set_flags (cipher,CRYPTO_TFM_RES_BAD_KEY_LEN ); +crypto_skcipher_set_flags (cipher,CRYPTO_TFM_RES_BAD_KEY_LEN ); ablkctx->enckey_len =0 ;return err;
@@ -1017,12 +1017,12 @@ static unsigned int adjust_ctr_overflow(u8 *iv, u32 bytes)return bytes; } -static int chcr_update_tweak (struct ablkcipher_request *req,u8 *iv, +static int chcr_update_tweak (struct skcipher_request *req,u8 *iv,u32 isfinal) { -struct crypto_ablkcipher *tfm =crypto_ablkcipher_reqtfm (req); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req);struct ablk_ctx *ablkctx =ABLK_CTX (c_ctx (tfm)); -struct chcr_blkcipher_req_ctx *reqctx =ablkcipher_request_ctx (req); +struct chcr_skcipher_req_ctx *reqctx =skcipher_request_ctx (req);struct crypto_aes_ctx aes;int ret, i;u8 *key;
@@ -1051,16 +1051,16 @@ static int chcr_update_tweak(struct ablkcipher_request *req, u8 *iv,return 0 ; } -static int chcr_update_cipher_iv (struct ablkcipher_request *req, +static int chcr_update_cipher_iv (struct skcipher_request *req,struct cpl_fw6_pld *fw6_pld,u8 *iv) { -struct crypto_ablkcipher *tfm =crypto_ablkcipher_reqtfm (req); -struct chcr_blkcipher_req_ctx *reqctx =ablkcipher_request_ctx (req); -int subtype =get_cryptoalg_subtype (crypto_ablkcipher_tfm (tfm)); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req); +struct chcr_skcipher_req_ctx *reqctx =skcipher_request_ctx (req); +int subtype =get_cryptoalg_subtype (tfm);int ret =0 ;if (subtype ==CRYPTO_ALG_SUB_TYPE_CTR ) -ctr_add_iv (iv, req->info, (reqctx->processed / +ctr_add_iv (iv, req->iv, (reqctx->processed /AES_BLOCK_SIZE ));else if (subtype ==CRYPTO_ALG_SUB_TYPE_CTR_RFC3686 ) *(__be32 *)(reqctx->iv + CTR_RFC3686_NONCE_SIZE +
@@ -1071,7 +1071,7 @@ static int chcr_update_cipher_iv(struct ablkcipher_request *req,else if (subtype ==CRYPTO_ALG_SUB_TYPE_CBC ) {if (reqctx->op)/*Updated before sending last WR*/ -memcpy (iv, req->info,AES_BLOCK_SIZE ); +memcpy (iv, req->iv,AES_BLOCK_SIZE );else memcpy (iv, &fw6_pld->data[2 ],AES_BLOCK_SIZE ); }
@@ -1085,16 +1085,16 @@ static int chcr_update_cipher_iv(struct ablkcipher_request *req,* for subsequent update requests */ -static int chcr_final_cipher_iv (struct ablkcipher_request *req, +static int chcr_final_cipher_iv (struct skcipher_request *req,struct cpl_fw6_pld *fw6_pld,u8 *iv) { -struct crypto_ablkcipher *tfm =crypto_ablkcipher_reqtfm (req); -struct chcr_blkcipher_req_ctx *reqctx =ablkcipher_request_ctx (req); -int subtype =get_cryptoalg_subtype (crypto_ablkcipher_tfm (tfm)); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req); +struct chcr_skcipher_req_ctx *reqctx =skcipher_request_ctx (req); +int subtype =get_cryptoalg_subtype (tfm);int ret =0 ;if (subtype ==CRYPTO_ALG_SUB_TYPE_CTR ) -ctr_add_iv (iv, req->info,DIV_ROUND_UP (reqctx->processed, +ctr_add_iv (iv, req->iv,DIV_ROUND_UP (reqctx->processed,AES_BLOCK_SIZE ));else if (subtype ==CRYPTO_ALG_SUB_TYPE_XTS ) ret =chcr_update_tweak (req, iv,1 );
@@ -1108,25 +1108,25 @@ static int chcr_final_cipher_iv(struct ablkcipher_request *req, } -static int chcr_handle_cipher_resp (struct ablkcipher_request *req, +static int chcr_handle_cipher_resp (struct skcipher_request *req,unsigned char *input,int err) { -struct crypto_ablkcipher *tfm =crypto_ablkcipher_reqtfm (req); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req);struct uld_ctx *u_ctx =ULD_CTX (c_ctx (tfm));struct ablk_ctx *ablkctx =ABLK_CTX (c_ctx (tfm));struct sk_buff *skb;struct cpl_fw6_pld *fw6_pld = (struct cpl_fw6_pld *)input; -struct chcr_blkcipher_req_ctx *reqctx =ablkcipher_request_ctx (req); +struct chcr_skcipher_req_ctx *reqctx =skcipher_request_ctx (req);struct cipher_wr_param wrparam;struct chcr_dev *dev =c_ctx (tfm)->dev;int bytes;if (err) goto unmap; -if (req->nbytes == reqctx->processed) { +if (req->cryptlen == reqctx->processed) {chcr_cipher_dma_unmap (&ULD_CTX (c_ctx (tfm))->lldi.pdev->dev, req); - err =chcr_final_cipher_iv (req, fw6_pld, req->info); + err =chcr_final_cipher_iv (req, fw6_pld, req->iv); goto complete; }
@@ -1134,13 +1134,13 @@ static int chcr_handle_cipher_resp(struct ablkcipher_request *req, bytes =chcr_sg_ent_in_wr (reqctx->srcsg, reqctx->dstsg,0 ,CIP_SPACE_LEFT (ablkctx->enckey_len), reqctx->src_ofst, reqctx->dst_ofst); -if ((bytes + reqctx->processed) >= req->nbytes) - bytes = req->nbytes - reqctx->processed; +if ((bytes + reqctx->processed) >= req->cryptlen) + bytes = req->cryptlen - reqctx->processed;else bytes =rounddown (bytes,16 ); }else {/*CTR mode counter overfloa*/ - bytes = req->nbytes - reqctx->processed; + bytes = req->cryptlen - reqctx->processed; } err =chcr_update_cipher_iv (req, fw6_pld, reqctx->iv);if (err)
@@ -1153,13 +1153,13 @@ static int chcr_handle_cipher_resp(struct ablkcipher_request *req, req->base.flags, req->src, req->dst, - req->nbytes, - req->info, + req->cryptlen, + req->iv, reqctx->op); goto complete; } -if (get_cryptoalg_subtype (crypto_ablkcipher_tfm (tfm)) == +if (get_cryptoalg_subtype (tfm) ==CRYPTO_ALG_SUB_TYPE_CTR ) bytes =adjust_ctr_overflow (reqctx->iv, bytes); wrparam.qid = u_ctx->lldi.rxq_ids[c_ctx (tfm)->rx_qidx];
@@ -1185,33 +1185,33 @@ static int chcr_handle_cipher_resp(struct ablkcipher_request *req,return err; } -static int process_cipher (struct ablkcipher_request *req, +static int process_cipher (struct skcipher_request *req,unsigned short qid,struct sk_buff **skb,unsigned short op_type) { -struct crypto_ablkcipher *tfm =crypto_ablkcipher_reqtfm (req); -unsigned int ivsize =crypto_ablkcipher_ivsize (tfm); -struct chcr_blkcipher_req_ctx *reqctx =ablkcipher_request_ctx (req); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req); +unsigned int ivsize =crypto_skcipher_ivsize (tfm); +struct chcr_skcipher_req_ctx *reqctx =skcipher_request_ctx (req);struct ablk_ctx *ablkctx =ABLK_CTX (c_ctx (tfm));struct cipher_wr_param wrparam;int bytes, err = -EINVAL ; reqctx->processed =0 ; -if (!req->info) +if (!req->iv) goto error;if ((ablkctx->enckey_len ==0 ) || (ivsize >AES_BLOCK_SIZE ) || - (req->nbytes ==0 ) || - (req->nbytes %crypto_ablkcipher_blocksize (tfm))) { + (req->cryptlen ==0 ) || + (req->cryptlen %crypto_skcipher_blocksize (tfm))) {pr_err ("AES: Invalid value of Key Len %d nbytes %d IV Len %d\n" , - ablkctx->enckey_len, req->nbytes, ivsize); + ablkctx->enckey_len, req->cryptlen, ivsize); goto error; } err =chcr_cipher_dma_map (&ULD_CTX (c_ctx (tfm))->lldi.pdev->dev, req);if (err) goto error; - if (req->nbytes < (SGE_MAX_WR_LEN - (sizeof(struct chcr_wr) + + if (req->cryptlen < (SGE_MAX_WR_LEN - (sizeof(struct chcr_wr) + AES_MIN_KEY_SIZE + sizeof(struct cpl_rx_phys_dsgl) +/*Min dsgl size*/
@@ -1219,14 +1219,14 @@ static int process_cipher(struct ablkcipher_request *req,/* Can be sent as Imm*/ unsigned int dnents =0 , transhdr_len, phys_dsgl, kctx_len; - dnents =sg_nents_xlen (req->dst, req->nbytes, + dnents =sg_nents_xlen (req->dst, req->cryptlen,CHCR_DST_SG_SIZE ,0 ); phys_dsgl =get_space_for_phys_dsgl (dnents); kctx_len =roundup (ablkctx->enckey_len,16 ); transhdr_len =CIPHER_TRANSHDR_SIZE (kctx_len, phys_dsgl); - reqctx->imm = (transhdr_len +IV + req->nbytes) <= + reqctx->imm = (transhdr_len +IV + req->cryptlen) <=SGE_MAX_WR_LEN ; - bytes =IV + req->nbytes; + bytes =IV + req->cryptlen; }else { reqctx->imm =0 ;
@@ -1236,21 +1236,21 @@ static int process_cipher(struct ablkcipher_request *req, bytes =chcr_sg_ent_in_wr (req->src, req->dst,0 ,CIP_SPACE_LEFT (ablkctx->enckey_len),0 ,0 ); -if ((bytes + reqctx->processed) >= req->nbytes) - bytes = req->nbytes - reqctx->processed; +if ((bytes + reqctx->processed) >= req->cryptlen) + bytes = req->cryptlen - reqctx->processed;else bytes =rounddown (bytes,16 ); }else { - bytes = req->nbytes; + bytes = req->cryptlen; } -if (get_cryptoalg_subtype (crypto_ablkcipher_tfm (tfm)) == +if (get_cryptoalg_subtype (tfm) ==CRYPTO_ALG_SUB_TYPE_CTR ) { - bytes =adjust_ctr_overflow (req->info, bytes); + bytes =adjust_ctr_overflow (req->iv, bytes); } -if (get_cryptoalg_subtype (crypto_ablkcipher_tfm (tfm)) == +if (get_cryptoalg_subtype (tfm) ==CRYPTO_ALG_SUB_TYPE_CTR_RFC3686 ) {memcpy (reqctx->iv, ablkctx->nonce,CTR_RFC3686_NONCE_SIZE ); -memcpy (reqctx->iv +CTR_RFC3686_NONCE_SIZE , req->info, +memcpy (reqctx->iv +CTR_RFC3686_NONCE_SIZE , req->iv,CTR_RFC3686_IV_SIZE );/* initialize counter portion of counter block */
@@ -1259,7 +1259,7 @@ static int process_cipher(struct ablkcipher_request *req, }else { -memcpy (reqctx->iv, req->info,IV ); +memcpy (reqctx->iv, req->iv,IV ); }if (unlikely (bytes ==0 )) { chcr_cipher_dma_unmap(&ULD_CTX(c_ctx(tfm))->lldi.pdev->dev,
@@ -1268,7 +1268,7 @@ static int process_cipher(struct ablkcipher_request *req, req->base.flags, req->src, req->dst, - req->nbytes, + req->cryptlen, reqctx->iv, op_type); goto error;
@@ -1296,9 +1296,9 @@ static int process_cipher(struct ablkcipher_request *req,return err; } -static int chcr_aes_encrypt (struct ablkcipher_request *req) +static int chcr_aes_encrypt (struct skcipher_request *req) { -struct crypto_ablkcipher *tfm =crypto_ablkcipher_reqtfm (req); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req);struct chcr_dev *dev =c_ctx (tfm)->dev;struct sk_buff *skb =NULL ;int err, isfull =0 ;
@@ -1329,9 +1329,9 @@ static int chcr_aes_encrypt(struct ablkcipher_request *req)return err; } -static int chcr_aes_decrypt (struct ablkcipher_request *req) +static int chcr_aes_decrypt (struct skcipher_request *req) { -struct crypto_ablkcipher *tfm =crypto_ablkcipher_reqtfm (req); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req);struct uld_ctx *u_ctx =ULD_CTX (c_ctx (tfm));struct chcr_dev *dev =c_ctx (tfm)->dev;struct sk_buff *skb =NULL ;
@@ -1398,27 +1398,28 @@ static int chcr_device_init(struct chcr_context *ctx)return err; } -static int chcr_cra_init (struct crypto_tfm *tfm) +static int chcr_init_tfm (struct crypto_skcipher *tfm) { -struct crypto_alg *alg = tfm->__crt_alg; -struct chcr_context *ctx =crypto_tfm_ctx (tfm); +struct skcipher_alg *alg =crypto_skcipher_alg (tfm); +struct chcr_context *ctx =crypto_skcipher_ctx (tfm);struct ablk_ctx *ablkctx =ABLK_CTX (ctx); - ablkctx->sw_cipher =crypto_alloc_sync_skcipher (alg->cra_name,0 , + ablkctx->sw_cipher =crypto_alloc_sync_skcipher (alg->base.cra_name,0 ,CRYPTO_ALG_NEED_FALLBACK );if (IS_ERR (ablkctx->sw_cipher)) { -pr_err ("failed to allocate fallback for %s\n" , alg->cra_name); +pr_err ("failed to allocate fallback for %s\n" , alg->base.cra_name);return PTR_ERR (ablkctx->sw_cipher); } - tfm->crt_ablkcipher.reqsize =sizeof (struct chcr_blkcipher_req_ctx ); -return chcr_device_init (crypto_tfm_ctx (tfm)); +crypto_skcipher_set_reqsize (tfm,sizeof (struct chcr_skcipher_req_ctx )); + +return chcr_device_init (ctx); } -static int chcr_rfc3686_init (struct crypto_tfm *tfm) +static int chcr_rfc3686_init (struct crypto_skcipher *tfm) { -struct crypto_alg *alg = tfm->__crt_alg; -struct chcr_context *ctx =crypto_tfm_ctx (tfm); +struct skcipher_alg *alg =crypto_skcipher_alg (tfm); +struct chcr_context *ctx =crypto_skcipher_ctx (tfm);struct ablk_ctx *ablkctx =ABLK_CTX (ctx);/*RFC3686 initialises IV counter value to 1, rfc3686(ctr(aes))
@@ -1427,17 +1428,17 @@ static int chcr_rfc3686_init(struct crypto_tfm *tfm) ablkctx->sw_cipher =crypto_alloc_sync_skcipher ("ctr(aes)" ,0 ,CRYPTO_ALG_NEED_FALLBACK );if (IS_ERR (ablkctx->sw_cipher)) { -pr_err ("failed to allocate fallback for %s\n" , alg->cra_name); +pr_err ("failed to allocate fallback for %s\n" , alg->base.cra_name);return PTR_ERR (ablkctx->sw_cipher); } - tfm->crt_ablkcipher.reqsize =sizeof (struct chcr_blkcipher_req_ctx ); -return chcr_device_init (crypto_tfm_ctx (tfm)); +crypto_skcipher_set_reqsize (tfm,sizeof (struct chcr_skcipher_req_ctx )); +return chcr_device_init (ctx); } -static void chcr_cra_exit (struct crypto_tfm *tfm) +static void chcr_exit_tfm (struct crypto_skcipher *tfm) { -struct chcr_context *ctx =crypto_tfm_ctx (tfm); +struct chcr_context *ctx =crypto_skcipher_ctx (tfm);struct ablk_ctx *ablkctx =ABLK_CTX (ctx);crypto_free_sync_skcipher (ablkctx->sw_cipher);
@@ -2056,8 +2057,8 @@ int chcr_handle_resp(struct crypto_async_request *req, unsigned char *input, err =chcr_handle_aead_resp (aead_request_cast (req), input, err);break ; -case CRYPTO_ALG_TYPE_ABLKCIPHER : -chcr_handle_cipher_resp (ablkcipher_request_cast (req), +case CRYPTO_ALG_TYPE_SKCIPHER : +chcr_handle_cipher_resp (skcipher_request_cast (req), input, err);break ;case CRYPTO_ALG_TYPE_AHASH :
@@ -2148,7 +2149,7 @@ static int chcr_ahash_setkey(struct crypto_ahash *tfm, const u8 *key,return err; } -static int chcr_aes_xts_setkey (struct crypto_ablkcipher *cipher,const u8 *key, +static int chcr_aes_xts_setkey (struct crypto_skcipher *cipher,const u8 *key,unsigned int key_len) {struct ablk_ctx *ablkctx =ABLK_CTX (c_ctx (cipher));
@@ -2172,7 +2173,7 @@ static int chcr_aes_xts_setkey(struct crypto_ablkcipher *cipher, const u8 *key, ablkctx->ciph_mode =CHCR_SCMD_CIPHER_MODE_AES_XTS ;return 0 ; badkey_err: -crypto_ablkcipher_set_flags (cipher,CRYPTO_TFM_RES_BAD_KEY_LEN ); +crypto_skcipher_set_flags (cipher,CRYPTO_TFM_RES_BAD_KEY_LEN ); ablkctx->enckey_len =0 ;return err;
@@ -2576,12 +2577,12 @@ void chcr_add_aead_dst_ent(struct aead_request *req,dsgl_walk_end (&dsgl_walk, qid, ctx->pci_chan_id); } -void chcr_add_cipher_src_ent (struct ablkcipher_request *req, +void chcr_add_cipher_src_ent (struct skcipher_request *req,void *ulptx,struct cipher_wr_param *wrparam) {struct ulptx_walk ulp_walk; -struct chcr_blkcipher_req_ctx *reqctx =ablkcipher_request_ctx (req); +struct chcr_skcipher_req_ctx *reqctx =skcipher_request_ctx (req);u8 *buf = ulptx;memcpy (buf, reqctx->iv,IV );
@@ -2599,13 +2600,13 @@ void chcr_add_cipher_src_ent(struct ablkcipher_request *req, } } -void chcr_add_cipher_dst_ent (struct ablkcipher_request *req, +void chcr_add_cipher_dst_ent (struct skcipher_request *req,struct cpl_rx_phys_dsgl *phys_cpl,struct cipher_wr_param *wrparam,unsigned short qid) { -struct chcr_blkcipher_req_ctx *reqctx =ablkcipher_request_ctx (req); -struct crypto_ablkcipher *tfm =crypto_ablkcipher_reqtfm (wrparam->req); +struct chcr_skcipher_req_ctx *reqctx =skcipher_request_ctx (req); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (wrparam->req);struct chcr_context *ctx =c_ctx (tfm);struct dsgl_walk dsgl_walk;
@@ -2680,7 +2681,7 @@ void chcr_hash_dma_unmap(struct device *dev, }int chcr_cipher_dma_map (struct device *dev, -struct ablkcipher_request *req) +struct skcipher_request *req) {int error;
@@ -2709,7 +2710,7 @@ int chcr_cipher_dma_map(struct device *dev, }void chcr_cipher_dma_unmap (struct device *dev, -struct ablkcipher_request *req) +struct skcipher_request *req) {if (req->src == req->dst) { dma_unmap_sg(dev, req->src, sg_nents(req->src),
@@ -3712,82 +3713,76 @@ static int chcr_aead_decrypt(struct aead_request *req)static struct chcr_alg_template driver_algs[] = {/* AES-CBC */ { - .type =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_SUB_TYPE_CBC , + .type =CRYPTO_ALG_TYPE_SKCIPHER |CRYPTO_ALG_SUB_TYPE_CBC , .is_registered =0 , - .alg.crypto = { - .cra_name ="cbc(aes)" , - .cra_driver_name ="cbc-aes-chcr" , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_init = chcr_cra_init, - .cra_exit = chcr_cra_exit, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = chcr_aes_cbc_setkey, - .encrypt = chcr_aes_encrypt, - .decrypt = chcr_aes_decrypt, + .alg.skcipher = { + .base.cra_name ="cbc(aes)" , + .base.cra_driver_name ="cbc-aes-chcr" , + .base.cra_blocksize =AES_BLOCK_SIZE , + + .init = chcr_init_tfm, + .exit = chcr_exit_tfm, + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , + .setkey = chcr_aes_cbc_setkey, + .encrypt = chcr_aes_encrypt, + .decrypt = chcr_aes_decrypt, } - } }, { - .type =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_SUB_TYPE_XTS , + .type =CRYPTO_ALG_TYPE_SKCIPHER |CRYPTO_ALG_SUB_TYPE_XTS , .is_registered =0 , - .alg.crypto = { - .cra_name ="xts(aes)" , - .cra_driver_name ="xts-aes-chcr" , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_init = chcr_cra_init, - .cra_exit =NULL , - .cra_u .ablkcipher = { - .min_keysize =2 *AES_MIN_KEY_SIZE , - .max_keysize =2 *AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = chcr_aes_xts_setkey, - .encrypt = chcr_aes_encrypt, - .decrypt = chcr_aes_decrypt, - } + .alg.skcipher = { + .base.cra_name ="xts(aes)" , + .base.cra_driver_name ="xts-aes-chcr" , + .base.cra_blocksize =AES_BLOCK_SIZE , + + .init = chcr_init_tfm, + .exit = chcr_exit_tfm, + .min_keysize =2 *AES_MIN_KEY_SIZE , + .max_keysize =2 *AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , + .setkey = chcr_aes_xts_setkey, + .encrypt = chcr_aes_encrypt, + .decrypt = chcr_aes_decrypt, } }, { - .type =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_SUB_TYPE_CTR , + .type =CRYPTO_ALG_TYPE_SKCIPHER |CRYPTO_ALG_SUB_TYPE_CTR , .is_registered =0 , - .alg.crypto = { - .cra_name ="ctr(aes)" , - .cra_driver_name ="ctr-aes-chcr" , - .cra_blocksize =1 , - .cra_init = chcr_cra_init, - .cra_exit = chcr_cra_exit, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = chcr_aes_ctr_setkey, - .encrypt = chcr_aes_encrypt, - .decrypt = chcr_aes_decrypt, - } + .alg.skcipher = { + .base.cra_name ="ctr(aes)" , + .base.cra_driver_name ="ctr-aes-chcr" , + .base.cra_blocksize =1 , + + .init = chcr_init_tfm, + .exit = chcr_exit_tfm, + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , + .setkey = chcr_aes_ctr_setkey, + .encrypt = chcr_aes_encrypt, + .decrypt = chcr_aes_decrypt, } }, { - .type =CRYPTO_ALG_TYPE_ABLKCIPHER | + .type =CRYPTO_ALG_TYPE_SKCIPHER |CRYPTO_ALG_SUB_TYPE_CTR_RFC3686 , .is_registered =0 , - .alg.crypto = { - .cra_name ="rfc3686(ctr(aes))" , - .cra_driver_name ="rfc3686-ctr-aes-chcr" , - .cra_blocksize =1 , - .cra_init = chcr_rfc3686_init, - .cra_exit = chcr_cra_exit, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE + -CTR_RFC3686_NONCE_SIZE , - .max_keysize =AES_MAX_KEY_SIZE + -CTR_RFC3686_NONCE_SIZE , - .ivsize =CTR_RFC3686_IV_SIZE , - .setkey = chcr_aes_rfc3686_setkey, - .encrypt = chcr_aes_encrypt, - .decrypt = chcr_aes_decrypt, - } + .alg.skcipher = { + .base.cra_name ="rfc3686(ctr(aes))" , + .base.cra_driver_name ="rfc3686-ctr-aes-chcr" , + .base.cra_blocksize =1 , + + .init = chcr_rfc3686_init, + .exit = chcr_exit_tfm, + .min_keysize =AES_MIN_KEY_SIZE +CTR_RFC3686_NONCE_SIZE , + .max_keysize =AES_MAX_KEY_SIZE +CTR_RFC3686_NONCE_SIZE , + .ivsize =CTR_RFC3686_IV_SIZE , + .setkey = chcr_aes_rfc3686_setkey, + .encrypt = chcr_aes_encrypt, + .decrypt = chcr_aes_decrypt, } },/* SHA */
@@ -4254,10 +4249,10 @@ static int chcr_unregister_alg(void)for (i =0 ; i <ARRAY_SIZE (driver_algs); i++) {switch (driver_algs[i].type &CRYPTO_ALG_TYPE_MASK ) { -case CRYPTO_ALG_TYPE_ABLKCIPHER : +case CRYPTO_ALG_TYPE_SKCIPHER :if (driver_algs[i].is_registered) -crypto_unregister_alg ( - &driver_algs[i].alg.crypto); +crypto_unregister_skcipher ( + &driver_algs[i].alg.skcipher);break ;case CRYPTO_ALG_TYPE_AEAD :if (driver_algs[i].is_registered)
@@ -4293,21 +4288,20 @@ static int chcr_register_alg(void)if (driver_algs[i].is_registered)continue ;switch (driver_algs[i].type &CRYPTO_ALG_TYPE_MASK ) { -case CRYPTO_ALG_TYPE_ABLKCIPHER : - driver_algs[i].alg.crypto.cra_priority = +case CRYPTO_ALG_TYPE_SKCIPHER : + driver_algs[i].alg.skcipher.base.cra_priority =CHCR_CRA_PRIORITY ; - driver_algs[i].alg.crypto.cra_module =THIS_MODULE ; - driver_algs[i].alg.crypto.cra_flags = -CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC | + driver_algs[i].alg.skcipher.base.cra_module =THIS_MODULE ; + driver_algs[i].alg.skcipher.base.cra_flags = +CRYPTO_ALG_TYPE_SKCIPHER |CRYPTO_ALG_ASYNC |CRYPTO_ALG_NEED_FALLBACK ; - driver_algs[i].alg.crypto.cra_ctxsize = + driver_algs[i].alg.skcipher.base.cra_ctxsize =sizeof (struct chcr_context ) +sizeof (struct ablk_ctx ); - driver_algs[i].alg.crypto.cra_alignmask =0 ; - driver_algs[i].alg.crypto.cra_type = - &crypto_ablkcipher_type; - err =crypto_register_alg (&driver_algs[i].alg.crypto); - name = driver_algs[i].alg.crypto.cra_driver_name; + driver_algs[i].alg.skcipher.base.cra_alignmask =0 ; + + err =crypto_register_skcipher (&driver_algs[i].alg.skcipher); + name = driver_algs[i].alg.skcipher.base.cra_driver_name;break ;case CRYPTO_ALG_TYPE_AEAD : driver_algs[i].alg.aead.base.cra_flags =
drivers/crypto/chelsio/chcr_algo.h +1 -1
@@ -287,7 +287,7 @@ struct hash_wr_param { };struct cipher_wr_param { -struct ablkcipher_request *req; +struct skcipher_request *req;char *iv;int bytes;unsigned short qid;
drivers/crypto/chelsio/chcr_crypto.h +8 -8
@@ -160,9 +160,9 @@ static inline struct chcr_context *a_ctx(struct crypto_aead *tfm)return crypto_aead_ctx (tfm); } -static inline struct chcr_context *c_ctx (struct crypto_ablkcipher *tfm) +static inline struct chcr_context *c_ctx (struct crypto_skcipher *tfm) { -return crypto_ablkcipher_ctx (tfm); +return crypto_skcipher_ctx (tfm); }static inline struct chcr_context *h_ctx (struct crypto_ahash *tfm)
@@ -285,7 +285,7 @@ struct chcr_ahash_req_ctx {u8 bfr2[CHCR_HASH_MAX_BLOCK_SIZE_128 ]; }; -struct chcr_blkcipher_req_ctx { +struct chcr_skcipher_req_ctx {struct sk_buff *skb;struct scatterlist *dstsg;unsigned int processed;
@@ -302,7 +302,7 @@ struct chcr_alg_template {u32 type;u32 is_registered;union { -struct crypto_alg crypto; +struct skcipher_alg skcipher;struct ahash_alg hash;struct aead_alg aead; } alg;
@@ -321,12 +321,12 @@ void chcr_add_aead_dst_ent(struct aead_request *req,struct cpl_rx_phys_dsgl *phys_cpl, unsigned short qid);void chcr_add_aead_src_ent (struct aead_request *req,struct ulptx_sgl *ulptx); -void chcr_add_cipher_src_ent (struct ablkcipher_request *req, +void chcr_add_cipher_src_ent (struct skcipher_request *req,void *ulptx,struct cipher_wr_param *wrparam); -int chcr_cipher_dma_map (struct device *dev,struct ablkcipher_request *req); -void chcr_cipher_dma_unmap (struct device *dev,struct ablkcipher_request *req); -void chcr_add_cipher_dst_ent (struct ablkcipher_request *req, +int chcr_cipher_dma_map (struct device *dev,struct skcipher_request *req); +void chcr_cipher_dma_unmap (struct device *dev,struct skcipher_request *req); +void chcr_add_cipher_dst_ent (struct skcipher_request *req,struct cpl_rx_phys_dsgl *phys_cpl,struct cipher_wr_param *wrparam,unsigned short qid);
Signature · 1 line
2.17.1
PATCH v4 14/29 crypto: hifn - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/hifn_795x.c | 183 ++++++++++---------- 1 file changed, 92 insertions(+), 91 deletions(-)
drivers/crypto/hifn_795x.c +92 -91
@@ -22,6 +22,7 @@#include <crypto/algapi.h> #include <crypto/internal/des.h> +#include <crypto/internal/skcipher.h> static char hifn_pll_ref[sizeof ("extNNN" )] ="ext" ;module_param_string (hifn_pll_ref, hifn_pll_ref,sizeof (hifn_pll_ref),0444 );
@@ -596,7 +597,7 @@ struct hifn_crypt_result {struct hifn_crypto_alg {struct list_head entry; -struct crypto_alg alg; +struct skcipher_alg alg;struct hifn_device *dev; };
@@ -1404,7 +1405,7 @@ static void hifn_cipher_walk_exit(struct hifn_cipher_walk *w) w->num =0 ; } -static int ablkcipher_add (unsigned int *drestp,struct scatterlist *dst, +static int skcipher_add (unsigned int *drestp,struct scatterlist *dst,unsigned int size,unsigned int *nbytesp) {unsigned int copy, drest = *drestp, nbytes = *nbytesp;
@@ -1433,11 +1434,11 @@ static int ablkcipher_add(unsigned int *drestp, struct scatterlist *dst,return idx; } -static int hifn_cipher_walk (struct ablkcipher_request *req, +static int hifn_cipher_walk (struct skcipher_request *req,struct hifn_cipher_walk *w) {struct scatterlist *dst, *t; -unsigned int nbytes = req->nbytes, offset, copy, diff; +unsigned int nbytes = req->cryptlen, offset, copy, diff;int idx, tidx, err; tidx = idx =0 ;
@@ -1459,7 +1460,7 @@ static int hifn_cipher_walk(struct ablkcipher_request *req, t = &w->cache[idx]; - err =ablkcipher_add (&dlen, dst, slen, &nbytes); + err =skcipher_add (&dlen, dst, slen, &nbytes);if (err <0 )return err;
@@ -1498,7 +1499,7 @@ static int hifn_cipher_walk(struct ablkcipher_request *req, dst = &req->dst[idx]; - err =ablkcipher_add (&dlen, dst, nbytes, &nbytes); + err =skcipher_add (&dlen, dst, nbytes, &nbytes);if (err <0 )return err;
@@ -1518,13 +1519,13 @@ static int hifn_cipher_walk(struct ablkcipher_request *req,return tidx; } -static int hifn_setup_session (struct ablkcipher_request *req) +static int hifn_setup_session (struct skcipher_request *req) {struct hifn_context *ctx =crypto_tfm_ctx (req->base.tfm); -struct hifn_request_context *rctx =ablkcipher_request_ctx (req); +struct hifn_request_context *rctx =skcipher_request_ctx (req);struct hifn_device *dev = ctx->dev;unsigned long dlen, flags; -unsigned int nbytes = req->nbytes, idx =0 ; +unsigned int nbytes = req->cryptlen, idx =0 ;int err = -EINVAL , sg_num;struct scatterlist *dst;
@@ -1563,7 +1564,7 @@ static int hifn_setup_session(struct ablkcipher_request *req) goto err_out; } - err =hifn_setup_dma (dev, ctx, rctx, req->src, req->dst, req->nbytes, req); + err =hifn_setup_dma (dev, ctx, rctx, req->src, req->dst, req->cryptlen, req);if (err) goto err_out;
@@ -1610,7 +1611,7 @@ static int hifn_start_device(struct hifn_device *dev)return 0 ; } -static int ablkcipher_get (void *saddr,unsigned int *srestp,unsigned int offset, +static int skcipher_get (void *saddr,unsigned int *srestp,unsigned int offset,struct scatterlist *dst,unsigned int size,unsigned int *nbytesp) {unsigned int srest = *srestp, nbytes = *nbytesp, copy;
@@ -1660,12 +1661,12 @@ static inline void hifn_complete_sa(struct hifn_device *dev, int i)BUG_ON (dev->started <0 ); } -static void hifn_process_ready (struct ablkcipher_request *req,int error) +static void hifn_process_ready (struct skcipher_request *req,int error) { -struct hifn_request_context *rctx =ablkcipher_request_ctx (req); +struct hifn_request_context *rctx =skcipher_request_ctx (req);if (rctx->walk.flags &ASYNC_FLAGS_MISALIGNED ) { -unsigned int nbytes = req->nbytes; +unsigned int nbytes = req->cryptlen;int idx =0 , err;struct scatterlist *dst, *t;void *saddr;
@@ -1688,7 +1689,7 @@ static void hifn_process_ready(struct ablkcipher_request *req, int error) saddr =kmap_atomic (sg_page (t)); - err =ablkcipher_get (saddr, &t->length, t->offset, + err =skcipher_get (saddr, &t->length, t->offset, dst, nbytes, &nbytes);if (err <0 ) {kunmap_atomic (saddr);
@@ -1910,7 +1911,7 @@ static void hifn_flush(struct hifn_device *dev) {unsigned long flags;struct crypto_async_request *async_req; -struct ablkcipher_request *req; +struct skcipher_request *req;struct hifn_dma *dma = (struct hifn_dma *)dev->desc_virt;int i;
@@ -1926,7 +1927,7 @@ static void hifn_flush(struct hifn_device *dev)spin_lock_irqsave (&dev->lock, flags);while ((async_req =crypto_dequeue_request (&dev->queue))) { - req =ablkcipher_request_cast (async_req); + req =skcipher_request_cast (async_req);spin_unlock_irqrestore (&dev->lock, flags);hifn_process_ready (req, -ENODEV );
@@ -1936,14 +1937,14 @@ static void hifn_flush(struct hifn_device *dev)spin_unlock_irqrestore (&dev->lock, flags); } -static int hifn_setkey (struct crypto_ablkcipher *cipher,const u8 *key, +static int hifn_setkey (struct crypto_skcipher *cipher,const u8 *key,unsigned int len) { -struct hifn_context *ctx =crypto_ablkcipher_ctx (cipher); +struct hifn_context *ctx =crypto_skcipher_ctx (cipher);struct hifn_device *dev = ctx->dev;int err; - err =verify_ablkcipher_des_key (cipher, key); + err =verify_skcipher_des_key (cipher, key);if (err)return err;
@@ -1955,14 +1956,14 @@ static int hifn_setkey(struct crypto_ablkcipher *cipher, const u8 *key,return 0 ; } -static int hifn_des3_setkey (struct crypto_ablkcipher *cipher,const u8 *key, +static int hifn_des3_setkey (struct crypto_skcipher *cipher,const u8 *key,unsigned int len) { -struct hifn_context *ctx =crypto_ablkcipher_ctx (cipher); +struct hifn_context *ctx =crypto_skcipher_ctx (cipher);struct hifn_device *dev = ctx->dev;int err; - err =verify_ablkcipher_des3_key (cipher, key); + err =verify_skcipher_des3_key (cipher, key);if (err)return err;
@@ -1974,36 +1975,36 @@ static int hifn_des3_setkey(struct crypto_ablkcipher *cipher, const u8 *key,return 0 ; } -static int hifn_handle_req (struct ablkcipher_request *req) +static int hifn_handle_req (struct skcipher_request *req) {struct hifn_context *ctx =crypto_tfm_ctx (req->base.tfm);struct hifn_device *dev = ctx->dev;int err = -EAGAIN ; -if (dev->started +DIV_ROUND_UP (req->nbytes,PAGE_SIZE ) <=HIFN_QUEUE_LENGTH ) +if (dev->started +DIV_ROUND_UP (req->cryptlen,PAGE_SIZE ) <=HIFN_QUEUE_LENGTH ) err =hifn_setup_session (req);if (err == -EAGAIN ) {unsigned long flags;spin_lock_irqsave (&dev->lock, flags); - err =ablkcipher_enqueue_request (&dev->queue, req); + err =crypto_enqueue_request (&dev->queue, &req->base);spin_unlock_irqrestore (&dev->lock, flags); }return err; } -static int hifn_setup_crypto_req (struct ablkcipher_request *req,u8 op, +static int hifn_setup_crypto_req (struct skcipher_request *req,u8 op,u8 type,u8 mode) {struct hifn_context *ctx =crypto_tfm_ctx (req->base.tfm); -struct hifn_request_context *rctx =ablkcipher_request_ctx (req); +struct hifn_request_context *rctx =skcipher_request_ctx (req);unsigned ivsize; - ivsize =crypto_ablkcipher_ivsize (crypto_ablkcipher_reqtfm (req)); + ivsize =crypto_skcipher_ivsize (crypto_skcipher_reqtfm (req)); -if (req->info && mode !=ACRYPTO_MODE_ECB ) { +if (req->iv && mode !=ACRYPTO_MODE_ECB ) {if (type ==ACRYPTO_TYPE_AES_128 ) ivsize =HIFN_AES_IV_LENGTH ;else if (type ==ACRYPTO_TYPE_DES )
@@ -2022,7 +2023,7 @@ static int hifn_setup_crypto_req(struct ablkcipher_request *req, u8 op, rctx->op = op; rctx->mode = mode; rctx->type = type; - rctx->iv = req->info; + rctx->iv = req->iv; rctx->ivsize = ivsize;/*
@@ -2037,7 +2038,7 @@ static int hifn_setup_crypto_req(struct ablkcipher_request *req, u8 op,static int hifn_process_queue (struct hifn_device *dev) {struct crypto_async_request *async_req, *backlog; -struct ablkcipher_request *req; +struct skcipher_request *req;unsigned long flags;int err =0 ;
@@ -2053,7 +2054,7 @@ static int hifn_process_queue(struct hifn_device *dev)if (backlog) backlog->complete (backlog, -EINPROGRESS ); - req =ablkcipher_request_cast (async_req); + req =skcipher_request_cast (async_req); err =hifn_handle_req (req);if (err)
@@ -2063,7 +2064,7 @@ static int hifn_process_queue(struct hifn_device *dev)return err; } -static int hifn_setup_crypto (struct ablkcipher_request *req,u8 op, +static int hifn_setup_crypto (struct skcipher_request *req,u8 op,u8 type,u8 mode) {int err;
@@ -2083,22 +2084,22 @@ static int hifn_setup_crypto(struct ablkcipher_request *req, u8 op,/* * AES ecryption functions. */ -static inline int hifn_encrypt_aes_ecb (struct ablkcipher_request *req) +static inline int hifn_encrypt_aes_ecb (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_ENCRYPT ,ACRYPTO_TYPE_AES_128 ,ACRYPTO_MODE_ECB ); } -static inline int hifn_encrypt_aes_cbc (struct ablkcipher_request *req) +static inline int hifn_encrypt_aes_cbc (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_ENCRYPT ,ACRYPTO_TYPE_AES_128 ,ACRYPTO_MODE_CBC ); } -static inline int hifn_encrypt_aes_cfb (struct ablkcipher_request *req) +static inline int hifn_encrypt_aes_cfb (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_ENCRYPT ,ACRYPTO_TYPE_AES_128 ,ACRYPTO_MODE_CFB ); } -static inline int hifn_encrypt_aes_ofb (struct ablkcipher_request *req) +static inline int hifn_encrypt_aes_ofb (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_ENCRYPT ,ACRYPTO_TYPE_AES_128 ,ACRYPTO_MODE_OFB );
@@ -2107,22 +2108,22 @@ static inline int hifn_encrypt_aes_ofb(struct ablkcipher_request *req)/* * AES decryption functions. */ -static inline int hifn_decrypt_aes_ecb (struct ablkcipher_request *req) +static inline int hifn_decrypt_aes_ecb (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_DECRYPT ,ACRYPTO_TYPE_AES_128 ,ACRYPTO_MODE_ECB ); } -static inline int hifn_decrypt_aes_cbc (struct ablkcipher_request *req) +static inline int hifn_decrypt_aes_cbc (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_DECRYPT ,ACRYPTO_TYPE_AES_128 ,ACRYPTO_MODE_CBC ); } -static inline int hifn_decrypt_aes_cfb (struct ablkcipher_request *req) +static inline int hifn_decrypt_aes_cfb (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_DECRYPT ,ACRYPTO_TYPE_AES_128 ,ACRYPTO_MODE_CFB ); } -static inline int hifn_decrypt_aes_ofb (struct ablkcipher_request *req) +static inline int hifn_decrypt_aes_ofb (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_DECRYPT ,ACRYPTO_TYPE_AES_128 ,ACRYPTO_MODE_OFB );
@@ -2131,22 +2132,22 @@ static inline int hifn_decrypt_aes_ofb(struct ablkcipher_request *req)/* * DES ecryption functions. */ -static inline int hifn_encrypt_des_ecb (struct ablkcipher_request *req) +static inline int hifn_encrypt_des_ecb (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_ENCRYPT ,ACRYPTO_TYPE_DES ,ACRYPTO_MODE_ECB ); } -static inline int hifn_encrypt_des_cbc (struct ablkcipher_request *req) +static inline int hifn_encrypt_des_cbc (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_ENCRYPT ,ACRYPTO_TYPE_DES ,ACRYPTO_MODE_CBC ); } -static inline int hifn_encrypt_des_cfb (struct ablkcipher_request *req) +static inline int hifn_encrypt_des_cfb (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_ENCRYPT ,ACRYPTO_TYPE_DES ,ACRYPTO_MODE_CFB ); } -static inline int hifn_encrypt_des_ofb (struct ablkcipher_request *req) +static inline int hifn_encrypt_des_ofb (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_ENCRYPT ,ACRYPTO_TYPE_DES ,ACRYPTO_MODE_OFB );
@@ -2155,22 +2156,22 @@ static inline int hifn_encrypt_des_ofb(struct ablkcipher_request *req)/* * DES decryption functions. */ -static inline int hifn_decrypt_des_ecb (struct ablkcipher_request *req) +static inline int hifn_decrypt_des_ecb (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_DECRYPT ,ACRYPTO_TYPE_DES ,ACRYPTO_MODE_ECB ); } -static inline int hifn_decrypt_des_cbc (struct ablkcipher_request *req) +static inline int hifn_decrypt_des_cbc (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_DECRYPT ,ACRYPTO_TYPE_DES ,ACRYPTO_MODE_CBC ); } -static inline int hifn_decrypt_des_cfb (struct ablkcipher_request *req) +static inline int hifn_decrypt_des_cfb (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_DECRYPT ,ACRYPTO_TYPE_DES ,ACRYPTO_MODE_CFB ); } -static inline int hifn_decrypt_des_ofb (struct ablkcipher_request *req) +static inline int hifn_decrypt_des_ofb (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_DECRYPT ,ACRYPTO_TYPE_DES ,ACRYPTO_MODE_OFB );
@@ -2179,44 +2180,44 @@ static inline int hifn_decrypt_des_ofb(struct ablkcipher_request *req)/* * 3DES ecryption functions. */ -static inline int hifn_encrypt_3des_ecb (struct ablkcipher_request *req) +static inline int hifn_encrypt_3des_ecb (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_ENCRYPT ,ACRYPTO_TYPE_3DES ,ACRYPTO_MODE_ECB ); } -static inline int hifn_encrypt_3des_cbc (struct ablkcipher_request *req) +static inline int hifn_encrypt_3des_cbc (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_ENCRYPT ,ACRYPTO_TYPE_3DES ,ACRYPTO_MODE_CBC ); } -static inline int hifn_encrypt_3des_cfb (struct ablkcipher_request *req) +static inline int hifn_encrypt_3des_cfb (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_ENCRYPT ,ACRYPTO_TYPE_3DES ,ACRYPTO_MODE_CFB ); } -static inline int hifn_encrypt_3des_ofb (struct ablkcipher_request *req) +static inline int hifn_encrypt_3des_ofb (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_ENCRYPT ,ACRYPTO_TYPE_3DES ,ACRYPTO_MODE_OFB ); }/* 3DES decryption functions. */ -static inline int hifn_decrypt_3des_ecb (struct ablkcipher_request *req) +static inline int hifn_decrypt_3des_ecb (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_DECRYPT ,ACRYPTO_TYPE_3DES ,ACRYPTO_MODE_ECB ); } -static inline int hifn_decrypt_3des_cbc (struct ablkcipher_request *req) +static inline int hifn_decrypt_3des_cbc (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_DECRYPT ,ACRYPTO_TYPE_3DES ,ACRYPTO_MODE_CBC ); } -static inline int hifn_decrypt_3des_cfb (struct ablkcipher_request *req) +static inline int hifn_decrypt_3des_cfb (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_DECRYPT ,ACRYPTO_TYPE_3DES ,ACRYPTO_MODE_CFB ); } -static inline int hifn_decrypt_3des_ofb (struct ablkcipher_request *req) +static inline int hifn_decrypt_3des_ofb (struct skcipher_request *req) {return hifn_setup_crypto (req,ACRYPTO_OP_DECRYPT ,ACRYPTO_TYPE_3DES ,ACRYPTO_MODE_OFB );
@@ -2226,16 +2227,16 @@ struct hifn_alg_template {char name[CRYPTO_MAX_ALG_NAME ];char drv_name[CRYPTO_MAX_ALG_NAME ];unsigned int bsize; -struct ablkcipher_alg ablkcipher; +struct skcipher_alg skcipher; }; -static struct hifn_alg_template hifn_alg_templates[] = { +static const struct hifn_alg_template hifn_alg_templates[] = {/* * 3DES ECB, CBC, CFB and OFB modes. */ { .name ="cfb(des3_ede)" , .drv_name ="cfb-3des" , .bsize =8 , - .ablkcipher = { + .skcipher = { .min_keysize =HIFN_3DES_KEY_LENGTH , .max_keysize =HIFN_3DES_KEY_LENGTH , .setkey = hifn_des3_setkey,
@@ -2245,7 +2246,7 @@ static struct hifn_alg_template hifn_alg_templates[] = { }, { .name = "ofb(des3_ede)", .drv_name = "ofb-3des", .bsize = 8, - .ablkcipher = { + .skcipher = { .min_keysize = HIFN_3DES_KEY_LENGTH, .max_keysize = HIFN_3DES_KEY_LENGTH, .setkey = hifn_des3_setkey,
@@ -2255,7 +2256,7 @@ static struct hifn_alg_template hifn_alg_templates[] = { }, { .name = "cbc(des3_ede)", .drv_name = "cbc-3des", .bsize = 8, - .ablkcipher = { + .skcipher = { .ivsize = HIFN_IV_LENGTH, .min_keysize = HIFN_3DES_KEY_LENGTH, .max_keysize = HIFN_3DES_KEY_LENGTH,
@@ -2266,7 +2267,7 @@ static struct hifn_alg_template hifn_alg_templates[] = { }, { .name = "ecb(des3_ede)", .drv_name = "ecb-3des", .bsize = 8, - .ablkcipher = { + .skcipher = { .min_keysize = HIFN_3DES_KEY_LENGTH, .max_keysize = HIFN_3DES_KEY_LENGTH, .setkey = hifn_des3_setkey,
@@ -2280,7 +2281,7 @@ static struct hifn_alg_template hifn_alg_templates[] = {*/ { .name = "cfb(des)", .drv_name = "cfb-des", .bsize = 8, - .ablkcipher = { + .skcipher = { .min_keysize = HIFN_DES_KEY_LENGTH, .max_keysize = HIFN_DES_KEY_LENGTH, .setkey = hifn_setkey,
@@ -2290,7 +2291,7 @@ static struct hifn_alg_template hifn_alg_templates[] = { }, { .name = "ofb(des)", .drv_name = "ofb-des", .bsize = 8, - .ablkcipher = { + .skcipher = { .min_keysize = HIFN_DES_KEY_LENGTH, .max_keysize = HIFN_DES_KEY_LENGTH, .setkey = hifn_setkey,
@@ -2300,7 +2301,7 @@ static struct hifn_alg_template hifn_alg_templates[] = { }, { .name = "cbc(des)", .drv_name = "cbc-des", .bsize = 8, - .ablkcipher = { + .skcipher = { .ivsize = HIFN_IV_LENGTH, .min_keysize = HIFN_DES_KEY_LENGTH, .max_keysize = HIFN_DES_KEY_LENGTH,
@@ -2311,7 +2312,7 @@ static struct hifn_alg_template hifn_alg_templates[] = { }, { .name = "ecb(des)", .drv_name = "ecb-des", .bsize = 8, - .ablkcipher = { + .skcipher = { .min_keysize = HIFN_DES_KEY_LENGTH, .max_keysize = HIFN_DES_KEY_LENGTH, .setkey = hifn_setkey,
@@ -2325,7 +2326,7 @@ static struct hifn_alg_template hifn_alg_templates[] = {*/ { .name = "ecb(aes)", .drv_name = "ecb-aes", .bsize = 16, - .ablkcipher = { + .skcipher = { .min_keysize = AES_MIN_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE, .setkey = hifn_setkey,
@@ -2335,7 +2336,7 @@ static struct hifn_alg_template hifn_alg_templates[] = { }, { .name = "cbc(aes)", .drv_name = "cbc-aes", .bsize = 16, - .ablkcipher = { + .skcipher = { .ivsize = HIFN_AES_IV_LENGTH, .min_keysize = AES_MIN_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE,
@@ -2346,7 +2347,7 @@ static struct hifn_alg_template hifn_alg_templates[] = { }, { .name = "cfb(aes)", .drv_name = "cfb-aes", .bsize = 16, - .ablkcipher = { + .skcipher = { .min_keysize = AES_MIN_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE, .setkey = hifn_setkey,
@@ -2356,7 +2357,7 @@ static struct hifn_alg_template hifn_alg_templates[] = { }, { .name = "ofb(aes)", .drv_name = "ofb-aes", .bsize = 16, - .ablkcipher = { + .skcipher = { .min_keysize = AES_MIN_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE, .setkey = hifn_setkey,
@@ -2366,18 +2367,19 @@ static struct hifn_alg_template hifn_alg_templates[] = { }, }; -static int hifn_cra_init (struct crypto_tfm *tfm) +static int hifn_init_tfm (struct crypto_skcipher *tfm) { -struct crypto_alg *alg = tfm->__crt_alg; +struct skcipher_alg *alg =crypto_skcipher_alg (tfm);struct hifn_crypto_alg *ha =crypto_alg_to_hifn (alg); -struct hifn_context *ctx =crypto_tfm_ctx (tfm); +struct hifn_context *ctx =crypto_skcipher_ctx (tfm); ctx->dev = ha->dev; - tfm->crt_ablkcipher.reqsize =sizeof (struct hifn_request_context ); +crypto_skcipher_set_reqsize (tfm,sizeof (struct hifn_request_context )); +return 0 ; } -static int hifn_alg_alloc (struct hifn_device *dev,struct hifn_alg_template *t) +static int hifn_alg_alloc (struct hifn_device *dev,const struct hifn_alg_template *t) {struct hifn_crypto_alg *alg;int err;
@@ -2386,26 +2388,25 @@ static int hifn_alg_alloc(struct hifn_device *dev, struct hifn_alg_template *t)if (!alg)return -ENOMEM ; -snprintf (alg->alg.cra_name,CRYPTO_MAX_ALG_NAME ,"%s" , t->name); -snprintf (alg->alg.cra_driver_name,CRYPTO_MAX_ALG_NAME ,"%s-%s" , + alg->alg = t->skcipher; + alg->alg.init = hifn_init_tfm; + +snprintf (alg->alg.base.cra_name,CRYPTO_MAX_ALG_NAME ,"%s" , t->name); +snprintf (alg->alg.base.cra_driver_name,CRYPTO_MAX_ALG_NAME ,"%s-%s" , t->drv_name, dev->name); - alg->alg.cra_priority =300 ; - alg->alg.cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_KERN_DRIVER_ONLY |CRYPTO_ALG_ASYNC ; - alg->alg.cra_blocksize = t->bsize; - alg->alg.cra_ctxsize =sizeof (struct hifn_context ); - alg->alg.cra_alignmask =0 ; - alg->alg.cra_type = &crypto_ablkcipher_type; - alg->alg.cra_module =THIS_MODULE ; - alg->alg.cra_u.ablkcipher = t->ablkcipher; - alg->alg.cra_init = hifn_cra_init; + alg->alg.base.cra_priority =300 ; + alg->alg.base.cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY |CRYPTO_ALG_ASYNC ; + alg->alg.base.cra_blocksize = t->bsize; + alg->alg.base.cra_ctxsize =sizeof (struct hifn_context ); + alg->alg.base.cra_alignmask =0 ; + alg->alg.base.cra_module =THIS_MODULE ; alg->dev = dev;list_add_tail (&alg->entry, &dev->alg_list); - err =crypto_register_alg (&alg->alg); + err =crypto_register_skcipher (&alg->alg);if (err) {list_del (&alg->entry);kfree (alg);
@@ -2420,7 +2421,7 @@ static void hifn_unregister_alg(struct hifn_device *dev)list_for_each_entry_safe (a, n, &dev->alg_list, entry) {list_del (&a->entry); -crypto_unregister_alg (&a->alg); +crypto_unregister_skcipher (&a->alg);kfree (a); } }
Signature · 1 line
2.17.1
PATCH v4 15/29 crypto: ixp4xx - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/ixp4xx_crypto.c | 228 ++++++++++---------- 1 file changed, 108 insertions(+), 120 deletions(-)
drivers/crypto/ixp4xx_crypto.c +108 -120
@@ -23,6 +23,7 @@#include <crypto/sha.h> #include <crypto/algapi.h> #include <crypto/internal/aead.h> +#include <crypto/internal/skcipher.h> #include <crypto/authenc.h> #include <crypto/scatterwalk.h>
@@ -137,7 +138,7 @@ struct crypt_ctl {/* Used by Host: 4*4 bytes*/ unsigned ctl_flags;union { -struct ablkcipher_request *ablk_req; +struct skcipher_request *ablk_req;struct aead_request *aead_req;struct crypto_tfm *tfm; } data;
@@ -186,7 +187,7 @@ struct ixp_ctx { };struct ixp_alg { -struct crypto_alg crypto; +struct skcipher_alg crypto;const struct ix_hash_algo *hash;u32 cfg_enc;u32 cfg_dec;
@@ -239,17 +240,17 @@ static inline struct crypt_ctl *crypt_phys2virt(dma_addr_t phys)static inline u32 cipher_cfg_enc (struct crypto_tfm *tfm) { - return container_of(tfm->__crt_alg, struct ixp_alg,crypto)->cfg_enc; + return container_of(tfm->__crt_alg, struct ixp_alg,crypto.base)->cfg_enc; }static inline u32 cipher_cfg_dec (struct crypto_tfm *tfm) { - return container_of(tfm->__crt_alg, struct ixp_alg,crypto)->cfg_dec; + return container_of(tfm->__crt_alg, struct ixp_alg,crypto.base)->cfg_dec; }static inline const struct ix_hash_algo *ix_hash (struct crypto_tfm *tfm) { - return container_of(tfm->__crt_alg, struct ixp_alg, crypto)->hash; + return container_of(tfm->__crt_alg, struct ixp_alg, crypto.base)->hash; }static int setup_crypt_desc (void )
@@ -378,8 +379,8 @@ static void one_packet(dma_addr_t phys)break ; }case CTL_FLAG_PERFORM_ABLK : { -struct ablkcipher_request *req = crypt->data.ablk_req; -struct ablk_ctx *req_ctx =ablkcipher_request_ctx (req); +struct skcipher_request *req = crypt->data.ablk_req; +struct ablk_ctx *req_ctx =skcipher_request_ctx (req);if (req_ctx->dst) {free_buf_chain (dev, req_ctx->dst, crypt->dst_buf);
@@ -571,10 +572,10 @@ static int init_tfm(struct crypto_tfm *tfm)return ret; } -static int init_tfm_ablk (struct crypto_tfm *tfm) +static int init_tfm_ablk (struct crypto_skcipher *tfm) { - tfm->crt_ablkcipher.reqsize =sizeof (struct ablk_ctx ); -return init_tfm (tfm); +crypto_skcipher_set_reqsize (tfm,sizeof (struct ablk_ctx )); +return init_tfm (crypto_skcipher_tfm (tfm)); }static int init_tfm_aead (struct crypto_aead *tfm)
@@ -590,6 +591,11 @@ static void exit_tfm(struct crypto_tfm *tfm)free_sa_dir (&ctx->decrypt); } +static void exit_tfm_ablk (struct crypto_skcipher *tfm) +{ +exit_tfm (crypto_skcipher_tfm (tfm)); +} +static void exit_tfm_aead (struct crypto_aead *tfm) {exit_tfm (crypto_aead_tfm (tfm));
@@ -809,10 +815,10 @@ static struct buffer_desc *chainup_buffers(struct device *dev,return buf; } -static int ablk_setkey (struct crypto_ablkcipher *tfm,const u8 *key, +static int ablk_setkey (struct crypto_skcipher *tfm,const u8 *key,unsigned int key_len) { -struct ixp_ctx *ctx =crypto_ablkcipher_ctx (tfm); +struct ixp_ctx *ctx =crypto_skcipher_ctx (tfm);u32 *flags = &tfm->base.crt_flags;int ret;
@@ -845,17 +851,17 @@ static int ablk_setkey(struct crypto_ablkcipher *tfm, const u8 *key,return ret; } -static int ablk_des3_setkey (struct crypto_ablkcipher *tfm,const u8 *key, +static int ablk_des3_setkey (struct crypto_skcipher *tfm,const u8 *key,unsigned int key_len) { -return verify_ablkcipher_des3_key (tfm, key) ?: +return verify_skcipher_des3_key (tfm, key) ?:ablk_setkey (tfm, key, key_len); } -static int ablk_rfc3686_setkey (struct crypto_ablkcipher *tfm,const u8 *key, +static int ablk_rfc3686_setkey (struct crypto_skcipher *tfm,const u8 *key,unsigned int key_len) { -struct ixp_ctx *ctx =crypto_ablkcipher_ctx (tfm); +struct ixp_ctx *ctx =crypto_skcipher_ctx (tfm);/* the nonce is stored in bytes at end of key */ if (key_len <CTR_RFC3686_NONCE_SIZE )
@@ -868,16 +874,16 @@ static int ablk_rfc3686_setkey(struct crypto_ablkcipher *tfm, const u8 *key,return ablk_setkey (tfm, key, key_len); } -static int ablk_perform (struct ablkcipher_request *req,int encrypt) +static int ablk_perform (struct skcipher_request *req,int encrypt) { -struct crypto_ablkcipher *tfm =crypto_ablkcipher_reqtfm (req); -struct ixp_ctx *ctx =crypto_ablkcipher_ctx (tfm); -unsigned ivsize =crypto_ablkcipher_ivsize (tfm); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req); +struct ixp_ctx *ctx =crypto_skcipher_ctx (tfm); +unsigned ivsize =crypto_skcipher_ivsize (tfm);struct ix_sa_dir *dir;struct crypt_ctl *crypt; -unsigned int nbytes = req->nbytes; +unsigned int nbytes = req->cryptlen;enum dma_data_direction src_direction =DMA_BIDIRECTIONAL ; -struct ablk_ctx *req_ctx =ablkcipher_request_ctx (req); +struct ablk_ctx *req_ctx =skcipher_request_ctx (req);struct buffer_desc src_hook;struct device *dev = &pdev->dev; gfp_t flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP ?
@@ -902,8 +908,8 @@ static int ablk_perform(struct ablkcipher_request *req, int encrypt) crypt->crypt_offs =0 ; crypt->crypt_len = nbytes; -BUG_ON (ivsize && !req->info); -memcpy (crypt->iv, req->info, ivsize); +BUG_ON (ivsize && !req->iv); +memcpy (crypt->iv, req->iv, ivsize);if (req->src != req->dst) {struct buffer_desc dst_hook; crypt->mode |=NPE_OP_NOT_IN_PLACE ;
@@ -941,22 +947,22 @@ static int ablk_perform(struct ablkcipher_request *req, int encrypt)return -ENOMEM ; } -static int ablk_encrypt (struct ablkcipher_request *req) +static int ablk_encrypt (struct skcipher_request *req) {return ablk_perform (req,1 ); } -static int ablk_decrypt (struct ablkcipher_request *req) +static int ablk_decrypt (struct skcipher_request *req) {return ablk_perform (req,0 ); } -static int ablk_rfc3686_crypt (struct ablkcipher_request *req) +static int ablk_rfc3686_crypt (struct skcipher_request *req) { -struct crypto_ablkcipher *tfm =crypto_ablkcipher_reqtfm (req); -struct ixp_ctx *ctx =crypto_ablkcipher_ctx (tfm); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req); +struct ixp_ctx *ctx =crypto_skcipher_ctx (tfm);u8 iv[CTR_RFC3686_BLOCK_SIZE ]; -u8 *info = req->info; +u8 *info = req->iv;int ret;/* set up counter block */
@@ -967,9 +973,9 @@ static int ablk_rfc3686_crypt(struct ablkcipher_request *req) *(__be32 *)(iv +CTR_RFC3686_NONCE_SIZE +CTR_RFC3686_IV_SIZE ) =cpu_to_be32 (1 ); - req->info = iv; + req->iv = iv; ret =ablk_perform (req,1 ); - req->info = info; + req->iv = info;return ret; }
@@ -1212,107 +1218,91 @@ static int aead_decrypt(struct aead_request *req)static struct ixp_alg ixp4xx_algos[] = { { .crypto = { - .cra_name ="cbc(des)" , - .cra_blocksize =DES_BLOCK_SIZE , - .cra_u = { .ablkcipher = { - .min_keysize =DES_KEY_SIZE , - .max_keysize =DES_KEY_SIZE , - .ivsize =DES_BLOCK_SIZE , - } - } + .base.cra_name ="cbc(des)" , + .base.cra_blocksize =DES_BLOCK_SIZE , + + .min_keysize =DES_KEY_SIZE , + .max_keysize =DES_KEY_SIZE , + .ivsize =DES_BLOCK_SIZE , }, .cfg_enc =CIPH_ENCR |MOD_DES |MOD_CBC_ENC |KEYLEN_192 , .cfg_dec =CIPH_DECR |MOD_DES |MOD_CBC_DEC |KEYLEN_192 , }, { .crypto = { - .cra_name ="ecb(des)" , - .cra_blocksize =DES_BLOCK_SIZE , - .cra_u = { .ablkcipher = { - .min_keysize =DES_KEY_SIZE , - .max_keysize =DES_KEY_SIZE , - } - } + .base.cra_name ="ecb(des)" , + .base.cra_blocksize =DES_BLOCK_SIZE , + .min_keysize =DES_KEY_SIZE , + .max_keysize =DES_KEY_SIZE , }, .cfg_enc =CIPH_ENCR |MOD_DES |MOD_ECB |KEYLEN_192 , .cfg_dec =CIPH_DECR |MOD_DES |MOD_ECB |KEYLEN_192 , }, { .crypto = { - .cra_name ="cbc(des3_ede)" , - .cra_blocksize =DES3_EDE_BLOCK_SIZE , - .cra_u = { .ablkcipher = { - .min_keysize =DES3_EDE_KEY_SIZE , - .max_keysize =DES3_EDE_KEY_SIZE , - .ivsize =DES3_EDE_BLOCK_SIZE , - .setkey = ablk_des3_setkey, - } - } + .base.cra_name ="cbc(des3_ede)" , + .base.cra_blocksize =DES3_EDE_BLOCK_SIZE , + + .min_keysize =DES3_EDE_KEY_SIZE , + .max_keysize =DES3_EDE_KEY_SIZE , + .ivsize =DES3_EDE_BLOCK_SIZE , + .setkey = ablk_des3_setkey, }, .cfg_enc =CIPH_ENCR |MOD_3DES |MOD_CBC_ENC |KEYLEN_192 , .cfg_dec =CIPH_DECR |MOD_3DES |MOD_CBC_DEC |KEYLEN_192 , }, { .crypto = { - .cra_name ="ecb(des3_ede)" , - .cra_blocksize =DES3_EDE_BLOCK_SIZE , - .cra_u = { .ablkcipher = { - .min_keysize =DES3_EDE_KEY_SIZE , - .max_keysize =DES3_EDE_KEY_SIZE , - .setkey = ablk_des3_setkey, - } - } + .base.cra_name ="ecb(des3_ede)" , + .base.cra_blocksize =DES3_EDE_BLOCK_SIZE , + + .min_keysize =DES3_EDE_KEY_SIZE , + .max_keysize =DES3_EDE_KEY_SIZE , + .setkey = ablk_des3_setkey, }, .cfg_enc =CIPH_ENCR |MOD_3DES |MOD_ECB |KEYLEN_192 , .cfg_dec =CIPH_DECR |MOD_3DES |MOD_ECB |KEYLEN_192 , }, { .crypto = { - .cra_name ="cbc(aes)" , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_u = { .ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - } - } + .base.cra_name ="cbc(aes)" , + .base.cra_blocksize =AES_BLOCK_SIZE , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , }, .cfg_enc =CIPH_ENCR |MOD_AES |MOD_CBC_ENC , .cfg_dec =CIPH_DECR |MOD_AES |MOD_CBC_DEC , }, { .crypto = { - .cra_name ="ecb(aes)" , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_u = { .ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - } - } + .base.cra_name ="ecb(aes)" , + .base.cra_blocksize =AES_BLOCK_SIZE , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , }, .cfg_enc =CIPH_ENCR |MOD_AES |MOD_ECB , .cfg_dec =CIPH_DECR |MOD_AES |MOD_ECB , }, { .crypto = { - .cra_name ="ctr(aes)" , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_u = { .ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - } - } + .base.cra_name ="ctr(aes)" , + .base.cra_blocksize =1 , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , }, .cfg_enc =CIPH_ENCR |MOD_AES |MOD_CTR , .cfg_dec =CIPH_ENCR |MOD_AES |MOD_CTR , }, { .crypto = { - .cra_name ="rfc3686(ctr(aes))" , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_u = { .ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = ablk_rfc3686_setkey, - .encrypt = ablk_rfc3686_crypt, - .decrypt = ablk_rfc3686_crypt } - } + .base.cra_name ="rfc3686(ctr(aes))" , + .base.cra_blocksize =1 , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , + .setkey = ablk_rfc3686_setkey, + .encrypt = ablk_rfc3686_crypt, + .decrypt = ablk_rfc3686_crypt, }, .cfg_enc =CIPH_ENCR |MOD_AES |MOD_CTR , .cfg_dec =CIPH_ENCR |MOD_AES |MOD_CTR ,
@@ -1421,10 +1411,10 @@ static int __init ixp_module_init(void)return err; }for (i=0 ; i< num; i++) { -struct crypto_alg *cra = &ixp4xx_algos[i].crypto; +struct skcipher_alg *cra = &ixp4xx_algos[i].crypto; -if (snprintf (cra->cra_driver_name,CRYPTO_MAX_ALG_NAME , -"%s" IXP_POSTFIX , cra->cra_name) >= +if (snprintf (cra->base.cra_driver_name,CRYPTO_MAX_ALG_NAME , +"%s" IXP_POSTFIX , cra->base.cra_name) >=CRYPTO_MAX_ALG_NAME ) {continue ;
@@ -1434,26 +1424,24 @@ static int __init ixp_module_init(void) }/* block ciphers */ - cra->cra_type = &crypto_ablkcipher_type; - cra->cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_KERN_DRIVER_ONLY | -CRYPTO_ALG_ASYNC ; -if (!cra->cra_ablkcipher.setkey) - cra->cra_ablkcipher.setkey = ablk_setkey; -if (!cra->cra_ablkcipher.encrypt) - cra->cra_ablkcipher.encrypt = ablk_encrypt; -if (!cra->cra_ablkcipher.decrypt) - cra->cra_ablkcipher.decrypt = ablk_decrypt; - cra->cra_init = init_tfm_ablk; - - cra->cra_ctxsize =sizeof (struct ixp_ctx ); - cra->cra_module =THIS_MODULE ; - cra->cra_alignmask =3 ; - cra->cra_priority =300 ; - cra->cra_exit = exit_tfm; -if (crypto_register_alg (cra)) + cra->base.cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY | +CRYPTO_ALG_ASYNC ; +if (!cra->setkey) + cra->setkey = ablk_setkey; +if (!cra->encrypt) + cra->encrypt = ablk_encrypt; +if (!cra->decrypt) + cra->decrypt = ablk_decrypt; + cra->init = init_tfm_ablk; + cra->exit = exit_tfm_ablk; + + cra->base.cra_ctxsize =sizeof (struct ixp_ctx ); + cra->base.cra_module =THIS_MODULE ; + cra->base.cra_alignmask =3 ; + cra->base.cra_priority =300 ; +if (crypto_register_skcipher (cra))printk (KERN_ERR "Failed to register '%s'\n" , - cra->cra_name); + cra->base.cra_name);else ixp4xx_algos[i].registered =1 ; }
@@ -1504,7 +1492,7 @@ static void __exit ixp_module_exit(void)for (i=0 ; i< num; i++) {if (ixp4xx_algos[i].registered) -crypto_unregister_alg (&ixp4xx_algos[i].crypto); +crypto_unregister_skcipher (&ixp4xx_algos[i].crypto); }release_ixp_crypto (&pdev->dev);platform_device_unregister (pdev);
Signature · 1 line
2.17.1
PATCH v4 16/29 crypto: mxs - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/mxs-dcp.c | 140 +++++++++----------- 1 file changed, 65 insertions(+), 75 deletions(-)
drivers/crypto/mxs-dcp.c +65 -75
@@ -211,11 +211,11 @@ static int mxs_dcp_start_dma(struct dcp_async_ctx *actx)* Encryption (AES128) */ static int mxs_dcp_run_aes (struct dcp_async_ctx *actx, -struct ablkcipher_request *req,int init) +struct skcipher_request *req,int init) {struct dcp *sdcp = global_sdcp;struct dcp_dma_desc *desc = &sdcp->coh->desc[actx->chan]; -struct dcp_aes_req_ctx *rctx =ablkcipher_request_ctx (req); +struct dcp_aes_req_ctx *rctx =skcipher_request_ctx (req);int ret; dma_addr_t key_phys = dma_map_single(sdcp->dev, sdcp->coh->aes_key,
@@ -274,9 +274,9 @@ static int mxs_dcp_aes_block_crypt(struct crypto_async_request *arq) {struct dcp *sdcp = global_sdcp; -struct ablkcipher_request *req =ablkcipher_request_cast (arq); +struct skcipher_request *req =skcipher_request_cast (arq);struct dcp_async_ctx *actx =crypto_tfm_ctx (arq->tfm); -struct dcp_aes_req_ctx *rctx =ablkcipher_request_ctx (req); +struct dcp_aes_req_ctx *rctx =skcipher_request_ctx (req);struct scatterlist *dst = req->dst;struct scatterlist *src = req->src;
@@ -305,7 +305,7 @@ static int mxs_dcp_aes_block_crypt(struct crypto_async_request *arq)if (!rctx->ecb) {/* Copy the CBC IV just past the key. */ -memcpy (key +AES_KEYSIZE_128 , req->info,AES_KEYSIZE_128 ); +memcpy (key +AES_KEYSIZE_128 , req->iv,AES_KEYSIZE_128 );/* CBC needs the INIT set. */ init =1 ; }else {
@@ -316,10 +316,10 @@ static int mxs_dcp_aes_block_crypt(struct crypto_async_request *arq) src_buf =sg_virt (src); len =sg_dma_len (src); tlen += len; - limit_hit = tlen > req->nbytes; + limit_hit = tlen > req->cryptlen;if (limit_hit) - len = req->nbytes - (tlen - len); + len = req->cryptlen - (tlen - len); do { if (actx->fill + len > out_off)
@@ -375,10 +375,10 @@ static int mxs_dcp_aes_block_crypt(struct crypto_async_request *arq)/* Copy the IV for CBC for chaining */ if (!rctx->ecb) {if (rctx->enc) -memcpy (req->info, out_buf+(last_out_len-AES_BLOCK_SIZE ), +memcpy (req->iv, out_buf+(last_out_len-AES_BLOCK_SIZE ),AES_BLOCK_SIZE );else -memcpy (req->info, in_buf+(last_out_len-AES_BLOCK_SIZE ), +memcpy (req->iv, in_buf+(last_out_len-AES_BLOCK_SIZE ),AES_BLOCK_SIZE ); }
@@ -422,17 +422,17 @@ static int dcp_chan_thread_aes(void *data)return 0 ; } -static int mxs_dcp_block_fallback (struct ablkcipher_request *req,int enc) +static int mxs_dcp_block_fallback (struct skcipher_request *req,int enc) { -struct crypto_ablkcipher *tfm =crypto_ablkcipher_reqtfm (req); -struct dcp_async_ctx *ctx =crypto_ablkcipher_ctx (tfm); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req); +struct dcp_async_ctx *ctx =crypto_skcipher_ctx (tfm);SYNC_SKCIPHER_REQUEST_ON_STACK (subreq, ctx->fallback);int ret;skcipher_request_set_sync_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); + req->cryptlen, req->iv);if (enc) ret =crypto_skcipher_encrypt (subreq);
@@ -444,12 +444,12 @@ static int mxs_dcp_block_fallback(struct ablkcipher_request *req, int enc)return ret; } -static int mxs_dcp_aes_enqueue (struct ablkcipher_request *req,int enc,int ecb) +static int mxs_dcp_aes_enqueue (struct skcipher_request *req,int enc,int ecb) {struct dcp *sdcp = global_sdcp;struct crypto_async_request *arq = &req->base;struct dcp_async_ctx *actx =crypto_tfm_ctx (arq->tfm); -struct dcp_aes_req_ctx *rctx =ablkcipher_request_ctx (req); +struct dcp_aes_req_ctx *rctx =skcipher_request_ctx (req);int ret;if (unlikely (actx->key_len !=AES_KEYSIZE_128 ))
@@ -468,30 +468,30 @@ static int mxs_dcp_aes_enqueue(struct ablkcipher_request *req, int enc, int ecb)return ret; } -static int mxs_dcp_aes_ecb_decrypt (struct ablkcipher_request *req) +static int mxs_dcp_aes_ecb_decrypt (struct skcipher_request *req) {return mxs_dcp_aes_enqueue (req,0 ,1 ); } -static int mxs_dcp_aes_ecb_encrypt (struct ablkcipher_request *req) +static int mxs_dcp_aes_ecb_encrypt (struct skcipher_request *req) {return mxs_dcp_aes_enqueue (req,1 ,1 ); } -static int mxs_dcp_aes_cbc_decrypt (struct ablkcipher_request *req) +static int mxs_dcp_aes_cbc_decrypt (struct skcipher_request *req) {return mxs_dcp_aes_enqueue (req,0 ,0 ); } -static int mxs_dcp_aes_cbc_encrypt (struct ablkcipher_request *req) +static int mxs_dcp_aes_cbc_encrypt (struct skcipher_request *req) {return mxs_dcp_aes_enqueue (req,1 ,0 ); } -static int mxs_dcp_aes_setkey (struct crypto_ablkcipher *tfm,const u8 *key, +static int mxs_dcp_aes_setkey (struct crypto_skcipher *tfm,const u8 *key,unsigned int len) { -struct dcp_async_ctx *actx =crypto_ablkcipher_ctx (tfm); +struct dcp_async_ctx *actx =crypto_skcipher_ctx (tfm);unsigned int ret;/*
@@ -525,10 +525,10 @@ static int mxs_dcp_aes_setkey(struct crypto_ablkcipher *tfm, const u8 *key,return ret; } -static int mxs_dcp_aes_fallback_init (struct crypto_tfm *tfm) +static int mxs_dcp_aes_fallback_init_tfm (struct crypto_skcipher *tfm) { -const char *name =crypto_tfm_alg_name (tfm); -struct dcp_async_ctx *actx =crypto_tfm_ctx (tfm); +const char *name =crypto_tfm_alg_name (crypto_skcipher_tfm (tfm)); +struct dcp_async_ctx *actx =crypto_skcipher_ctx (tfm);struct crypto_sync_skcipher *blk; blk =crypto_alloc_sync_skcipher (name,0 ,CRYPTO_ALG_NEED_FALLBACK );
@@ -536,13 +536,13 @@ static int mxs_dcp_aes_fallback_init(struct crypto_tfm *tfm)return PTR_ERR (blk); actx->fallback = blk; - tfm->crt_ablkcipher.reqsize =sizeof (struct dcp_aes_req_ctx ); +crypto_skcipher_set_reqsize (tfm,sizeof (struct dcp_aes_req_ctx ));return 0 ; } -static void mxs_dcp_aes_fallback_exit (struct crypto_tfm *tfm) +static void mxs_dcp_aes_fallback_exit_tfm (struct crypto_skcipher *tfm) { -struct dcp_async_ctx *actx =crypto_tfm_ctx (tfm); +struct dcp_async_ctx *actx =crypto_skcipher_ctx (tfm);crypto_free_sync_skcipher (actx->fallback); }
@@ -854,54 +854,44 @@ static void dcp_sha_cra_exit(struct crypto_tfm *tfm) }/* AES 128 ECB and AES 128 CBC */ -static struct crypto_alg dcp_aes_algs[] = { +static struct skcipher_alg dcp_aes_algs[] = { { - .cra_name ="ecb(aes)" , - .cra_driver_name ="ecb-aes-dcp" , - .cra_priority =400 , - .cra_alignmask =15 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC | + .base.cra_name ="ecb(aes)" , + .base.cra_driver_name ="ecb-aes-dcp" , + .base.cra_priority =400 , + .base.cra_alignmask =15 , + .base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_NEED_FALLBACK , - .cra_init = mxs_dcp_aes_fallback_init, - .cra_exit = mxs_dcp_aes_fallback_exit, - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct dcp_async_ctx ), - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_u = { - .ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .setkey = mxs_dcp_aes_setkey, - .encrypt = mxs_dcp_aes_ecb_encrypt, - .decrypt = mxs_dcp_aes_ecb_decrypt - }, - }, + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct dcp_async_ctx ), + .base.cra_module =THIS_MODULE , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = mxs_dcp_aes_setkey, + .encrypt = mxs_dcp_aes_ecb_encrypt, + .decrypt = mxs_dcp_aes_ecb_decrypt, + .init = mxs_dcp_aes_fallback_init_tfm, + .exit = mxs_dcp_aes_fallback_exit_tfm, }, { - .cra_name ="cbc(aes)" , - .cra_driver_name ="cbc-aes-dcp" , - .cra_priority =400 , - .cra_alignmask =15 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC | + .base.cra_name ="cbc(aes)" , + .base.cra_driver_name ="cbc-aes-dcp" , + .base.cra_priority =400 , + .base.cra_alignmask =15 , + .base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_NEED_FALLBACK , - .cra_init = mxs_dcp_aes_fallback_init, - .cra_exit = mxs_dcp_aes_fallback_exit, - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct dcp_async_ctx ), - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_u = { - .ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .setkey = mxs_dcp_aes_setkey, - .encrypt = mxs_dcp_aes_cbc_encrypt, - .decrypt = mxs_dcp_aes_cbc_decrypt, - .ivsize =AES_BLOCK_SIZE , - }, - }, + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct dcp_async_ctx ), + .base.cra_module =THIS_MODULE , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = mxs_dcp_aes_setkey, + .encrypt = mxs_dcp_aes_cbc_encrypt, + .decrypt = mxs_dcp_aes_cbc_decrypt, + .ivsize =AES_BLOCK_SIZE , + .init = mxs_dcp_aes_fallback_init_tfm, + .exit = mxs_dcp_aes_fallback_exit_tfm, }, };
@@ -1104,8 +1094,8 @@ static int mxs_dcp_probe(struct platform_device *pdev) sdcp->caps =readl (sdcp->base +MXS_DCP_CAPABILITY1 );if (sdcp->caps &MXS_DCP_CAPABILITY1_AES128 ) { - ret =crypto_register_algs (dcp_aes_algs, -ARRAY_SIZE (dcp_aes_algs)); + ret =crypto_register_skciphers (dcp_aes_algs, +ARRAY_SIZE (dcp_aes_algs));if (ret) {/* Failed to register algorithm. */ dev_err (dev,"Failed to register AES crypto!\n" );
@@ -1139,7 +1129,7 @@ static int mxs_dcp_probe(struct platform_device *pdev) err_unregister_aes:if (sdcp->caps &MXS_DCP_CAPABILITY1_AES128 ) -crypto_unregister_algs (dcp_aes_algs,ARRAY_SIZE (dcp_aes_algs)); +crypto_unregister_skciphers (dcp_aes_algs,ARRAY_SIZE (dcp_aes_algs)); err_destroy_aes_thread:kthread_stop (sdcp->thread[DCP_CHAN_CRYPTO ]);
@@ -1164,7 +1154,7 @@ static int mxs_dcp_remove(struct platform_device *pdev)crypto_unregister_ahash (&dcp_sha1_alg);if (sdcp->caps &MXS_DCP_CAPABILITY1_AES128 ) -crypto_unregister_algs (dcp_aes_algs,ARRAY_SIZE (dcp_aes_algs)); +crypto_unregister_skciphers (dcp_aes_algs,ARRAY_SIZE (dcp_aes_algs));kthread_stop (sdcp->thread[DCP_CHAN_HASH_SHA ]);kthread_stop (sdcp->thread[DCP_CHAN_CRYPTO ]);
Signature · 1 line
2.17.1
PATCH v4 17/29 crypto: mediatek - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/mediatek/mtk-aes.c | 248 +++++++++----------- 1 file changed, 116 insertions(+), 132 deletions(-)
drivers/crypto/mediatek/mtk-aes.c +116 -132
@@ -11,6 +11,7 @@#include <crypto/aes.h> #include <crypto/gcm.h> +#include <crypto/internal/skcipher.h> #include "mtk-platform.h" #define AES_QUEUE_SIZE 512
@@ -414,7 +415,7 @@ static int mtk_aes_map(struct mtk_cryp *cryp, struct mtk_aes_rec *aes)static void mtk_aes_info_init (struct mtk_cryp *cryp,struct mtk_aes_rec *aes,size_t len) { -struct ablkcipher_request *req =ablkcipher_request_cast (aes->areq); +struct skcipher_request *req =skcipher_request_cast (aes->areq);struct mtk_aes_base_ctx *ctx = aes->ctx;struct mtk_aes_info *info = &ctx->info;u32 cnt =0 ;
@@ -450,7 +451,7 @@ static void mtk_aes_info_init(struct mtk_cryp *cryp, struct mtk_aes_rec *aes,return ; } -mtk_aes_write_state_le (info->state + ctx->keylen, req->info, +mtk_aes_write_state_le (info->state + ctx->keylen, (void *)req->iv,AES_BLOCK_SIZE ); ctr: info->tfm[0 ] +=AES_TFM_SIZE (SIZE_IN_WORDS (AES_BLOCK_SIZE ));
@@ -552,13 +553,13 @@ static int mtk_aes_transfer_complete(struct mtk_cryp *cryp,static int mtk_aes_start (struct mtk_cryp *cryp,struct mtk_aes_rec *aes) { -struct ablkcipher_request *req =ablkcipher_request_cast (aes->areq); -struct mtk_aes_reqctx *rctx =ablkcipher_request_ctx (req); +struct skcipher_request *req =skcipher_request_cast (aes->areq); +struct mtk_aes_reqctx *rctx =skcipher_request_ctx (req);mtk_aes_set_mode (aes, rctx); aes->resume = mtk_aes_transfer_complete; -return mtk_aes_dma (cryp, aes, req->src, req->dst, req->nbytes); +return mtk_aes_dma (cryp, aes, req->src, req->dst, req->cryptlen); } static inline struct mtk_aes_ctr_ctx *
@@ -571,7 +572,7 @@ static int mtk_aes_ctr_transfer(struct mtk_cryp *cryp, struct mtk_aes_rec *aes) {struct mtk_aes_base_ctx *ctx = aes->ctx;struct mtk_aes_ctr_ctx *cctx =mtk_aes_ctr_ctx_cast (ctx); -struct ablkcipher_request *req =ablkcipher_request_cast (aes->areq); +struct skcipher_request *req =skcipher_request_cast (aes->areq);struct scatterlist *src, *dst;u32 start, end, ctr, blocks;size_t datalen;
@@ -579,11 +580,11 @@ static int mtk_aes_ctr_transfer(struct mtk_cryp *cryp, struct mtk_aes_rec *aes)/* Check for transfer completion. */ cctx->offset += aes->total; -if (cctx->offset >= req->nbytes) +if (cctx->offset >= req->cryptlen)return mtk_aes_transfer_complete (cryp, aes);/* Compute data length. */ - datalen = req->nbytes - cctx->offset; + datalen = req->cryptlen - cctx->offset; blocks =DIV_ROUND_UP (datalen,AES_BLOCK_SIZE ); ctr =be32_to_cpu (cctx->iv[3 ]);
@@ -620,12 +621,12 @@ static int mtk_aes_ctr_transfer(struct mtk_cryp *cryp, struct mtk_aes_rec *aes)static int mtk_aes_ctr_start (struct mtk_cryp *cryp,struct mtk_aes_rec *aes) {struct mtk_aes_ctr_ctx *cctx =mtk_aes_ctr_ctx_cast (aes->ctx); -struct ablkcipher_request *req =ablkcipher_request_cast (aes->areq); -struct mtk_aes_reqctx *rctx =ablkcipher_request_ctx (req); +struct skcipher_request *req =skcipher_request_cast (aes->areq); +struct mtk_aes_reqctx *rctx =skcipher_request_ctx (req);mtk_aes_set_mode (aes, rctx); -memcpy (cctx->iv, req->info,AES_BLOCK_SIZE ); +memcpy (cctx->iv, req->iv,AES_BLOCK_SIZE ); cctx->offset =0 ; aes->total =0 ; aes->resume = mtk_aes_ctr_transfer;
@@ -634,10 +635,10 @@ static int mtk_aes_ctr_start(struct mtk_cryp *cryp, struct mtk_aes_rec *aes) }/* Check and set the AES key to transform state buffer */ -static int mtk_aes_setkey (struct crypto_ablkcipher *tfm, +static int mtk_aes_setkey (struct crypto_skcipher *tfm,const u8 *key,u32 keylen) { -struct mtk_aes_base_ctx *ctx =crypto_ablkcipher_ctx (tfm); +struct mtk_aes_base_ctx *ctx =crypto_skcipher_ctx (tfm);switch (keylen) {case AES_KEYSIZE_128 :
@@ -651,7 +652,7 @@ static int mtk_aes_setkey(struct crypto_ablkcipher *tfm,break ;default : -crypto_ablkcipher_set_flags (tfm,CRYPTO_TFM_RES_BAD_KEY_LEN ); +crypto_skcipher_set_flags (tfm,CRYPTO_TFM_RES_BAD_KEY_LEN );return -EINVAL ; }
@@ -661,10 +662,10 @@ static int mtk_aes_setkey(struct crypto_ablkcipher *tfm,return 0 ; } -static int mtk_aes_crypt (struct ablkcipher_request *req,u64 mode) +static int mtk_aes_crypt (struct skcipher_request *req,u64 mode) { -struct crypto_ablkcipher *ablkcipher =crypto_ablkcipher_reqtfm (req); -struct mtk_aes_base_ctx *ctx =crypto_ablkcipher_ctx (ablkcipher); +struct crypto_skcipher *skcipher =crypto_skcipher_reqtfm (req); +struct mtk_aes_base_ctx *ctx =crypto_skcipher_ctx (skcipher);struct mtk_aes_reqctx *rctx;struct mtk_cryp *cryp;
@@ -672,185 +673,168 @@ static int mtk_aes_crypt(struct ablkcipher_request *req, u64 mode)if (!cryp)return -ENODEV ; - rctx =ablkcipher_request_ctx (req); + rctx =skcipher_request_ctx (req); rctx->mode = mode;return mtk_aes_handle_queue (cryp, !(mode &AES_FLAGS_ENCRYPT ), &req->base); } -static int mtk_aes_ecb_encrypt (struct ablkcipher_request *req) +static int mtk_aes_ecb_encrypt (struct skcipher_request *req) {return mtk_aes_crypt (req,AES_FLAGS_ENCRYPT |AES_FLAGS_ECB ); } -static int mtk_aes_ecb_decrypt (struct ablkcipher_request *req) +static int mtk_aes_ecb_decrypt (struct skcipher_request *req) {return mtk_aes_crypt (req,AES_FLAGS_ECB ); } -static int mtk_aes_cbc_encrypt (struct ablkcipher_request *req) +static int mtk_aes_cbc_encrypt (struct skcipher_request *req) {return mtk_aes_crypt (req,AES_FLAGS_ENCRYPT |AES_FLAGS_CBC ); } -static int mtk_aes_cbc_decrypt (struct ablkcipher_request *req) +static int mtk_aes_cbc_decrypt (struct skcipher_request *req) {return mtk_aes_crypt (req,AES_FLAGS_CBC ); } -static int mtk_aes_ctr_encrypt (struct ablkcipher_request *req) +static int mtk_aes_ctr_encrypt (struct skcipher_request *req) {return mtk_aes_crypt (req,AES_FLAGS_ENCRYPT |AES_FLAGS_CTR ); } -static int mtk_aes_ctr_decrypt (struct ablkcipher_request *req) +static int mtk_aes_ctr_decrypt (struct skcipher_request *req) {return mtk_aes_crypt (req,AES_FLAGS_CTR ); } -static int mtk_aes_ofb_encrypt (struct ablkcipher_request *req) +static int mtk_aes_ofb_encrypt (struct skcipher_request *req) {return mtk_aes_crypt (req,AES_FLAGS_ENCRYPT |AES_FLAGS_OFB ); } -static int mtk_aes_ofb_decrypt (struct ablkcipher_request *req) +static int mtk_aes_ofb_decrypt (struct skcipher_request *req) {return mtk_aes_crypt (req,AES_FLAGS_OFB ); } -static int mtk_aes_cfb_encrypt (struct ablkcipher_request *req) +static int mtk_aes_cfb_encrypt (struct skcipher_request *req) {return mtk_aes_crypt (req,AES_FLAGS_ENCRYPT |AES_FLAGS_CFB128 ); } -static int mtk_aes_cfb_decrypt (struct ablkcipher_request *req) +static int mtk_aes_cfb_decrypt (struct skcipher_request *req) {return mtk_aes_crypt (req,AES_FLAGS_CFB128 ); } -static int mtk_aes_cra_init (struct crypto_tfm *tfm) +static int mtk_aes_init_tfm (struct crypto_skcipher *tfm) { -struct mtk_aes_ctx *ctx =crypto_tfm_ctx (tfm); +struct mtk_aes_ctx *ctx =crypto_skcipher_ctx (tfm); - tfm->crt_ablkcipher.reqsize =sizeof (struct mtk_aes_reqctx ); +crypto_skcipher_set_reqsize (tfm,sizeof (struct mtk_aes_reqctx )); ctx->base.start = mtk_aes_start;return 0 ; } -static int mtk_aes_ctr_cra_init (struct crypto_tfm *tfm) +static int mtk_aes_ctr_init_tfm (struct crypto_skcipher *tfm) { -struct mtk_aes_ctx *ctx =crypto_tfm_ctx (tfm); +struct mtk_aes_ctx *ctx =crypto_skcipher_ctx (tfm); - tfm->crt_ablkcipher.reqsize =sizeof (struct mtk_aes_reqctx ); +crypto_skcipher_set_reqsize (tfm,sizeof (struct mtk_aes_reqctx )); ctx->base.start = mtk_aes_ctr_start;return 0 ; } -static struct crypto_alg aes_algs[] = { +static struct skcipher_alg aes_algs[] = { { - .cra_name ="cbc(aes)" , - .cra_driver_name ="cbc-aes-mtk" , - .cra_priority =400 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_init = mtk_aes_cra_init, - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct mtk_aes_ctx ), - .cra_alignmask =0xf , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .setkey = mtk_aes_setkey, - .encrypt = mtk_aes_cbc_encrypt, - .decrypt = mtk_aes_cbc_decrypt, - .ivsize =AES_BLOCK_SIZE , - } + .base.cra_name ="cbc(aes)" , + .base.cra_driver_name ="cbc-aes-mtk" , + .base.cra_priority =400 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct mtk_aes_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = mtk_aes_setkey, + .encrypt = mtk_aes_cbc_encrypt, + .decrypt = mtk_aes_cbc_decrypt, + .ivsize =AES_BLOCK_SIZE , + .init = mtk_aes_init_tfm, }, { - .cra_name ="ecb(aes)" , - .cra_driver_name ="ecb-aes-mtk" , - .cra_priority =400 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_init = mtk_aes_cra_init, - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct mtk_aes_ctx ), - .cra_alignmask =0xf , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .setkey = mtk_aes_setkey, - .encrypt = mtk_aes_ecb_encrypt, - .decrypt = mtk_aes_ecb_decrypt, - } + .base.cra_name ="ecb(aes)" , + .base.cra_driver_name ="ecb-aes-mtk" , + .base.cra_priority =400 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct mtk_aes_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = mtk_aes_setkey, + .encrypt = mtk_aes_ecb_encrypt, + .decrypt = mtk_aes_ecb_decrypt, + .init = mtk_aes_init_tfm, }, { - .cra_name ="ctr(aes)" , - .cra_driver_name ="ctr-aes-mtk" , - .cra_priority =400 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_init = mtk_aes_ctr_cra_init, - .cra_blocksize =1 , - .cra_ctxsize =sizeof (struct mtk_aes_ctr_ctx ), - .cra_alignmask =0xf , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = mtk_aes_setkey, - .encrypt = mtk_aes_ctr_encrypt, - .decrypt = mtk_aes_ctr_decrypt, - } + .base.cra_name ="ctr(aes)" , + .base.cra_driver_name ="ctr-aes-mtk" , + .base.cra_priority =400 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =1 , + .base.cra_ctxsize =sizeof (struct mtk_aes_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , + .setkey = mtk_aes_setkey, + .encrypt = mtk_aes_ctr_encrypt, + .decrypt = mtk_aes_ctr_decrypt, + .init = mtk_aes_ctr_init_tfm, }, { - .cra_name ="ofb(aes)" , - .cra_driver_name ="ofb-aes-mtk" , - .cra_priority =400 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_init = mtk_aes_cra_init, - .cra_blocksize =1 , - .cra_ctxsize =sizeof (struct mtk_aes_ctx ), - .cra_alignmask =0xf , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = mtk_aes_setkey, - .encrypt = mtk_aes_ofb_encrypt, - .decrypt = mtk_aes_ofb_decrypt, - } + .base.cra_name ="ofb(aes)" , + .base.cra_driver_name ="ofb-aes-mtk" , + .base.cra_priority =400 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct mtk_aes_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , + .setkey = mtk_aes_setkey, + .encrypt = mtk_aes_ofb_encrypt, + .decrypt = mtk_aes_ofb_decrypt, }, { - .cra_name ="cfb(aes)" , - .cra_driver_name ="cfb-aes-mtk" , - .cra_priority =400 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_init = mtk_aes_cra_init, - .cra_blocksize =1 , - .cra_ctxsize =sizeof (struct mtk_aes_ctx ), - .cra_alignmask =0xf , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = mtk_aes_setkey, - .encrypt = mtk_aes_cfb_encrypt, - .decrypt = mtk_aes_cfb_decrypt, - } + .base.cra_name ="cfb(aes)" , + .base.cra_driver_name ="cfb-aes-mtk" , + .base.cra_priority =400 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =1 , + .base.cra_ctxsize =sizeof (struct mtk_aes_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , + .setkey = mtk_aes_setkey, + .encrypt = mtk_aes_cfb_encrypt, + .decrypt = mtk_aes_cfb_decrypt, }, };
@@ -1259,7 +1243,7 @@ static void mtk_aes_unregister_algs(void)crypto_unregister_aead (&aes_gcm_alg);for (i =0 ; i <ARRAY_SIZE (aes_algs); i++) -crypto_unregister_alg (&aes_algs[i]); +crypto_unregister_skcipher (&aes_algs[i]); }static int mtk_aes_register_algs (void )
@@ -1267,7 +1251,7 @@ static int mtk_aes_register_algs(void)int err, i;for (i =0 ; i <ARRAY_SIZE (aes_algs); i++) { - err =crypto_register_alg (&aes_algs[i]); + err =crypto_register_skcipher (&aes_algs[i]);if (err) goto err_aes_algs; }
@@ -1280,7 +1264,7 @@ static int mtk_aes_register_algs(void) err_aes_algs:for (; i--; ) -crypto_unregister_alg (&aes_algs[i]); +crypto_unregister_skcipher (&aes_algs[i]);return err; }
Signature · 1 line
2.17.1
PATCH v4 18/29 crypto: sahara - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/sahara.c | 156 ++++++++++---------- 1 file changed, 75 insertions(+), 81 deletions(-)
drivers/crypto/sahara.c +75 -81
@@ -547,7 +547,7 @@ static int sahara_hw_descriptor_create(struct sahara_dev *dev)return -EINVAL ; } -static int sahara_aes_process (struct ablkcipher_request *req) +static int sahara_aes_process (struct skcipher_request *req) {struct sahara_dev *dev = dev_ptr;struct sahara_ctx *ctx;
@@ -558,20 +558,20 @@ static int sahara_aes_process(struct ablkcipher_request *req)/* Request is ready to be dispatched by the device */ dev_dbg (dev->device,"dispatch request (nbytes=%d, src=%p, dst=%p)\n" , - req->nbytes, req->src, req->dst); + req->cryptlen, req->src, req->dst);/* assign new request to device */ - dev->total = req->nbytes; + dev->total = req->cryptlen; dev->in_sg = req->src; dev->out_sg = req->dst; - rctx =ablkcipher_request_ctx (req); - ctx =crypto_ablkcipher_ctx (crypto_ablkcipher_reqtfm (req)); + rctx =skcipher_request_ctx (req); + ctx =crypto_skcipher_ctx (crypto_skcipher_reqtfm (req)); rctx->mode &=FLAGS_MODE_MASK ; dev->flags = (dev->flags & ~FLAGS_MODE_MASK ) | rctx->mode; -if ((dev->flags &FLAGS_CBC ) && req->info) -memcpy (dev->iv_base, req->info,AES_KEYSIZE_128 ); +if ((dev->flags &FLAGS_CBC ) && req->iv) +memcpy (dev->iv_base, req->iv,AES_KEYSIZE_128 );/* assign new context to device */ dev->ctx = ctx;
@@ -597,10 +597,10 @@ static int sahara_aes_process(struct ablkcipher_request *req)return 0 ; } -static int sahara_aes_setkey (struct crypto_ablkcipher *tfm,const u8 *key, +static int sahara_aes_setkey (struct crypto_skcipher *tfm,const u8 *key,unsigned int keylen) { -struct sahara_ctx *ctx =crypto_ablkcipher_ctx (tfm); +struct sahara_ctx *ctx =crypto_skcipher_ctx (tfm);int ret; ctx->keylen = keylen;
@@ -630,16 +630,16 @@ static int sahara_aes_setkey(struct crypto_ablkcipher *tfm, const u8 *key,return ret; } -static int sahara_aes_crypt (struct ablkcipher_request *req,unsigned long mode) +static int sahara_aes_crypt (struct skcipher_request *req,unsigned long mode) { -struct sahara_aes_reqctx *rctx =ablkcipher_request_ctx (req); +struct sahara_aes_reqctx *rctx =skcipher_request_ctx (req);struct sahara_dev *dev = dev_ptr;int err =0 ;dev_dbg (dev->device,"nbytes: %d, enc: %d, cbc: %d\n" , - req->nbytes, !!(mode &FLAGS_ENCRYPT ), !!(mode &FLAGS_CBC )); + req->cryptlen, !!(mode &FLAGS_ENCRYPT ), !!(mode &FLAGS_CBC )); -if (!IS_ALIGNED (req->nbytes,AES_BLOCK_SIZE )) { +if (!IS_ALIGNED (req->cryptlen,AES_BLOCK_SIZE )) {dev_err (dev->device,"request size is not exact amount of AES blocks\n" );return -EINVAL ;
@@ -648,7 +648,7 @@ static int sahara_aes_crypt(struct ablkcipher_request *req, unsigned long mode) rctx->mode = mode;mutex_lock (&dev->queue_mutex); - err =ablkcipher_enqueue_request (&dev->queue, req); + err =crypto_enqueue_request (&dev->queue, &req->base);mutex_unlock (&dev->queue_mutex);wake_up_process (dev->kthread);
@@ -656,10 +656,10 @@ static int sahara_aes_crypt(struct ablkcipher_request *req, unsigned long mode)return err; } -static int sahara_aes_ecb_encrypt (struct ablkcipher_request *req) +static int sahara_aes_ecb_encrypt (struct skcipher_request *req) { -struct sahara_ctx *ctx =crypto_ablkcipher_ctx ( -crypto_ablkcipher_reqtfm (req)); +struct sahara_ctx *ctx =crypto_skcipher_ctx ( +crypto_skcipher_reqtfm (req));int err;if (unlikely (ctx->keylen !=AES_KEYSIZE_128 )) {
@@ -669,7 +669,7 @@ static int sahara_aes_ecb_encrypt(struct ablkcipher_request *req)skcipher_request_set_callback (subreq, req->base.flags,NULL ,NULL );skcipher_request_set_crypt (subreq, req->src, req->dst, - req->nbytes, req->info); + req->cryptlen, req->iv); err =crypto_skcipher_encrypt (subreq);skcipher_request_zero (subreq);return err;
@@ -678,10 +678,10 @@ static int sahara_aes_ecb_encrypt(struct ablkcipher_request *req)return sahara_aes_crypt (req,FLAGS_ENCRYPT ); } -static int sahara_aes_ecb_decrypt (struct ablkcipher_request *req) +static int sahara_aes_ecb_decrypt (struct skcipher_request *req) { -struct sahara_ctx *ctx =crypto_ablkcipher_ctx ( -crypto_ablkcipher_reqtfm (req)); +struct sahara_ctx *ctx =crypto_skcipher_ctx ( +crypto_skcipher_reqtfm (req));int err;if (unlikely (ctx->keylen !=AES_KEYSIZE_128 )) {
@@ -691,7 +691,7 @@ static int sahara_aes_ecb_decrypt(struct ablkcipher_request *req)skcipher_request_set_callback (subreq, req->base.flags,NULL ,NULL );skcipher_request_set_crypt (subreq, req->src, req->dst, - req->nbytes, req->info); + req->cryptlen, req->iv); err =crypto_skcipher_decrypt (subreq);skcipher_request_zero (subreq);return err;
@@ -700,10 +700,10 @@ static int sahara_aes_ecb_decrypt(struct ablkcipher_request *req)return sahara_aes_crypt (req,0 ); } -static int sahara_aes_cbc_encrypt (struct ablkcipher_request *req) +static int sahara_aes_cbc_encrypt (struct skcipher_request *req) { -struct sahara_ctx *ctx =crypto_ablkcipher_ctx ( -crypto_ablkcipher_reqtfm (req)); +struct sahara_ctx *ctx =crypto_skcipher_ctx ( +crypto_skcipher_reqtfm (req));int err;if (unlikely (ctx->keylen !=AES_KEYSIZE_128 )) {
@@ -713,7 +713,7 @@ static int sahara_aes_cbc_encrypt(struct ablkcipher_request *req)skcipher_request_set_callback (subreq, req->base.flags,NULL ,NULL );skcipher_request_set_crypt (subreq, req->src, req->dst, - req->nbytes, req->info); + req->cryptlen, req->iv); err =crypto_skcipher_encrypt (subreq);skcipher_request_zero (subreq);return err;
@@ -722,10 +722,10 @@ static int sahara_aes_cbc_encrypt(struct ablkcipher_request *req)return sahara_aes_crypt (req,FLAGS_ENCRYPT |FLAGS_CBC ); } -static int sahara_aes_cbc_decrypt (struct ablkcipher_request *req) +static int sahara_aes_cbc_decrypt (struct skcipher_request *req) { -struct sahara_ctx *ctx =crypto_ablkcipher_ctx ( -crypto_ablkcipher_reqtfm (req)); +struct sahara_ctx *ctx =crypto_skcipher_ctx ( +crypto_skcipher_reqtfm (req));int err;if (unlikely (ctx->keylen !=AES_KEYSIZE_128 )) {
@@ -735,7 +735,7 @@ static int sahara_aes_cbc_decrypt(struct ablkcipher_request *req)skcipher_request_set_callback (subreq, req->base.flags,NULL ,NULL );skcipher_request_set_crypt (subreq, req->src, req->dst, - req->nbytes, req->info); + req->cryptlen, req->iv); err =crypto_skcipher_decrypt (subreq);skcipher_request_zero (subreq);return err;
@@ -744,10 +744,10 @@ static int sahara_aes_cbc_decrypt(struct ablkcipher_request *req)return sahara_aes_crypt (req,FLAGS_CBC ); } -static int sahara_aes_cra_init (struct crypto_tfm *tfm) +static int sahara_aes_init_tfm (struct crypto_skcipher *tfm) { -const char *name =crypto_tfm_alg_name (tfm); -struct sahara_ctx *ctx =crypto_tfm_ctx (tfm); +const char *name =crypto_tfm_alg_name (&tfm->base); +struct sahara_ctx *ctx =crypto_skcipher_ctx (tfm); ctx->fallback =crypto_alloc_sync_skcipher (name,0 ,CRYPTO_ALG_NEED_FALLBACK );
@@ -756,14 +756,14 @@ static int sahara_aes_cra_init(struct crypto_tfm *tfm)return PTR_ERR (ctx->fallback); } - tfm->crt_ablkcipher.reqsize =sizeof (struct sahara_aes_reqctx ); +crypto_skcipher_set_reqsize (tfm,sizeof (struct sahara_aes_reqctx ));return 0 ; } -static void sahara_aes_cra_exit (struct crypto_tfm *tfm) +static void sahara_aes_exit_tfm (struct crypto_skcipher *tfm) { -struct sahara_ctx *ctx =crypto_tfm_ctx (tfm); +struct sahara_ctx *ctx =crypto_skcipher_ctx (tfm);crypto_free_sync_skcipher (ctx->fallback); }
@@ -1071,8 +1071,8 @@ static int sahara_queue_manage(void *data) ret =sahara_sha_process (req); }else { -struct ablkcipher_request *req = -ablkcipher_request_cast (async_req); +struct skcipher_request *req = +skcipher_request_cast (async_req); ret =sahara_aes_process (req); }
@@ -1189,48 +1189,42 @@ static int sahara_sha_cra_init(struct crypto_tfm *tfm)return 0 ; } -static struct crypto_alg aes_algs[] = { +static struct skcipher_alg aes_algs[] = { { - .cra_name ="ecb(aes)" , - .cra_driver_name ="sahara-ecb-aes" , - .cra_priority =300 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC |CRYPTO_ALG_NEED_FALLBACK , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct sahara_ctx ), - .cra_alignmask =0x0 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = sahara_aes_cra_init, - .cra_exit = sahara_aes_cra_exit, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .setkey = sahara_aes_setkey, - .encrypt = sahara_aes_ecb_encrypt, - .decrypt = sahara_aes_ecb_decrypt, - } + .base.cra_name ="ecb(aes)" , + .base.cra_driver_name ="sahara-ecb-aes" , + .base.cra_priority =300 , + .base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_NEED_FALLBACK , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct sahara_ctx ), + .base.cra_alignmask =0x0 , + .base.cra_module =THIS_MODULE , + + .init = sahara_aes_init_tfm, + .exit = sahara_aes_exit_tfm, + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = sahara_aes_setkey, + .encrypt = sahara_aes_ecb_encrypt, + .decrypt = sahara_aes_ecb_decrypt, }, { - .cra_name ="cbc(aes)" , - .cra_driver_name ="sahara-cbc-aes" , - .cra_priority =300 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC |CRYPTO_ALG_NEED_FALLBACK , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct sahara_ctx ), - .cra_alignmask =0x0 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = sahara_aes_cra_init, - .cra_exit = sahara_aes_cra_exit, - .cra_u.ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = sahara_aes_setkey, - .encrypt = sahara_aes_cbc_encrypt, - .decrypt = sahara_aes_cbc_decrypt, - } + .base.cra_name ="cbc(aes)" , + .base.cra_driver_name ="sahara-cbc-aes" , + .base.cra_priority =300 , + .base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_NEED_FALLBACK , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct sahara_ctx ), + .base.cra_alignmask =0x0 , + .base.cra_module =THIS_MODULE , + + .init = sahara_aes_init_tfm, + .exit = sahara_aes_exit_tfm, + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , + .setkey = sahara_aes_setkey, + .encrypt = sahara_aes_cbc_encrypt, + .decrypt = sahara_aes_cbc_decrypt, } };
@@ -1318,7 +1312,7 @@ static int sahara_register_algs(struct sahara_dev *dev)unsigned int i, j, k, l;for (i =0 ; i <ARRAY_SIZE (aes_algs); i++) { - err =crypto_register_alg (&aes_algs[i]); + err =crypto_register_skcipher (&aes_algs[i]);if (err) goto err_aes_algs; }
@@ -1348,7 +1342,7 @@ static int sahara_register_algs(struct sahara_dev *dev) err_aes_algs:for (j =0 ; j < i; j++) -crypto_unregister_alg (&aes_algs[j]); +crypto_unregister_skcipher (&aes_algs[j]);return err; }
@@ -1358,7 +1352,7 @@ static void sahara_unregister_algs(struct sahara_dev *dev)unsigned int i;for (i =0 ; i <ARRAY_SIZE (aes_algs); i++) -crypto_unregister_alg (&aes_algs[i]); +crypto_unregister_skcipher (&aes_algs[i]);for (i =0 ; i <ARRAY_SIZE (sha_v3_algs); i++)crypto_unregister_ahash (&sha_v3_algs[i]);
Signature · 1 line
2.17.1
PATCH v4 19/29 crypto: picoxcell - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/picoxcell_crypto.c | 386 ++++++++++---------- 1 file changed, 184 insertions(+), 202 deletions(-)
drivers/crypto/picoxcell_crypto.c +184 -202
@@ -134,7 +134,7 @@ struct spacc_engine {struct spacc_alg {unsigned long ctrl_default;unsigned long type; -struct crypto_alg alg; +struct skcipher_alg alg;struct spacc_engine *engine;struct list_head entry;int key_offs;
@@ -173,7 +173,7 @@ struct spacc_aead_ctx {static int spacc_ablk_submit (struct spacc_req *req); -static inline struct spacc_alg *to_spacc_alg (struct crypto_alg *alg) +static inline struct spacc_alg *to_spacc_skcipher (struct skcipher_alg *alg) { return alg ? container_of(alg, struct spacc_alg, alg) : NULL; }
@@ -733,13 +733,13 @@ static void spacc_aead_cra_exit(struct crypto_aead *tfm)* Set the DES key for a block cipher transform. This also performs weak key * checking if the transform has requested it. */ -static int spacc_des_setkey (struct crypto_ablkcipher *cipher,const u8 *key, +static int spacc_des_setkey (struct crypto_skcipher *cipher,const u8 *key,unsigned int len) { -struct spacc_ablk_ctx *ctx =crypto_ablkcipher_ctx (cipher); +struct spacc_ablk_ctx *ctx =crypto_skcipher_ctx (cipher);int err; - err =verify_ablkcipher_des_key (cipher, key); + err =verify_skcipher_des_key (cipher, key);if (err)return err;
@@ -753,13 +753,13 @@ static int spacc_des_setkey(struct crypto_ablkcipher *cipher, const u8 *key,* Set the 3DES key for a block cipher transform. This also performs weak key * checking if the transform has requested it. */ -static int spacc_des3_setkey (struct crypto_ablkcipher *cipher,const u8 *key, +static int spacc_des3_setkey (struct crypto_skcipher *cipher,const u8 *key,unsigned int len) { -struct spacc_ablk_ctx *ctx =crypto_ablkcipher_ctx (cipher); +struct spacc_ablk_ctx *ctx =crypto_skcipher_ctx (cipher);int err; - err =verify_ablkcipher_des3_key (cipher, key); + err =verify_skcipher_des3_key (cipher, key);if (err)return err;
@@ -773,15 +773,15 @@ static int spacc_des3_setkey(struct crypto_ablkcipher *cipher, const u8 *key,* Set the key for an AES block cipher. Some key lengths are not supported in * hardware so this must also check whether a fallback is needed. */ -static int spacc_aes_setkey (struct crypto_ablkcipher *cipher,const u8 *key, +static int spacc_aes_setkey (struct crypto_skcipher *cipher,const u8 *key,unsigned int len) { -struct crypto_tfm *tfm =crypto_ablkcipher_tfm (cipher); +struct crypto_tfm *tfm =crypto_skcipher_tfm (cipher);struct spacc_ablk_ctx *ctx =crypto_tfm_ctx (tfm);int err =0 ;if (len >AES_MAX_KEY_SIZE ) { -crypto_ablkcipher_set_flags (cipher,CRYPTO_TFM_RES_BAD_KEY_LEN ); +crypto_skcipher_set_flags (cipher,CRYPTO_TFM_RES_BAD_KEY_LEN );return -EINVAL ; }
@@ -822,15 +822,15 @@ static int spacc_aes_setkey(struct crypto_ablkcipher *cipher, const u8 *key,return err; } -static int spacc_kasumi_f8_setkey (struct crypto_ablkcipher *cipher, +static int spacc_kasumi_f8_setkey (struct crypto_skcipher *cipher,const u8 *key,unsigned int len) { -struct crypto_tfm *tfm =crypto_ablkcipher_tfm (cipher); +struct crypto_tfm *tfm =crypto_skcipher_tfm (cipher);struct spacc_ablk_ctx *ctx =crypto_tfm_ctx (tfm);int err =0 ;if (len >AES_MAX_KEY_SIZE ) { -crypto_ablkcipher_set_flags (cipher,CRYPTO_TFM_RES_BAD_KEY_LEN ); +crypto_skcipher_set_flags (cipher,CRYPTO_TFM_RES_BAD_KEY_LEN ); err = -EINVAL ; goto out; }
@@ -844,12 +844,12 @@ static int spacc_kasumi_f8_setkey(struct crypto_ablkcipher *cipher,static int spacc_ablk_need_fallback (struct spacc_req *req) { +struct skcipher_request *ablk_req =skcipher_request_cast (req->req); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (ablk_req); +struct spacc_alg *spacc_alg =to_spacc_skcipher (crypto_skcipher_alg (tfm));struct spacc_ablk_ctx *ctx; -struct crypto_tfm *tfm = req->req->tfm; -struct crypto_alg *alg = req->req->tfm->__crt_alg; -struct spacc_alg *spacc_alg =to_spacc_alg (alg); - ctx =crypto_tfm_ctx (tfm); + ctx =crypto_skcipher_ctx (tfm);return (spacc_alg->ctrl_default &SPACC_CRYPTO_ALG_MASK ) == SPA_CTRL_CIPH_ALG_AES &&
@@ -859,39 +859,39 @@ static int spacc_ablk_need_fallback(struct spacc_req *req)static void spacc_ablk_complete (struct spacc_req *req) { -struct ablkcipher_request *ablk_req =ablkcipher_request_cast (req->req); +struct skcipher_request *ablk_req =skcipher_request_cast (req->req);if (ablk_req->src != ablk_req->dst) {spacc_free_ddt (req, req->src_ddt, req->src_addr, ablk_req->src, - ablk_req->nbytes,DMA_TO_DEVICE ); + ablk_req->cryptlen,DMA_TO_DEVICE );spacc_free_ddt (req, req->dst_ddt, req->dst_addr, ablk_req->dst, - ablk_req->nbytes,DMA_FROM_DEVICE ); + ablk_req->cryptlen,DMA_FROM_DEVICE ); }else spacc_free_ddt (req, req->dst_ddt, req->dst_addr, ablk_req->dst, - ablk_req->nbytes,DMA_BIDIRECTIONAL ); + ablk_req->cryptlen,DMA_BIDIRECTIONAL ); req->req->complete (req->req, req->result); }static int spacc_ablk_submit (struct spacc_req *req) { -struct crypto_tfm *tfm = req->req->tfm; -struct spacc_ablk_ctx *ctx =crypto_tfm_ctx (tfm); -struct ablkcipher_request *ablk_req =ablkcipher_request_cast (req->req); -struct crypto_alg *alg = req->req->tfm->__crt_alg; -struct spacc_alg *spacc_alg =to_spacc_alg (alg); +struct skcipher_request *ablk_req =skcipher_request_cast (req->req); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (ablk_req); +struct skcipher_alg *alg =crypto_skcipher_alg (tfm); +struct spacc_alg *spacc_alg =to_spacc_skcipher (alg); +struct spacc_ablk_ctx *ctx =crypto_skcipher_ctx (tfm);struct spacc_engine *engine = ctx->generic.engine;u32 ctrl; req->ctx_id =spacc_load_ctx (&ctx->generic, ctx->key, - ctx->key_len, ablk_req->info, alg->cra_ablkcipher.ivsize, + ctx->key_len, ablk_req->iv, alg->ivsize,NULL ,0 );writel (req->src_addr, engine->regs +SPA_SRC_PTR_REG_OFFSET );writel (req->dst_addr, engine->regs +SPA_DST_PTR_REG_OFFSET );writel (0 , engine->regs +SPA_OFFSET_REG_OFFSET ); -writel (ablk_req->nbytes, engine->regs +SPA_PROC_LEN_REG_OFFSET ); +writel (ablk_req->cryptlen, engine->regs +SPA_PROC_LEN_REG_OFFSET );writel (0 , engine->regs +SPA_ICV_OFFSET_REG_OFFSET );writel (0 , engine->regs +SPA_AUX_INFO_REG_OFFSET );writel (0 , engine->regs +SPA_AAD_LEN_REG_OFFSET );
@@ -907,11 +907,11 @@ static int spacc_ablk_submit(struct spacc_req *req)return -EINPROGRESS ; } -static int spacc_ablk_do_fallback (struct ablkcipher_request *req, +static int spacc_ablk_do_fallback (struct skcipher_request *req,unsigned alg_type,bool is_encrypt) {struct crypto_tfm *old_tfm = -crypto_ablkcipher_tfm (crypto_ablkcipher_reqtfm (req)); +crypto_skcipher_tfm (crypto_skcipher_reqtfm (req));struct spacc_ablk_ctx *ctx =crypto_tfm_ctx (old_tfm);SYNC_SKCIPHER_REQUEST_ON_STACK (subreq, ctx->sw_cipher);int err;
@@ -924,7 +924,7 @@ static int spacc_ablk_do_fallback(struct ablkcipher_request *req,skcipher_request_set_sync_tfm (subreq, ctx->sw_cipher);skcipher_request_set_callback (subreq, req->base.flags,NULL ,NULL );skcipher_request_set_crypt (subreq, req->src, req->dst, - req->nbytes, req->info); + req->cryptlen, req->iv); err = is_encrypt ?crypto_skcipher_encrypt (subreq) :crypto_skcipher_decrypt (subreq);skcipher_request_zero (subreq);
@@ -932,12 +932,13 @@ static int spacc_ablk_do_fallback(struct ablkcipher_request *req,return err; } -static int spacc_ablk_setup (struct ablkcipher_request *req,unsigned alg_type, +static int spacc_ablk_setup (struct skcipher_request *req,unsigned alg_type,bool is_encrypt) { -struct crypto_alg *alg = req->base.tfm->__crt_alg; -struct spacc_engine *engine =to_spacc_alg (alg)->engine; -struct spacc_req *dev_req =ablkcipher_request_ctx (req); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req); +struct skcipher_alg *alg =crypto_skcipher_alg (tfm); +struct spacc_engine *engine =to_spacc_skcipher (alg)->engine; +struct spacc_req *dev_req =skcipher_request_ctx (req);unsigned long flags;int err = -ENOMEM ;
@@ -956,17 +957,17 @@ static int spacc_ablk_setup(struct ablkcipher_request *req, unsigned alg_type,*/ if (req->src != req->dst) { dev_req->src_ddt =spacc_sg_to_ddt (engine, req->src, - req->nbytes,DMA_TO_DEVICE , &dev_req->src_addr); + req->cryptlen,DMA_TO_DEVICE , &dev_req->src_addr);if (!dev_req->src_ddt) goto out; dev_req->dst_ddt =spacc_sg_to_ddt (engine, req->dst, - req->nbytes,DMA_FROM_DEVICE , &dev_req->dst_addr); + req->cryptlen,DMA_FROM_DEVICE , &dev_req->dst_addr);if (!dev_req->dst_ddt) goto out_free_src; }else { dev_req->dst_ddt =spacc_sg_to_ddt (engine, req->dst, - req->nbytes,DMA_BIDIRECTIONAL , &dev_req->dst_addr); + req->cryptlen,DMA_BIDIRECTIONAL , &dev_req->dst_addr);if (!dev_req->dst_ddt) goto out;
@@ -999,65 +1000,65 @@ static int spacc_ablk_setup(struct ablkcipher_request *req, unsigned alg_type, out_free_ddts:spacc_free_ddt (dev_req, dev_req->dst_ddt, dev_req->dst_addr, req->dst, - req->nbytes, req->src == req->dst ? + req->cryptlen, req->src == req->dst ?DMA_BIDIRECTIONAL :DMA_FROM_DEVICE ); out_free_src:if (req->src != req->dst)spacc_free_ddt (dev_req, dev_req->src_ddt, dev_req->src_addr, - req->src, req->nbytes,DMA_TO_DEVICE ); + req->src, req->cryptlen,DMA_TO_DEVICE ); out:return err; } -static int spacc_ablk_cra_init (struct crypto_tfm *tfm) +static int spacc_ablk_init_tfm (struct crypto_skcipher *tfm) { -struct spacc_ablk_ctx *ctx =crypto_tfm_ctx (tfm); -struct crypto_alg *alg = tfm->__crt_alg; -struct spacc_alg *spacc_alg =to_spacc_alg (alg); +struct spacc_ablk_ctx *ctx =crypto_skcipher_ctx (tfm); +struct skcipher_alg *alg =crypto_skcipher_alg (tfm); +struct spacc_alg *spacc_alg =to_spacc_skcipher (alg);struct spacc_engine *engine = spacc_alg->engine; ctx->generic.flags = spacc_alg->type; ctx->generic.engine = engine; -if (alg->cra_flags &CRYPTO_ALG_NEED_FALLBACK ) { +if (alg->base.cra_flags &CRYPTO_ALG_NEED_FALLBACK ) { ctx->sw_cipher =crypto_alloc_sync_skcipher ( - alg->cra_name,0 ,CRYPTO_ALG_NEED_FALLBACK ); + alg->base.cra_name,0 ,CRYPTO_ALG_NEED_FALLBACK );if (IS_ERR (ctx->sw_cipher)) {dev_warn (engine->dev,"failed to allocate fallback for %s\n" , - alg->cra_name); + alg->base.cra_name);return PTR_ERR (ctx->sw_cipher); } } ctx->generic.key_offs = spacc_alg->key_offs; ctx->generic.iv_offs = spacc_alg->iv_offs; - tfm->crt_ablkcipher.reqsize =sizeof (struct spacc_req ); +crypto_skcipher_set_reqsize (tfm,sizeof (struct spacc_req ));return 0 ; } -static void spacc_ablk_cra_exit (struct crypto_tfm *tfm) +static void spacc_ablk_exit_tfm (struct crypto_skcipher *tfm) { -struct spacc_ablk_ctx *ctx =crypto_tfm_ctx (tfm); +struct spacc_ablk_ctx *ctx =crypto_skcipher_ctx (tfm);crypto_free_sync_skcipher (ctx->sw_cipher); } -static int spacc_ablk_encrypt (struct ablkcipher_request *req) +static int spacc_ablk_encrypt (struct skcipher_request *req) { -struct crypto_ablkcipher *cipher =crypto_ablkcipher_reqtfm (req); -struct crypto_tfm *tfm =crypto_ablkcipher_tfm (cipher); -struct spacc_alg *alg =to_spacc_alg (tfm->__crt_alg); +struct crypto_skcipher *cipher =crypto_skcipher_reqtfm (req); +struct skcipher_alg *alg =crypto_skcipher_alg (cipher); +struct spacc_alg *spacc_alg =to_spacc_skcipher (alg); -return spacc_ablk_setup (req, alg->type,1 ); +return spacc_ablk_setup (req, spacc_alg->type,1 ); } -static int spacc_ablk_decrypt (struct ablkcipher_request *req) +static int spacc_ablk_decrypt (struct skcipher_request *req) { -struct crypto_ablkcipher *cipher =crypto_ablkcipher_reqtfm (req); -struct crypto_tfm *tfm =crypto_ablkcipher_tfm (cipher); -struct spacc_alg *alg =to_spacc_alg (tfm->__crt_alg); +struct crypto_skcipher *cipher =crypto_skcipher_reqtfm (req); +struct skcipher_alg *alg =crypto_skcipher_alg (cipher); +struct spacc_alg *spacc_alg =to_spacc_skcipher (alg); -return spacc_ablk_setup (req, alg->type,0 ); +return spacc_ablk_setup (req, spacc_alg->type,0 ); }static inline int spacc_fifo_stat_empty (struct spacc_engine *engine)
@@ -1233,27 +1234,24 @@ static struct spacc_alg ipsec_engine_algs[] = { .key_offs = 0, .iv_offs = AES_MAX_KEY_SIZE, .alg = { - .cra_name = "cbc(aes)", - .cra_driver_name = "cbc-aes-picoxcell", - .cra_priority = SPACC_CRYPTO_ALG_PRIORITY, - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_KERN_DRIVER_ONLY | -CRYPTO_ALG_ASYNC | - CRYPTO_ALG_NEED_FALLBACK, - .cra_blocksize = AES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct spacc_ablk_ctx), - .cra_type = &crypto_ablkcipher_type, - .cra_module = THIS_MODULE, - .cra_ablkcipher = { - .setkey = spacc_aes_setkey, - .encrypt = spacc_ablk_encrypt, - .decrypt = spacc_ablk_decrypt, - .min_keysize = AES_MIN_KEY_SIZE, - .max_keysize = AES_MAX_KEY_SIZE, - .ivsize = AES_BLOCK_SIZE, - }, - .cra_init = spacc_ablk_cra_init, - .cra_exit = spacc_ablk_cra_exit, + .base.cra_name = "cbc(aes)", + .base.cra_driver_name = "cbc-aes-picoxcell", + .base.cra_priority = SPACC_CRYPTO_ALG_PRIORITY, + .base.cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY | +CRYPTO_ALG_ASYNC | + CRYPTO_ALG_NEED_FALLBACK, + .base.cra_blocksize = AES_BLOCK_SIZE, + .base.cra_ctxsize = sizeof(struct spacc_ablk_ctx), + .base.cra_module = THIS_MODULE, + + .setkey = spacc_aes_setkey, + .encrypt = spacc_ablk_encrypt, + .decrypt = spacc_ablk_decrypt, + .min_keysize = AES_MIN_KEY_SIZE, + .max_keysize = AES_MAX_KEY_SIZE, + .ivsize = AES_BLOCK_SIZE, + .init = spacc_ablk_init_tfm, + .exit = spacc_ablk_exit_tfm, }, }, {
@@ -1261,25 +1259,23 @@ static struct spacc_alg ipsec_engine_algs[] = { .iv_offs = AES_MAX_KEY_SIZE, .ctrl_default = SPA_CTRL_CIPH_ALG_AES | SPA_CTRL_CIPH_MODE_ECB, .alg = { - .cra_name = "ecb(aes)", - .cra_driver_name = "ecb-aes-picoxcell", - .cra_priority = SPACC_CRYPTO_ALG_PRIORITY, - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_KERN_DRIVER_ONLY | - CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK, - .cra_blocksize = AES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct spacc_ablk_ctx), - .cra_type = &crypto_ablkcipher_type, - .cra_module = THIS_MODULE, - .cra_ablkcipher = { - .setkey = spacc_aes_setkey, - .encrypt = spacc_ablk_encrypt, - .decrypt = spacc_ablk_decrypt, - .min_keysize = AES_MIN_KEY_SIZE, - .max_keysize = AES_MAX_KEY_SIZE, - }, - .cra_init = spacc_ablk_cra_init, - .cra_exit = spacc_ablk_cra_exit, + .base.cra_name = "ecb(aes)", + .base.cra_driver_name = "ecb-aes-picoxcell", + .base.cra_priority = SPACC_CRYPTO_ALG_PRIORITY, + .base.cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY | +CRYPTO_ALG_ASYNC | + CRYPTO_ALG_NEED_FALLBACK, + .base.cra_blocksize = AES_BLOCK_SIZE, + .base.cra_ctxsize = sizeof(struct spacc_ablk_ctx), + .base.cra_module = THIS_MODULE, + + .setkey = spacc_aes_setkey, + .encrypt = spacc_ablk_encrypt, + .decrypt = spacc_ablk_decrypt, + .min_keysize = AES_MIN_KEY_SIZE, + .max_keysize = AES_MAX_KEY_SIZE, + .init = spacc_ablk_init_tfm, + .exit = spacc_ablk_exit_tfm, }, }, {
@@ -1287,26 +1283,23 @@ static struct spacc_alg ipsec_engine_algs[] = { .iv_offs = 0, .ctrl_default = SPA_CTRL_CIPH_ALG_DES | SPA_CTRL_CIPH_MODE_CBC, .alg = { - .cra_name = "cbc(des)", - .cra_driver_name = "cbc-des-picoxcell", - .cra_priority = SPACC_CRYPTO_ALG_PRIORITY, - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC | - CRYPTO_ALG_KERN_DRIVER_ONLY, - .cra_blocksize = DES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct spacc_ablk_ctx), - .cra_type = &crypto_ablkcipher_type, - .cra_module = THIS_MODULE, - .cra_ablkcipher = { - .setkey = spacc_des_setkey, - .encrypt = spacc_ablk_encrypt, - .decrypt = spacc_ablk_decrypt, - .min_keysize = DES_KEY_SIZE, - .max_keysize = DES_KEY_SIZE, - .ivsize = DES_BLOCK_SIZE, - }, - .cra_init = spacc_ablk_cra_init, - .cra_exit = spacc_ablk_cra_exit, + .base.cra_name = "cbc(des)", + .base.cra_driver_name = "cbc-des-picoxcell", + .base.cra_priority = SPACC_CRYPTO_ALG_PRIORITY, + .base.cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY | + CRYPTO_ALG_ASYNC, + .base.cra_blocksize = DES_BLOCK_SIZE, + .base.cra_ctxsize = sizeof(struct spacc_ablk_ctx), + .base.cra_module = THIS_MODULE, + + .setkey = spacc_des_setkey, + .encrypt = spacc_ablk_encrypt, + .decrypt = spacc_ablk_decrypt, + .min_keysize = DES_KEY_SIZE, + .max_keysize = DES_KEY_SIZE, + .ivsize = DES_BLOCK_SIZE, + .init = spacc_ablk_init_tfm, + .exit = spacc_ablk_exit_tfm, }, }, {
@@ -1314,25 +1307,22 @@ static struct spacc_alg ipsec_engine_algs[] = { .iv_offs = 0, .ctrl_default = SPA_CTRL_CIPH_ALG_DES | SPA_CTRL_CIPH_MODE_ECB, .alg = { - .cra_name = "ecb(des)", - .cra_driver_name = "ecb-des-picoxcell", - .cra_priority = SPACC_CRYPTO_ALG_PRIORITY, - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC | - CRYPTO_ALG_KERN_DRIVER_ONLY, - .cra_blocksize = DES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct spacc_ablk_ctx), - .cra_type = &crypto_ablkcipher_type, - .cra_module = THIS_MODULE, - .cra_ablkcipher = { - .setkey = spacc_des_setkey, - .encrypt = spacc_ablk_encrypt, - .decrypt = spacc_ablk_decrypt, - .min_keysize = DES_KEY_SIZE, - .max_keysize = DES_KEY_SIZE, - }, - .cra_init = spacc_ablk_cra_init, - .cra_exit = spacc_ablk_cra_exit, + .base.cra_name = "ecb(des)", + .base.cra_driver_name = "ecb-des-picoxcell", + .base.cra_priority = SPACC_CRYPTO_ALG_PRIORITY, + .base.cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY | + CRYPTO_ALG_ASYNC, + .base.cra_blocksize = DES_BLOCK_SIZE, + .base.cra_ctxsize = sizeof(struct spacc_ablk_ctx), + .base.cra_module = THIS_MODULE, + + .setkey = spacc_des_setkey, + .encrypt = spacc_ablk_encrypt, + .decrypt = spacc_ablk_decrypt, + .min_keysize = DES_KEY_SIZE, + .max_keysize = DES_KEY_SIZE, + .init = spacc_ablk_init_tfm, + .exit = spacc_ablk_exit_tfm, }, }, {
@@ -1340,26 +1330,23 @@ static struct spacc_alg ipsec_engine_algs[] = { .iv_offs = 0, .ctrl_default = SPA_CTRL_CIPH_ALG_DES | SPA_CTRL_CIPH_MODE_CBC, .alg = { - .cra_name = "cbc(des3_ede)", - .cra_driver_name = "cbc-des3-ede-picoxcell", - .cra_priority = SPACC_CRYPTO_ALG_PRIORITY, - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC | - CRYPTO_ALG_KERN_DRIVER_ONLY, - .cra_blocksize = DES3_EDE_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct spacc_ablk_ctx), - .cra_type = &crypto_ablkcipher_type, - .cra_module = THIS_MODULE, - .cra_ablkcipher = { - .setkey = spacc_des3_setkey, - .encrypt = spacc_ablk_encrypt, - .decrypt = spacc_ablk_decrypt, - .min_keysize = DES3_EDE_KEY_SIZE, - .max_keysize = DES3_EDE_KEY_SIZE, - .ivsize = DES3_EDE_BLOCK_SIZE, - }, - .cra_init = spacc_ablk_cra_init, - .cra_exit = spacc_ablk_cra_exit, + .base.cra_name = "cbc(des3_ede)", + .base.cra_driver_name = "cbc-des3-ede-picoxcell", + .base.cra_priority = SPACC_CRYPTO_ALG_PRIORITY, + .base.cra_flags =CRYPTO_ALG_ASYNC | + CRYPTO_ALG_KERN_DRIVER_ONLY, + .base.cra_blocksize = DES3_EDE_BLOCK_SIZE, + .base.cra_ctxsize = sizeof(struct spacc_ablk_ctx), + .base.cra_module = THIS_MODULE, + + .setkey = spacc_des3_setkey, + .encrypt = spacc_ablk_encrypt, + .decrypt = spacc_ablk_decrypt, + .min_keysize = DES3_EDE_KEY_SIZE, + .max_keysize = DES3_EDE_KEY_SIZE, + .ivsize = DES3_EDE_BLOCK_SIZE, + .init = spacc_ablk_init_tfm, + .exit = spacc_ablk_exit_tfm, }, }, {
@@ -1367,25 +1354,22 @@ static struct spacc_alg ipsec_engine_algs[] = { .iv_offs = 0, .ctrl_default = SPA_CTRL_CIPH_ALG_DES | SPA_CTRL_CIPH_MODE_ECB, .alg = { - .cra_name = "ecb(des3_ede)", - .cra_driver_name = "ecb-des3-ede-picoxcell", - .cra_priority = SPACC_CRYPTO_ALG_PRIORITY, - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC | - CRYPTO_ALG_KERN_DRIVER_ONLY, - .cra_blocksize = DES3_EDE_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct spacc_ablk_ctx), - .cra_type = &crypto_ablkcipher_type, - .cra_module = THIS_MODULE, - .cra_ablkcipher = { - .setkey = spacc_des3_setkey, - .encrypt = spacc_ablk_encrypt, - .decrypt = spacc_ablk_decrypt, - .min_keysize = DES3_EDE_KEY_SIZE, - .max_keysize = DES3_EDE_KEY_SIZE, - }, - .cra_init = spacc_ablk_cra_init, - .cra_exit = spacc_ablk_cra_exit, + .base.cra_name = "ecb(des3_ede)", + .base.cra_driver_name = "ecb-des3-ede-picoxcell", + .base.cra_priority = SPACC_CRYPTO_ALG_PRIORITY, + .base.cra_flags =CRYPTO_ALG_ASYNC | + CRYPTO_ALG_KERN_DRIVER_ONLY, + .base.cra_blocksize = DES3_EDE_BLOCK_SIZE, + .base.cra_ctxsize = sizeof(struct spacc_ablk_ctx), + .base.cra_module = THIS_MODULE, + + .setkey = spacc_des3_setkey, + .encrypt = spacc_ablk_encrypt, + .decrypt = spacc_ablk_decrypt, + .min_keysize = DES3_EDE_KEY_SIZE, + .max_keysize = DES3_EDE_KEY_SIZE, + .init = spacc_ablk_init_tfm, + .exit = spacc_ablk_exit_tfm, }, }, };
@@ -1581,25 +1565,23 @@ static struct spacc_alg l2_engine_algs[] = { .ctrl_default = SPA_CTRL_CIPH_ALG_KASUMI | SPA_CTRL_CIPH_MODE_F8, .alg = { - .cra_name = "f8(kasumi)", - .cra_driver_name = "f8-kasumi-picoxcell", - .cra_priority = SPACC_CRYPTO_ALG_PRIORITY, - .cra_flags =CRYPTO_ALG_ASYNC | - CRYPTO_ALG_KERN_DRIVER_ONLY, - .cra_blocksize = 8, - .cra_ctxsize = sizeof(struct spacc_ablk_ctx), - .cra_type = &crypto_ablkcipher_type, - .cra_module = THIS_MODULE, - .cra_ablkcipher = { - .setkey = spacc_kasumi_f8_setkey, - .encrypt = spacc_ablk_encrypt, - .decrypt = spacc_ablk_decrypt, - .min_keysize = 16, - .max_keysize = 16, - .ivsize = 8, - }, - .cra_init = spacc_ablk_cra_init, - .cra_exit = spacc_ablk_cra_exit, + .base.cra_name = "f8(kasumi)", + .base.cra_driver_name = "f8-kasumi-picoxcell", + .base.cra_priority = SPACC_CRYPTO_ALG_PRIORITY, + .base.cra_flags =CRYPTO_ALG_ASYNC | + CRYPTO_ALG_KERN_DRIVER_ONLY, + .base.cra_blocksize = 8, + .base.cra_ctxsize = sizeof(struct spacc_ablk_ctx), + .base.cra_module = THIS_MODULE, + + .setkey = spacc_kasumi_f8_setkey, + .encrypt = spacc_ablk_encrypt, + .decrypt = spacc_ablk_decrypt, + .min_keysize = 16, + .max_keysize = 16, + .ivsize = 8, + .init = spacc_ablk_init_tfm, + .exit = spacc_ablk_exit_tfm, }, }, };
@@ -1721,7 +1703,7 @@ static int spacc_probe(struct platform_device *pdev)INIT_LIST_HEAD (&engine->registered_algs);for (i =0 ; i < engine->num_algs; ++i) { engine->algs[i].engine = engine; - err =crypto_register_alg (&engine->algs[i].alg); + err =crypto_register_skcipher (&engine->algs[i].alg);if (!err) {list_add_tail (&engine->algs[i].entry, &engine->registered_algs);
@@ -1729,10 +1711,10 @@ static int spacc_probe(struct platform_device *pdev) }if (err)dev_err (engine->dev,"failed to register alg \"%s\"\n" , - engine->algs[i].alg.cra_name); + engine->algs[i].alg.base.cra_name);else dev_dbg (engine->dev,"registered alg \"%s\"\n" , - engine->algs[i].alg.cra_name); + engine->algs[i].alg.base.cra_name); }INIT_LIST_HEAD (&engine->registered_aeads);
@@ -1781,7 +1763,7 @@ static int spacc_remove(struct platform_device *pdev)list_for_each_entry_safe (alg, next, &engine->registered_algs, entry) {list_del (&alg->entry); -crypto_unregister_alg (&alg->alg); +crypto_unregister_skcipher (&alg->alg); }clk_disable_unprepare (engine->clk);
Signature · 1 line
2.17.1
PATCH v4 20/29 crypto: qce - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
---
drivers/crypto/qce/Makefile | 2 +-
drivers/crypto/qce/cipher.h | 8 +-
drivers/crypto/qce/common.c | 12 +-
drivers/crypto/qce/common.h | 3 +-
drivers/crypto/qce/core.c | 2 +-
drivers/crypto/qce/{ablkcipher.c => skcipher.c} | 172 ++++++++++----------
6 files changed, 100 insertions(+), 99 deletions(-)drivers/crypto/qce/Makefile +1 -1
@@ -4,4 +4,4 @@ qcrypto-objs := core.o \ common.o \ dma.o \ sha.o \ - ablkcipher.o + skcipher.o
drivers/crypto/qce/cipher.h +4 -4
@@ -45,12 +45,12 @@ struct qce_cipher_reqctx {unsigned int cryptlen; }; -static inline struct qce_alg_template *to_cipher_tmpl (struct crypto_tfm *tfm) +static inline struct qce_alg_template *to_cipher_tmpl (struct crypto_skcipher *tfm) { -struct crypto_alg *alg = tfm->__crt_alg; - return container_of(alg, struct qce_alg_template, alg.crypto); +struct skcipher_alg *alg =crypto_skcipher_alg (tfm); + return container_of(alg, struct qce_alg_template, alg.skcipher); } -extern const struct qce_algo_ops ablkcipher_ops; +extern const struct qce_algo_ops skcipher_ops;#endif /* _CIPHER_H_ */
drivers/crypto/qce/common.c +6 -6
@@ -304,13 +304,13 @@ static int qce_setup_regs_ahash(struct crypto_async_request *async_req,return 0 ; } -static int qce_setup_regs_ablkcipher (struct crypto_async_request *async_req, +static int qce_setup_regs_skcipher (struct crypto_async_request *async_req,u32 totallen,u32 offset) { -struct ablkcipher_request *req =ablkcipher_request_cast (async_req); -struct qce_cipher_reqctx *rctx =ablkcipher_request_ctx (req); +struct skcipher_request *req =skcipher_request_cast (async_req); +struct qce_cipher_reqctx *rctx =skcipher_request_ctx (req);struct qce_cipher_ctx *ctx =crypto_tfm_ctx (async_req->tfm); -struct qce_alg_template *tmpl =to_cipher_tmpl (async_req->tfm); +struct qce_alg_template *tmpl =to_cipher_tmpl (crypto_skcipher_reqtfm (req));struct qce_device *qce = tmpl->qce;__be32 enckey[QCE_MAX_CIPHER_KEY_SIZE /sizeof (__be32)] = {0 };__be32 enciv[QCE_MAX_IV_SIZE /sizeof (__be32)] = {0 };
@@ -389,8 +389,8 @@ int qce_start(struct crypto_async_request *async_req, u32 type, u32 totallen, u32 offset) {switch (type) { -case CRYPTO_ALG_TYPE_ABLKCIPHER : -return qce_setup_regs_ablkcipher (async_req, totallen, offset); +case CRYPTO_ALG_TYPE_SKCIPHER : +return qce_setup_regs_skcipher (async_req, totallen, offset);case CRYPTO_ALG_TYPE_AHASH :return qce_setup_regs_ahash (async_req, totallen, offset);default :
drivers/crypto/qce/common.h +2 -1
@@ -10,6 +10,7 @@#include <linux/types.h> #include <crypto/aes.h> #include <crypto/hash.h> +#include <crypto/internal/skcipher.h> /* key size in bytes */ #define QCE_SHA_HMAC_KEY_SIZE 64
@@ -79,7 +80,7 @@ struct qce_alg_template {unsigned long alg_flags;const u32 *std_iv;union { -struct crypto_alg crypto; +struct skcipher_alg skcipher;struct ahash_alg ahash; } alg;struct qce_device *qce;
drivers/crypto/qce/core.c +1 -1
@@ -22,7 +22,7 @@#define QCE_QUEUE_LENGTH 1static const struct qce_algo_ops *qce_ops[] = { - &ablkcipher_ops, + &skcipher_ops, &ahash_ops, };
drivers/crypto/qce/skcipher.c renamed from drivers/crypto/qce/ablkcipher.c +86 -86
343 lines not on this page · raw message
Signature · 1 line
2.17.1
PATCH v4 21/29 crypto: stm32 - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/stm32/stm32-cryp.c | 338 +++++++++----------- 1 file changed, 159 insertions(+), 179 deletions(-)
drivers/crypto/stm32/stm32-cryp.c +159 -179
@@ -19,6 +19,7 @@#include <crypto/engine.h> #include <crypto/scatterwalk.h> #include <crypto/internal/aead.h> +#include <crypto/internal/skcipher.h> #define DRIVER_NAME "stm32-cryp"
@@ -137,7 +138,7 @@ struct stm32_cryp {struct crypto_engine *engine; -struct ablkcipher_request *req; +struct skcipher_request *req;struct aead_request *areq;size_t authsize;
@@ -395,8 +396,8 @@ static void stm32_cryp_hw_write_iv(struct stm32_cryp *cryp, u32 *iv)static void stm32_cryp_get_iv (struct stm32_cryp *cryp) { -struct ablkcipher_request *req = cryp->req; -u32 *tmp = req->info; +struct skcipher_request *req = cryp->req; +u32 *tmp = (void *)req->iv;if (!tmp)return ;
@@ -616,7 +617,7 @@ static int stm32_cryp_hw_init(struct stm32_cryp *cryp)case CR_TDES_CBC :case CR_AES_CBC :case CR_AES_CTR : -stm32_cryp_hw_write_iv (cryp, (u32 *)cryp->req->info); +stm32_cryp_hw_write_iv (cryp, (u32 *)cryp->req->iv);break ;default :
@@ -667,7 +668,7 @@ static void stm32_cryp_finish_req(struct stm32_cryp *cryp, int err)if (is_gcm (cryp) ||is_ccm (cryp))crypto_finalize_aead_request (cryp->engine, cryp->areq, err);else -crypto_finalize_ablkcipher_request (cryp->engine, cryp->req, +crypto_finalize_skcipher_request (cryp->engine, cryp->req, err);memset (cryp->ctx->key,0 , cryp->ctx->keylen);
@@ -685,11 +686,11 @@ static int stm32_cryp_cipher_one_req(struct crypto_engine *engine, void *areq);static int stm32_cryp_prepare_cipher_req (struct crypto_engine *engine,void *areq); -static int stm32_cryp_cra_init (struct crypto_tfm *tfm) +static int stm32_cryp_init_tfm (struct crypto_skcipher *tfm) { -struct stm32_cryp_ctx *ctx =crypto_tfm_ctx (tfm); +struct stm32_cryp_ctx *ctx =crypto_skcipher_ctx (tfm); - tfm->crt_ablkcipher.reqsize =sizeof (struct stm32_cryp_reqctx ); +crypto_skcipher_set_reqsize (tfm,sizeof (struct stm32_cryp_reqctx )); ctx->enginectx.op.do_one_request = stm32_cryp_cipher_one_req; ctx->enginectx.op.prepare_request = stm32_cryp_prepare_cipher_req;
@@ -714,11 +715,11 @@ static int stm32_cryp_aes_aead_init(struct crypto_aead *tfm)return 0 ; } -static int stm32_cryp_crypt (struct ablkcipher_request *req,unsigned long mode) +static int stm32_cryp_crypt (struct skcipher_request *req,unsigned long mode) { -struct stm32_cryp_ctx *ctx =crypto_ablkcipher_ctx ( -crypto_ablkcipher_reqtfm (req)); -struct stm32_cryp_reqctx *rctx =ablkcipher_request_ctx (req); +struct stm32_cryp_ctx *ctx =crypto_skcipher_ctx ( +crypto_skcipher_reqtfm (req)); +struct stm32_cryp_reqctx *rctx =skcipher_request_ctx (req);struct stm32_cryp *cryp =stm32_cryp_find_dev (ctx);if (!cryp)
@@ -726,7 +727,7 @@ static int stm32_cryp_crypt(struct ablkcipher_request *req, unsigned long mode) rctx->mode = mode; -return crypto_transfer_ablkcipher_request_to_engine (cryp->engine, req); +return crypto_transfer_skcipher_request_to_engine (cryp->engine, req); }static int stm32_cryp_aead_crypt (struct aead_request *req,unsigned long mode)
@@ -743,10 +744,10 @@ static int stm32_cryp_aead_crypt(struct aead_request *req, unsigned long mode)return crypto_transfer_aead_request_to_engine (cryp->engine, req); } -static int stm32_cryp_setkey (struct crypto_ablkcipher *tfm,const u8 *key, +static int stm32_cryp_setkey (struct crypto_skcipher *tfm,const u8 *key,unsigned int keylen) { -struct stm32_cryp_ctx *ctx =crypto_ablkcipher_ctx (tfm); +struct stm32_cryp_ctx *ctx =crypto_skcipher_ctx (tfm);memcpy (ctx->key, key, keylen); ctx->keylen = keylen;
@@ -754,7 +755,7 @@ static int stm32_cryp_setkey(struct crypto_ablkcipher *tfm, const u8 *key,return 0 ; } -static int stm32_cryp_aes_setkey (struct crypto_ablkcipher *tfm,const u8 *key, +static int stm32_cryp_aes_setkey (struct crypto_skcipher *tfm,const u8 *key,unsigned int keylen) { if (keylen != AES_KEYSIZE_128 && keylen != AES_KEYSIZE_192 &&
@@ -764,17 +765,17 @@ static int stm32_cryp_aes_setkey(struct crypto_ablkcipher *tfm, const u8 *key,return stm32_cryp_setkey (tfm, key, keylen); } -static int stm32_cryp_des_setkey (struct crypto_ablkcipher *tfm,const u8 *key, +static int stm32_cryp_des_setkey (struct crypto_skcipher *tfm,const u8 *key,unsigned int keylen) { -return verify_ablkcipher_des_key (tfm, key) ?: +return verify_skcipher_des_key (tfm, key) ?:stm32_cryp_setkey (tfm, key, keylen); } -static int stm32_cryp_tdes_setkey (struct crypto_ablkcipher *tfm,const u8 *key, +static int stm32_cryp_tdes_setkey (struct crypto_skcipher *tfm,const u8 *key,unsigned int keylen) { -return verify_ablkcipher_des3_key (tfm, key) ?: +return verify_skcipher_des3_key (tfm, key) ?:stm32_cryp_setkey (tfm, key, keylen); }
@@ -818,32 +819,32 @@ static int stm32_cryp_aes_ccm_setauthsize(struct crypto_aead *tfm,return 0 ; } -static int stm32_cryp_aes_ecb_encrypt (struct ablkcipher_request *req) +static int stm32_cryp_aes_ecb_encrypt (struct skcipher_request *req) {return stm32_cryp_crypt (req,FLG_AES |FLG_ECB |FLG_ENCRYPT ); } -static int stm32_cryp_aes_ecb_decrypt (struct ablkcipher_request *req) +static int stm32_cryp_aes_ecb_decrypt (struct skcipher_request *req) {return stm32_cryp_crypt (req,FLG_AES |FLG_ECB ); } -static int stm32_cryp_aes_cbc_encrypt (struct ablkcipher_request *req) +static int stm32_cryp_aes_cbc_encrypt (struct skcipher_request *req) {return stm32_cryp_crypt (req,FLG_AES |FLG_CBC |FLG_ENCRYPT ); } -static int stm32_cryp_aes_cbc_decrypt (struct ablkcipher_request *req) +static int stm32_cryp_aes_cbc_decrypt (struct skcipher_request *req) {return stm32_cryp_crypt (req,FLG_AES |FLG_CBC ); } -static int stm32_cryp_aes_ctr_encrypt (struct ablkcipher_request *req) +static int stm32_cryp_aes_ctr_encrypt (struct skcipher_request *req) {return stm32_cryp_crypt (req,FLG_AES |FLG_CTR |FLG_ENCRYPT ); } -static int stm32_cryp_aes_ctr_decrypt (struct ablkcipher_request *req) +static int stm32_cryp_aes_ctr_decrypt (struct skcipher_request *req) {return stm32_cryp_crypt (req,FLG_AES |FLG_CTR ); }
@@ -868,47 +869,47 @@ static int stm32_cryp_aes_ccm_decrypt(struct aead_request *req)return stm32_cryp_aead_crypt (req,FLG_AES |FLG_CCM ); } -static int stm32_cryp_des_ecb_encrypt (struct ablkcipher_request *req) +static int stm32_cryp_des_ecb_encrypt (struct skcipher_request *req) {return stm32_cryp_crypt (req,FLG_DES |FLG_ECB |FLG_ENCRYPT ); } -static int stm32_cryp_des_ecb_decrypt (struct ablkcipher_request *req) +static int stm32_cryp_des_ecb_decrypt (struct skcipher_request *req) {return stm32_cryp_crypt (req,FLG_DES |FLG_ECB ); } -static int stm32_cryp_des_cbc_encrypt (struct ablkcipher_request *req) +static int stm32_cryp_des_cbc_encrypt (struct skcipher_request *req) {return stm32_cryp_crypt (req,FLG_DES |FLG_CBC |FLG_ENCRYPT ); } -static int stm32_cryp_des_cbc_decrypt (struct ablkcipher_request *req) +static int stm32_cryp_des_cbc_decrypt (struct skcipher_request *req) {return stm32_cryp_crypt (req,FLG_DES |FLG_CBC ); } -static int stm32_cryp_tdes_ecb_encrypt (struct ablkcipher_request *req) +static int stm32_cryp_tdes_ecb_encrypt (struct skcipher_request *req) {return stm32_cryp_crypt (req,FLG_TDES |FLG_ECB |FLG_ENCRYPT ); } -static int stm32_cryp_tdes_ecb_decrypt (struct ablkcipher_request *req) +static int stm32_cryp_tdes_ecb_decrypt (struct skcipher_request *req) {return stm32_cryp_crypt (req,FLG_TDES |FLG_ECB ); } -static int stm32_cryp_tdes_cbc_encrypt (struct ablkcipher_request *req) +static int stm32_cryp_tdes_cbc_encrypt (struct skcipher_request *req) {return stm32_cryp_crypt (req,FLG_TDES |FLG_CBC |FLG_ENCRYPT ); } -static int stm32_cryp_tdes_cbc_decrypt (struct ablkcipher_request *req) +static int stm32_cryp_tdes_cbc_decrypt (struct skcipher_request *req) {return stm32_cryp_crypt (req,FLG_TDES |FLG_CBC ); } -static int stm32_cryp_prepare_req (struct ablkcipher_request *req, +static int stm32_cryp_prepare_req (struct skcipher_request *req,struct aead_request *areq) {struct stm32_cryp_ctx *ctx;
@@ -919,7 +920,7 @@ static int stm32_cryp_prepare_req(struct ablkcipher_request *req,if (!req && !areq)return -EINVAL ; - ctx = req ?crypto_ablkcipher_ctx (crypto_ablkcipher_reqtfm (req)) : + ctx = req ?crypto_skcipher_ctx (crypto_skcipher_reqtfm (req)) :crypto_aead_ctx (crypto_aead_reqtfm (areq)); cryp = ctx->cryp;
@@ -927,7 +928,7 @@ static int stm32_cryp_prepare_req(struct ablkcipher_request *req,if (!cryp)return -ENODEV ; - rctx = req ?ablkcipher_request_ctx (req) :aead_request_ctx (areq); + rctx = req ?skcipher_request_ctx (req) :aead_request_ctx (areq); rctx->mode &=FLG_MODE_MASK ; ctx->cryp = cryp;
@@ -939,7 +940,7 @@ static int stm32_cryp_prepare_req(struct ablkcipher_request *req,if (req) { cryp->req = req; cryp->areq =NULL ; - cryp->total_in = req->nbytes; + cryp->total_in = req->cryptlen; cryp->total_out = cryp->total_in; }else {/*
@@ -1016,8 +1017,8 @@ static int stm32_cryp_prepare_req(struct ablkcipher_request *req,static int stm32_cryp_prepare_cipher_req (struct crypto_engine *engine,void *areq) { -struct ablkcipher_request *req =container_of (areq, - struct ablkcipher_request, +struct skcipher_request *req =container_of (areq, + struct skcipher_request, base);return stm32_cryp_prepare_req (req,NULL );
@@ -1025,11 +1026,11 @@ static int stm32_cryp_prepare_cipher_req(struct crypto_engine *engine,static int stm32_cryp_cipher_one_req (struct crypto_engine *engine,void *areq) { -struct ablkcipher_request *req =container_of (areq, - struct ablkcipher_request, +struct skcipher_request *req =container_of (areq, + struct skcipher_request, base); -struct stm32_cryp_ctx *ctx =crypto_ablkcipher_ctx ( -crypto_ablkcipher_reqtfm (req)); +struct stm32_cryp_ctx *ctx =crypto_skcipher_ctx ( +crypto_skcipher_reqtfm (req));struct stm32_cryp *cryp = ctx->cryp;if (!cryp)
@@ -1724,150 +1725,129 @@ static irqreturn_t stm32_cryp_irq(int irq, void *arg)return IRQ_WAKE_THREAD ; } -static struct crypto_alg crypto_algs[] = { -{ - .cra_name ="ecb(aes)" , - .cra_driver_name ="stm32-ecb-aes" , - .cra_priority =200 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct stm32_cryp_ctx ), - .cra_alignmask =0xf , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = stm32_cryp_cra_init, - .cra_ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .setkey = stm32_cryp_aes_setkey, - .encrypt = stm32_cryp_aes_ecb_encrypt, - .decrypt = stm32_cryp_aes_ecb_decrypt, - } +static struct skcipher_alg crypto_algs[] = { +{ + .base.cra_name ="ecb(aes)" , + .base.cra_driver_name ="stm32-ecb-aes" , + .base.cra_priority =200 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct stm32_cryp_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .init = stm32_cryp_init_tfm, + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .setkey = stm32_cryp_aes_setkey, + .encrypt = stm32_cryp_aes_ecb_encrypt, + .decrypt = stm32_cryp_aes_ecb_decrypt, }, { - .cra_name ="cbc(aes)" , - .cra_driver_name ="stm32-cbc-aes" , - .cra_priority =200 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct stm32_cryp_ctx ), - .cra_alignmask =0xf , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = stm32_cryp_cra_init, - .cra_ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = stm32_cryp_aes_setkey, - .encrypt = stm32_cryp_aes_cbc_encrypt, - .decrypt = stm32_cryp_aes_cbc_decrypt, - } + .base.cra_name ="cbc(aes)" , + .base.cra_driver_name ="stm32-cbc-aes" , + .base.cra_priority =200 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct stm32_cryp_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .init = stm32_cryp_init_tfm, + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , + .setkey = stm32_cryp_aes_setkey, + .encrypt = stm32_cryp_aes_cbc_encrypt, + .decrypt = stm32_cryp_aes_cbc_decrypt, }, { - .cra_name ="ctr(aes)" , - .cra_driver_name ="stm32-ctr-aes" , - .cra_priority =200 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_blocksize =1 , - .cra_ctxsize =sizeof (struct stm32_cryp_ctx ), - .cra_alignmask =0xf , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = stm32_cryp_cra_init, - .cra_ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - .setkey = stm32_cryp_aes_setkey, - .encrypt = stm32_cryp_aes_ctr_encrypt, - .decrypt = stm32_cryp_aes_ctr_decrypt, - } + .base.cra_name ="ctr(aes)" , + .base.cra_driver_name ="stm32-ctr-aes" , + .base.cra_priority =200 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =1 , + .base.cra_ctxsize =sizeof (struct stm32_cryp_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .init = stm32_cryp_init_tfm, + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , + .setkey = stm32_cryp_aes_setkey, + .encrypt = stm32_cryp_aes_ctr_encrypt, + .decrypt = stm32_cryp_aes_ctr_decrypt, }, { - .cra_name ="ecb(des)" , - .cra_driver_name ="stm32-ecb-des" , - .cra_priority =200 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_blocksize =DES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct stm32_cryp_ctx ), - .cra_alignmask =0xf , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = stm32_cryp_cra_init, - .cra_ablkcipher = { - .min_keysize =DES_BLOCK_SIZE , - .max_keysize =DES_BLOCK_SIZE , - .setkey = stm32_cryp_des_setkey, - .encrypt = stm32_cryp_des_ecb_encrypt, - .decrypt = stm32_cryp_des_ecb_decrypt, - } + .base.cra_name ="ecb(des)" , + .base.cra_driver_name ="stm32-ecb-des" , + .base.cra_priority =200 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =DES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct stm32_cryp_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .init = stm32_cryp_init_tfm, + .min_keysize =DES_BLOCK_SIZE , + .max_keysize =DES_BLOCK_SIZE , + .setkey = stm32_cryp_des_setkey, + .encrypt = stm32_cryp_des_ecb_encrypt, + .decrypt = stm32_cryp_des_ecb_decrypt, }, { - .cra_name ="cbc(des)" , - .cra_driver_name ="stm32-cbc-des" , - .cra_priority =200 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_blocksize =DES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct stm32_cryp_ctx ), - .cra_alignmask =0xf , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = stm32_cryp_cra_init, - .cra_ablkcipher = { - .min_keysize =DES_BLOCK_SIZE , - .max_keysize =DES_BLOCK_SIZE , - .ivsize =DES_BLOCK_SIZE , - .setkey = stm32_cryp_des_setkey, - .encrypt = stm32_cryp_des_cbc_encrypt, - .decrypt = stm32_cryp_des_cbc_decrypt, - } + .base.cra_name ="cbc(des)" , + .base.cra_driver_name ="stm32-cbc-des" , + .base.cra_priority =200 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =DES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct stm32_cryp_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .init = stm32_cryp_init_tfm, + .min_keysize =DES_BLOCK_SIZE , + .max_keysize =DES_BLOCK_SIZE , + .ivsize =DES_BLOCK_SIZE , + .setkey = stm32_cryp_des_setkey, + .encrypt = stm32_cryp_des_cbc_encrypt, + .decrypt = stm32_cryp_des_cbc_decrypt, }, { - .cra_name ="ecb(des3_ede)" , - .cra_driver_name ="stm32-ecb-des3" , - .cra_priority =200 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_blocksize =DES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct stm32_cryp_ctx ), - .cra_alignmask =0xf , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = stm32_cryp_cra_init, - .cra_ablkcipher = { - .min_keysize =3 *DES_BLOCK_SIZE , - .max_keysize =3 *DES_BLOCK_SIZE , - .setkey = stm32_cryp_tdes_setkey, - .encrypt = stm32_cryp_tdes_ecb_encrypt, - .decrypt = stm32_cryp_tdes_ecb_decrypt, - } + .base.cra_name ="ecb(des3_ede)" , + .base.cra_driver_name ="stm32-ecb-des3" , + .base.cra_priority =200 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =DES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct stm32_cryp_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .init = stm32_cryp_init_tfm, + .min_keysize =3 *DES_BLOCK_SIZE , + .max_keysize =3 *DES_BLOCK_SIZE , + .setkey = stm32_cryp_tdes_setkey, + .encrypt = stm32_cryp_tdes_ecb_encrypt, + .decrypt = stm32_cryp_tdes_ecb_decrypt, }, { - .cra_name ="cbc(des3_ede)" , - .cra_driver_name ="stm32-cbc-des3" , - .cra_priority =200 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_blocksize =DES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct stm32_cryp_ctx ), - .cra_alignmask =0xf , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = stm32_cryp_cra_init, - .cra_ablkcipher = { - .min_keysize =3 *DES_BLOCK_SIZE , - .max_keysize =3 *DES_BLOCK_SIZE , - .ivsize =DES_BLOCK_SIZE , - .setkey = stm32_cryp_tdes_setkey, - .encrypt = stm32_cryp_tdes_cbc_encrypt, - .decrypt = stm32_cryp_tdes_cbc_decrypt, - } + .base.cra_name ="cbc(des3_ede)" , + .base.cra_driver_name ="stm32-cbc-des3" , + .base.cra_priority =200 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =DES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct stm32_cryp_ctx ), + .base.cra_alignmask =0xf , + .base.cra_module =THIS_MODULE , + + .init = stm32_cryp_init_tfm, + .min_keysize =3 *DES_BLOCK_SIZE , + .max_keysize =3 *DES_BLOCK_SIZE , + .ivsize =DES_BLOCK_SIZE , + .setkey = stm32_cryp_tdes_setkey, + .encrypt = stm32_cryp_tdes_cbc_encrypt, + .decrypt = stm32_cryp_tdes_cbc_decrypt, }, };
@@ -2010,7 +1990,7 @@ static int stm32_cryp_probe(struct platform_device *pdev) goto err_engine2; } - ret =crypto_register_algs (crypto_algs,ARRAY_SIZE (crypto_algs)); + ret =crypto_register_skciphers (crypto_algs,ARRAY_SIZE (crypto_algs));if (ret) {dev_err (dev,"Could not register algs\n" ); goto err_algs;
@@ -2027,7 +2007,7 @@ static int stm32_cryp_probe(struct platform_device *pdev)return 0 ; err_aead_algs: -crypto_unregister_algs (crypto_algs,ARRAY_SIZE (crypto_algs)); +crypto_unregister_skciphers (crypto_algs,ARRAY_SIZE (crypto_algs)); err_algs: err_engine2:crypto_engine_exit (cryp->engine);
@@ -2059,7 +2039,7 @@ static int stm32_cryp_remove(struct platform_device *pdev)return ret;crypto_unregister_aeads (aead_algs,ARRAY_SIZE (aead_algs)); -crypto_unregister_algs (crypto_algs,ARRAY_SIZE (crypto_algs)); +crypto_unregister_skciphers (crypto_algs,ARRAY_SIZE (crypto_algs));crypto_engine_exit (cryp->engine);
Signature · 1 line
2.17.1
PATCH v4 22/29 crypto: niagara2 - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/n2_core.c | 194 ++++++++++---------- 1 file changed, 96 insertions(+), 98 deletions(-)
drivers/crypto/n2_core.c +96 -98
@@ -23,6 +23,7 @@#include <linux/sched.h> #include <crypto/internal/hash.h> +#include <crypto/internal/skcipher.h> #include <crypto/scatterwalk.h> #include <crypto/algapi.h>
@@ -657,7 +658,7 @@ static int n2_hmac_async_digest(struct ahash_request *req) ctx->hash_key_len); } -struct n2_cipher_context { +struct n2_skcipher_context {int key_len;int enc_type;union {
@@ -683,7 +684,7 @@ struct n2_crypto_chunk { };struct n2_request_context { -struct ablkcipher_walk walk; +struct skcipher_walk walk;struct list_head chunk_list;struct n2_crypto_chunk chunk;u8 temp_iv[16 ];
@@ -708,29 +709,29 @@ struct n2_request_context {* is not a valid sequence. */ -struct n2_cipher_alg { +struct n2_skcipher_alg {struct list_head entry;u8 enc_type; -struct crypto_alg alg; +struct skcipher_alg skcipher; }; -static inline struct n2_cipher_alg *n2_cipher_alg (struct crypto_tfm *tfm) +static inline struct n2_skcipher_alg *n2_skcipher_alg (struct crypto_skcipher *tfm) { -struct crypto_alg *alg = tfm->__crt_alg; +struct skcipher_alg *alg =crypto_skcipher_alg (tfm); - return container_of(alg, struct n2_cipher_alg, alg); + return container_of(alg, struct n2_skcipher_alg, skcipher); } -struct n2_cipher_request_context { -struct ablkcipher_walk walk; +struct n2_skcipher_request_context { +struct skcipher_walk walk; }; -static int n2_aes_setkey (struct crypto_ablkcipher *cipher,const u8 *key, +static int n2_aes_setkey (struct crypto_skcipher *skcipher,const u8 *key,unsigned int keylen) { -struct crypto_tfm *tfm =crypto_ablkcipher_tfm (cipher); -struct n2_cipher_context *ctx =crypto_tfm_ctx (tfm); -struct n2_cipher_alg *n2alg =n2_cipher_alg (tfm); +struct crypto_tfm *tfm =crypto_skcipher_tfm (skcipher); +struct n2_skcipher_context *ctx =crypto_tfm_ctx (tfm); +struct n2_skcipher_alg *n2alg =n2_skcipher_alg (skcipher); ctx->enc_type = (n2alg->enc_type &ENC_TYPE_CHAINING_MASK );
@@ -745,7 +746,7 @@ static int n2_aes_setkey(struct crypto_ablkcipher *cipher, const u8 *key, ctx->enc_type |=ENC_TYPE_ALG_AES256 ;break ;default : -crypto_ablkcipher_set_flags (cipher,CRYPTO_TFM_RES_BAD_KEY_LEN ); +crypto_skcipher_set_flags (skcipher,CRYPTO_TFM_RES_BAD_KEY_LEN );return -EINVAL ; }
@@ -754,15 +755,15 @@ static int n2_aes_setkey(struct crypto_ablkcipher *cipher, const u8 *key,return 0 ; } -static int n2_des_setkey (struct crypto_ablkcipher *cipher,const u8 *key, +static int n2_des_setkey (struct crypto_skcipher *skcipher,const u8 *key,unsigned int keylen) { -struct crypto_tfm *tfm =crypto_ablkcipher_tfm (cipher); -struct n2_cipher_context *ctx =crypto_tfm_ctx (tfm); -struct n2_cipher_alg *n2alg =n2_cipher_alg (tfm); +struct crypto_tfm *tfm =crypto_skcipher_tfm (skcipher); +struct n2_skcipher_context *ctx =crypto_tfm_ctx (tfm); +struct n2_skcipher_alg *n2alg =n2_skcipher_alg (skcipher);int err; - err =verify_ablkcipher_des_key (cipher, key); + err =verify_skcipher_des_key (skcipher, key);if (err)return err;
@@ -773,15 +774,15 @@ static int n2_des_setkey(struct crypto_ablkcipher *cipher, const u8 *key,return 0 ; } -static int n2_3des_setkey (struct crypto_ablkcipher *cipher,const u8 *key, +static int n2_3des_setkey (struct crypto_skcipher *skcipher,const u8 *key,unsigned int keylen) { -struct crypto_tfm *tfm =crypto_ablkcipher_tfm (cipher); -struct n2_cipher_context *ctx =crypto_tfm_ctx (tfm); -struct n2_cipher_alg *n2alg =n2_cipher_alg (tfm); +struct crypto_tfm *tfm =crypto_skcipher_tfm (skcipher); +struct n2_skcipher_context *ctx =crypto_tfm_ctx (tfm); +struct n2_skcipher_alg *n2alg =n2_skcipher_alg (skcipher);int err; - err =verify_ablkcipher_des3_key (cipher, key); + err =verify_skcipher_des3_key (skcipher, key);if (err)return err;
@@ -792,12 +793,12 @@ static int n2_3des_setkey(struct crypto_ablkcipher *cipher, const u8 *key,return 0 ; } -static int n2_arc4_setkey (struct crypto_ablkcipher *cipher,const u8 *key, +static int n2_arc4_setkey (struct crypto_skcipher *skcipher,const u8 *key,unsigned int keylen) { -struct crypto_tfm *tfm =crypto_ablkcipher_tfm (cipher); -struct n2_cipher_context *ctx =crypto_tfm_ctx (tfm); -struct n2_cipher_alg *n2alg =n2_cipher_alg (tfm); +struct crypto_tfm *tfm =crypto_skcipher_tfm (skcipher); +struct n2_skcipher_context *ctx =crypto_tfm_ctx (tfm); +struct n2_skcipher_alg *n2alg =n2_skcipher_alg (skcipher);u8 *s = ctx->key.arc4;u8 *x = s +256 ;u8 *y = x +1 ;
@@ -822,7 +823,7 @@ static int n2_arc4_setkey(struct crypto_ablkcipher *cipher, const u8 *key,return 0 ; } -static inline int cipher_descriptor_len (int nbytes,unsigned int block_size) +static inline int skcipher_descriptor_len (int nbytes,unsigned int block_size) {int this_len = nbytes;
@@ -830,10 +831,11 @@ static inline int cipher_descriptor_len(int nbytes, unsigned int block_size)return this_len > (1 <<16 ) ? (1 <<16 ) : this_len; } -static int __n2_crypt_chunk (struct crypto_tfm *tfm,struct n2_crypto_chunk *cp, +static int __n2_crypt_chunk (struct crypto_skcipher *skcipher, +struct n2_crypto_chunk *cp,struct spu_queue *qp,bool encrypt) { -struct n2_cipher_context *ctx =crypto_tfm_ctx (tfm); +struct n2_skcipher_context *ctx =crypto_skcipher_ctx (skcipher);struct cwq_initial_entry *ent;bool in_place;int i;
@@ -877,18 +879,17 @@ static int __n2_crypt_chunk(struct crypto_tfm *tfm, struct n2_crypto_chunk *cp,return (spu_queue_submit (qp, ent) !=HV_EOK ) ? -EINVAL :0 ; } -static int n2_compute_chunks (struct ablkcipher_request *req) +static int n2_compute_chunks (struct skcipher_request *req) { -struct n2_request_context *rctx =ablkcipher_request_ctx (req); -struct ablkcipher_walk *walk = &rctx->walk; +struct n2_request_context *rctx =skcipher_request_ctx (req); +struct skcipher_walk *walk = &rctx->walk;struct n2_crypto_chunk *chunk;unsigned long dest_prev;unsigned int tot_len;bool prev_in_place;int err, nbytes; -ablkcipher_walk_init (walk, req->dst, req->src, req->nbytes); - err =ablkcipher_walk_phys (req, walk); + err =skcipher_walk_async (walk, req);if (err)return err;
@@ -910,12 +911,12 @@ static int n2_compute_chunks(struct ablkcipher_request *req)bool in_place;int this_len; - src_paddr = (page_to_phys (walk->src.page) + - walk->src.offset); - dest_paddr = (page_to_phys (walk->dst.page) + - walk->dst.offset); + src_paddr = (page_to_phys (walk->src.phys.page) + + walk->src.phys.offset); + dest_paddr = (page_to_phys (walk->dst.phys.page) + + walk->dst.phys.offset); in_place = (src_paddr == dest_paddr); - this_len =cipher_descriptor_len (nbytes, walk->blocksize); + this_len =skcipher_descriptor_len (nbytes, walk->blocksize);if (chunk->arr_len !=0 ) { if (in_place != prev_in_place ||
@@ -946,7 +947,7 @@ static int n2_compute_chunks(struct ablkcipher_request *req) prev_in_place = in_place; tot_len += this_len; - err =ablkcipher_walk_done (req, walk, nbytes - this_len); + err =skcipher_walk_done (walk, nbytes - this_len);if (err)break ; }
@@ -958,15 +959,14 @@ static int n2_compute_chunks(struct ablkcipher_request *req)return err; } -static void n2_chunk_complete (struct ablkcipher_request *req,void *final_iv) +static void n2_chunk_complete (struct skcipher_request *req,void *final_iv) { -struct n2_request_context *rctx =ablkcipher_request_ctx (req); +struct n2_request_context *rctx =skcipher_request_ctx (req);struct n2_crypto_chunk *c, *tmp;if (final_iv)memcpy (rctx->walk.iv, final_iv, rctx->walk.blocksize); -ablkcipher_walk_complete (&rctx->walk);list_for_each_entry_safe (c, tmp, &rctx->chunk_list, entry) {list_del (&c->entry);if (unlikely (c != &rctx->chunk))
@@ -975,10 +975,10 @@ static void n2_chunk_complete(struct ablkcipher_request *req, void *final_iv) } -static int n2_do_ecb (struct ablkcipher_request *req,bool encrypt) +static int n2_do_ecb (struct skcipher_request *req,bool encrypt) { -struct n2_request_context *rctx =ablkcipher_request_ctx (req); -struct crypto_tfm *tfm = req->base.tfm; +struct n2_request_context *rctx =skcipher_request_ctx (req); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req);int err =n2_compute_chunks (req);struct n2_crypto_chunk *c, *tmp;unsigned long flags, hv_ret;
@@ -1017,20 +1017,20 @@ static int n2_do_ecb(struct ablkcipher_request *req, bool encrypt)return err; } -static int n2_encrypt_ecb (struct ablkcipher_request *req) +static int n2_encrypt_ecb (struct skcipher_request *req) {return n2_do_ecb (req, true); } -static int n2_decrypt_ecb (struct ablkcipher_request *req) +static int n2_decrypt_ecb (struct skcipher_request *req) {return n2_do_ecb (req, false); } -static int n2_do_chaining (struct ablkcipher_request *req,bool encrypt) +static int n2_do_chaining (struct skcipher_request *req,bool encrypt) { -struct n2_request_context *rctx =ablkcipher_request_ctx (req); -struct crypto_tfm *tfm = req->base.tfm; +struct n2_request_context *rctx =skcipher_request_ctx (req); +struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req);unsigned long flags, hv_ret, iv_paddr;int err =n2_compute_chunks (req);struct n2_crypto_chunk *c, *tmp;
@@ -1107,32 +1107,32 @@ static int n2_do_chaining(struct ablkcipher_request *req, bool encrypt)return err; } -static int n2_encrypt_chaining (struct ablkcipher_request *req) +static int n2_encrypt_chaining (struct skcipher_request *req) {return n2_do_chaining (req, true); } -static int n2_decrypt_chaining (struct ablkcipher_request *req) +static int n2_decrypt_chaining (struct skcipher_request *req) {return n2_do_chaining (req, false); } -struct n2_cipher_tmpl { +struct n2_skcipher_tmpl {const char *name;const char *drv_name;u8 block_size;u8 enc_type; -struct ablkcipher_alg ablkcipher; +struct skcipher_alg skcipher; }; -static const struct n2_cipher_tmpl cipher_tmpls[] = { +static const struct n2_skcipher_tmpl skcipher_tmpls[] = {/* ARC4: only ECB is supported (chaining bits ignored) */ { .name ="ecb(arc4)" , .drv_name ="ecb-arc4" , .block_size =1 , .enc_type = (ENC_TYPE_ALG_RC4_STREAM |ENC_TYPE_CHAINING_ECB ), - .ablkcipher = { + .skcipher = { .min_keysize =1 , .max_keysize =256 , .setkey = n2_arc4_setkey,
@@ -1147,7 +1147,7 @@ static const struct n2_cipher_tmpl cipher_tmpls[] = { .block_size = DES_BLOCK_SIZE, .enc_type = (ENC_TYPE_ALG_DES | ENC_TYPE_CHAINING_ECB), - .ablkcipher = { + .skcipher = { .min_keysize = DES_KEY_SIZE, .max_keysize = DES_KEY_SIZE, .setkey = n2_des_setkey,
@@ -1160,7 +1160,7 @@ static const struct n2_cipher_tmpl cipher_tmpls[] = { .block_size = DES_BLOCK_SIZE, .enc_type = (ENC_TYPE_ALG_DES | ENC_TYPE_CHAINING_CBC), - .ablkcipher = { + .skcipher = { .ivsize = DES_BLOCK_SIZE, .min_keysize = DES_KEY_SIZE, .max_keysize = DES_KEY_SIZE,
@@ -1174,7 +1174,7 @@ static const struct n2_cipher_tmpl cipher_tmpls[] = { .block_size = DES_BLOCK_SIZE, .enc_type = (ENC_TYPE_ALG_DES | ENC_TYPE_CHAINING_CFB), - .ablkcipher = { + .skcipher = { .min_keysize = DES_KEY_SIZE, .max_keysize = DES_KEY_SIZE, .setkey = n2_des_setkey,
@@ -1189,7 +1189,7 @@ static const struct n2_cipher_tmpl cipher_tmpls[] = { .block_size = DES_BLOCK_SIZE, .enc_type = (ENC_TYPE_ALG_3DES | ENC_TYPE_CHAINING_ECB), - .ablkcipher = { + .skcipher = { .min_keysize = 3 * DES_KEY_SIZE, .max_keysize = 3 * DES_KEY_SIZE, .setkey = n2_3des_setkey,
@@ -1202,7 +1202,7 @@ static const struct n2_cipher_tmpl cipher_tmpls[] = { .block_size = DES_BLOCK_SIZE, .enc_type = (ENC_TYPE_ALG_3DES | ENC_TYPE_CHAINING_CBC), - .ablkcipher = { + .skcipher = { .ivsize = DES_BLOCK_SIZE, .min_keysize = 3 * DES_KEY_SIZE, .max_keysize = 3 * DES_KEY_SIZE,
@@ -1216,7 +1216,7 @@ static const struct n2_cipher_tmpl cipher_tmpls[] = { .block_size = DES_BLOCK_SIZE, .enc_type = (ENC_TYPE_ALG_3DES | ENC_TYPE_CHAINING_CFB), - .ablkcipher = { + .skcipher = { .min_keysize = 3 * DES_KEY_SIZE, .max_keysize = 3 * DES_KEY_SIZE, .setkey = n2_3des_setkey,
@@ -1230,7 +1230,7 @@ static const struct n2_cipher_tmpl cipher_tmpls[] = { .block_size = AES_BLOCK_SIZE, .enc_type = (ENC_TYPE_ALG_AES128 | ENC_TYPE_CHAINING_ECB), - .ablkcipher = { + .skcipher = { .min_keysize = AES_MIN_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE, .setkey = n2_aes_setkey,
@@ -1243,7 +1243,7 @@ static const struct n2_cipher_tmpl cipher_tmpls[] = { .block_size = AES_BLOCK_SIZE, .enc_type = (ENC_TYPE_ALG_AES128 | ENC_TYPE_CHAINING_CBC), - .ablkcipher = { + .skcipher = { .ivsize = AES_BLOCK_SIZE, .min_keysize = AES_MIN_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE,
@@ -1257,7 +1257,7 @@ static const struct n2_cipher_tmpl cipher_tmpls[] = { .block_size = AES_BLOCK_SIZE, .enc_type = (ENC_TYPE_ALG_AES128 | ENC_TYPE_CHAINING_COUNTER), - .ablkcipher = { + .skcipher = { .ivsize = AES_BLOCK_SIZE, .min_keysize = AES_MIN_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE,
@@ -1268,9 +1268,9 @@ static const struct n2_cipher_tmpl cipher_tmpls[] = { }, }; -#define NUM_CIPHER_TMPLS ARRAY_SIZE(cipher_tmpls) +#define NUM_CIPHER_TMPLS ARRAY_SIZE(skcipher_tmpls) -static LIST_HEAD (cipher_algs); +static LIST_HEAD (skcipher_algs);struct n2_hash_tmpl {const char *name;
@@ -1344,14 +1344,14 @@ static int algs_registered;static void __n2_unregister_algs (void ) { -struct n2_cipher_alg *cipher, *cipher_tmp; +struct n2_skcipher_alg *skcipher, *skcipher_tmp;struct n2_ahash_alg *alg, *alg_tmp;struct n2_hmac_alg *hmac, *hmac_tmp; -list_for_each_entry_safe (cipher, cipher_tmp, &cipher_algs, entry) { -crypto_unregister_alg (&cipher->alg); -list_del (&cipher->entry); -kfree (cipher); +list_for_each_entry_safe (skcipher, skcipher_tmp, &skcipher_algs, entry) { +crypto_unregister_skcipher (&skcipher->skcipher); +list_del (&skcipher->entry); +kfree (skcipher); }list_for_each_entry_safe (hmac, hmac_tmp, &hmac_algs, derived.entry) {crypto_unregister_ahash (&hmac->derived.alg);
@@ -1365,44 +1365,42 @@ static void __n2_unregister_algs(void) } } -static int n2_cipher_cra_init (struct crypto_tfm *tfm) +static int n2_skcipher_init_tfm (struct crypto_skcipher *tfm) { - tfm->crt_ablkcipher.reqsize =sizeof (struct n2_request_context ); +crypto_skcipher_set_reqsize (tfm,sizeof (struct n2_request_context ));return 0 ; } -static int __n2_register_one_cipher (const struct n2_cipher_tmpl *tmpl) +static int __n2_register_one_skcipher (const struct n2_skcipher_tmpl *tmpl) { -struct n2_cipher_alg *p =kzalloc (sizeof (*p),GFP_KERNEL ); -struct crypto_alg *alg; +struct n2_skcipher_alg *p =kzalloc (sizeof (*p),GFP_KERNEL ); +struct skcipher_alg *alg;int err;if (!p)return -ENOMEM ; - alg = &p->alg; + alg = &p->skcipher; + *alg = tmpl->skcipher; -snprintf (alg->cra_name,CRYPTO_MAX_ALG_NAME ,"%s" , tmpl->name); -snprintf (alg->cra_driver_name,CRYPTO_MAX_ALG_NAME ,"%s-n2" , tmpl->drv_name); - alg->cra_priority =N2_CRA_PRIORITY ; - alg->cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_KERN_DRIVER_ONLY |CRYPTO_ALG_ASYNC ; - alg->cra_blocksize = tmpl->block_size; +snprintf (alg->base.cra_name,CRYPTO_MAX_ALG_NAME ,"%s" , tmpl->name); +snprintf (alg->base.cra_driver_name,CRYPTO_MAX_ALG_NAME ,"%s-n2" , tmpl->drv_name); + alg->base.cra_priority =N2_CRA_PRIORITY ; + alg->base.cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY |CRYPTO_ALG_ASYNC ; + alg->base.cra_blocksize = tmpl->block_size; p->enc_type = tmpl->enc_type; - alg->cra_ctxsize =sizeof (struct n2_cipher_context ); - alg->cra_type = &crypto_ablkcipher_type; - alg->cra_u.ablkcipher = tmpl->ablkcipher; - alg->cra_init = n2_cipher_cra_init; - alg->cra_module =THIS_MODULE ; - -list_add (&p->entry, &cipher_algs); - err =crypto_register_alg (alg); + alg->base.cra_ctxsize =sizeof (struct n2_skcipher_context ); + alg->base.cra_module =THIS_MODULE ; + alg->init = n2_skcipher_init_tfm; + +list_add (&p->entry, &skcipher_algs); + err =crypto_register_skcipher (alg);if (err) { -pr_err ("%s alg registration failed\n" , alg->cra_name); +pr_err ("%s alg registration failed\n" , alg->base.cra_name);list_del (&p->entry);kfree (p); }else { -pr_info ("%s alg registered\n" , alg->cra_name); +pr_info ("%s alg registered\n" , alg->base.cra_name); }return err; }
@@ -1517,7 +1515,7 @@ static int n2_register_algs(void) } }for (i =0 ; i <NUM_CIPHER_TMPLS ; i++) { - err =__n2_register_one_cipher (&cipher_tmpls[i]); + err =__n2_register_one_skcipher (&skcipher_tmpls[i]);if (err) {__n2_unregister_algs (); goto out;
Signature · 1 line
2.17.1
PATCH v4 23/29 crypto: rockchip - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/rockchip/Makefile | 2 +- drivers/crypto/rockchip/rk3288_crypto.c | 8 +- drivers/crypto/rockchip/rk3288_crypto.h | 3 +- drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c | 556 -------------------- drivers/crypto/rockchip/rk3288_crypto_skcipher.c | 538 +++++++++++++++++++ 5 files changed, 545 insertions(+), 562 deletions(-)
drivers/crypto/rockchip/Makefile +1 -1
@@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-only obj-$(CONFIG_CRYPTO_DEV_ROCKCHIP) += rk_crypto.o rk_crypto-objs := rk3288_crypto.o \ - rk3288_crypto_ablkcipher.o \ + rk3288_crypto_skcipher.o \ rk3288_crypto_ahash.o
drivers/crypto/rockchip/rk3288_crypto.c +4 -4
@@ -264,8 +264,8 @@ static int rk_crypto_register(struct rk_crypto_info *crypto_info)for (i =0 ; i <ARRAY_SIZE (rk_cipher_algs); i++) { rk_cipher_algs[i]->dev = crypto_info;if (rk_cipher_algs[i]->type ==ALG_TYPE_CIPHER ) - err =crypto_register_alg ( - &rk_cipher_algs[i]->alg.crypto); + err =crypto_register_skcipher ( + &rk_cipher_algs[i]->alg.skcipher);else err =crypto_register_ahash ( &rk_cipher_algs[i]->alg.hash);
@@ -277,7 +277,7 @@ static int rk_crypto_register(struct rk_crypto_info *crypto_info) err_cipher_algs:for (k =0 ; k < i; k++) {if (rk_cipher_algs[i]->type ==ALG_TYPE_CIPHER ) -crypto_unregister_alg (&rk_cipher_algs[k]->alg.crypto); +crypto_unregister_skcipher (&rk_cipher_algs[k]->alg.skcipher);else crypto_unregister_ahash (&rk_cipher_algs[i]->alg.hash); }
@@ -290,7 +290,7 @@ static void rk_crypto_unregister(void)for (i =0 ; i <ARRAY_SIZE (rk_cipher_algs); i++) {if (rk_cipher_algs[i]->type ==ALG_TYPE_CIPHER ) -crypto_unregister_alg (&rk_cipher_algs[i]->alg.crypto); +crypto_unregister_skcipher (&rk_cipher_algs[i]->alg.skcipher);else crypto_unregister_ahash (&rk_cipher_algs[i]->alg.hash); }
drivers/crypto/rockchip/rk3288_crypto.h +2 -1
@@ -8,6 +8,7 @@#include <linux/interrupt.h> #include <linux/delay.h> #include <crypto/internal/hash.h> +#include <crypto/internal/skcipher.h> #include <crypto/md5.h> #include <crypto/sha.h>
@@ -256,7 +257,7 @@ enum alg_type {struct rk_crypto_tmp {struct rk_crypto_info *dev;union { -struct crypto_alg crypto; +struct skcipher_alg skcipher;struct ahash_alg hash; } alg;enum alg_type type;
drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c deleted +0 -556
556 lines not on this page · raw message
drivers/crypto/rockchip/rk3288_crypto_skcipher.c new file +538 -0
538 lines not on this page · raw message
Signature · 1 line
2.17.1
PATCH v4 24/29 crypto: talitos - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/talitos.c | 308 +++++++++----------- 1 file changed, 143 insertions(+), 165 deletions(-)
drivers/crypto/talitos.c +143 -165
@@ -35,7 +35,7 @@#include <crypto/md5.h> #include <crypto/internal/aead.h> #include <crypto/authenc.h> -#include <crypto/skcipher.h> +#include <crypto/internal/skcipher.h> #include <crypto/hash.h> #include <crypto/internal/hash.h> #include <crypto/scatterwalk.h>
@@ -1490,10 +1490,10 @@ static int aead_decrypt(struct aead_request *req)return ipsec_esp (edesc, req, false, ipsec_esp_decrypt_swauth_done); } -static int ablkcipher_setkey (struct crypto_ablkcipher *cipher, +static int skcipher_setkey (struct crypto_skcipher *cipher,const u8 *key,unsigned int keylen) { -struct talitos_ctx *ctx =crypto_ablkcipher_ctx (cipher); +struct talitos_ctx *ctx =crypto_skcipher_ctx (cipher);struct device *dev = ctx->dev;if (ctx->keylen)
@@ -1507,39 +1507,39 @@ static int ablkcipher_setkey(struct crypto_ablkcipher *cipher,return 0 ; } -static int ablkcipher_des_setkey (struct crypto_ablkcipher *cipher, +static int skcipher_des_setkey (struct crypto_skcipher *cipher,const u8 *key,unsigned int keylen) { -return verify_ablkcipher_des_key (cipher, key) ?: -ablkcipher_setkey (cipher, key, keylen); +return verify_skcipher_des_key (cipher, key) ?: +skcipher_setkey (cipher, key, keylen); } -static int ablkcipher_des3_setkey (struct crypto_ablkcipher *cipher, +static int skcipher_des3_setkey (struct crypto_skcipher *cipher,const u8 *key,unsigned int keylen) { -return verify_ablkcipher_des3_key (cipher, key) ?: -ablkcipher_setkey (cipher, key, keylen); +return verify_skcipher_des3_key (cipher, key) ?: +skcipher_setkey (cipher, key, keylen); } -static int ablkcipher_aes_setkey (struct crypto_ablkcipher *cipher, +static int skcipher_aes_setkey (struct crypto_skcipher *cipher,const u8 *key,unsigned int keylen) {if (keylen ==AES_KEYSIZE_128 || keylen ==AES_KEYSIZE_192 || keylen ==AES_KEYSIZE_256 ) -return ablkcipher_setkey (cipher, key, keylen); +return skcipher_setkey (cipher, key, keylen); -crypto_ablkcipher_set_flags (cipher,CRYPTO_TFM_RES_BAD_KEY_LEN ); +crypto_skcipher_set_flags (cipher,CRYPTO_TFM_RES_BAD_KEY_LEN );return -EINVAL ; }static void common_nonsnoop_unmap (struct device *dev,struct talitos_edesc *edesc, -struct ablkcipher_request *areq) +struct skcipher_request *areq) {unmap_single_talitos_ptr (dev, &edesc->desc.ptr[5 ],DMA_FROM_DEVICE ); -talitos_sg_unmap (dev, edesc, areq->src, areq->dst, areq->nbytes,0 ); +talitos_sg_unmap (dev, edesc, areq->src, areq->dst, areq->cryptlen,0 );unmap_single_talitos_ptr (dev, &edesc->desc.ptr[1 ],DMA_TO_DEVICE );if (edesc->dma_len)
@@ -1547,20 +1547,20 @@ static void common_nonsnoop_unmap(struct device *dev, DMA_BIDIRECTIONAL); } -static void ablkcipher_done (struct device *dev, +static void skcipher_done (struct device *dev,struct talitos_desc *desc,void *context,int err) { -struct ablkcipher_request *areq = context; -struct crypto_ablkcipher *cipher =crypto_ablkcipher_reqtfm (areq); -struct talitos_ctx *ctx =crypto_ablkcipher_ctx (cipher); -unsigned int ivsize =crypto_ablkcipher_ivsize (cipher); +struct skcipher_request *areq = context; +struct crypto_skcipher *cipher =crypto_skcipher_reqtfm (areq); +struct talitos_ctx *ctx =crypto_skcipher_ctx (cipher); +unsigned int ivsize =crypto_skcipher_ivsize (cipher);struct talitos_edesc *edesc; edesc = container_of(desc, struct talitos_edesc, desc);common_nonsnoop_unmap (dev, edesc, areq); -memcpy (areq->info, ctx->iv, ivsize); +memcpy (areq->iv, ctx->iv, ivsize);kfree (edesc);
@@ -1568,17 +1568,17 @@ static void ablkcipher_done(struct device *dev, }static int common_nonsnoop (struct talitos_edesc *edesc, -struct ablkcipher_request *areq, +struct skcipher_request *areq,void (*callback) (struct device *dev,struct talitos_desc *desc,void *context,int error)) { -struct crypto_ablkcipher *cipher =crypto_ablkcipher_reqtfm (areq); -struct talitos_ctx *ctx =crypto_ablkcipher_ctx (cipher); +struct crypto_skcipher *cipher =crypto_skcipher_reqtfm (areq); +struct talitos_ctx *ctx =crypto_skcipher_ctx (cipher);struct device *dev = ctx->dev;struct talitos_desc *desc = &edesc->desc; -unsigned int cryptlen = areq->nbytes; -unsigned int ivsize =crypto_ablkcipher_ivsize (cipher); +unsigned int cryptlen = areq->cryptlen; +unsigned int ivsize =crypto_skcipher_ivsize (cipher);int sg_count, ret;bool sync_needed = false;struct talitos_private *priv =dev_get_drvdata (dev);
@@ -1638,65 +1638,65 @@ static int common_nonsnoop(struct talitos_edesc *edesc,return ret; } -static struct talitos_edesc *ablkcipher_edesc_alloc (struct ablkcipher_request * +static struct talitos_edesc *skcipher_edesc_alloc (struct skcipher_request * areq,bool encrypt) { -struct crypto_ablkcipher *cipher =crypto_ablkcipher_reqtfm (areq); -struct talitos_ctx *ctx =crypto_ablkcipher_ctx (cipher); -unsigned int ivsize =crypto_ablkcipher_ivsize (cipher); +struct crypto_skcipher *cipher =crypto_skcipher_reqtfm (areq); +struct talitos_ctx *ctx =crypto_skcipher_ctx (cipher); +unsigned int ivsize =crypto_skcipher_ivsize (cipher);return talitos_edesc_alloc (ctx->dev, areq->src, areq->dst, - areq->info,0 , areq->nbytes,0 , ivsize,0 , + areq->iv,0 , areq->cryptlen,0 , ivsize,0 , areq->base.flags, encrypt); } -static int ablkcipher_encrypt (struct ablkcipher_request *areq) +static int skcipher_encrypt (struct skcipher_request *areq) { -struct crypto_ablkcipher *cipher =crypto_ablkcipher_reqtfm (areq); -struct talitos_ctx *ctx =crypto_ablkcipher_ctx (cipher); +struct crypto_skcipher *cipher =crypto_skcipher_reqtfm (areq); +struct talitos_ctx *ctx =crypto_skcipher_ctx (cipher);struct talitos_edesc *edesc;unsigned int blocksize = -crypto_tfm_alg_blocksize (crypto_ablkcipher_tfm (cipher)); +crypto_tfm_alg_blocksize (crypto_skcipher_tfm (cipher)); -if (!areq->nbytes) +if (!areq->cryptlen)return 0 ; -if (areq->nbytes % blocksize) +if (areq->cryptlen % blocksize)return -EINVAL ;/* allocate extended descriptor */ - edesc =ablkcipher_edesc_alloc (areq, true); + edesc =skcipher_edesc_alloc (areq, true);if (IS_ERR (edesc))return PTR_ERR (edesc);/* set encrypt */ edesc->desc.hdr = ctx->desc_hdr_template |DESC_HDR_MODE0_ENCRYPT ; -return common_nonsnoop (edesc, areq, ablkcipher_done); +return common_nonsnoop (edesc, areq, skcipher_done); } -static int ablkcipher_decrypt (struct ablkcipher_request *areq) +static int skcipher_decrypt (struct skcipher_request *areq) { -struct crypto_ablkcipher *cipher =crypto_ablkcipher_reqtfm (areq); -struct talitos_ctx *ctx =crypto_ablkcipher_ctx (cipher); +struct crypto_skcipher *cipher =crypto_skcipher_reqtfm (areq); +struct talitos_ctx *ctx =crypto_skcipher_ctx (cipher);struct talitos_edesc *edesc;unsigned int blocksize = -crypto_tfm_alg_blocksize (crypto_ablkcipher_tfm (cipher)); +crypto_tfm_alg_blocksize (crypto_skcipher_tfm (cipher)); -if (!areq->nbytes) +if (!areq->cryptlen)return 0 ; -if (areq->nbytes % blocksize) +if (areq->cryptlen % blocksize)return -EINVAL ;/* allocate extended descriptor */ - edesc =ablkcipher_edesc_alloc (areq, false); + edesc =skcipher_edesc_alloc (areq, false);if (IS_ERR (edesc))return PTR_ERR (edesc); edesc->desc.hdr = ctx->desc_hdr_template |DESC_HDR_DIR_INBOUND ; -return common_nonsnoop (edesc, areq, ablkcipher_done); +return common_nonsnoop (edesc, areq, skcipher_done); } static void common_nonsnoop_hash_unmap(struct device *dev,
@@ -2257,7 +2257,7 @@ struct talitos_alg_template {u32 type;u32 priority;union { -struct crypto_alg crypto; +struct skcipher_alg skcipher;struct ahash_alg hash;struct aead_alg aead; } alg;
@@ -2702,123 +2702,102 @@ static struct talitos_alg_template driver_algs[] = {DESC_HDR_MODE1_MDEU_PAD |DESC_HDR_MODE1_MDEU_MD5_HMAC , }, - /* ABLKCIPHER algorithms. */ - { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, - .alg.crypto = { - .cra_name ="ecb(aes)" , - .cra_driver_name = "ecb-aes-talitos", - .cra_blocksize = AES_BLOCK_SIZE, - .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize = AES_MAX_KEY_SIZE, - .setkey = ablkcipher_aes_setkey, - } + /* SKCIPHER algorithms. */ + { .type = CRYPTO_ALG_TYPE_SKCIPHER, + .alg.skcipher = { + .base.cra_name ="ecb(aes)" , + .base.cra_driver_name = "ecb-aes-talitos", + .base.cra_blocksize = AES_BLOCK_SIZE, + .base.cra_flags = CRYPTO_ALG_ASYNC, + .min_keysize = AES_MIN_KEY_SIZE, + .max_keysize = AES_MAX_KEY_SIZE, + .setkey = skcipher_aes_setkey, }, .desc_hdr_template =DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU |DESC_HDR_SEL0_AESU , }, - { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, - .alg.crypto = { - .cra_name ="cbc(aes)" , - .cra_driver_name = "cbc-aes-talitos", - .cra_blocksize = AES_BLOCK_SIZE, - .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize = AES_MAX_KEY_SIZE, - .ivsize = AES_BLOCK_SIZE, - .setkey = ablkcipher_aes_setkey, - } + { .type = CRYPTO_ALG_TYPE_SKCIPHER, + .alg.skcipher = { + .base.cra_name ="cbc(aes)" , + .base.cra_driver_name = "cbc-aes-talitos", + .base.cra_blocksize = AES_BLOCK_SIZE, + .base.cra_flags = CRYPTO_ALG_ASYNC, + .min_keysize = AES_MIN_KEY_SIZE, + .max_keysize = AES_MAX_KEY_SIZE, + .ivsize = AES_BLOCK_SIZE, + .setkey = skcipher_aes_setkey, }, .desc_hdr_template =DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU |DESC_HDR_SEL0_AESU |DESC_HDR_MODE0_AESU_CBC , }, - { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, - .alg.crypto = { - .cra_name ="ctr(aes)" , - .cra_driver_name = "ctr-aes-talitos", - .cra_blocksize = 1, - .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_ablkcipher = { - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize = AES_MAX_KEY_SIZE, - .ivsize = AES_BLOCK_SIZE, - .setkey = ablkcipher_aes_setkey, - } + { .type = CRYPTO_ALG_TYPE_SKCIPHER, + .alg.skcipher = { + .base.cra_name ="ctr(aes)" , + .base.cra_driver_name = "ctr-aes-talitos", + .base.cra_blocksize = 1, + .base.cra_flags = CRYPTO_ALG_ASYNC, + .min_keysize = AES_MIN_KEY_SIZE, + .max_keysize = AES_MAX_KEY_SIZE, + .ivsize = AES_BLOCK_SIZE, + .setkey = skcipher_aes_setkey, }, .desc_hdr_template =DESC_HDR_TYPE_AESU_CTR_NONSNOOP |DESC_HDR_SEL0_AESU |DESC_HDR_MODE0_AESU_CTR , }, - { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, - .alg.crypto = { - .cra_name ="ecb(des)" , - .cra_driver_name = "ecb-des-talitos", - .cra_blocksize = DES_BLOCK_SIZE, - .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_ablkcipher = { - .min_keysize =DES_KEY_SIZE , - .max_keysize = DES_KEY_SIZE, - .setkey = ablkcipher_des_setkey, - } + { .type = CRYPTO_ALG_TYPE_SKCIPHER, + .alg.skcipher = { + .base.cra_name ="ecb(des)" , + .base.cra_driver_name = "ecb-des-talitos", + .base.cra_blocksize = DES_BLOCK_SIZE, + .base.cra_flags = CRYPTO_ALG_ASYNC, + .min_keysize = DES_KEY_SIZE, + .max_keysize = DES_KEY_SIZE, + .setkey = skcipher_des_setkey, }, .desc_hdr_template =DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU |DESC_HDR_SEL0_DEU , }, - { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, - .alg.crypto = { - .cra_name ="cbc(des)" , - .cra_driver_name = "cbc-des-talitos", - .cra_blocksize = DES_BLOCK_SIZE, - .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_ablkcipher = { - .min_keysize =DES_KEY_SIZE , - .max_keysize = DES_KEY_SIZE, - .ivsize = DES_BLOCK_SIZE, - .setkey = ablkcipher_des_setkey, - } + { .type = CRYPTO_ALG_TYPE_SKCIPHER, + .alg.skcipher = { + .base.cra_name ="cbc(des)" , + .base.cra_driver_name = "cbc-des-talitos", + .base.cra_blocksize = DES_BLOCK_SIZE, + .base.cra_flags = CRYPTO_ALG_ASYNC, + .min_keysize = DES_KEY_SIZE, + .max_keysize = DES_KEY_SIZE, + .ivsize = DES_BLOCK_SIZE, + .setkey = skcipher_des_setkey, }, .desc_hdr_template =DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU |DESC_HDR_SEL0_DEU |DESC_HDR_MODE0_DEU_CBC , }, - { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, - .alg.crypto = { - .cra_name ="ecb(des3_ede)" , - .cra_driver_name = "ecb-3des-talitos", - .cra_blocksize = DES3_EDE_BLOCK_SIZE, - .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_ablkcipher = { - .min_keysize =DES3_EDE_KEY_SIZE , - .max_keysize = DES3_EDE_KEY_SIZE, - .setkey = ablkcipher_des3_setkey, - } + { .type = CRYPTO_ALG_TYPE_SKCIPHER, + .alg.skcipher = { + .base.cra_name ="ecb(des3_ede)" , + .base.cra_driver_name = "ecb-3des-talitos", + .base.cra_blocksize = DES3_EDE_BLOCK_SIZE, + .base.cra_flags = CRYPTO_ALG_ASYNC, + .min_keysize = DES3_EDE_KEY_SIZE, + .max_keysize = DES3_EDE_KEY_SIZE, + .setkey = skcipher_des3_setkey, }, .desc_hdr_template =DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU |DESC_HDR_SEL0_DEU |DESC_HDR_MODE0_DEU_3DES , }, - { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, - .alg.crypto = { - .cra_name ="cbc(des3_ede)" , - .cra_driver_name = "cbc-3des-talitos", - .cra_blocksize = DES3_EDE_BLOCK_SIZE, - .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | -CRYPTO_ALG_ASYNC , - .cra_ablkcipher = { - .min_keysize =DES3_EDE_KEY_SIZE , - .max_keysize = DES3_EDE_KEY_SIZE, - .ivsize = DES3_EDE_BLOCK_SIZE, - .setkey = ablkcipher_des3_setkey, - } + { .type = CRYPTO_ALG_TYPE_SKCIPHER, + .alg.skcipher = { + .base.cra_name ="cbc(des3_ede)" , + .base.cra_driver_name = "cbc-3des-talitos", + .base.cra_blocksize = DES3_EDE_BLOCK_SIZE, + .base.cra_flags = CRYPTO_ALG_ASYNC, + .min_keysize = DES3_EDE_KEY_SIZE, + .max_keysize = DES3_EDE_KEY_SIZE, + .ivsize = DES3_EDE_BLOCK_SIZE, + .setkey = skcipher_des3_setkey, }, .desc_hdr_template =DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | DESC_HDR_SEL0_DEU |
@@ -3036,46 +3015,45 @@ static int talitos_init_common(struct talitos_ctx *ctx,return 0 ; } -static int talitos_cra_init (struct crypto_tfm *tfm) +static int talitos_cra_init_aead (struct crypto_aead *tfm) { -struct crypto_alg *alg = tfm->__crt_alg; +struct aead_alg *alg =crypto_aead_alg (tfm);struct talitos_crypto_alg *talitos_alg; -struct talitos_ctx *ctx =crypto_tfm_ctx (tfm); +struct talitos_ctx *ctx =crypto_aead_ctx (tfm); -if ((alg->cra_flags &CRYPTO_ALG_TYPE_MASK ) ==CRYPTO_ALG_TYPE_AHASH ) - talitos_alg =container_of (__crypto_ahash_alg (alg), - struct talitos_crypto_alg, - algt.alg.hash); -else - talitos_alg = container_of(alg, struct talitos_crypto_alg, - algt.alg.crypto); + talitos_alg = container_of(alg, struct talitos_crypto_alg, + algt.alg.aead);return talitos_init_common (ctx, talitos_alg); } -static int talitos_cra_init_aead (struct crypto_aead *tfm) +static int talitos_cra_init_skcipher (struct crypto_skcipher *tfm) { -struct aead_alg *alg =crypto_aead_alg (tfm); +struct skcipher_alg *alg =crypto_skcipher_alg (tfm);struct talitos_crypto_alg *talitos_alg; -struct talitos_ctx *ctx =crypto_aead_ctx (tfm); +struct talitos_ctx *ctx =crypto_skcipher_ctx (tfm); talitos_alg = container_of(alg, struct talitos_crypto_alg, - algt.alg.aead); + algt.alg.skcipher);return talitos_init_common (ctx, talitos_alg); }static int talitos_cra_init_ahash (struct crypto_tfm *tfm) { +struct crypto_alg *alg = tfm->__crt_alg; +struct talitos_crypto_alg *talitos_alg;struct talitos_ctx *ctx =crypto_tfm_ctx (tfm); -talitos_cra_init (tfm); + talitos_alg =container_of (__crypto_ahash_alg (alg), + struct talitos_crypto_alg, + algt.alg.hash); ctx->keylen =0 ;crypto_ahash_set_reqsize (__crypto_ahash_cast (tfm),sizeof (struct talitos_ahash_req_ctx )); -return 0 ; +return talitos_init_common (ctx, talitos_alg); }static void talitos_cra_exit (struct crypto_tfm *tfm)
@@ -3116,7 +3094,8 @@ static int talitos_remove(struct platform_device *ofdev)list_for_each_entry_safe (t_alg, n, &priv->alg_list, entry) {switch (t_alg->algt.type) { -case CRYPTO_ALG_TYPE_ABLKCIPHER : +case CRYPTO_ALG_TYPE_SKCIPHER : +crypto_unregister_skcipher (&t_alg->algt.alg.skcipher);break ;case CRYPTO_ALG_TYPE_AEAD :crypto_unregister_aead (&t_alg->algt.alg.aead);
@@ -3160,15 +3139,14 @@ static struct talitos_crypto_alg *talitos_alg_alloc(struct device *dev, t_alg->algt = *template;switch (t_alg->algt.type) { -case CRYPTO_ALG_TYPE_ABLKCIPHER : - alg = &t_alg->algt.alg.crypto; - alg->cra_init = talitos_cra_init; +case CRYPTO_ALG_TYPE_SKCIPHER : + alg = &t_alg->algt.alg.skcipher.base; alg->cra_exit = talitos_cra_exit; - alg->cra_type = &crypto_ablkcipher_type; - alg->cra_ablkcipher.setkey = alg->cra_ablkcipher.setkey ?: - ablkcipher_setkey; - alg->cra_ablkcipher.encrypt = ablkcipher_encrypt; - alg->cra_ablkcipher.decrypt = ablkcipher_decrypt; + t_alg->algt.alg.skcipher.init = talitos_cra_init_skcipher; + t_alg->algt.alg.skcipher.setkey = + t_alg->algt.alg.skcipher.setkey ?: skcipher_setkey; + t_alg->algt.alg.skcipher.encrypt = skcipher_encrypt; + t_alg->algt.alg.skcipher.decrypt = skcipher_decrypt;break ;case CRYPTO_ALG_TYPE_AEAD : alg = &t_alg->algt.alg.aead.base;
@@ -3465,10 +3443,10 @@ static int talitos_probe(struct platform_device *ofdev) }switch (t_alg->algt.type) { -case CRYPTO_ALG_TYPE_ABLKCIPHER : - err =crypto_register_alg ( - &t_alg->algt.alg.crypto); - alg = &t_alg->algt.alg.crypto; +case CRYPTO_ALG_TYPE_SKCIPHER : + err =crypto_register_skcipher ( + &t_alg->algt.alg.skcipher); + alg = &t_alg->algt.alg.skcipher.base;break ;case CRYPTO_ALG_TYPE_AEAD :
Signature · 1 line
2.17.1
PATCH v4 25/29 crypto: qat - switch to skcipher API
In reply to Ard BiesheuvelCommit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API.
So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future.
--- drivers/crypto/qat/qat_common/qat_algs.c | 304 ++++++++++---------- drivers/crypto/qat/qat_common/qat_crypto.h | 4 +- 2 files changed, 146 insertions(+), 162 deletions(-)
drivers/crypto/qat/qat_common/qat_algs.c +144 -160
@@ -48,6 +48,7 @@#include <linux/slab.h> #include <linux/crypto.h> #include <crypto/internal/aead.h> +#include <crypto/internal/skcipher.h> #include <crypto/aes.h> #include <crypto/sha.h> #include <crypto/hash.h>
@@ -122,7 +123,7 @@ struct qat_alg_aead_ctx {char opad[SHA512_BLOCK_SIZE ]; }; -struct qat_alg_ablkcipher_ctx { +struct qat_alg_skcipher_ctx {struct icp_qat_hw_cipher_algo_blk *enc_cd;struct icp_qat_hw_cipher_algo_blk *dec_cd;dma_addr_t enc_cd_paddr;
@@ -130,7 +131,7 @@ struct qat_alg_ablkcipher_ctx {struct icp_qat_fw_la_bulk_req enc_fw_req;struct icp_qat_fw_la_bulk_req dec_fw_req;struct qat_crypto_instance *inst; -struct crypto_tfm *tfm; +struct crypto_skcipher *tfm; };static int qat_get_inter_state_size (enum icp_qat_hw_auth_algo qat_hash_alg)
@@ -463,10 +464,10 @@ static int qat_alg_aead_init_dec_session(struct crypto_aead *aead_tfm,return 0 ; } -static void qat_alg_ablkcipher_init_com (struct qat_alg_ablkcipher_ctx *ctx, -struct icp_qat_fw_la_bulk_req *req, -struct icp_qat_hw_cipher_algo_blk *cd, -const uint8_t *key,unsigned int keylen) +static void qat_alg_skcipher_init_com (struct qat_alg_skcipher_ctx *ctx, +struct icp_qat_fw_la_bulk_req *req, +struct icp_qat_hw_cipher_algo_blk *cd, +const uint8_t *key,unsigned int keylen) {struct icp_qat_fw_comn_req_hdr_cd_pars *cd_pars = &req->cd_pars;struct icp_qat_fw_comn_req_hdr *header = &req->comn_hdr;
@@ -485,28 +486,28 @@ static void qat_alg_ablkcipher_init_com(struct qat_alg_ablkcipher_ctx *ctx,ICP_QAT_FW_COMN_NEXT_ID_SET (cd_ctrl,ICP_QAT_FW_SLICE_DRAM_WR ); } -static void qat_alg_ablkcipher_init_enc (struct qat_alg_ablkcipher_ctx *ctx, -int alg,const uint8_t *key, -unsigned int keylen,int mode) +static void qat_alg_skcipher_init_enc (struct qat_alg_skcipher_ctx *ctx, +int alg,const uint8_t *key, +unsigned int keylen,int mode) {struct icp_qat_hw_cipher_algo_blk *enc_cd = ctx->enc_cd;struct icp_qat_fw_la_bulk_req *req = &ctx->enc_fw_req;struct icp_qat_fw_comn_req_hdr_cd_pars *cd_pars = &req->cd_pars; -qat_alg_ablkcipher_init_com (ctx, req, enc_cd, key, keylen); +qat_alg_skcipher_init_com (ctx, req, enc_cd, key, keylen); cd_pars->u.s.content_desc_addr = ctx->enc_cd_paddr; enc_cd->aes.cipher_config.val =QAT_AES_HW_CONFIG_ENC (alg, mode); } -static void qat_alg_ablkcipher_init_dec (struct qat_alg_ablkcipher_ctx *ctx, -int alg,const uint8_t *key, -unsigned int keylen,int mode) +static void qat_alg_skcipher_init_dec (struct qat_alg_skcipher_ctx *ctx, +int alg,const uint8_t *key, +unsigned int keylen,int mode) {struct icp_qat_hw_cipher_algo_blk *dec_cd = ctx->dec_cd;struct icp_qat_fw_la_bulk_req *req = &ctx->dec_fw_req;struct icp_qat_fw_comn_req_hdr_cd_pars *cd_pars = &req->cd_pars; -qat_alg_ablkcipher_init_com (ctx, req, dec_cd, key, keylen); +qat_alg_skcipher_init_com (ctx, req, dec_cd, key, keylen); cd_pars->u.s.content_desc_addr = ctx->dec_cd_paddr;if (mode !=ICP_QAT_HW_CIPHER_CTR_MODE )
@@ -577,21 +578,21 @@ static int qat_alg_aead_init_sessions(struct crypto_aead *tfm, const u8 *key,return -EFAULT ; } -static int qat_alg_ablkcipher_init_sessions (struct qat_alg_ablkcipher_ctx *ctx, -const uint8_t *key, -unsigned int keylen, -int mode) +static int qat_alg_skcipher_init_sessions (struct qat_alg_skcipher_ctx *ctx, +const uint8_t *key, +unsigned int keylen, +int mode) {int alg;if (qat_alg_validate_key (keylen, &alg, mode)) goto bad_key; -qat_alg_ablkcipher_init_enc (ctx, alg, key, keylen, mode); -qat_alg_ablkcipher_init_dec (ctx, alg, key, keylen, mode); +qat_alg_skcipher_init_enc (ctx, alg, key, keylen, mode); +qat_alg_skcipher_init_dec (ctx, alg, key, keylen, mode);return 0 ; bad_key: -crypto_tfm_set_flags (ctx->tfm,CRYPTO_TFM_RES_BAD_KEY_LEN ); +crypto_skcipher_set_flags (ctx->tfm,CRYPTO_TFM_RES_BAD_KEY_LEN );return -EINVAL ; }
@@ -832,12 +833,12 @@ static void qat_aead_alg_callback(struct icp_qat_fw_la_resp *qat_resp, areq->base.complete (&areq->base, res); } -static void qat_ablkcipher_alg_callback (struct icp_qat_fw_la_resp *qat_resp, -struct qat_crypto_request *qat_req) +static void qat_skcipher_alg_callback (struct icp_qat_fw_la_resp *qat_resp, +struct qat_crypto_request *qat_req) { -struct qat_alg_ablkcipher_ctx *ctx = qat_req->ablkcipher_ctx; +struct qat_alg_skcipher_ctx *ctx = qat_req->skcipher_ctx;struct qat_crypto_instance *inst = ctx->inst; -struct ablkcipher_request *areq = qat_req->ablkcipher_req; +struct skcipher_request *sreq = qat_req->skcipher_req;uint8_t stat_filed = qat_resp->comn_resp.comn_status;struct device *dev = &GET_DEV (ctx->inst->accel_dev);int res =0 , qat_res =ICP_QAT_FW_COMN_RESP_CRYPTO_STAT_GET (stat_filed);
@@ -846,11 +847,11 @@ static void qat_ablkcipher_alg_callback(struct icp_qat_fw_la_resp *qat_resp,if (unlikely (qat_res !=ICP_QAT_FW_COMN_STATUS_FLAG_OK )) res = -EINVAL ; -memcpy (areq->info, qat_req->iv,AES_BLOCK_SIZE ); +memcpy (sreq->iv, qat_req->iv,AES_BLOCK_SIZE );dma_free_coherent (dev,AES_BLOCK_SIZE , qat_req->iv, qat_req->iv_paddr); - areq->base.complete (&areq->base, res); + sreq->base.complete (&sreq->base, res); }void qat_alg_callback (void *resp)
@@ -949,21 +950,21 @@ static int qat_alg_aead_enc(struct aead_request *areq)return -EINPROGRESS ; } -static int qat_alg_ablkcipher_rekey (struct qat_alg_ablkcipher_ctx *ctx, -const u8 *key,unsigned int keylen, -int mode) +static int qat_alg_skcipher_rekey (struct qat_alg_skcipher_ctx *ctx, +const u8 *key,unsigned int keylen, +int mode) {memset (ctx->enc_cd,0 ,sizeof (*ctx->enc_cd));memset (ctx->dec_cd,0 ,sizeof (*ctx->dec_cd));memset (&ctx->enc_fw_req,0 ,sizeof (ctx->enc_fw_req));memset (&ctx->dec_fw_req,0 ,sizeof (ctx->dec_fw_req)); -return qat_alg_ablkcipher_init_sessions (ctx, key, keylen, mode); +return qat_alg_skcipher_init_sessions (ctx, key, keylen, mode); } -static int qat_alg_ablkcipher_newkey (struct qat_alg_ablkcipher_ctx *ctx, -const u8 *key,unsigned int keylen, -int mode) +static int qat_alg_skcipher_newkey (struct qat_alg_skcipher_ctx *ctx, +const u8 *key,unsigned int keylen, +int mode) {struct qat_crypto_instance *inst =NULL ;struct device *dev;
@@ -990,7 +991,7 @@ static int qat_alg_ablkcipher_newkey(struct qat_alg_ablkcipher_ctx *ctx, goto out_free_enc; } - ret =qat_alg_ablkcipher_init_sessions (ctx, key, keylen, mode); + ret =qat_alg_skcipher_init_sessions (ctx, key, keylen, mode);if (ret) goto out_free_all;
@@ -1012,51 +1013,51 @@ static int qat_alg_ablkcipher_newkey(struct qat_alg_ablkcipher_ctx *ctx,return ret; } -static int qat_alg_ablkcipher_setkey (struct crypto_ablkcipher *tfm, -const u8 *key,unsigned int keylen, -int mode) +static int qat_alg_skcipher_setkey (struct crypto_skcipher *tfm, +const u8 *key,unsigned int keylen, +int mode) { -struct qat_alg_ablkcipher_ctx *ctx =crypto_ablkcipher_ctx (tfm); +struct qat_alg_skcipher_ctx *ctx =crypto_skcipher_ctx (tfm);if (ctx->enc_cd) -return qat_alg_ablkcipher_rekey (ctx, key, keylen, mode); +return qat_alg_skcipher_rekey (ctx, key, keylen, mode);else -return qat_alg_ablkcipher_newkey (ctx, key, keylen, mode); +return qat_alg_skcipher_newkey (ctx, key, keylen, mode); } -static int qat_alg_ablkcipher_cbc_setkey (struct crypto_ablkcipher *tfm, -const u8 *key,unsigned int keylen) +static int qat_alg_skcipher_cbc_setkey (struct crypto_skcipher *tfm, +const u8 *key,unsigned int keylen) { -return qat_alg_ablkcipher_setkey (tfm, key, keylen, -ICP_QAT_HW_CIPHER_CBC_MODE ); +return qat_alg_skcipher_setkey (tfm, key, keylen, +ICP_QAT_HW_CIPHER_CBC_MODE ); } -static int qat_alg_ablkcipher_ctr_setkey (struct crypto_ablkcipher *tfm, -const u8 *key,unsigned int keylen) +static int qat_alg_skcipher_ctr_setkey (struct crypto_skcipher *tfm, +const u8 *key,unsigned int keylen) { -return qat_alg_ablkcipher_setkey (tfm, key, keylen, -ICP_QAT_HW_CIPHER_CTR_MODE ); +return qat_alg_skcipher_setkey (tfm, key, keylen, +ICP_QAT_HW_CIPHER_CTR_MODE ); } -static int qat_alg_ablkcipher_xts_setkey (struct crypto_ablkcipher *tfm, -const u8 *key,unsigned int keylen) +static int qat_alg_skcipher_xts_setkey (struct crypto_skcipher *tfm, +const u8 *key,unsigned int keylen) { -return qat_alg_ablkcipher_setkey (tfm, key, keylen, -ICP_QAT_HW_CIPHER_XTS_MODE ); +return qat_alg_skcipher_setkey (tfm, key, keylen, +ICP_QAT_HW_CIPHER_XTS_MODE ); } -static int qat_alg_ablkcipher_encrypt (struct ablkcipher_request *req) +static int qat_alg_skcipher_encrypt (struct skcipher_request *req) { -struct crypto_ablkcipher *atfm =crypto_ablkcipher_reqtfm (req); -struct crypto_tfm *tfm =crypto_ablkcipher_tfm (atfm); -struct qat_alg_ablkcipher_ctx *ctx =crypto_tfm_ctx (tfm); -struct qat_crypto_request *qat_req =ablkcipher_request_ctx (req); +struct crypto_skcipher *stfm =crypto_skcipher_reqtfm (req); +struct crypto_tfm *tfm =crypto_skcipher_tfm (stfm); +struct qat_alg_skcipher_ctx *ctx =crypto_tfm_ctx (tfm); +struct qat_crypto_request *qat_req =skcipher_request_ctx (req);struct icp_qat_fw_la_cipher_req_params *cipher_param;struct icp_qat_fw_la_bulk_req *msg;struct device *dev = &GET_DEV (ctx->inst->accel_dev);int ret, ctr =0 ; -if (req->nbytes ==0 ) +if (req->cryptlen ==0 )return 0 ; qat_req->iv = dma_alloc_coherent(dev, AES_BLOCK_SIZE,
@@ -1073,17 +1074,17 @@ static int qat_alg_ablkcipher_encrypt(struct ablkcipher_request *req) msg = &qat_req->req; *msg = ctx->enc_fw_req; - qat_req->ablkcipher_ctx = ctx; - qat_req->ablkcipher_req = req; - qat_req->cb = qat_ablkcipher_alg_callback; + qat_req->skcipher_ctx = ctx; + qat_req->skcipher_req = req; + qat_req->cb = qat_skcipher_alg_callback; qat_req->req.comn_mid.opaque_data = (uint64_t )(__force long )qat_req; qat_req->req.comn_mid.src_data_addr = qat_req->buf.blp; qat_req->req.comn_mid.dest_data_addr = qat_req->buf.bloutp; cipher_param = (void *)&qat_req->req.serv_specif_rqpars; - cipher_param->cipher_length = req->nbytes; + cipher_param->cipher_length = req->cryptlen; cipher_param->cipher_offset =0 ; cipher_param->u.s.cipher_IV_ptr = qat_req->iv_paddr; -memcpy (qat_req->iv, req->info,AES_BLOCK_SIZE ); +memcpy (qat_req->iv, req->iv,AES_BLOCK_SIZE );do { ret =adf_send_message (ctx->inst->sym_tx, (uint32_t *)msg); }while (ret == -EAGAIN && ctr++ <10 );
@@ -1097,26 +1098,26 @@ static int qat_alg_ablkcipher_encrypt(struct ablkcipher_request *req)return -EINPROGRESS ; } -static int qat_alg_ablkcipher_blk_encrypt (struct ablkcipher_request *req) +static int qat_alg_skcipher_blk_encrypt (struct skcipher_request *req) { -if (req->nbytes %AES_BLOCK_SIZE !=0 ) +if (req->cryptlen %AES_BLOCK_SIZE !=0 )return -EINVAL ; -return qat_alg_ablkcipher_encrypt (req); +return qat_alg_skcipher_encrypt (req); } -static int qat_alg_ablkcipher_decrypt (struct ablkcipher_request *req) +static int qat_alg_skcipher_decrypt (struct skcipher_request *req) { -struct crypto_ablkcipher *atfm =crypto_ablkcipher_reqtfm (req); -struct crypto_tfm *tfm =crypto_ablkcipher_tfm (atfm); -struct qat_alg_ablkcipher_ctx *ctx =crypto_tfm_ctx (tfm); -struct qat_crypto_request *qat_req =ablkcipher_request_ctx (req); +struct crypto_skcipher *stfm =crypto_skcipher_reqtfm (req); +struct crypto_tfm *tfm =crypto_skcipher_tfm (stfm); +struct qat_alg_skcipher_ctx *ctx =crypto_tfm_ctx (tfm); +struct qat_crypto_request *qat_req =skcipher_request_ctx (req);struct icp_qat_fw_la_cipher_req_params *cipher_param;struct icp_qat_fw_la_bulk_req *msg;struct device *dev = &GET_DEV (ctx->inst->accel_dev);int ret, ctr =0 ; -if (req->nbytes ==0 ) +if (req->cryptlen ==0 )return 0 ; qat_req->iv = dma_alloc_coherent(dev, AES_BLOCK_SIZE,
@@ -1133,17 +1134,17 @@ static int qat_alg_ablkcipher_decrypt(struct ablkcipher_request *req) msg = &qat_req->req; *msg = ctx->dec_fw_req; - qat_req->ablkcipher_ctx = ctx; - qat_req->ablkcipher_req = req; - qat_req->cb = qat_ablkcipher_alg_callback; + qat_req->skcipher_ctx = ctx; + qat_req->skcipher_req = req; + qat_req->cb = qat_skcipher_alg_callback; qat_req->req.comn_mid.opaque_data = (uint64_t )(__force long )qat_req; qat_req->req.comn_mid.src_data_addr = qat_req->buf.blp; qat_req->req.comn_mid.dest_data_addr = qat_req->buf.bloutp; cipher_param = (void *)&qat_req->req.serv_specif_rqpars; - cipher_param->cipher_length = req->nbytes; + cipher_param->cipher_length = req->cryptlen; cipher_param->cipher_offset =0 ; cipher_param->u.s.cipher_IV_ptr = qat_req->iv_paddr; -memcpy (qat_req->iv, req->info,AES_BLOCK_SIZE ); +memcpy (qat_req->iv, req->iv,AES_BLOCK_SIZE );do { ret =adf_send_message (ctx->inst->sym_tx, (uint32_t *)msg); }while (ret == -EAGAIN && ctr++ <10 );
@@ -1157,12 +1158,12 @@ static int qat_alg_ablkcipher_decrypt(struct ablkcipher_request *req)return -EINPROGRESS ; } -static int qat_alg_ablkcipher_blk_decrypt (struct ablkcipher_request *req) +static int qat_alg_skcipher_blk_decrypt (struct skcipher_request *req) { -if (req->nbytes %AES_BLOCK_SIZE !=0 ) +if (req->cryptlen %AES_BLOCK_SIZE !=0 )return -EINVAL ; -return qat_alg_ablkcipher_decrypt (req); +return qat_alg_skcipher_decrypt (req); } static int qat_alg_aead_init(struct crypto_aead *tfm, enum icp_qat_hw_auth_algo hash,
@@ -1218,18 +1219,18 @@ static void qat_alg_aead_exit(struct crypto_aead *tfm)qat_crypto_put_instance (inst); } -static int qat_alg_ablkcipher_init (struct crypto_tfm *tfm) +static int qat_alg_skcipher_init_tfm (struct crypto_skcipher *tfm) { -struct qat_alg_ablkcipher_ctx *ctx =crypto_tfm_ctx (tfm); +struct qat_alg_skcipher_ctx *ctx =crypto_skcipher_ctx (tfm); - tfm->crt_ablkcipher.reqsize =sizeof (struct qat_crypto_request ); +crypto_skcipher_set_reqsize (tfm,sizeof (struct qat_crypto_request )); ctx->tfm = tfm;return 0 ; } -static void qat_alg_ablkcipher_exit (struct crypto_tfm *tfm) +static void qat_alg_skcipher_exit_tfm (struct crypto_skcipher *tfm) { -struct qat_alg_ablkcipher_ctx *ctx =crypto_tfm_ctx (tfm); +struct qat_alg_skcipher_ctx *ctx =crypto_skcipher_ctx (tfm);struct qat_crypto_instance *inst = ctx->inst;struct device *dev;
@@ -1308,92 +1309,75 @@ static struct aead_alg qat_aeads[] = { { .maxauthsize = SHA512_DIGEST_SIZE, } }; -static struct crypto_alg qat_algs[] = { { - .cra_name ="cbc(aes)" , - .cra_driver_name ="qat_aes_cbc" , - .cra_priority =4001 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct qat_alg_ablkcipher_ctx ), - .cra_alignmask =0 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = qat_alg_ablkcipher_init, - .cra_exit = qat_alg_ablkcipher_exit, - .cra_u = { - .ablkcipher = { - .setkey = qat_alg_ablkcipher_cbc_setkey, - .decrypt = qat_alg_ablkcipher_blk_decrypt, - .encrypt = qat_alg_ablkcipher_blk_encrypt, - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - }, - }, +static struct skcipher_alg qat_skciphers[] = { { + .base.cra_name ="cbc(aes)" , + .base.cra_driver_name ="qat_aes_cbc" , + .base.cra_priority =4001 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct qat_alg_skcipher_ctx ), + .base.cra_alignmask =0 , + .base.cra_module =THIS_MODULE , + + .init = qat_alg_skcipher_init_tfm, + .exit = qat_alg_skcipher_exit_tfm, + .setkey = qat_alg_skcipher_cbc_setkey, + .decrypt = qat_alg_skcipher_blk_decrypt, + .encrypt = qat_alg_skcipher_blk_encrypt, + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , }, { - .cra_name ="ctr(aes)" , - .cra_driver_name ="qat_aes_ctr" , - .cra_priority =4001 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =1 , - .cra_ctxsize =sizeof (struct qat_alg_ablkcipher_ctx ), - .cra_alignmask =0 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = qat_alg_ablkcipher_init, - .cra_exit = qat_alg_ablkcipher_exit, - .cra_u = { - .ablkcipher = { - .setkey = qat_alg_ablkcipher_ctr_setkey, - .decrypt = qat_alg_ablkcipher_decrypt, - .encrypt = qat_alg_ablkcipher_encrypt, - .min_keysize =AES_MIN_KEY_SIZE , - .max_keysize =AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - }, - }, + .base.cra_name ="ctr(aes)" , + .base.cra_driver_name ="qat_aes_ctr" , + .base.cra_priority =4001 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =1 , + .base.cra_ctxsize =sizeof (struct qat_alg_skcipher_ctx ), + .base.cra_alignmask =0 , + .base.cra_module =THIS_MODULE , + + .init = qat_alg_skcipher_init_tfm, + .exit = qat_alg_skcipher_exit_tfm, + .setkey = qat_alg_skcipher_ctr_setkey, + .decrypt = qat_alg_skcipher_decrypt, + .encrypt = qat_alg_skcipher_encrypt, + .min_keysize =AES_MIN_KEY_SIZE , + .max_keysize =AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , }, { - .cra_name ="xts(aes)" , - .cra_driver_name ="qat_aes_xts" , - .cra_priority =4001 , - .cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC , - .cra_blocksize =AES_BLOCK_SIZE , - .cra_ctxsize =sizeof (struct qat_alg_ablkcipher_ctx ), - .cra_alignmask =0 , - .cra_type = &crypto_ablkcipher_type, - .cra_module =THIS_MODULE , - .cra_init = qat_alg_ablkcipher_init, - .cra_exit = qat_alg_ablkcipher_exit, - .cra_u = { - .ablkcipher = { - .setkey = qat_alg_ablkcipher_xts_setkey, - .decrypt = qat_alg_ablkcipher_blk_decrypt, - .encrypt = qat_alg_ablkcipher_blk_encrypt, - .min_keysize =2 *AES_MIN_KEY_SIZE , - .max_keysize =2 *AES_MAX_KEY_SIZE , - .ivsize =AES_BLOCK_SIZE , - }, - }, + .base.cra_name ="xts(aes)" , + .base.cra_driver_name ="qat_aes_xts" , + .base.cra_priority =4001 , + .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_blocksize =AES_BLOCK_SIZE , + .base.cra_ctxsize =sizeof (struct qat_alg_skcipher_ctx ), + .base.cra_alignmask =0 , + .base.cra_module =THIS_MODULE , + + .init = qat_alg_skcipher_init_tfm, + .exit = qat_alg_skcipher_exit_tfm, + .setkey = qat_alg_skcipher_xts_setkey, + .decrypt = qat_alg_skcipher_blk_decrypt, + .encrypt = qat_alg_skcipher_blk_encrypt, + .min_keysize =2 *AES_MIN_KEY_SIZE , + .max_keysize =2 *AES_MAX_KEY_SIZE , + .ivsize =AES_BLOCK_SIZE , } };int qat_algs_register (void ) { -int ret =0 , i; +int ret =0 ;mutex_lock (&algs_lock);if (++active_devs !=1 ) goto unlock; -for (i =0 ; i <ARRAY_SIZE (qat_algs); i++) - qat_algs[i].cra_flags =CRYPTO_ALG_TYPE_ABLKCIPHER |CRYPTO_ALG_ASYNC ; - - ret =crypto_register_algs (qat_algs,ARRAY_SIZE (qat_algs)); + ret =crypto_register_skciphers (qat_skciphers, +ARRAY_SIZE (qat_skciphers));if (ret) goto unlock; -for (i =0 ; i <ARRAY_SIZE (qat_aeads); i++) - qat_aeads[i].base.cra_flags =CRYPTO_ALG_ASYNC ; - ret =crypto_register_aeads (qat_aeads,ARRAY_SIZE (qat_aeads));if (ret) goto unreg_algs;
@@ -1403,7 +1387,7 @@ int qat_algs_register(void)return ret; unreg_algs: -crypto_unregister_algs (qat_algs,ARRAY_SIZE (qat_algs)); +crypto_unregister_skciphers (qat_skciphers,ARRAY_SIZE (qat_skciphers)); goto unlock; }
@@ -1414,7 +1398,7 @@ void qat_algs_unregister(void) goto unlock;crypto_unregister_aeads (qat_aeads,ARRAY_SIZE (qat_aeads)); -crypto_unregister_algs (qat_algs,ARRAY_SIZE (qat_algs)); +crypto_unregister_skciphers (qat_skciphers,ARRAY_SIZE (qat_skciphers)); unlock:mutex_unlock (&algs_lock);
drivers/crypto/qat/qat_common/qat_crypto.h +2 -2
@@ -79,11 +79,11 @@ struct qat_crypto_request {struct icp_qat_fw_la_bulk_req req;union {struct qat_alg_aead_ctx *aead_ctx; -struct qat_alg_ablkcipher_ctx *ablkcipher_ctx; +struct qat_alg_skcipher_ctx *skcipher_ctx; };union {struct aead_request *aead_req; -struct ablkcipher_request *ablkcipher_req; +struct skcipher_request *skcipher_req; };struct qat_crypto_request_buffs buf; void (*cb)(struct icp_qat_fw_la_resp *resp,
Signature · 1 line
2.17.1
PATCH v4 26/29 crypto: marvell/cesa - rename blkcipher to skcipher
In reply to Ard BiesheuvelThe driver specific types contain some rudimentary references to the blkcipher API, which is deprecated and will be removed. To avoid confusion, rename these to skcipher. This is a cosmetic change only, as the code does not actually use the blkcipher API.
--- drivers/crypto/marvell/cesa.h | 6 +++--- drivers/crypto/marvell/cipher.c | 14 +++++++------- 2 files changed, 10 insertions(+), 10 deletions(-)
drivers/crypto/marvell/cesa.h +3 -3
@@ -232,13 +232,13 @@ struct mv_cesa_sec_accel_desc { };/** -* struct mv_cesa_blkcipher_op_ctx - cipher operation context +* struct mv_cesa_skcipher_op_ctx - cipher operation context * @key: cipher key * @iv: cipher IV * * Context associated to a cipher operation. */ -struct mv_cesa_blkcipher_op_ctx { +struct mv_cesa_skcipher_op_ctx {u32 key[8 ];u32 iv[4 ]; };
@@ -265,7 +265,7 @@ struct mv_cesa_hash_op_ctx {struct mv_cesa_op_ctx {struct mv_cesa_sec_accel_desc desc;union { -struct mv_cesa_blkcipher_op_ctx blkcipher; +struct mv_cesa_skcipher_op_ctx skcipher;struct mv_cesa_hash_op_ctx hash; } ctx; };
drivers/crypto/marvell/cipher.c +7 -7
@@ -209,7 +209,7 @@ mv_cesa_skcipher_complete(struct crypto_async_request *req)struct mv_cesa_req *basereq; basereq = &creq->base; -memcpy (skreq->iv, basereq->chain.last->op->ctx.blkcipher.iv, +memcpy (skreq->iv, basereq->chain.last->op->ctx.skcipher.iv, ivsize); }else { memcpy_fromio(skreq->iv,
@@ -470,7 +470,7 @@ static int mv_cesa_des_op(struct skcipher_request *req,mv_cesa_update_op_cfg (tmpl,CESA_SA_DESC_CFG_CRYPTM_DES ,CESA_SA_DESC_CFG_CRYPTM_MSK ); -memcpy (tmpl->ctx.blkcipher.key, ctx->key,DES_KEY_SIZE ); +memcpy (tmpl->ctx.skcipher.key, ctx->key,DES_KEY_SIZE );return mv_cesa_skcipher_queue_req (req, tmpl); }
@@ -523,7 +523,7 @@ static int mv_cesa_cbc_des_op(struct skcipher_request *req,mv_cesa_update_op_cfg (tmpl,CESA_SA_DESC_CFG_CRYPTCM_CBC ,CESA_SA_DESC_CFG_CRYPTCM_MSK ); -memcpy (tmpl->ctx.blkcipher.iv, req->iv,DES_BLOCK_SIZE ); +memcpy (tmpl->ctx.skcipher.iv, req->iv,DES_BLOCK_SIZE );return mv_cesa_des_op (req, tmpl); }
@@ -575,7 +575,7 @@ static int mv_cesa_des3_op(struct skcipher_request *req,mv_cesa_update_op_cfg (tmpl,CESA_SA_DESC_CFG_CRYPTM_3DES ,CESA_SA_DESC_CFG_CRYPTM_MSK ); -memcpy (tmpl->ctx.blkcipher.key, ctx->key,DES3_EDE_KEY_SIZE ); +memcpy (tmpl->ctx.skcipher.key, ctx->key,DES3_EDE_KEY_SIZE );return mv_cesa_skcipher_queue_req (req, tmpl); }
@@ -628,7 +628,7 @@ struct skcipher_alg mv_cesa_ecb_des3_ede_alg = {static int mv_cesa_cbc_des3_op (struct skcipher_request *req,struct mv_cesa_op_ctx *tmpl) { -memcpy (tmpl->ctx.blkcipher.iv, req->iv,DES3_EDE_BLOCK_SIZE ); +memcpy (tmpl->ctx.skcipher.iv, req->iv,DES3_EDE_BLOCK_SIZE );return mv_cesa_des3_op (req, tmpl); }
@@ -694,7 +694,7 @@ static int mv_cesa_aes_op(struct skcipher_request *req, key = ctx->aes.key_enc;for (i =0 ; i < ctx->aes.key_length /sizeof (u32); i++) - tmpl->ctx.blkcipher.key[i] =cpu_to_le32 (key[i]); + tmpl->ctx.skcipher.key[i] =cpu_to_le32 (key[i]);if (ctx->aes.key_length ==24 ) cfg |=CESA_SA_DESC_CFG_AES_LEN_192 ;
@@ -755,7 +755,7 @@ static int mv_cesa_cbc_aes_op(struct skcipher_request *req, {mv_cesa_update_op_cfg (tmpl,CESA_SA_DESC_CFG_CRYPTCM_CBC ,CESA_SA_DESC_CFG_CRYPTCM_MSK ); -memcpy (tmpl->ctx.blkcipher.iv, req->iv,AES_BLOCK_SIZE ); +memcpy (tmpl->ctx.skcipher.iv, req->iv,AES_BLOCK_SIZE );return mv_cesa_aes_op (req, tmpl); }
Signature · 1 line
2.17.1
PATCH v4 27/29 crypto: nx - remove stale comment referring to the blkcipher walk API
In reply to Ard BiesheuvelThese drivers do not use either the deprecated blkcipher or the current skcipher walk API, so this comment must refer to a previous state of the driver that no longer exists. So drop the comments.
--- drivers/crypto/nx/nx-aes-ccm.c | 5 ----- drivers/crypto/nx/nx-aes-gcm.c | 5 ----- 2 files changed, 10 deletions(-)
drivers/crypto/nx/nx-aes-ccm.c +0 -5
@@ -525,11 +525,6 @@ static int ccm_aes_nx_decrypt(struct aead_request *req)return ccm_nx_decrypt (req, req->iv, req->assoclen); } -/* tell the block cipher walk routines that this is a stream cipher by -* setting cra_blocksize to 1. Even using blkcipher_walk_virt_block -* during encrypt/decrypt doesn't solve this problem, because it calls -* blkcipher_walk_done under the covers, which doesn't use walk->blocksize, -* but instead uses this tfm->blocksize. */ struct aead_alg nx_ccm_aes_alg = { .base = { .cra_name ="ccm(aes)" ,
drivers/crypto/nx/nx-aes-gcm.c +0 -5
@@ -467,11 +467,6 @@ static int gcm4106_aes_nx_decrypt(struct aead_request *req)return gcm_aes_nx_crypt (req,0 , req->assoclen -8 ); } -/* tell the block cipher walk routines that this is a stream cipher by -* setting cra_blocksize to 1. Even using blkcipher_walk_virt_block -* during encrypt/decrypt doesn't solve this problem, because it calls -* blkcipher_walk_done under the covers, which doesn't use walk->blocksize, -* but instead uses this tfm->blocksize. */ struct aead_alg nx_gcm_aes_alg = { .base = { .cra_name ="gcm(aes)" ,
Signature · 1 line
2.17.1
PATCH v4 28/29 crypto: remove deprecated and unused ablkcipher support
In reply to Ard BiesheuvelNow that all users of the deprecated ablkcipher interface have been moved to the skcipher interface, ablkcipher is no longer used and can be removed.
--- Documentation/crypto/api-skcipher.rst | 20 +- Documentation/crypto/architecture.rst | 2 - Documentation/crypto/crypto_engine.rst | 4 - crypto/Makefile | 4 +- crypto/ablkcipher.c | 407 ------------------ crypto/algapi.c | 26 -- crypto/crypto_engine.c | 29 -- crypto/skcipher.c | 106 ----- include/crypto/aead.h | 2 +- include/crypto/algapi.h | 75 ---- include/crypto/engine.h | 4 - include/crypto/hash.h | 2 +- include/crypto/internal/des.h | 12 - include/crypto/internal/skcipher.h | 20 - include/crypto/skcipher.h | 6 - include/linux/crypto.h | 435 -------------------- 16 files changed, 4 insertions(+), 1150 deletions(-)
Documentation/crypto/api-skcipher.rst +1 -19
@@ -5,7 +5,7 @@ Block Cipher Algorithm Definitions :doc: Block Cipher Algorithm Definitions .. kernel-doc:: include/linux/crypto.h - :functions: crypto_alg ablkcipher_alg cipher_alg compress_alg + :functions: crypto_alg cipher_alg compress_alg Symmetric Key Cipher API ------------------------
@@ -33,21 +33,3 @@ Single Block Cipher API .. kernel-doc:: include/linux/crypto.h :functions: crypto_alloc_cipher crypto_free_cipher crypto_has_cipher crypto_cipher_blocksize crypto_cipher_setkey crypto_cipher_encrypt_one crypto_cipher_decrypt_one - -Asynchronous Block Cipher API - Deprecated ------------------------------------------- - -.. kernel-doc:: include/linux/crypto.h - :doc: Asynchronous Block Cipher API - -.. kernel-doc:: include/linux/crypto.h - :functions: crypto_free_ablkcipher crypto_ablkcipher_ivsize crypto_ablkcipher_blocksize crypto_ablkcipher_setkey crypto_ablkcipher_reqtfm crypto_ablkcipher_encrypt crypto_ablkcipher_decrypt - -Asynchronous Cipher Request Handle - Deprecated ------------------------------------------------ - -.. kernel-doc:: include/linux/crypto.h - :doc: Asynchronous Cipher Request Handle - -.. kernel-doc:: include/linux/crypto.h - :functions: crypto_ablkcipher_reqsize ablkcipher_request_set_tfm ablkcipher_request_alloc ablkcipher_request_free ablkcipher_request_set_callback ablkcipher_request_set_crypt
Documentation/crypto/architecture.rst +0 -2
@@ -201,8 +201,6 @@ the aforementioned cipher types: - CRYPTO_ALG_TYPE_AEAD Authenticated Encryption with Associated Data (MAC) -- CRYPTO_ALG_TYPE_ABLKCIPHER Asynchronous multi-block cipher - - CRYPTO_ALG_TYPE_KPP Key-agreement Protocol Primitive (KPP) such as an ECDH or DH implementation
Documentation/crypto/crypto_engine.rst +0 -4
@@ -63,8 +63,6 @@ request by using: When your driver receives a crypto_request, you must to transfer it to the crypto engine via one of: -* crypto_transfer_ablkcipher_request_to_engine() - * crypto_transfer_aead_request_to_engine() * crypto_transfer_akcipher_request_to_engine()
@@ -75,8 +73,6 @@ the crypto engine via one of: At the end of the request process, a call to one of the following functions is needed: -* crypto_finalize_ablkcipher_request() - * crypto_finalize_aead_request() * crypto_finalize_akcipher_request()
crypto/Makefile +1 -3
@@ -15,9 +15,7 @@ obj-$(CONFIG_CRYPTO_ALGAPI2) += crypto_algapi.o obj-$(CONFIG_CRYPTO_AEAD2) += aead.o -crypto_skcipher-y := ablkcipher.o -crypto_skcipher-y += skcipher.o -obj-$(CONFIG_CRYPTO_SKCIPHER2) += crypto_skcipher.o +obj-$(CONFIG_CRYPTO_SKCIPHER2) += skcipher.o obj-$(CONFIG_CRYPTO_SEQIV) += seqiv.o obj-$(CONFIG_CRYPTO_ECHAINIV) += echainiv.o
crypto/ablkcipher.c deleted +0 -407
407 lines not on this page · raw message
crypto/algapi.c +0 -26
@@ -1052,32 +1052,6 @@ void crypto_stats_get(struct crypto_alg *alg) }EXPORT_SYMBOL_GPL (crypto_stats_get); -void crypto_stats_ablkcipher_encrypt (unsigned int nbytes,int ret, -struct crypto_alg *alg) -{ -if (ret && ret != -EINPROGRESS && ret != -EBUSY ) { -atomic64_inc (&alg->stats.cipher.err_cnt); - }else { -atomic64_inc (&alg->stats.cipher.encrypt_cnt); -atomic64_add (nbytes, &alg->stats.cipher.encrypt_tlen); - } -crypto_alg_put (alg); -} -EXPORT_SYMBOL_GPL (crypto_stats_ablkcipher_encrypt); - -void crypto_stats_ablkcipher_decrypt (unsigned int nbytes,int ret, -struct crypto_alg *alg) -{ -if (ret && ret != -EINPROGRESS && ret != -EBUSY ) { -atomic64_inc (&alg->stats.cipher.err_cnt); - }else { -atomic64_inc (&alg->stats.cipher.decrypt_cnt); -atomic64_add (nbytes, &alg->stats.cipher.decrypt_tlen); - } -crypto_alg_put (alg); -} -EXPORT_SYMBOL_GPL (crypto_stats_ablkcipher_decrypt); -void crypto_stats_aead_encrypt (unsigned int cryptlen,struct crypto_alg *alg,int ret) {
crypto/crypto_engine.c +0 -29
@@ -213,20 +213,6 @@ static int crypto_transfer_request_to_engine(struct crypto_engine *engine,return crypto_transfer_request (engine, req, true); } -/** -* crypto_transfer_ablkcipher_request_to_engine - transfer one ablkcipher_request -* to list into the engine queue -* @engine: the hardware engine -* @req: the request need to be listed into the engine queue -* TODO: Remove this function when skcipher conversion is finished -*/ -int crypto_transfer_ablkcipher_request_to_engine (struct crypto_engine *engine, -struct ablkcipher_request *req) -{ -return crypto_transfer_request_to_engine (engine, &req->base); -} -EXPORT_SYMBOL_GPL (crypto_transfer_ablkcipher_request_to_engine); -/** * crypto_transfer_aead_request_to_engine - transfer one aead_request * to list into the engine queue
@@ -279,21 +265,6 @@ int crypto_transfer_skcipher_request_to_engine(struct crypto_engine *engine, }EXPORT_SYMBOL_GPL (crypto_transfer_skcipher_request_to_engine); -/** -* crypto_finalize_ablkcipher_request - finalize one ablkcipher_request if -* the request is done -* @engine: the hardware engine -* @req: the request need to be finalized -* @err: error number -* TODO: Remove this function when skcipher conversion is finished -*/ -void crypto_finalize_ablkcipher_request (struct crypto_engine *engine, -struct ablkcipher_request *req,int err) -{ -return crypto_finalize_request (engine, &req->base, err); -} -EXPORT_SYMBOL_GPL (crypto_finalize_ablkcipher_request); -/** * crypto_finalize_aead_request - finalize one aead_request if * the request is done
crypto/skcipher.c +0 -106
124 lines not on this page · raw message
include/crypto/aead.h +1 -1
@@ -321,7 +321,7 @@ int crypto_aead_encrypt(struct aead_request *req);/** * crypto_aead_decrypt() - decrypt ciphertext -* @req: reference to the ablkcipher_request handle that holds all information +* @req: reference to the aead_request handle that holds all information * needed to perform the cipher operation * * Decrypt ciphertext data using the aead_request handle. That data structure
include/crypto/algapi.h +0 -75
105 lines not on this page · raw message
include/crypto/engine.h +0 -4
@@ -83,8 +83,6 @@ struct crypto_engine_ctx {struct crypto_engine_op op; }; -int crypto_transfer_ablkcipher_request_to_engine (struct crypto_engine *engine, -struct ablkcipher_request *req);int crypto_transfer_aead_request_to_engine (struct crypto_engine *engine,struct aead_request *req); int crypto_transfer_akcipher_request_to_engine(struct crypto_engine *engine,
@@ -93,8 +91,6 @@ int crypto_transfer_hash_request_to_engine(struct crypto_engine *engine, struct ahash_request *req);int crypto_transfer_skcipher_request_to_engine (struct crypto_engine *engine,struct skcipher_request *req); -void crypto_finalize_ablkcipher_request (struct crypto_engine *engine, -struct ablkcipher_request *req,int err);void crypto_finalize_aead_request (struct crypto_engine *engine,struct aead_request *req,int err); void crypto_finalize_akcipher_request(struct crypto_engine *engine,
include/crypto/hash.h +1 -1
@@ -227,7 +227,7 @@ struct crypto_shash {* CRYPTO_ALG_TYPE_AHASH (listed as type "ahash" in /proc/crypto) * * The asynchronous cipher operation discussion provided for the -* CRYPTO_ALG_TYPE_ABLKCIPHER API applies here as well. +* CRYPTO_ALG_TYPE_SKCIPHER API applies here as well. */ static inline struct crypto_ahash *__crypto_ahash_cast (struct crypto_tfm *tfm)
include/crypto/internal/des.h +0 -12
@@ -117,18 +117,6 @@ static inline int verify_skcipher_des3_key(struct crypto_skcipher *tfm,return crypto_des3_ede_verify_key (crypto_skcipher_tfm (tfm), key); } -static inline int verify_ablkcipher_des_key (struct crypto_ablkcipher *tfm, -const u8 *key) -{ -return crypto_des_verify_key (crypto_ablkcipher_tfm (tfm), key); -} - -static inline int verify_ablkcipher_des3_key (struct crypto_ablkcipher *tfm, -const u8 *key) -{ -return crypto_des3_ede_verify_key (crypto_ablkcipher_tfm (tfm), key); -} -static inline int verify_aead_des_key (struct crypto_aead *tfm,const u8 *key,int keylen) {
include/crypto/internal/skcipher.h +0 -20
@@ -153,17 +153,6 @@ static inline void skcipher_walk_abort(struct skcipher_walk *walk)skcipher_walk_done (walk, -ECANCELED ); } -static inline void ablkcipher_request_complete (struct ablkcipher_request *req, -int err) -{ - req->base.complete (&req->base, err); -} - -static inline u32 ablkcipher_request_flags (struct ablkcipher_request *req) -{ -return req->base.flags; -} -static inline void *crypto_skcipher_ctx (struct crypto_skcipher *tfm) {return crypto_tfm_ctx (&tfm->base);
@@ -182,27 +171,18 @@ static inline u32 skcipher_request_flags(struct skcipher_request *req)static inline unsigned int crypto_skcipher_alg_min_keysize (struct skcipher_alg *alg) { -if (alg->base.cra_ablkcipher.encrypt) -return alg->base.cra_ablkcipher.min_keysize; -return alg->min_keysize; }static inline unsigned int crypto_skcipher_alg_max_keysize (struct skcipher_alg *alg) { -if (alg->base.cra_ablkcipher.encrypt) -return alg->base.cra_ablkcipher.max_keysize; -return alg->max_keysize; }static inline unsigned int crypto_skcipher_alg_walksize (struct skcipher_alg *alg) { -if (alg->base.cra_ablkcipher.encrypt) -return alg->base.cra_blocksize; -return alg->walksize; }
include/crypto/skcipher.h +0 -6
@@ -241,9 +241,6 @@ static inline struct skcipher_alg *crypto_skcipher_alg(static inline unsigned int crypto_skcipher_alg_ivsize (struct skcipher_alg *alg) { -if (alg->base.cra_ablkcipher.encrypt) -return alg->base.cra_ablkcipher.ivsize; -return alg->ivsize; }
@@ -286,9 +283,6 @@ static inline unsigned int crypto_skcipher_blocksize(static inline unsigned int crypto_skcipher_alg_chunksize (struct skcipher_alg *alg) { -if (alg->base.cra_ablkcipher.encrypt) -return alg->base.cra_blocksize; -return alg->chunksize; }
include/linux/crypto.h +0 -435
519 lines not on this page · raw message
Signature · 1 line
2.17.1
PATCH v4 29/29 crypto: ccree - update a stale reference to ablkcipher
In reply to Ard BiesheuvelThe ccree driver does not use the ablkcipher interface but contains a rudimentary reference to it in the naming of an unrelated macro. Let's rename it to avoid confusion.
--- drivers/crypto/ccree/cc_cipher.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/crypto/ccree/cc_cipher.c +2 -2
@@ -16,7 +16,7 @@#include "cc_cipher.h" #include "cc_request_mgr.h" -#define MAX_ABLKCIPHER_SEQ_LEN 6 +#define MAX_SKCIPHER_SEQ_LEN 6#define template_skcipher template_u.skcipher
@@ -822,7 +822,7 @@ static int cc_cipher_process(struct skcipher_request *req,void *iv = req->iv;struct cc_cipher_ctx *ctx_p =crypto_tfm_ctx (tfm);struct device *dev =drvdata_to_dev (ctx_p->drvdata); -struct cc_hw_desc desc[MAX_ABLKCIPHER_SEQ_LEN ]; +struct cc_hw_desc desc[MAX_SKCIPHER_SEQ_LEN ];struct cc_crypto_req cc_req = {};int rc;unsigned int seq_len =0 ;
Signature · 1 line
2.17.1
Herbert Xu
maintainerQuoted 146 lines · Ard Biesheuvel
This series converts all drivers for h/w accelerators that produce the ablkcipher API to the skcipher API, so that we can finally retire the long deprecated ablkcipher code.
Changes since v3:
- add acks from Tudor, Gilad and Eric
- incorporate updated version of the QAT patch from Giovanni
- rebased onto latest cryptodev/master
- updated wording in commit logs to refer to ablkcipher not blkcipher [which has already been removed]Changes since v2:
- added a patch that removes the ablkcipher support code itself
- fix an issue in the talitos code
- add tero's ack to patch #5
- add stanimir's ack to patch #20Changes since v1:
- remove some more [cosmetic] references to [a]blkcipher (#26-#27)
- add back missing IV for cbc(aes) in the omap driver, fixing a crash
- add Gary's ack to #4
- add Linus's ack to #6 and #15
- add Kamil's and Krzysztof's acks to #7
- fixed a bug in the Atmel patch (#8)
- add Horia's tested-by to #16
- add Dave's ack to #22Patches #1, #2 are fixes for the virtio driver, which need to be applied first so that they can be backported
Patches #3 and #4 have been tested by me on actual 'hardware' (given the virtual nature of the virtio driver). Patch #5 was tested by Tero. Patch #7 was tested successfully in kernelci. Patches #8 and #9 were tested by Tudor. Patch #16 was tested by Horia. Patch #25 was updated with changes proposed by Giovanni, so I assume he tested them as well. Patch #24 was fixed in v2 in response to a test failure report.
All other patches have been build tested *only*, and should preferably be tested on actual hardware before being merged. Note that patches can be merged piecemeal (with the exception of #1 .. #3 which should be taken as a set, and #28 which removes the ablkcipher support code) since there are no dependencies between them. However, deferring this series indefinitely until everyone has chimed in doesn't seem like a useful approach either, so I am leaving it up to the maintainers to decide when we have reached critical mass and the whole series can be taken.
Cc Herbert Xu <[email protected]>Cc "David S. Miller" <[email protected]>Cc Eric Biggers <[email protected]>Ard Biesheuvel (29):
crypto: virtio - implement missing support for output IVs
crypto: virtio - deal with unsupported input sizes
crypto: virtio - switch to skcipher API
crypto: ccp - switch from ablkcipher to skcipher
crypto: omap - switch to skcipher API
crypto: ux500 - switch to skcipher API
crypto: s5p - switch to skcipher API
crypto: atmel-aes - switch to skcipher API
crypto: atmel-tdes - switch to skcipher API
crypto: bcm-spu - switch to skcipher API
crypto: nitrox - removecra_typereference to ablkcipher
crypto: cavium/cpt - switch to skcipher API
crypto: chelsio - switch to skcipher API
crypto: hifn - switch to skcipher API
crypto: ixp4xx - switch to skcipher API
crypto: mxs - switch to skcipher API
crypto: mediatek - switch to skcipher API
crypto: sahara - switch to skcipher API
crypto: picoxcell - switch to skcipher API
crypto: qce - switch to skcipher API
crypto: stm32 - switch to skcipher API
crypto: niagara2 - switch to skcipher API
crypto: rockchip - switch to skcipher API
crypto: talitos - switch to skcipher API
crypto: qat - switch to skcipher API
crypto: marvell/cesa - rename blkcipher to skcipher
crypto: nx - remove stale comment referring to the blkcipher walk API
crypto: remove deprecated and unused ablkcipher support
crypto: ccree - update a stale reference to ablkcipherDocumentation/crypto/api-skcipher.rst | 20 +- Documentation/crypto/architecture.rst | 2 - Documentation/crypto/crypto_engine.rst | 4 - crypto/Makefile | 4 +- crypto/ablkcipher.c | 407 ------------- crypto/algapi.c | 26 - crypto/crypto_engine.c | 29 - crypto/skcipher.c | 106 ---- drivers/crypto/Kconfig | 2 +- drivers/crypto/atmel-aes.c | 509 ++++++++-------- drivers/crypto/atmel-tdes.c | 433 +++++++------- drivers/crypto/bcm/cipher.c | 373 ++++++------ drivers/crypto/bcm/cipher.h | 10 +- drivers/crypto/bcm/spu2.c | 6 +- drivers/crypto/cavium/cpt/cptvf_algs.c | 292 +++++---- .../crypto/cavium/nitrox/nitrox_skcipher.c | 1 - drivers/crypto/ccp/ccp-crypto-aes-galois.c | 7 +- drivers/crypto/ccp/ccp-crypto-aes-xts.c | 94 +-- drivers/crypto/ccp/ccp-crypto-aes.c | 169 +++--- drivers/crypto/ccp/ccp-crypto-des3.c | 100 ++-- drivers/crypto/ccp/ccp-crypto-main.c | 14 +- drivers/crypto/ccp/ccp-crypto.h | 13 +- drivers/crypto/ccree/cc_cipher.c | 4 +- drivers/crypto/chelsio/chcr_algo.c | 334 ++++++----- drivers/crypto/chelsio/chcr_algo.h | 2 +- drivers/crypto/chelsio/chcr_crypto.h | 16 +- drivers/crypto/hifn_795x.c | 183 +++--- drivers/crypto/ixp4xx_crypto.c | 228 ++++--- drivers/crypto/marvell/cesa.h | 6 +- drivers/crypto/marvell/cipher.c | 14 +- drivers/crypto/mediatek/mtk-aes.c | 248 ++++---- drivers/crypto/mxs-dcp.c | 140 ++--- drivers/crypto/n2_core.c | 194 +++--- drivers/crypto/nx/nx-aes-ccm.c | 5 - drivers/crypto/nx/nx-aes-gcm.c | 5 - drivers/crypto/omap-aes.c | 209 ++++--- drivers/crypto/omap-aes.h | 4 +- drivers/crypto/omap-des.c | 232 ++++---- drivers/crypto/picoxcell_crypto.c | 386 ++++++------ drivers/crypto/qat/qat_common/qat_algs.c | 304 +++++----- drivers/crypto/qat/qat_common/qat_crypto.h | 4 +- drivers/crypto/qce/Makefile | 2 +- drivers/crypto/qce/cipher.h | 8 +- drivers/crypto/qce/common.c | 12 +- drivers/crypto/qce/common.h | 3 +- drivers/crypto/qce/core.c | 2 +- .../crypto/qce/{ablkcipher.c => skcipher.c} | 172 +++--- drivers/crypto/rockchip/Makefile | 2 +- drivers/crypto/rockchip/rk3288_crypto.c | 8 +- drivers/crypto/rockchip/rk3288_crypto.h | 3 +- .../rockchip/rk3288_crypto_ablkcipher.c | 556 ------------------ .../crypto/rockchip/rk3288_crypto_skcipher.c | 538 +++++++++++++++++ drivers/crypto/s5p-sss.c | 187 +++--- drivers/crypto/sahara.c | 156 +++-- drivers/crypto/stm32/stm32-cryp.c | 338 +++++------ drivers/crypto/talitos.c | 308 +++++----- drivers/crypto/ux500/cryp/cryp_core.c | 371 +++++------- drivers/crypto/virtio/virtio_crypto_algs.c | 192 +++--- drivers/crypto/virtio/virtio_crypto_common.h | 2 +- include/crypto/aead.h | 2 +- include/crypto/algapi.h | 75 --- include/crypto/engine.h | 4 - include/crypto/hash.h | 2 +- include/crypto/internal/des.h | 12 -
Quoted 8 lines
include/crypto/internal/skcipher.h | 20 -
include/crypto/skcipher.h | 6 -
include/linux/crypto.h | 435 --------------
67 files changed, 3531 insertions(+), 5024 deletions(-)
delete mode 100644 crypto/ablkcipher.c
rename drivers/crypto/qce/{ablkcipher.c => skcipher.c} (61%)
delete mode 100644 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c
create mode 100644 drivers/crypto/rockchip/rk3288_crypto_skcipher.cAll applied with addition of the changes suggested by Tudor. Thanks.
Signature · 3 lines
Email: Herbert Xu <[email protected]> Home Page: http://gondor.apana.org.au/~herbert/ PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt