Skip to content

L
linux
Commit ac0d3d13 authored by Ard Biesheuvel's avatar Ard Biesheuvel Committed by Herbert Xu
Browse files
Options

crypto: cavium/cpt - switch to skcipher API 

Commit 7a7ffe65 ("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.
Signed-off-by: default avatarArd Biesheuvel <ardb@kernel.org>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent e8306261
Hide whitespace changes
Inline Side-by-side
Showing with 134 additions and 158 deletions
drivers/crypto/cavium/cpt/cptvf_algs.c
View file @ ac0d3d13
...@@ -92,15 +92,15 @@ static inline void update_output_data(struct cpt_request_info *req_info, ...@@ -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) u32 *argcnt)
{ {
struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req); struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
struct cvm_enc_ctx *ctx = crypto_ablkcipher_ctx(tfm); struct cvm_enc_ctx *ctx = crypto_skcipher_ctx(tfm);
struct cvm_req_ctx *rctx = ablkcipher_request_ctx(req); struct cvm_req_ctx *rctx = skcipher_request_ctx(req);
struct fc_context *fctx = &rctx->fctx; struct fc_context *fctx = &rctx->fctx;
u64 *offset_control = &rctx->control_word; 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; struct cpt_request_info *req_info = &rctx->cpt_req;
u64 *ctrl_flags = NULL; u64 *ctrl_flags = NULL;
...@@ -115,7 +115,7 @@ static inline u32 create_ctx_hdr(struct ablkcipher_request *req, u32 enc, ...@@ -115,7 +115,7 @@ static inline u32 create_ctx_hdr(struct ablkcipher_request *req, u32 enc,
else else
req_info->req.opcode.s.minor = 3; 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 */ req_info->req.param2 = 0; /*Auth data length */
fctx->enc.enc_ctrl.e.enc_cipher = ctx->cipher_type; 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, ...@@ -147,32 +147,32 @@ static inline u32 create_ctx_hdr(struct ablkcipher_request *req, u32 enc,
return 0; 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) 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; struct cpt_request_info *req_info = &rctx->cpt_req;
u32 argcnt = 0; u32 argcnt = 0;
create_ctx_hdr(req, enc, &argcnt); create_ctx_hdr(req, enc, &argcnt);
update_input_iv(req_info, req->info, enc_iv_len, &argcnt); update_input_iv(req_info, req->iv, enc_iv_len, &argcnt);
update_input_data(req_info, req->src, req->nbytes, &argcnt); update_input_data(req_info, req->src, req->cryptlen, &argcnt);
req_info->incnt = argcnt; req_info->incnt = argcnt;
return 0; 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) struct cpt_request_info *req_info)
{ {
req_info->callback = (void *)cvm_callback; req_info->callback = (void *)cvm_callback;
req_info->callback_arg = (void *)&req->base; 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) 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; struct cpt_request_info *req_info = &rctx->cpt_req;
u32 argcnt = 0; u32 argcnt = 0;
...@@ -184,16 +184,16 @@ static inline void create_output_list(struct ablkcipher_request *req, ...@@ -184,16 +184,16 @@ static inline void create_output_list(struct ablkcipher_request *req,
* [ 16 Bytes/ [ Request Enc/Dec/ DATA Len AES CBC ] * [ 16 Bytes/ [ Request Enc/Dec/ DATA Len AES CBC ]
*/ */
/* Reading IV information */ /* Reading IV information */
update_output_iv(req_info, req->info, enc_iv_len, &argcnt); update_output_iv(req_info, req->iv, enc_iv_len, &argcnt);
update_output_data(req_info, req->dst, req->nbytes, &argcnt); update_output_data(req_info, req->dst, req->cryptlen, &argcnt);
req_info->outcnt = 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 crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
struct cvm_req_ctx *rctx = ablkcipher_request_ctx(req); struct cvm_req_ctx *rctx = skcipher_request_ctx(req);
u32 enc_iv_len = crypto_ablkcipher_ivsize(tfm); u32 enc_iv_len = crypto_skcipher_ivsize(tfm);
struct fc_context *fctx = &rctx->fctx; struct fc_context *fctx = &rctx->fctx;
struct cpt_request_info *req_info = &rctx->cpt_req; struct cpt_request_info *req_info = &rctx->cpt_req;
void *cdev = NULL; void *cdev = NULL;
...@@ -217,20 +217,20 @@ static inline int cvm_enc_dec(struct ablkcipher_request *req, u32 enc) ...@@ -217,20 +217,20 @@ static inline int cvm_enc_dec(struct ablkcipher_request *req, u32 enc)
return -EINPROGRESS; return -EINPROGRESS;
} }
static int cvm_encrypt(struct ablkcipher_request *req) static int cvm_encrypt(struct skcipher_request *req)
{ {
return cvm_enc_dec(req, true); 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); 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) 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); struct cvm_enc_ctx *ctx = crypto_tfm_ctx(tfm);
int err; int err;
const u8 *key1 = key; const u8 *key1 = key;
...@@ -284,10 +284,10 @@ static int cvm_validate_keylen(struct cvm_enc_ctx *ctx, u32 keylen) ...@@ -284,10 +284,10 @@ static int cvm_validate_keylen(struct cvm_enc_ctx *ctx, u32 keylen)
return -EINVAL; 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) 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); struct cvm_enc_ctx *ctx = crypto_tfm_ctx(tfm);
ctx->cipher_type = cipher_type; ctx->cipher_type = cipher_type;
...@@ -295,183 +295,159 @@ static int cvm_setkey(struct crypto_ablkcipher *cipher, const u8 *key, ...@@ -295,183 +295,159 @@ static int cvm_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
memcpy(ctx->enc_key, key, keylen); memcpy(ctx->enc_key, key, keylen);
return 0; return 0;
} else { } else {
crypto_ablkcipher_set_flags(cipher, crypto_skcipher_set_flags(cipher,
CRYPTO_TFM_RES_BAD_KEY_LEN); CRYPTO_TFM_RES_BAD_KEY_LEN);
return -EINVAL; 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) u32 keylen)
{ {
return cvm_setkey(cipher, key, keylen, AES_CBC); 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) u32 keylen)
{ {
return cvm_setkey(cipher, key, keylen, AES_ECB); 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) u32 keylen)
{ {
return cvm_setkey(cipher, key, keylen, AES_CFB); 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) u32 keylen)
{ {
return verify_ablkcipher_des3_key(cipher, key) ?: return verify_skcipher_des3_key(cipher, key) ?:
cvm_setkey(cipher, key, keylen, DES3_CBC); 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) u32 keylen)
{ {
return verify_ablkcipher_des3_key(cipher, key) ?: return verify_skcipher_des3_key(cipher, key) ?:
cvm_setkey(cipher, key, keylen, DES3_ECB); 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; return 0;
} }
static struct crypto_alg algs[] = { { static struct skcipher_alg algs[] = { {
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, .base.cra_flags = CRYPTO_ALG_ASYNC,
.cra_blocksize = AES_BLOCK_SIZE, .base.cra_blocksize = AES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct cvm_enc_ctx), .base.cra_ctxsize = sizeof(struct cvm_enc_ctx),
.cra_alignmask = 7, .base.cra_alignmask = 7,
.cra_priority = 4001, .base.cra_priority = 4001,
.cra_name = "xts(aes)", .base.cra_name = "xts(aes)",
.cra_driver_name = "cavium-xts-aes", .base.cra_driver_name = "cavium-xts-aes",
.cra_type = &crypto_ablkcipher_type, .base.cra_module = THIS_MODULE,
.cra_u = {
.ablkcipher = { .ivsize = AES_BLOCK_SIZE,
.ivsize = AES_BLOCK_SIZE, .min_keysize = 2 * AES_MIN_KEY_SIZE,
.min_keysize = 2 * AES_MIN_KEY_SIZE, .max_keysize = 2 * AES_MAX_KEY_SIZE,
.max_keysize = 2 * AES_MAX_KEY_SIZE, .setkey = cvm_xts_setkey,
.setkey = cvm_xts_setkey, .encrypt = cvm_encrypt,
.encrypt = cvm_encrypt, .decrypt = cvm_decrypt,
.decrypt = cvm_decrypt, .init = cvm_enc_dec_init,
},
},
.cra_init = cvm_enc_dec_init,
.cra_module = THIS_MODULE,
}, { }, {
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, .base.cra_flags = CRYPTO_ALG_ASYNC,
.cra_blocksize = AES_BLOCK_SIZE, .base.cra_blocksize = AES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct cvm_enc_ctx), .base.cra_ctxsize = sizeof(struct cvm_enc_ctx),
.cra_alignmask = 7, .base.cra_alignmask = 7,
.cra_priority = 4001, .base.cra_priority = 4001,
.cra_name = "cbc(aes)", .base.cra_name = "cbc(aes)",
.cra_driver_name = "cavium-cbc-aes", .base.cra_driver_name = "cavium-cbc-aes",
.cra_type = &crypto_ablkcipher_type, .base.cra_module = THIS_MODULE,
.cra_u = {
.ablkcipher = { .ivsize = AES_BLOCK_SIZE,
.ivsize = AES_BLOCK_SIZE, .min_keysize = AES_MIN_KEY_SIZE,
.min_keysize = AES_MIN_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE, .setkey = cvm_cbc_aes_setkey,
.setkey = cvm_cbc_aes_setkey, .encrypt = cvm_encrypt,
.encrypt = cvm_encrypt, .decrypt = cvm_decrypt,
.decrypt = cvm_decrypt, .init = cvm_enc_dec_init,
},
},
.cra_init = cvm_enc_dec_init,
.cra_module = THIS_MODULE,
}, { }, {
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, .base.cra_flags = CRYPTO_ALG_ASYNC,
.cra_blocksize = AES_BLOCK_SIZE, .base.cra_blocksize = AES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct cvm_enc_ctx), .base.cra_ctxsize = sizeof(struct cvm_enc_ctx),
.cra_alignmask = 7, .base.cra_alignmask = 7,
.cra_priority = 4001, .base.cra_priority = 4001,
.cra_name = "ecb(aes)", .base.cra_name = "ecb(aes)",
.cra_driver_name = "cavium-ecb-aes", .base.cra_driver_name = "cavium-ecb-aes",
.cra_type = &crypto_ablkcipher_type, .base.cra_module = THIS_MODULE,
.cra_u = {
.ablkcipher = { .min_keysize = AES_MIN_KEY_SIZE,
.ivsize = AES_BLOCK_SIZE, .max_keysize = AES_MAX_KEY_SIZE,
.min_keysize = AES_MIN_KEY_SIZE, .setkey = cvm_ecb_aes_setkey,
.max_keysize = AES_MAX_KEY_SIZE, .encrypt = cvm_encrypt,
.setkey = cvm_ecb_aes_setkey, .decrypt = cvm_decrypt,
.encrypt = cvm_encrypt, .init = cvm_enc_dec_init,
.decrypt = cvm_decrypt,
},
},
.cra_init = cvm_enc_dec_init,
.cra_module = THIS_MODULE,
}, { }, {
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, .base.cra_flags = CRYPTO_ALG_ASYNC,
.cra_blocksize = AES_BLOCK_SIZE, .base.cra_blocksize = AES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct cvm_enc_ctx), .base.cra_ctxsize = sizeof(struct cvm_enc_ctx),
.cra_alignmask = 7, .base.cra_alignmask = 7,
.cra_priority = 4001, .base.cra_priority = 4001,
.cra_name = "cfb(aes)", .base.cra_name = "cfb(aes)",
.cra_driver_name = "cavium-cfb-aes", .base.cra_driver_name = "cavium-cfb-aes",
.cra_type = &crypto_ablkcipher_type, .base.cra_module = THIS_MODULE,
.cra_u = {
.ablkcipher = { .ivsize = AES_BLOCK_SIZE,
.ivsize = AES_BLOCK_SIZE, .min_keysize = AES_MIN_KEY_SIZE,
.min_keysize = AES_MIN_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE, .setkey = cvm_cfb_aes_setkey,
.setkey = cvm_cfb_aes_setkey, .encrypt = cvm_encrypt,
.encrypt = cvm_encrypt, .decrypt = cvm_decrypt,
.decrypt = cvm_decrypt, .init = cvm_enc_dec_init,
},
},
.cra_init = cvm_enc_dec_init,
.cra_module = THIS_MODULE,
}, { }, {
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, .base.cra_flags = CRYPTO_ALG_ASYNC,
.cra_blocksize = DES3_EDE_BLOCK_SIZE, .base.cra_blocksize = DES3_EDE_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct cvm_des3_ctx), .base.cra_ctxsize = sizeof(struct cvm_des3_ctx),
.cra_alignmask = 7, .base.cra_alignmask = 7,
.cra_priority = 4001, .base.cra_priority = 4001,
.cra_name = "cbc(des3_ede)", .base.cra_name = "cbc(des3_ede)",
.cra_driver_name = "cavium-cbc-des3_ede", .base.cra_driver_name = "cavium-cbc-des3_ede",
.cra_type = &crypto_ablkcipher_type, .base.cra_module = THIS_MODULE,
.cra_u = {
.ablkcipher = { .min_keysize = DES3_EDE_KEY_SIZE,
.min_keysize = DES3_EDE_KEY_SIZE, .max_keysize = DES3_EDE_KEY_SIZE,
.max_keysize = DES3_EDE_KEY_SIZE, .ivsize = DES_BLOCK_SIZE,
.ivsize = DES_BLOCK_SIZE, .setkey = cvm_cbc_des3_setkey,
.setkey = cvm_cbc_des3_setkey, .encrypt = cvm_encrypt,
.encrypt = cvm_encrypt, .decrypt = cvm_decrypt,
.decrypt = cvm_decrypt, .init = cvm_enc_dec_init,
},
},
.cra_init = cvm_enc_dec_init,
.cra_module = THIS_MODULE,
}, { }, {
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, .base.cra_flags = CRYPTO_ALG_ASYNC,
.cra_blocksize = DES3_EDE_BLOCK_SIZE, .base.cra_blocksize = DES3_EDE_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct cvm_des3_ctx), .base.cra_ctxsize = sizeof(struct cvm_des3_ctx),
.cra_alignmask = 7, .base.cra_alignmask = 7,
.cra_priority = 4001, .base.cra_priority = 4001,
.cra_name = "ecb(des3_ede)", .base.cra_name = "ecb(des3_ede)",
.cra_driver_name = "cavium-ecb-des3_ede", .base.cra_driver_name = "cavium-ecb-des3_ede",
.cra_type = &crypto_ablkcipher_type, .base.cra_module = THIS_MODULE,
.cra_u = {
.ablkcipher = { .min_keysize = DES3_EDE_KEY_SIZE,
.min_keysize = DES3_EDE_KEY_SIZE, .max_keysize = DES3_EDE_KEY_SIZE,
.max_keysize = DES3_EDE_KEY_SIZE, .ivsize = DES_BLOCK_SIZE,
.ivsize = DES_BLOCK_SIZE, .setkey = cvm_ecb_des3_setkey,
.setkey = cvm_ecb_des3_setkey, .encrypt = cvm_encrypt,
.encrypt = cvm_encrypt, .decrypt = cvm_decrypt,
.decrypt = cvm_decrypt, .init = cvm_enc_dec_init,
},
},
.cra_init = cvm_enc_dec_init,
.cra_module = THIS_MODULE,
} }; } };
static inline int cav_register_algs(void) static inline int cav_register_algs(void)
{ {
int err = 0; int err = 0;
err = crypto_register_algs(algs, ARRAY_SIZE(algs)); err = crypto_register_skciphers(algs, ARRAY_SIZE(algs));
if (err) if (err)
return err; return err;
...@@ -480,7 +456,7 @@ static inline int cav_register_algs(void) ...@@ -480,7 +456,7 @@ static inline int cav_register_algs(void)
static inline void cav_unregister_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) int cvm_crypto_init(struct cpt_vf *cptvf)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7