1 // SPDX-License-Identifier: GPL-2.0 2 /* Marvell OcteonTX CPT driver 3 * 4 * Copyright (C) 2019 Marvell International Ltd. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10 11 #include <crypto/aes.h> 12 #include <crypto/authenc.h> 13 #include <crypto/cryptd.h> 14 #include <crypto/des.h> 15 #include <crypto/internal/aead.h> 16 #include <crypto/sha1.h> 17 #include <crypto/sha2.h> 18 #include <crypto/xts.h> 19 #include <crypto/scatterwalk.h> 20 #include <linux/rtnetlink.h> 21 #include <linux/sort.h> 22 #include <linux/module.h> 23 #include "otx_cptvf.h" 24 #include "otx_cptvf_algs.h" 25 #include "otx_cptvf_reqmgr.h" 26 27 #define CPT_MAX_VF_NUM 64 28 /* Size of salt in AES GCM mode */ 29 #define AES_GCM_SALT_SIZE 4 30 /* Size of IV in AES GCM mode */ 31 #define AES_GCM_IV_SIZE 8 32 /* Size of ICV (Integrity Check Value) in AES GCM mode */ 33 #define AES_GCM_ICV_SIZE 16 34 /* Offset of IV in AES GCM mode */ 35 #define AES_GCM_IV_OFFSET 8 36 #define CONTROL_WORD_LEN 8 37 #define KEY2_OFFSET 48 38 #define DMA_MODE_FLAG(dma_mode) \ 39 (((dma_mode) == OTX_CPT_DMA_GATHER_SCATTER) ? (1 << 7) : 0) 40 41 /* Truncated SHA digest size */ 42 #define SHA1_TRUNC_DIGEST_SIZE 12 43 #define SHA256_TRUNC_DIGEST_SIZE 16 44 #define SHA384_TRUNC_DIGEST_SIZE 24 45 #define SHA512_TRUNC_DIGEST_SIZE 32 46 47 static DEFINE_MUTEX(mutex); 48 static int is_crypto_registered; 49 50 struct cpt_device_desc { 51 enum otx_cptpf_type pf_type; 52 struct pci_dev *dev; 53 int num_queues; 54 }; 55 56 struct cpt_device_table { 57 atomic_t count; 58 struct cpt_device_desc desc[CPT_MAX_VF_NUM]; 59 }; 60 61 static struct cpt_device_table se_devices = { 62 .count = ATOMIC_INIT(0) 63 }; 64 65 static struct cpt_device_table ae_devices = { 66 .count = ATOMIC_INIT(0) 67 }; 68 69 static inline int get_se_device(struct pci_dev **pdev, int *cpu_num) 70 { 71 int count, ret = 0; 72 73 count = atomic_read(&se_devices.count); 74 if (count < 1) 75 return -ENODEV; 76 77 *cpu_num = get_cpu(); 78 79 if (se_devices.desc[0].pf_type == OTX_CPT_SE) { 80 /* 81 * On OcteonTX platform there is one CPT instruction queue bound 82 * to each VF. We get maximum performance if one CPT queue 83 * is available for each cpu otherwise CPT queues need to be 84 * shared between cpus. 85 */ 86 if (*cpu_num >= count) 87 *cpu_num %= count; 88 *pdev = se_devices.desc[*cpu_num].dev; 89 } else { 90 pr_err("Unknown PF type %d\n", se_devices.desc[0].pf_type); 91 ret = -EINVAL; 92 } 93 put_cpu(); 94 95 return ret; 96 } 97 98 static inline int validate_hmac_cipher_null(struct otx_cpt_req_info *cpt_req) 99 { 100 struct otx_cpt_req_ctx *rctx; 101 struct aead_request *req; 102 struct crypto_aead *tfm; 103 104 req = container_of(cpt_req->areq, struct aead_request, base); 105 tfm = crypto_aead_reqtfm(req); 106 rctx = aead_request_ctx_dma(req); 107 if (memcmp(rctx->fctx.hmac.s.hmac_calc, 108 rctx->fctx.hmac.s.hmac_recv, 109 crypto_aead_authsize(tfm)) != 0) 110 return -EBADMSG; 111 112 return 0; 113 } 114 115 static void otx_cpt_aead_callback(int status, void *arg1, void *arg2) 116 { 117 struct otx_cpt_info_buffer *cpt_info = arg2; 118 struct crypto_async_request *areq = arg1; 119 struct otx_cpt_req_info *cpt_req; 120 struct pci_dev *pdev; 121 122 if (!cpt_info) 123 goto complete; 124 125 cpt_req = cpt_info->req; 126 if (!status) { 127 /* 128 * When selected cipher is NULL we need to manually 129 * verify whether calculated hmac value matches 130 * received hmac value 131 */ 132 if (cpt_req->req_type == OTX_CPT_AEAD_ENC_DEC_NULL_REQ && 133 !cpt_req->is_enc) 134 status = validate_hmac_cipher_null(cpt_req); 135 } 136 pdev = cpt_info->pdev; 137 do_request_cleanup(pdev, cpt_info); 138 139 complete: 140 if (areq) 141 areq->complete(areq, status); 142 } 143 144 static void output_iv_copyback(struct crypto_async_request *areq) 145 { 146 struct otx_cpt_req_info *req_info; 147 struct skcipher_request *sreq; 148 struct crypto_skcipher *stfm; 149 struct otx_cpt_req_ctx *rctx; 150 struct otx_cpt_enc_ctx *ctx; 151 u32 start, ivsize; 152 153 sreq = container_of(areq, struct skcipher_request, base); 154 stfm = crypto_skcipher_reqtfm(sreq); 155 ctx = crypto_skcipher_ctx(stfm); 156 if (ctx->cipher_type == OTX_CPT_AES_CBC || 157 ctx->cipher_type == OTX_CPT_DES3_CBC) { 158 rctx = skcipher_request_ctx_dma(sreq); 159 req_info = &rctx->cpt_req; 160 ivsize = crypto_skcipher_ivsize(stfm); 161 start = sreq->cryptlen - ivsize; 162 163 if (req_info->is_enc) { 164 scatterwalk_map_and_copy(sreq->iv, sreq->dst, start, 165 ivsize, 0); 166 } else { 167 if (sreq->src != sreq->dst) { 168 scatterwalk_map_and_copy(sreq->iv, sreq->src, 169 start, ivsize, 0); 170 } else { 171 memcpy(sreq->iv, req_info->iv_out, ivsize); 172 kfree(req_info->iv_out); 173 } 174 } 175 } 176 } 177 178 static void otx_cpt_skcipher_callback(int status, void *arg1, void *arg2) 179 { 180 struct otx_cpt_info_buffer *cpt_info = arg2; 181 struct crypto_async_request *areq = arg1; 182 struct pci_dev *pdev; 183 184 if (areq) { 185 if (!status) 186 output_iv_copyback(areq); 187 if (cpt_info) { 188 pdev = cpt_info->pdev; 189 do_request_cleanup(pdev, cpt_info); 190 } 191 areq->complete(areq, status); 192 } 193 } 194 195 static inline void update_input_data(struct otx_cpt_req_info *req_info, 196 struct scatterlist *inp_sg, 197 u32 nbytes, u32 *argcnt) 198 { 199 req_info->req.dlen += nbytes; 200 201 while (nbytes) { 202 u32 len = min(nbytes, inp_sg->length); 203 u8 *ptr = sg_virt(inp_sg); 204 205 req_info->in[*argcnt].vptr = (void *)ptr; 206 req_info->in[*argcnt].size = len; 207 nbytes -= len; 208 ++(*argcnt); 209 inp_sg = sg_next(inp_sg); 210 } 211 } 212 213 static inline void update_output_data(struct otx_cpt_req_info *req_info, 214 struct scatterlist *outp_sg, 215 u32 offset, u32 nbytes, u32 *argcnt) 216 { 217 req_info->rlen += nbytes; 218 219 while (nbytes) { 220 u32 len = min(nbytes, outp_sg->length - offset); 221 u8 *ptr = sg_virt(outp_sg); 222 223 req_info->out[*argcnt].vptr = (void *) (ptr + offset); 224 req_info->out[*argcnt].size = len; 225 nbytes -= len; 226 ++(*argcnt); 227 offset = 0; 228 outp_sg = sg_next(outp_sg); 229 } 230 } 231 232 static inline u32 create_ctx_hdr(struct skcipher_request *req, u32 enc, 233 u32 *argcnt) 234 { 235 struct crypto_skcipher *stfm = crypto_skcipher_reqtfm(req); 236 struct otx_cpt_req_ctx *rctx = skcipher_request_ctx_dma(req); 237 struct otx_cpt_req_info *req_info = &rctx->cpt_req; 238 struct crypto_tfm *tfm = crypto_skcipher_tfm(stfm); 239 struct otx_cpt_enc_ctx *ctx = crypto_tfm_ctx(tfm); 240 struct otx_cpt_fc_ctx *fctx = &rctx->fctx; 241 int ivsize = crypto_skcipher_ivsize(stfm); 242 u32 start = req->cryptlen - ivsize; 243 gfp_t flags; 244 245 flags = (req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) ? 246 GFP_KERNEL : GFP_ATOMIC; 247 req_info->ctrl.s.dma_mode = OTX_CPT_DMA_GATHER_SCATTER; 248 req_info->ctrl.s.se_req = OTX_CPT_SE_CORE_REQ; 249 250 req_info->req.opcode.s.major = OTX_CPT_MAJOR_OP_FC | 251 DMA_MODE_FLAG(OTX_CPT_DMA_GATHER_SCATTER); 252 if (enc) { 253 req_info->req.opcode.s.minor = 2; 254 } else { 255 req_info->req.opcode.s.minor = 3; 256 if ((ctx->cipher_type == OTX_CPT_AES_CBC || 257 ctx->cipher_type == OTX_CPT_DES3_CBC) && 258 req->src == req->dst) { 259 req_info->iv_out = kmalloc(ivsize, flags); 260 if (!req_info->iv_out) 261 return -ENOMEM; 262 263 scatterwalk_map_and_copy(req_info->iv_out, req->src, 264 start, ivsize, 0); 265 } 266 } 267 /* Encryption data length */ 268 req_info->req.param1 = req->cryptlen; 269 /* Authentication data length */ 270 req_info->req.param2 = 0; 271 272 fctx->enc.enc_ctrl.e.enc_cipher = ctx->cipher_type; 273 fctx->enc.enc_ctrl.e.aes_key = ctx->key_type; 274 fctx->enc.enc_ctrl.e.iv_source = OTX_CPT_FROM_CPTR; 275 276 if (ctx->cipher_type == OTX_CPT_AES_XTS) 277 memcpy(fctx->enc.encr_key, ctx->enc_key, ctx->key_len * 2); 278 else 279 memcpy(fctx->enc.encr_key, ctx->enc_key, ctx->key_len); 280 281 memcpy(fctx->enc.encr_iv, req->iv, crypto_skcipher_ivsize(stfm)); 282 283 fctx->enc.enc_ctrl.flags = cpu_to_be64(fctx->enc.enc_ctrl.cflags); 284 285 /* 286 * Storing Packet Data Information in offset 287 * Control Word First 8 bytes 288 */ 289 req_info->in[*argcnt].vptr = (u8 *)&rctx->ctrl_word; 290 req_info->in[*argcnt].size = CONTROL_WORD_LEN; 291 req_info->req.dlen += CONTROL_WORD_LEN; 292 ++(*argcnt); 293 294 req_info->in[*argcnt].vptr = (u8 *)fctx; 295 req_info->in[*argcnt].size = sizeof(struct otx_cpt_fc_ctx); 296 req_info->req.dlen += sizeof(struct otx_cpt_fc_ctx); 297 298 ++(*argcnt); 299 300 return 0; 301 } 302 303 static inline u32 create_input_list(struct skcipher_request *req, u32 enc, 304 u32 enc_iv_len) 305 { 306 struct otx_cpt_req_ctx *rctx = skcipher_request_ctx_dma(req); 307 struct otx_cpt_req_info *req_info = &rctx->cpt_req; 308 u32 argcnt = 0; 309 int ret; 310 311 ret = create_ctx_hdr(req, enc, &argcnt); 312 if (ret) 313 return ret; 314 315 update_input_data(req_info, req->src, req->cryptlen, &argcnt); 316 req_info->incnt = argcnt; 317 318 return 0; 319 } 320 321 static inline void create_output_list(struct skcipher_request *req, 322 u32 enc_iv_len) 323 { 324 struct otx_cpt_req_ctx *rctx = skcipher_request_ctx_dma(req); 325 struct otx_cpt_req_info *req_info = &rctx->cpt_req; 326 u32 argcnt = 0; 327 328 /* 329 * OUTPUT Buffer Processing 330 * AES encryption/decryption output would be 331 * received in the following format 332 * 333 * ------IV--------|------ENCRYPTED/DECRYPTED DATA-----| 334 * [ 16 Bytes/ [ Request Enc/Dec/ DATA Len AES CBC ] 335 */ 336 update_output_data(req_info, req->dst, 0, req->cryptlen, &argcnt); 337 req_info->outcnt = argcnt; 338 } 339 340 static inline int cpt_enc_dec(struct skcipher_request *req, u32 enc) 341 { 342 struct crypto_skcipher *stfm = crypto_skcipher_reqtfm(req); 343 struct otx_cpt_req_ctx *rctx = skcipher_request_ctx_dma(req); 344 struct otx_cpt_req_info *req_info = &rctx->cpt_req; 345 u32 enc_iv_len = crypto_skcipher_ivsize(stfm); 346 struct pci_dev *pdev; 347 int status, cpu_num; 348 349 /* Validate that request doesn't exceed maximum CPT supported size */ 350 if (req->cryptlen > OTX_CPT_MAX_REQ_SIZE) 351 return -E2BIG; 352 353 /* Clear control words */ 354 rctx->ctrl_word.flags = 0; 355 rctx->fctx.enc.enc_ctrl.flags = 0; 356 357 status = create_input_list(req, enc, enc_iv_len); 358 if (status) 359 return status; 360 create_output_list(req, enc_iv_len); 361 362 status = get_se_device(&pdev, &cpu_num); 363 if (status) 364 return status; 365 366 req_info->callback = (void *)otx_cpt_skcipher_callback; 367 req_info->areq = &req->base; 368 req_info->req_type = OTX_CPT_ENC_DEC_REQ; 369 req_info->is_enc = enc; 370 req_info->is_trunc_hmac = false; 371 req_info->ctrl.s.grp = 0; 372 373 /* 374 * We perform an asynchronous send and once 375 * the request is completed the driver would 376 * intimate through registered call back functions 377 */ 378 status = otx_cpt_do_request(pdev, req_info, cpu_num); 379 380 return status; 381 } 382 383 static int otx_cpt_skcipher_encrypt(struct skcipher_request *req) 384 { 385 return cpt_enc_dec(req, true); 386 } 387 388 static int otx_cpt_skcipher_decrypt(struct skcipher_request *req) 389 { 390 return cpt_enc_dec(req, false); 391 } 392 393 static int otx_cpt_skcipher_xts_setkey(struct crypto_skcipher *tfm, 394 const u8 *key, u32 keylen) 395 { 396 struct otx_cpt_enc_ctx *ctx = crypto_skcipher_ctx(tfm); 397 const u8 *key2 = key + (keylen / 2); 398 const u8 *key1 = key; 399 int ret; 400 401 ret = xts_check_key(crypto_skcipher_tfm(tfm), key, keylen); 402 if (ret) 403 return ret; 404 ctx->key_len = keylen; 405 memcpy(ctx->enc_key, key1, keylen / 2); 406 memcpy(ctx->enc_key + KEY2_OFFSET, key2, keylen / 2); 407 ctx->cipher_type = OTX_CPT_AES_XTS; 408 switch (ctx->key_len) { 409 case 2 * AES_KEYSIZE_128: 410 ctx->key_type = OTX_CPT_AES_128_BIT; 411 break; 412 case 2 * AES_KEYSIZE_256: 413 ctx->key_type = OTX_CPT_AES_256_BIT; 414 break; 415 default: 416 return -EINVAL; 417 } 418 419 return 0; 420 } 421 422 static int cpt_des_setkey(struct crypto_skcipher *tfm, const u8 *key, 423 u32 keylen, u8 cipher_type) 424 { 425 struct otx_cpt_enc_ctx *ctx = crypto_skcipher_ctx(tfm); 426 427 if (keylen != DES3_EDE_KEY_SIZE) 428 return -EINVAL; 429 430 ctx->key_len = keylen; 431 ctx->cipher_type = cipher_type; 432 433 memcpy(ctx->enc_key, key, keylen); 434 435 return 0; 436 } 437 438 static int cpt_aes_setkey(struct crypto_skcipher *tfm, const u8 *key, 439 u32 keylen, u8 cipher_type) 440 { 441 struct otx_cpt_enc_ctx *ctx = crypto_skcipher_ctx(tfm); 442 443 switch (keylen) { 444 case AES_KEYSIZE_128: 445 ctx->key_type = OTX_CPT_AES_128_BIT; 446 break; 447 case AES_KEYSIZE_192: 448 ctx->key_type = OTX_CPT_AES_192_BIT; 449 break; 450 case AES_KEYSIZE_256: 451 ctx->key_type = OTX_CPT_AES_256_BIT; 452 break; 453 default: 454 return -EINVAL; 455 } 456 ctx->key_len = keylen; 457 ctx->cipher_type = cipher_type; 458 459 memcpy(ctx->enc_key, key, keylen); 460 461 return 0; 462 } 463 464 static int otx_cpt_skcipher_cbc_aes_setkey(struct crypto_skcipher *tfm, 465 const u8 *key, u32 keylen) 466 { 467 return cpt_aes_setkey(tfm, key, keylen, OTX_CPT_AES_CBC); 468 } 469 470 static int otx_cpt_skcipher_ecb_aes_setkey(struct crypto_skcipher *tfm, 471 const u8 *key, u32 keylen) 472 { 473 return cpt_aes_setkey(tfm, key, keylen, OTX_CPT_AES_ECB); 474 } 475 476 static int otx_cpt_skcipher_cfb_aes_setkey(struct crypto_skcipher *tfm, 477 const u8 *key, u32 keylen) 478 { 479 return cpt_aes_setkey(tfm, key, keylen, OTX_CPT_AES_CFB); 480 } 481 482 static int otx_cpt_skcipher_cbc_des3_setkey(struct crypto_skcipher *tfm, 483 const u8 *key, u32 keylen) 484 { 485 return cpt_des_setkey(tfm, key, keylen, OTX_CPT_DES3_CBC); 486 } 487 488 static int otx_cpt_skcipher_ecb_des3_setkey(struct crypto_skcipher *tfm, 489 const u8 *key, u32 keylen) 490 { 491 return cpt_des_setkey(tfm, key, keylen, OTX_CPT_DES3_ECB); 492 } 493 494 static int otx_cpt_enc_dec_init(struct crypto_skcipher *tfm) 495 { 496 struct otx_cpt_enc_ctx *ctx = crypto_skcipher_ctx(tfm); 497 498 memset(ctx, 0, sizeof(*ctx)); 499 /* 500 * Additional memory for skcipher_request is 501 * allocated since the cryptd daemon uses 502 * this memory for request_ctx information 503 */ 504 crypto_skcipher_set_reqsize_dma( 505 tfm, sizeof(struct otx_cpt_req_ctx) + 506 sizeof(struct skcipher_request)); 507 508 return 0; 509 } 510 511 static int cpt_aead_init(struct crypto_aead *tfm, u8 cipher_type, u8 mac_type) 512 { 513 struct otx_cpt_aead_ctx *ctx = crypto_aead_ctx_dma(tfm); 514 515 ctx->cipher_type = cipher_type; 516 ctx->mac_type = mac_type; 517 518 /* 519 * When selected cipher is NULL we use HMAC opcode instead of 520 * FLEXICRYPTO opcode therefore we don't need to use HASH algorithms 521 * for calculating ipad and opad 522 */ 523 if (ctx->cipher_type != OTX_CPT_CIPHER_NULL) { 524 switch (ctx->mac_type) { 525 case OTX_CPT_SHA1: 526 ctx->hashalg = crypto_alloc_shash("sha1", 0, 527 CRYPTO_ALG_ASYNC); 528 if (IS_ERR(ctx->hashalg)) 529 return PTR_ERR(ctx->hashalg); 530 break; 531 532 case OTX_CPT_SHA256: 533 ctx->hashalg = crypto_alloc_shash("sha256", 0, 534 CRYPTO_ALG_ASYNC); 535 if (IS_ERR(ctx->hashalg)) 536 return PTR_ERR(ctx->hashalg); 537 break; 538 539 case OTX_CPT_SHA384: 540 ctx->hashalg = crypto_alloc_shash("sha384", 0, 541 CRYPTO_ALG_ASYNC); 542 if (IS_ERR(ctx->hashalg)) 543 return PTR_ERR(ctx->hashalg); 544 break; 545 546 case OTX_CPT_SHA512: 547 ctx->hashalg = crypto_alloc_shash("sha512", 0, 548 CRYPTO_ALG_ASYNC); 549 if (IS_ERR(ctx->hashalg)) 550 return PTR_ERR(ctx->hashalg); 551 break; 552 } 553 } 554 555 crypto_aead_set_reqsize_dma(tfm, sizeof(struct otx_cpt_req_ctx)); 556 557 return 0; 558 } 559 560 static int otx_cpt_aead_cbc_aes_sha1_init(struct crypto_aead *tfm) 561 { 562 return cpt_aead_init(tfm, OTX_CPT_AES_CBC, OTX_CPT_SHA1); 563 } 564 565 static int otx_cpt_aead_cbc_aes_sha256_init(struct crypto_aead *tfm) 566 { 567 return cpt_aead_init(tfm, OTX_CPT_AES_CBC, OTX_CPT_SHA256); 568 } 569 570 static int otx_cpt_aead_cbc_aes_sha384_init(struct crypto_aead *tfm) 571 { 572 return cpt_aead_init(tfm, OTX_CPT_AES_CBC, OTX_CPT_SHA384); 573 } 574 575 static int otx_cpt_aead_cbc_aes_sha512_init(struct crypto_aead *tfm) 576 { 577 return cpt_aead_init(tfm, OTX_CPT_AES_CBC, OTX_CPT_SHA512); 578 } 579 580 static int otx_cpt_aead_ecb_null_sha1_init(struct crypto_aead *tfm) 581 { 582 return cpt_aead_init(tfm, OTX_CPT_CIPHER_NULL, OTX_CPT_SHA1); 583 } 584 585 static int otx_cpt_aead_ecb_null_sha256_init(struct crypto_aead *tfm) 586 { 587 return cpt_aead_init(tfm, OTX_CPT_CIPHER_NULL, OTX_CPT_SHA256); 588 } 589 590 static int otx_cpt_aead_ecb_null_sha384_init(struct crypto_aead *tfm) 591 { 592 return cpt_aead_init(tfm, OTX_CPT_CIPHER_NULL, OTX_CPT_SHA384); 593 } 594 595 static int otx_cpt_aead_ecb_null_sha512_init(struct crypto_aead *tfm) 596 { 597 return cpt_aead_init(tfm, OTX_CPT_CIPHER_NULL, OTX_CPT_SHA512); 598 } 599 600 static int otx_cpt_aead_gcm_aes_init(struct crypto_aead *tfm) 601 { 602 return cpt_aead_init(tfm, OTX_CPT_AES_GCM, OTX_CPT_MAC_NULL); 603 } 604 605 static void otx_cpt_aead_exit(struct crypto_aead *tfm) 606 { 607 struct otx_cpt_aead_ctx *ctx = crypto_aead_ctx_dma(tfm); 608 609 kfree(ctx->ipad); 610 kfree(ctx->opad); 611 if (ctx->hashalg) 612 crypto_free_shash(ctx->hashalg); 613 kfree(ctx->sdesc); 614 } 615 616 /* 617 * This is the Integrity Check Value validation (aka the authentication tag 618 * length) 619 */ 620 static int otx_cpt_aead_set_authsize(struct crypto_aead *tfm, 621 unsigned int authsize) 622 { 623 struct otx_cpt_aead_ctx *ctx = crypto_aead_ctx_dma(tfm); 624 625 switch (ctx->mac_type) { 626 case OTX_CPT_SHA1: 627 if (authsize != SHA1_DIGEST_SIZE && 628 authsize != SHA1_TRUNC_DIGEST_SIZE) 629 return -EINVAL; 630 631 if (authsize == SHA1_TRUNC_DIGEST_SIZE) 632 ctx->is_trunc_hmac = true; 633 break; 634 635 case OTX_CPT_SHA256: 636 if (authsize != SHA256_DIGEST_SIZE && 637 authsize != SHA256_TRUNC_DIGEST_SIZE) 638 return -EINVAL; 639 640 if (authsize == SHA256_TRUNC_DIGEST_SIZE) 641 ctx->is_trunc_hmac = true; 642 break; 643 644 case OTX_CPT_SHA384: 645 if (authsize != SHA384_DIGEST_SIZE && 646 authsize != SHA384_TRUNC_DIGEST_SIZE) 647 return -EINVAL; 648 649 if (authsize == SHA384_TRUNC_DIGEST_SIZE) 650 ctx->is_trunc_hmac = true; 651 break; 652 653 case OTX_CPT_SHA512: 654 if (authsize != SHA512_DIGEST_SIZE && 655 authsize != SHA512_TRUNC_DIGEST_SIZE) 656 return -EINVAL; 657 658 if (authsize == SHA512_TRUNC_DIGEST_SIZE) 659 ctx->is_trunc_hmac = true; 660 break; 661 662 case OTX_CPT_MAC_NULL: 663 if (ctx->cipher_type == OTX_CPT_AES_GCM) { 664 if (authsize != AES_GCM_ICV_SIZE) 665 return -EINVAL; 666 } else 667 return -EINVAL; 668 break; 669 670 default: 671 return -EINVAL; 672 } 673 674 tfm->authsize = authsize; 675 return 0; 676 } 677 678 static struct otx_cpt_sdesc *alloc_sdesc(struct crypto_shash *alg) 679 { 680 struct otx_cpt_sdesc *sdesc; 681 int size; 682 683 size = sizeof(struct shash_desc) + crypto_shash_descsize(alg); 684 sdesc = kmalloc(size, GFP_KERNEL); 685 if (!sdesc) 686 return NULL; 687 688 sdesc->shash.tfm = alg; 689 690 return sdesc; 691 } 692 693 static inline void swap_data32(void *buf, u32 len) 694 { 695 cpu_to_be32_array(buf, buf, len / 4); 696 } 697 698 static inline void swap_data64(void *buf, u32 len) 699 { 700 __be64 *dst = buf; 701 u64 *src = buf; 702 int i = 0; 703 704 for (i = 0 ; i < len / 8; i++, src++, dst++) 705 *dst = cpu_to_be64p(src); 706 } 707 708 static int copy_pad(u8 mac_type, u8 *out_pad, u8 *in_pad) 709 { 710 struct sha512_state *sha512; 711 struct sha256_state *sha256; 712 struct sha1_state *sha1; 713 714 switch (mac_type) { 715 case OTX_CPT_SHA1: 716 sha1 = (struct sha1_state *) in_pad; 717 swap_data32(sha1->state, SHA1_DIGEST_SIZE); 718 memcpy(out_pad, &sha1->state, SHA1_DIGEST_SIZE); 719 break; 720 721 case OTX_CPT_SHA256: 722 sha256 = (struct sha256_state *) in_pad; 723 swap_data32(sha256->state, SHA256_DIGEST_SIZE); 724 memcpy(out_pad, &sha256->state, SHA256_DIGEST_SIZE); 725 break; 726 727 case OTX_CPT_SHA384: 728 case OTX_CPT_SHA512: 729 sha512 = (struct sha512_state *) in_pad; 730 swap_data64(sha512->state, SHA512_DIGEST_SIZE); 731 memcpy(out_pad, &sha512->state, SHA512_DIGEST_SIZE); 732 break; 733 734 default: 735 return -EINVAL; 736 } 737 738 return 0; 739 } 740 741 static int aead_hmac_init(struct crypto_aead *cipher) 742 { 743 struct otx_cpt_aead_ctx *ctx = crypto_aead_ctx_dma(cipher); 744 int state_size = crypto_shash_statesize(ctx->hashalg); 745 int ds = crypto_shash_digestsize(ctx->hashalg); 746 int bs = crypto_shash_blocksize(ctx->hashalg); 747 int authkeylen = ctx->auth_key_len; 748 u8 *ipad = NULL, *opad = NULL; 749 int ret = 0, icount = 0; 750 751 ctx->sdesc = alloc_sdesc(ctx->hashalg); 752 if (!ctx->sdesc) 753 return -ENOMEM; 754 755 ctx->ipad = kzalloc(bs, GFP_KERNEL); 756 if (!ctx->ipad) { 757 ret = -ENOMEM; 758 goto calc_fail; 759 } 760 761 ctx->opad = kzalloc(bs, GFP_KERNEL); 762 if (!ctx->opad) { 763 ret = -ENOMEM; 764 goto calc_fail; 765 } 766 767 ipad = kzalloc(state_size, GFP_KERNEL); 768 if (!ipad) { 769 ret = -ENOMEM; 770 goto calc_fail; 771 } 772 773 opad = kzalloc(state_size, GFP_KERNEL); 774 if (!opad) { 775 ret = -ENOMEM; 776 goto calc_fail; 777 } 778 779 if (authkeylen > bs) { 780 ret = crypto_shash_digest(&ctx->sdesc->shash, ctx->key, 781 authkeylen, ipad); 782 if (ret) 783 goto calc_fail; 784 785 authkeylen = ds; 786 } else { 787 memcpy(ipad, ctx->key, authkeylen); 788 } 789 790 memset(ipad + authkeylen, 0, bs - authkeylen); 791 memcpy(opad, ipad, bs); 792 793 for (icount = 0; icount < bs; icount++) { 794 ipad[icount] ^= 0x36; 795 opad[icount] ^= 0x5c; 796 } 797 798 /* 799 * Partial Hash calculated from the software 800 * algorithm is retrieved for IPAD & OPAD 801 */ 802 803 /* IPAD Calculation */ 804 crypto_shash_init(&ctx->sdesc->shash); 805 crypto_shash_update(&ctx->sdesc->shash, ipad, bs); 806 crypto_shash_export(&ctx->sdesc->shash, ipad); 807 ret = copy_pad(ctx->mac_type, ctx->ipad, ipad); 808 if (ret) 809 goto calc_fail; 810 811 /* OPAD Calculation */ 812 crypto_shash_init(&ctx->sdesc->shash); 813 crypto_shash_update(&ctx->sdesc->shash, opad, bs); 814 crypto_shash_export(&ctx->sdesc->shash, opad); 815 ret = copy_pad(ctx->mac_type, ctx->opad, opad); 816 if (ret) 817 goto calc_fail; 818 819 kfree(ipad); 820 kfree(opad); 821 822 return 0; 823 824 calc_fail: 825 kfree(ctx->ipad); 826 ctx->ipad = NULL; 827 kfree(ctx->opad); 828 ctx->opad = NULL; 829 kfree(ipad); 830 kfree(opad); 831 kfree(ctx->sdesc); 832 ctx->sdesc = NULL; 833 834 return ret; 835 } 836 837 static int otx_cpt_aead_cbc_aes_sha_setkey(struct crypto_aead *cipher, 838 const unsigned char *key, 839 unsigned int keylen) 840 { 841 struct otx_cpt_aead_ctx *ctx = crypto_aead_ctx_dma(cipher); 842 struct crypto_authenc_key_param *param; 843 int enckeylen = 0, authkeylen = 0; 844 struct rtattr *rta = (void *)key; 845 int status = -EINVAL; 846 847 if (!RTA_OK(rta, keylen)) 848 goto badkey; 849 850 if (rta->rta_type != CRYPTO_AUTHENC_KEYA_PARAM) 851 goto badkey; 852 853 if (RTA_PAYLOAD(rta) < sizeof(*param)) 854 goto badkey; 855 856 param = RTA_DATA(rta); 857 enckeylen = be32_to_cpu(param->enckeylen); 858 key += RTA_ALIGN(rta->rta_len); 859 keylen -= RTA_ALIGN(rta->rta_len); 860 if (keylen < enckeylen) 861 goto badkey; 862 863 if (keylen > OTX_CPT_MAX_KEY_SIZE) 864 goto badkey; 865 866 authkeylen = keylen - enckeylen; 867 memcpy(ctx->key, key, keylen); 868 869 switch (enckeylen) { 870 case AES_KEYSIZE_128: 871 ctx->key_type = OTX_CPT_AES_128_BIT; 872 break; 873 case AES_KEYSIZE_192: 874 ctx->key_type = OTX_CPT_AES_192_BIT; 875 break; 876 case AES_KEYSIZE_256: 877 ctx->key_type = OTX_CPT_AES_256_BIT; 878 break; 879 default: 880 /* Invalid key length */ 881 goto badkey; 882 } 883 884 ctx->enc_key_len = enckeylen; 885 ctx->auth_key_len = authkeylen; 886 887 status = aead_hmac_init(cipher); 888 if (status) 889 goto badkey; 890 891 return 0; 892 badkey: 893 return status; 894 } 895 896 static int otx_cpt_aead_ecb_null_sha_setkey(struct crypto_aead *cipher, 897 const unsigned char *key, 898 unsigned int keylen) 899 { 900 struct otx_cpt_aead_ctx *ctx = crypto_aead_ctx_dma(cipher); 901 struct crypto_authenc_key_param *param; 902 struct rtattr *rta = (void *)key; 903 int enckeylen = 0; 904 905 if (!RTA_OK(rta, keylen)) 906 goto badkey; 907 908 if (rta->rta_type != CRYPTO_AUTHENC_KEYA_PARAM) 909 goto badkey; 910 911 if (RTA_PAYLOAD(rta) < sizeof(*param)) 912 goto badkey; 913 914 param = RTA_DATA(rta); 915 enckeylen = be32_to_cpu(param->enckeylen); 916 key += RTA_ALIGN(rta->rta_len); 917 keylen -= RTA_ALIGN(rta->rta_len); 918 if (enckeylen != 0) 919 goto badkey; 920 921 if (keylen > OTX_CPT_MAX_KEY_SIZE) 922 goto badkey; 923 924 memcpy(ctx->key, key, keylen); 925 ctx->enc_key_len = enckeylen; 926 ctx->auth_key_len = keylen; 927 return 0; 928 badkey: 929 return -EINVAL; 930 } 931 932 static int otx_cpt_aead_gcm_aes_setkey(struct crypto_aead *cipher, 933 const unsigned char *key, 934 unsigned int keylen) 935 { 936 struct otx_cpt_aead_ctx *ctx = crypto_aead_ctx_dma(cipher); 937 938 /* 939 * For aes gcm we expect to get encryption key (16, 24, 32 bytes) 940 * and salt (4 bytes) 941 */ 942 switch (keylen) { 943 case AES_KEYSIZE_128 + AES_GCM_SALT_SIZE: 944 ctx->key_type = OTX_CPT_AES_128_BIT; 945 ctx->enc_key_len = AES_KEYSIZE_128; 946 break; 947 case AES_KEYSIZE_192 + AES_GCM_SALT_SIZE: 948 ctx->key_type = OTX_CPT_AES_192_BIT; 949 ctx->enc_key_len = AES_KEYSIZE_192; 950 break; 951 case AES_KEYSIZE_256 + AES_GCM_SALT_SIZE: 952 ctx->key_type = OTX_CPT_AES_256_BIT; 953 ctx->enc_key_len = AES_KEYSIZE_256; 954 break; 955 default: 956 /* Invalid key and salt length */ 957 return -EINVAL; 958 } 959 960 /* Store encryption key and salt */ 961 memcpy(ctx->key, key, keylen); 962 963 return 0; 964 } 965 966 static inline u32 create_aead_ctx_hdr(struct aead_request *req, u32 enc, 967 u32 *argcnt) 968 { 969 struct otx_cpt_req_ctx *rctx = aead_request_ctx_dma(req); 970 struct crypto_aead *tfm = crypto_aead_reqtfm(req); 971 struct otx_cpt_aead_ctx *ctx = crypto_aead_ctx_dma(tfm); 972 struct otx_cpt_req_info *req_info = &rctx->cpt_req; 973 struct otx_cpt_fc_ctx *fctx = &rctx->fctx; 974 int mac_len = crypto_aead_authsize(tfm); 975 int ds; 976 977 rctx->ctrl_word.e.enc_data_offset = req->assoclen; 978 979 switch (ctx->cipher_type) { 980 case OTX_CPT_AES_CBC: 981 fctx->enc.enc_ctrl.e.iv_source = OTX_CPT_FROM_CPTR; 982 /* Copy encryption key to context */ 983 memcpy(fctx->enc.encr_key, ctx->key + ctx->auth_key_len, 984 ctx->enc_key_len); 985 /* Copy IV to context */ 986 memcpy(fctx->enc.encr_iv, req->iv, crypto_aead_ivsize(tfm)); 987 988 ds = crypto_shash_digestsize(ctx->hashalg); 989 if (ctx->mac_type == OTX_CPT_SHA384) 990 ds = SHA512_DIGEST_SIZE; 991 if (ctx->ipad) 992 memcpy(fctx->hmac.e.ipad, ctx->ipad, ds); 993 if (ctx->opad) 994 memcpy(fctx->hmac.e.opad, ctx->opad, ds); 995 break; 996 997 case OTX_CPT_AES_GCM: 998 fctx->enc.enc_ctrl.e.iv_source = OTX_CPT_FROM_DPTR; 999 /* Copy encryption key to context */ 1000 memcpy(fctx->enc.encr_key, ctx->key, ctx->enc_key_len); 1001 /* Copy salt to context */ 1002 memcpy(fctx->enc.encr_iv, ctx->key + ctx->enc_key_len, 1003 AES_GCM_SALT_SIZE); 1004 1005 rctx->ctrl_word.e.iv_offset = req->assoclen - AES_GCM_IV_OFFSET; 1006 break; 1007 1008 default: 1009 /* Unknown cipher type */ 1010 return -EINVAL; 1011 } 1012 rctx->ctrl_word.flags = cpu_to_be64(rctx->ctrl_word.cflags); 1013 1014 req_info->ctrl.s.dma_mode = OTX_CPT_DMA_GATHER_SCATTER; 1015 req_info->ctrl.s.se_req = OTX_CPT_SE_CORE_REQ; 1016 req_info->req.opcode.s.major = OTX_CPT_MAJOR_OP_FC | 1017 DMA_MODE_FLAG(OTX_CPT_DMA_GATHER_SCATTER); 1018 if (enc) { 1019 req_info->req.opcode.s.minor = 2; 1020 req_info->req.param1 = req->cryptlen; 1021 req_info->req.param2 = req->cryptlen + req->assoclen; 1022 } else { 1023 req_info->req.opcode.s.minor = 3; 1024 req_info->req.param1 = req->cryptlen - mac_len; 1025 req_info->req.param2 = req->cryptlen + req->assoclen - mac_len; 1026 } 1027 1028 fctx->enc.enc_ctrl.e.enc_cipher = ctx->cipher_type; 1029 fctx->enc.enc_ctrl.e.aes_key = ctx->key_type; 1030 fctx->enc.enc_ctrl.e.mac_type = ctx->mac_type; 1031 fctx->enc.enc_ctrl.e.mac_len = mac_len; 1032 fctx->enc.enc_ctrl.flags = cpu_to_be64(fctx->enc.enc_ctrl.cflags); 1033 1034 /* 1035 * Storing Packet Data Information in offset 1036 * Control Word First 8 bytes 1037 */ 1038 req_info->in[*argcnt].vptr = (u8 *)&rctx->ctrl_word; 1039 req_info->in[*argcnt].size = CONTROL_WORD_LEN; 1040 req_info->req.dlen += CONTROL_WORD_LEN; 1041 ++(*argcnt); 1042 1043 req_info->in[*argcnt].vptr = (u8 *)fctx; 1044 req_info->in[*argcnt].size = sizeof(struct otx_cpt_fc_ctx); 1045 req_info->req.dlen += sizeof(struct otx_cpt_fc_ctx); 1046 ++(*argcnt); 1047 1048 return 0; 1049 } 1050 1051 static inline u32 create_hmac_ctx_hdr(struct aead_request *req, u32 *argcnt, 1052 u32 enc) 1053 { 1054 struct otx_cpt_req_ctx *rctx = aead_request_ctx_dma(req); 1055 struct crypto_aead *tfm = crypto_aead_reqtfm(req); 1056 struct otx_cpt_aead_ctx *ctx = crypto_aead_ctx_dma(tfm); 1057 struct otx_cpt_req_info *req_info = &rctx->cpt_req; 1058 1059 req_info->ctrl.s.dma_mode = OTX_CPT_DMA_GATHER_SCATTER; 1060 req_info->ctrl.s.se_req = OTX_CPT_SE_CORE_REQ; 1061 req_info->req.opcode.s.major = OTX_CPT_MAJOR_OP_HMAC | 1062 DMA_MODE_FLAG(OTX_CPT_DMA_GATHER_SCATTER); 1063 req_info->is_trunc_hmac = ctx->is_trunc_hmac; 1064 1065 req_info->req.opcode.s.minor = 0; 1066 req_info->req.param1 = ctx->auth_key_len; 1067 req_info->req.param2 = ctx->mac_type << 8; 1068 1069 /* Add authentication key */ 1070 req_info->in[*argcnt].vptr = ctx->key; 1071 req_info->in[*argcnt].size = round_up(ctx->auth_key_len, 8); 1072 req_info->req.dlen += round_up(ctx->auth_key_len, 8); 1073 ++(*argcnt); 1074 1075 return 0; 1076 } 1077 1078 static inline u32 create_aead_input_list(struct aead_request *req, u32 enc) 1079 { 1080 struct otx_cpt_req_ctx *rctx = aead_request_ctx_dma(req); 1081 struct otx_cpt_req_info *req_info = &rctx->cpt_req; 1082 u32 inputlen = req->cryptlen + req->assoclen; 1083 u32 status, argcnt = 0; 1084 1085 status = create_aead_ctx_hdr(req, enc, &argcnt); 1086 if (status) 1087 return status; 1088 update_input_data(req_info, req->src, inputlen, &argcnt); 1089 req_info->incnt = argcnt; 1090 1091 return 0; 1092 } 1093 1094 static inline u32 create_aead_output_list(struct aead_request *req, u32 enc, 1095 u32 mac_len) 1096 { 1097 struct otx_cpt_req_ctx *rctx = aead_request_ctx_dma(req); 1098 struct otx_cpt_req_info *req_info = &rctx->cpt_req; 1099 u32 argcnt = 0, outputlen = 0; 1100 1101 if (enc) 1102 outputlen = req->cryptlen + req->assoclen + mac_len; 1103 else 1104 outputlen = req->cryptlen + req->assoclen - mac_len; 1105 1106 update_output_data(req_info, req->dst, 0, outputlen, &argcnt); 1107 req_info->outcnt = argcnt; 1108 1109 return 0; 1110 } 1111 1112 static inline u32 create_aead_null_input_list(struct aead_request *req, 1113 u32 enc, u32 mac_len) 1114 { 1115 struct otx_cpt_req_ctx *rctx = aead_request_ctx_dma(req); 1116 struct otx_cpt_req_info *req_info = &rctx->cpt_req; 1117 u32 inputlen, argcnt = 0; 1118 1119 if (enc) 1120 inputlen = req->cryptlen + req->assoclen; 1121 else 1122 inputlen = req->cryptlen + req->assoclen - mac_len; 1123 1124 create_hmac_ctx_hdr(req, &argcnt, enc); 1125 update_input_data(req_info, req->src, inputlen, &argcnt); 1126 req_info->incnt = argcnt; 1127 1128 return 0; 1129 } 1130 1131 static inline u32 create_aead_null_output_list(struct aead_request *req, 1132 u32 enc, u32 mac_len) 1133 { 1134 struct otx_cpt_req_ctx *rctx = aead_request_ctx_dma(req); 1135 struct otx_cpt_req_info *req_info = &rctx->cpt_req; 1136 struct scatterlist *dst; 1137 u8 *ptr = NULL; 1138 int argcnt = 0, status, offset; 1139 u32 inputlen; 1140 1141 if (enc) 1142 inputlen = req->cryptlen + req->assoclen; 1143 else 1144 inputlen = req->cryptlen + req->assoclen - mac_len; 1145 1146 /* 1147 * If source and destination are different 1148 * then copy payload to destination 1149 */ 1150 if (req->src != req->dst) { 1151 1152 ptr = kmalloc(inputlen, (req_info->areq->flags & 1153 CRYPTO_TFM_REQ_MAY_SLEEP) ? 1154 GFP_KERNEL : GFP_ATOMIC); 1155 if (!ptr) { 1156 status = -ENOMEM; 1157 goto error; 1158 } 1159 1160 status = sg_copy_to_buffer(req->src, sg_nents(req->src), ptr, 1161 inputlen); 1162 if (status != inputlen) { 1163 status = -EINVAL; 1164 goto error_free; 1165 } 1166 status = sg_copy_from_buffer(req->dst, sg_nents(req->dst), ptr, 1167 inputlen); 1168 if (status != inputlen) { 1169 status = -EINVAL; 1170 goto error_free; 1171 } 1172 kfree(ptr); 1173 } 1174 1175 if (enc) { 1176 /* 1177 * In an encryption scenario hmac needs 1178 * to be appended after payload 1179 */ 1180 dst = req->dst; 1181 offset = inputlen; 1182 while (offset >= dst->length) { 1183 offset -= dst->length; 1184 dst = sg_next(dst); 1185 if (!dst) { 1186 status = -ENOENT; 1187 goto error; 1188 } 1189 } 1190 1191 update_output_data(req_info, dst, offset, mac_len, &argcnt); 1192 } else { 1193 /* 1194 * In a decryption scenario calculated hmac for received 1195 * payload needs to be compare with hmac received 1196 */ 1197 status = sg_copy_buffer(req->src, sg_nents(req->src), 1198 rctx->fctx.hmac.s.hmac_recv, mac_len, 1199 inputlen, true); 1200 if (status != mac_len) { 1201 status = -EINVAL; 1202 goto error; 1203 } 1204 1205 req_info->out[argcnt].vptr = rctx->fctx.hmac.s.hmac_calc; 1206 req_info->out[argcnt].size = mac_len; 1207 argcnt++; 1208 } 1209 1210 req_info->outcnt = argcnt; 1211 return 0; 1212 1213 error_free: 1214 kfree(ptr); 1215 error: 1216 return status; 1217 } 1218 1219 static u32 cpt_aead_enc_dec(struct aead_request *req, u8 reg_type, u8 enc) 1220 { 1221 struct otx_cpt_req_ctx *rctx = aead_request_ctx_dma(req); 1222 struct otx_cpt_req_info *req_info = &rctx->cpt_req; 1223 struct crypto_aead *tfm = crypto_aead_reqtfm(req); 1224 struct pci_dev *pdev; 1225 u32 status, cpu_num; 1226 1227 /* Clear control words */ 1228 rctx->ctrl_word.flags = 0; 1229 rctx->fctx.enc.enc_ctrl.flags = 0; 1230 1231 req_info->callback = otx_cpt_aead_callback; 1232 req_info->areq = &req->base; 1233 req_info->req_type = reg_type; 1234 req_info->is_enc = enc; 1235 req_info->is_trunc_hmac = false; 1236 1237 switch (reg_type) { 1238 case OTX_CPT_AEAD_ENC_DEC_REQ: 1239 status = create_aead_input_list(req, enc); 1240 if (status) 1241 return status; 1242 status = create_aead_output_list(req, enc, 1243 crypto_aead_authsize(tfm)); 1244 if (status) 1245 return status; 1246 break; 1247 1248 case OTX_CPT_AEAD_ENC_DEC_NULL_REQ: 1249 status = create_aead_null_input_list(req, enc, 1250 crypto_aead_authsize(tfm)); 1251 if (status) 1252 return status; 1253 status = create_aead_null_output_list(req, enc, 1254 crypto_aead_authsize(tfm)); 1255 if (status) 1256 return status; 1257 break; 1258 1259 default: 1260 return -EINVAL; 1261 } 1262 1263 /* Validate that request doesn't exceed maximum CPT supported size */ 1264 if (req_info->req.param1 > OTX_CPT_MAX_REQ_SIZE || 1265 req_info->req.param2 > OTX_CPT_MAX_REQ_SIZE) 1266 return -E2BIG; 1267 1268 status = get_se_device(&pdev, &cpu_num); 1269 if (status) 1270 return status; 1271 1272 req_info->ctrl.s.grp = 0; 1273 1274 status = otx_cpt_do_request(pdev, req_info, cpu_num); 1275 /* 1276 * We perform an asynchronous send and once 1277 * the request is completed the driver would 1278 * intimate through registered call back functions 1279 */ 1280 return status; 1281 } 1282 1283 static int otx_cpt_aead_encrypt(struct aead_request *req) 1284 { 1285 return cpt_aead_enc_dec(req, OTX_CPT_AEAD_ENC_DEC_REQ, true); 1286 } 1287 1288 static int otx_cpt_aead_decrypt(struct aead_request *req) 1289 { 1290 return cpt_aead_enc_dec(req, OTX_CPT_AEAD_ENC_DEC_REQ, false); 1291 } 1292 1293 static int otx_cpt_aead_null_encrypt(struct aead_request *req) 1294 { 1295 return cpt_aead_enc_dec(req, OTX_CPT_AEAD_ENC_DEC_NULL_REQ, true); 1296 } 1297 1298 static int otx_cpt_aead_null_decrypt(struct aead_request *req) 1299 { 1300 return cpt_aead_enc_dec(req, OTX_CPT_AEAD_ENC_DEC_NULL_REQ, false); 1301 } 1302 1303 static struct skcipher_alg otx_cpt_skciphers[] = { { 1304 .base.cra_name = "xts(aes)", 1305 .base.cra_driver_name = "cpt_xts_aes", 1306 .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, 1307 .base.cra_blocksize = AES_BLOCK_SIZE, 1308 .base.cra_ctxsize = sizeof(struct otx_cpt_enc_ctx), 1309 .base.cra_alignmask = 7, 1310 .base.cra_priority = 4001, 1311 .base.cra_module = THIS_MODULE, 1312 1313 .init = otx_cpt_enc_dec_init, 1314 .ivsize = AES_BLOCK_SIZE, 1315 .min_keysize = 2 * AES_MIN_KEY_SIZE, 1316 .max_keysize = 2 * AES_MAX_KEY_SIZE, 1317 .setkey = otx_cpt_skcipher_xts_setkey, 1318 .encrypt = otx_cpt_skcipher_encrypt, 1319 .decrypt = otx_cpt_skcipher_decrypt, 1320 }, { 1321 .base.cra_name = "cbc(aes)", 1322 .base.cra_driver_name = "cpt_cbc_aes", 1323 .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, 1324 .base.cra_blocksize = AES_BLOCK_SIZE, 1325 .base.cra_ctxsize = sizeof(struct otx_cpt_enc_ctx), 1326 .base.cra_alignmask = 7, 1327 .base.cra_priority = 4001, 1328 .base.cra_module = THIS_MODULE, 1329 1330 .init = otx_cpt_enc_dec_init, 1331 .ivsize = AES_BLOCK_SIZE, 1332 .min_keysize = AES_MIN_KEY_SIZE, 1333 .max_keysize = AES_MAX_KEY_SIZE, 1334 .setkey = otx_cpt_skcipher_cbc_aes_setkey, 1335 .encrypt = otx_cpt_skcipher_encrypt, 1336 .decrypt = otx_cpt_skcipher_decrypt, 1337 }, { 1338 .base.cra_name = "ecb(aes)", 1339 .base.cra_driver_name = "cpt_ecb_aes", 1340 .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, 1341 .base.cra_blocksize = AES_BLOCK_SIZE, 1342 .base.cra_ctxsize = sizeof(struct otx_cpt_enc_ctx), 1343 .base.cra_alignmask = 7, 1344 .base.cra_priority = 4001, 1345 .base.cra_module = THIS_MODULE, 1346 1347 .init = otx_cpt_enc_dec_init, 1348 .ivsize = 0, 1349 .min_keysize = AES_MIN_KEY_SIZE, 1350 .max_keysize = AES_MAX_KEY_SIZE, 1351 .setkey = otx_cpt_skcipher_ecb_aes_setkey, 1352 .encrypt = otx_cpt_skcipher_encrypt, 1353 .decrypt = otx_cpt_skcipher_decrypt, 1354 }, { 1355 .base.cra_name = "cfb(aes)", 1356 .base.cra_driver_name = "cpt_cfb_aes", 1357 .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, 1358 .base.cra_blocksize = AES_BLOCK_SIZE, 1359 .base.cra_ctxsize = sizeof(struct otx_cpt_enc_ctx), 1360 .base.cra_alignmask = 7, 1361 .base.cra_priority = 4001, 1362 .base.cra_module = THIS_MODULE, 1363 1364 .init = otx_cpt_enc_dec_init, 1365 .ivsize = AES_BLOCK_SIZE, 1366 .min_keysize = AES_MIN_KEY_SIZE, 1367 .max_keysize = AES_MAX_KEY_SIZE, 1368 .setkey = otx_cpt_skcipher_cfb_aes_setkey, 1369 .encrypt = otx_cpt_skcipher_encrypt, 1370 .decrypt = otx_cpt_skcipher_decrypt, 1371 }, { 1372 .base.cra_name = "cbc(des3_ede)", 1373 .base.cra_driver_name = "cpt_cbc_des3_ede", 1374 .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, 1375 .base.cra_blocksize = DES3_EDE_BLOCK_SIZE, 1376 .base.cra_ctxsize = sizeof(struct otx_cpt_des3_ctx), 1377 .base.cra_alignmask = 7, 1378 .base.cra_priority = 4001, 1379 .base.cra_module = THIS_MODULE, 1380 1381 .init = otx_cpt_enc_dec_init, 1382 .min_keysize = DES3_EDE_KEY_SIZE, 1383 .max_keysize = DES3_EDE_KEY_SIZE, 1384 .ivsize = DES_BLOCK_SIZE, 1385 .setkey = otx_cpt_skcipher_cbc_des3_setkey, 1386 .encrypt = otx_cpt_skcipher_encrypt, 1387 .decrypt = otx_cpt_skcipher_decrypt, 1388 }, { 1389 .base.cra_name = "ecb(des3_ede)", 1390 .base.cra_driver_name = "cpt_ecb_des3_ede", 1391 .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, 1392 .base.cra_blocksize = DES3_EDE_BLOCK_SIZE, 1393 .base.cra_ctxsize = sizeof(struct otx_cpt_des3_ctx), 1394 .base.cra_alignmask = 7, 1395 .base.cra_priority = 4001, 1396 .base.cra_module = THIS_MODULE, 1397 1398 .init = otx_cpt_enc_dec_init, 1399 .min_keysize = DES3_EDE_KEY_SIZE, 1400 .max_keysize = DES3_EDE_KEY_SIZE, 1401 .ivsize = 0, 1402 .setkey = otx_cpt_skcipher_ecb_des3_setkey, 1403 .encrypt = otx_cpt_skcipher_encrypt, 1404 .decrypt = otx_cpt_skcipher_decrypt, 1405 } }; 1406 1407 static struct aead_alg otx_cpt_aeads[] = { { 1408 .base = { 1409 .cra_name = "authenc(hmac(sha1),cbc(aes))", 1410 .cra_driver_name = "cpt_hmac_sha1_cbc_aes", 1411 .cra_blocksize = AES_BLOCK_SIZE, 1412 .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, 1413 .cra_ctxsize = sizeof(struct otx_cpt_aead_ctx) + CRYPTO_DMA_PADDING, 1414 .cra_priority = 4001, 1415 .cra_alignmask = 0, 1416 .cra_module = THIS_MODULE, 1417 }, 1418 .init = otx_cpt_aead_cbc_aes_sha1_init, 1419 .exit = otx_cpt_aead_exit, 1420 .setkey = otx_cpt_aead_cbc_aes_sha_setkey, 1421 .setauthsize = otx_cpt_aead_set_authsize, 1422 .encrypt = otx_cpt_aead_encrypt, 1423 .decrypt = otx_cpt_aead_decrypt, 1424 .ivsize = AES_BLOCK_SIZE, 1425 .maxauthsize = SHA1_DIGEST_SIZE, 1426 }, { 1427 .base = { 1428 .cra_name = "authenc(hmac(sha256),cbc(aes))", 1429 .cra_driver_name = "cpt_hmac_sha256_cbc_aes", 1430 .cra_blocksize = AES_BLOCK_SIZE, 1431 .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, 1432 .cra_ctxsize = sizeof(struct otx_cpt_aead_ctx) + CRYPTO_DMA_PADDING, 1433 .cra_priority = 4001, 1434 .cra_alignmask = 0, 1435 .cra_module = THIS_MODULE, 1436 }, 1437 .init = otx_cpt_aead_cbc_aes_sha256_init, 1438 .exit = otx_cpt_aead_exit, 1439 .setkey = otx_cpt_aead_cbc_aes_sha_setkey, 1440 .setauthsize = otx_cpt_aead_set_authsize, 1441 .encrypt = otx_cpt_aead_encrypt, 1442 .decrypt = otx_cpt_aead_decrypt, 1443 .ivsize = AES_BLOCK_SIZE, 1444 .maxauthsize = SHA256_DIGEST_SIZE, 1445 }, { 1446 .base = { 1447 .cra_name = "authenc(hmac(sha384),cbc(aes))", 1448 .cra_driver_name = "cpt_hmac_sha384_cbc_aes", 1449 .cra_blocksize = AES_BLOCK_SIZE, 1450 .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, 1451 .cra_ctxsize = sizeof(struct otx_cpt_aead_ctx) + CRYPTO_DMA_PADDING, 1452 .cra_priority = 4001, 1453 .cra_alignmask = 0, 1454 .cra_module = THIS_MODULE, 1455 }, 1456 .init = otx_cpt_aead_cbc_aes_sha384_init, 1457 .exit = otx_cpt_aead_exit, 1458 .setkey = otx_cpt_aead_cbc_aes_sha_setkey, 1459 .setauthsize = otx_cpt_aead_set_authsize, 1460 .encrypt = otx_cpt_aead_encrypt, 1461 .decrypt = otx_cpt_aead_decrypt, 1462 .ivsize = AES_BLOCK_SIZE, 1463 .maxauthsize = SHA384_DIGEST_SIZE, 1464 }, { 1465 .base = { 1466 .cra_name = "authenc(hmac(sha512),cbc(aes))", 1467 .cra_driver_name = "cpt_hmac_sha512_cbc_aes", 1468 .cra_blocksize = AES_BLOCK_SIZE, 1469 .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, 1470 .cra_ctxsize = sizeof(struct otx_cpt_aead_ctx) + CRYPTO_DMA_PADDING, 1471 .cra_priority = 4001, 1472 .cra_alignmask = 0, 1473 .cra_module = THIS_MODULE, 1474 }, 1475 .init = otx_cpt_aead_cbc_aes_sha512_init, 1476 .exit = otx_cpt_aead_exit, 1477 .setkey = otx_cpt_aead_cbc_aes_sha_setkey, 1478 .setauthsize = otx_cpt_aead_set_authsize, 1479 .encrypt = otx_cpt_aead_encrypt, 1480 .decrypt = otx_cpt_aead_decrypt, 1481 .ivsize = AES_BLOCK_SIZE, 1482 .maxauthsize = SHA512_DIGEST_SIZE, 1483 }, { 1484 .base = { 1485 .cra_name = "authenc(hmac(sha1),ecb(cipher_null))", 1486 .cra_driver_name = "cpt_hmac_sha1_ecb_null", 1487 .cra_blocksize = 1, 1488 .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, 1489 .cra_ctxsize = sizeof(struct otx_cpt_aead_ctx) + CRYPTO_DMA_PADDING, 1490 .cra_priority = 4001, 1491 .cra_alignmask = 0, 1492 .cra_module = THIS_MODULE, 1493 }, 1494 .init = otx_cpt_aead_ecb_null_sha1_init, 1495 .exit = otx_cpt_aead_exit, 1496 .setkey = otx_cpt_aead_ecb_null_sha_setkey, 1497 .setauthsize = otx_cpt_aead_set_authsize, 1498 .encrypt = otx_cpt_aead_null_encrypt, 1499 .decrypt = otx_cpt_aead_null_decrypt, 1500 .ivsize = 0, 1501 .maxauthsize = SHA1_DIGEST_SIZE, 1502 }, { 1503 .base = { 1504 .cra_name = "authenc(hmac(sha256),ecb(cipher_null))", 1505 .cra_driver_name = "cpt_hmac_sha256_ecb_null", 1506 .cra_blocksize = 1, 1507 .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, 1508 .cra_ctxsize = sizeof(struct otx_cpt_aead_ctx) + CRYPTO_DMA_PADDING, 1509 .cra_priority = 4001, 1510 .cra_alignmask = 0, 1511 .cra_module = THIS_MODULE, 1512 }, 1513 .init = otx_cpt_aead_ecb_null_sha256_init, 1514 .exit = otx_cpt_aead_exit, 1515 .setkey = otx_cpt_aead_ecb_null_sha_setkey, 1516 .setauthsize = otx_cpt_aead_set_authsize, 1517 .encrypt = otx_cpt_aead_null_encrypt, 1518 .decrypt = otx_cpt_aead_null_decrypt, 1519 .ivsize = 0, 1520 .maxauthsize = SHA256_DIGEST_SIZE, 1521 }, { 1522 .base = { 1523 .cra_name = "authenc(hmac(sha384),ecb(cipher_null))", 1524 .cra_driver_name = "cpt_hmac_sha384_ecb_null", 1525 .cra_blocksize = 1, 1526 .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, 1527 .cra_ctxsize = sizeof(struct otx_cpt_aead_ctx) + CRYPTO_DMA_PADDING, 1528 .cra_priority = 4001, 1529 .cra_alignmask = 0, 1530 .cra_module = THIS_MODULE, 1531 }, 1532 .init = otx_cpt_aead_ecb_null_sha384_init, 1533 .exit = otx_cpt_aead_exit, 1534 .setkey = otx_cpt_aead_ecb_null_sha_setkey, 1535 .setauthsize = otx_cpt_aead_set_authsize, 1536 .encrypt = otx_cpt_aead_null_encrypt, 1537 .decrypt = otx_cpt_aead_null_decrypt, 1538 .ivsize = 0, 1539 .maxauthsize = SHA384_DIGEST_SIZE, 1540 }, { 1541 .base = { 1542 .cra_name = "authenc(hmac(sha512),ecb(cipher_null))", 1543 .cra_driver_name = "cpt_hmac_sha512_ecb_null", 1544 .cra_blocksize = 1, 1545 .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, 1546 .cra_ctxsize = sizeof(struct otx_cpt_aead_ctx) + CRYPTO_DMA_PADDING, 1547 .cra_priority = 4001, 1548 .cra_alignmask = 0, 1549 .cra_module = THIS_MODULE, 1550 }, 1551 .init = otx_cpt_aead_ecb_null_sha512_init, 1552 .exit = otx_cpt_aead_exit, 1553 .setkey = otx_cpt_aead_ecb_null_sha_setkey, 1554 .setauthsize = otx_cpt_aead_set_authsize, 1555 .encrypt = otx_cpt_aead_null_encrypt, 1556 .decrypt = otx_cpt_aead_null_decrypt, 1557 .ivsize = 0, 1558 .maxauthsize = SHA512_DIGEST_SIZE, 1559 }, { 1560 .base = { 1561 .cra_name = "rfc4106(gcm(aes))", 1562 .cra_driver_name = "cpt_rfc4106_gcm_aes", 1563 .cra_blocksize = 1, 1564 .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, 1565 .cra_ctxsize = sizeof(struct otx_cpt_aead_ctx) + CRYPTO_DMA_PADDING, 1566 .cra_priority = 4001, 1567 .cra_alignmask = 0, 1568 .cra_module = THIS_MODULE, 1569 }, 1570 .init = otx_cpt_aead_gcm_aes_init, 1571 .exit = otx_cpt_aead_exit, 1572 .setkey = otx_cpt_aead_gcm_aes_setkey, 1573 .setauthsize = otx_cpt_aead_set_authsize, 1574 .encrypt = otx_cpt_aead_encrypt, 1575 .decrypt = otx_cpt_aead_decrypt, 1576 .ivsize = AES_GCM_IV_SIZE, 1577 .maxauthsize = AES_GCM_ICV_SIZE, 1578 } }; 1579 1580 static inline int is_any_alg_used(void) 1581 { 1582 int i; 1583 1584 for (i = 0; i < ARRAY_SIZE(otx_cpt_skciphers); i++) 1585 if (refcount_read(&otx_cpt_skciphers[i].base.cra_refcnt) != 1) 1586 return true; 1587 for (i = 0; i < ARRAY_SIZE(otx_cpt_aeads); i++) 1588 if (refcount_read(&otx_cpt_aeads[i].base.cra_refcnt) != 1) 1589 return true; 1590 return false; 1591 } 1592 1593 static inline int cpt_register_algs(void) 1594 { 1595 int i, err = 0; 1596 1597 if (!IS_ENABLED(CONFIG_DM_CRYPT)) { 1598 for (i = 0; i < ARRAY_SIZE(otx_cpt_skciphers); i++) 1599 otx_cpt_skciphers[i].base.cra_flags &= ~CRYPTO_ALG_DEAD; 1600 1601 err = crypto_register_skciphers(otx_cpt_skciphers, 1602 ARRAY_SIZE(otx_cpt_skciphers)); 1603 if (err) 1604 return err; 1605 } 1606 1607 for (i = 0; i < ARRAY_SIZE(otx_cpt_aeads); i++) 1608 otx_cpt_aeads[i].base.cra_flags &= ~CRYPTO_ALG_DEAD; 1609 1610 err = crypto_register_aeads(otx_cpt_aeads, ARRAY_SIZE(otx_cpt_aeads)); 1611 if (err) { 1612 crypto_unregister_skciphers(otx_cpt_skciphers, 1613 ARRAY_SIZE(otx_cpt_skciphers)); 1614 return err; 1615 } 1616 1617 return 0; 1618 } 1619 1620 static inline void cpt_unregister_algs(void) 1621 { 1622 crypto_unregister_skciphers(otx_cpt_skciphers, 1623 ARRAY_SIZE(otx_cpt_skciphers)); 1624 crypto_unregister_aeads(otx_cpt_aeads, ARRAY_SIZE(otx_cpt_aeads)); 1625 } 1626 1627 static int compare_func(const void *lptr, const void *rptr) 1628 { 1629 struct cpt_device_desc *ldesc = (struct cpt_device_desc *) lptr; 1630 struct cpt_device_desc *rdesc = (struct cpt_device_desc *) rptr; 1631 1632 if (ldesc->dev->devfn < rdesc->dev->devfn) 1633 return -1; 1634 if (ldesc->dev->devfn > rdesc->dev->devfn) 1635 return 1; 1636 return 0; 1637 } 1638 1639 static void swap_func(void *lptr, void *rptr, int size) 1640 { 1641 struct cpt_device_desc *ldesc = (struct cpt_device_desc *) lptr; 1642 struct cpt_device_desc *rdesc = (struct cpt_device_desc *) rptr; 1643 1644 swap(*ldesc, *rdesc); 1645 } 1646 1647 int otx_cpt_crypto_init(struct pci_dev *pdev, struct module *mod, 1648 enum otx_cptpf_type pf_type, 1649 enum otx_cptvf_type engine_type, 1650 int num_queues, int num_devices) 1651 { 1652 int ret = 0; 1653 int count; 1654 1655 mutex_lock(&mutex); 1656 switch (engine_type) { 1657 case OTX_CPT_SE_TYPES: 1658 count = atomic_read(&se_devices.count); 1659 if (count >= CPT_MAX_VF_NUM) { 1660 dev_err(&pdev->dev, "No space to add a new device\n"); 1661 ret = -ENOSPC; 1662 goto err; 1663 } 1664 se_devices.desc[count].pf_type = pf_type; 1665 se_devices.desc[count].num_queues = num_queues; 1666 se_devices.desc[count++].dev = pdev; 1667 atomic_inc(&se_devices.count); 1668 1669 if (atomic_read(&se_devices.count) == num_devices && 1670 is_crypto_registered == false) { 1671 if (cpt_register_algs()) { 1672 dev_err(&pdev->dev, 1673 "Error in registering crypto algorithms\n"); 1674 ret = -EINVAL; 1675 goto err; 1676 } 1677 try_module_get(mod); 1678 is_crypto_registered = true; 1679 } 1680 sort(se_devices.desc, count, sizeof(struct cpt_device_desc), 1681 compare_func, swap_func); 1682 break; 1683 1684 case OTX_CPT_AE_TYPES: 1685 count = atomic_read(&ae_devices.count); 1686 if (count >= CPT_MAX_VF_NUM) { 1687 dev_err(&pdev->dev, "No space to a add new device\n"); 1688 ret = -ENOSPC; 1689 goto err; 1690 } 1691 ae_devices.desc[count].pf_type = pf_type; 1692 ae_devices.desc[count].num_queues = num_queues; 1693 ae_devices.desc[count++].dev = pdev; 1694 atomic_inc(&ae_devices.count); 1695 sort(ae_devices.desc, count, sizeof(struct cpt_device_desc), 1696 compare_func, swap_func); 1697 break; 1698 1699 default: 1700 dev_err(&pdev->dev, "Unknown VF type %d\n", engine_type); 1701 ret = BAD_OTX_CPTVF_TYPE; 1702 } 1703 err: 1704 mutex_unlock(&mutex); 1705 return ret; 1706 } 1707 1708 void otx_cpt_crypto_exit(struct pci_dev *pdev, struct module *mod, 1709 enum otx_cptvf_type engine_type) 1710 { 1711 struct cpt_device_table *dev_tbl; 1712 bool dev_found = false; 1713 int i, j, count; 1714 1715 mutex_lock(&mutex); 1716 1717 dev_tbl = (engine_type == OTX_CPT_AE_TYPES) ? &ae_devices : &se_devices; 1718 count = atomic_read(&dev_tbl->count); 1719 for (i = 0; i < count; i++) 1720 if (pdev == dev_tbl->desc[i].dev) { 1721 for (j = i; j < count-1; j++) 1722 dev_tbl->desc[j] = dev_tbl->desc[j+1]; 1723 dev_found = true; 1724 break; 1725 } 1726 1727 if (!dev_found) { 1728 dev_err(&pdev->dev, "%s device not found\n", __func__); 1729 goto exit; 1730 } 1731 1732 if (engine_type != OTX_CPT_AE_TYPES) { 1733 if (atomic_dec_and_test(&se_devices.count) && 1734 !is_any_alg_used()) { 1735 cpt_unregister_algs(); 1736 module_put(mod); 1737 is_crypto_registered = false; 1738 } 1739 } else 1740 atomic_dec(&ae_devices.count); 1741 exit: 1742 mutex_unlock(&mutex); 1743 } 1744