drivers/crypto/cnxk/cnxk_ae.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2021 Marvell.
   3  */
   4
   5 #ifndef _CNXK_AE_H_
   6 #define _CNXK_AE_H_
   7
   8 #include <rte_common.h>
   9 #include <rte_crypto_asym.h>
  10 #include <rte_malloc.h>
  11
  12 #include "roc_api.h"
  13 #include "cnxk_cryptodev_ops.h"
  14
  15 struct cnxk_ae_sess {
  16         enum rte_crypto_asym_xform_type xfrm_type;
  17         union {
  18                 struct rte_crypto_rsa_xform rsa_ctx;
  19                 struct rte_crypto_modex_xform mod_ctx;
  20                 struct roc_ae_ec_ctx ec_ctx;
  21         };
  22         uint64_t *cnxk_fpm_iova;
  23         struct roc_ae_ec_group **ec_grp;
  24         uint64_t cpt_inst_w7;
  25 };
  26
  27 static __rte_always_inline void
  28 cnxk_ae_modex_param_normalize(uint8_t **data, size_t *len)
  29 {
  30         size_t i;
  31
  32         /* Strip leading NUL bytes */
  33         for (i = 0; i < *len; i++) {
  34                 if ((*data)[i] != 0)
  35                         break;
  36         }
  37         *data += i;
  38         *len -= i;
  39 }
  40
  41 static __rte_always_inline int
  42 cnxk_ae_fill_modex_params(struct cnxk_ae_sess *sess,
  43                           struct rte_crypto_asym_xform *xform)
  44 {
  45         struct rte_crypto_modex_xform *ctx = &sess->mod_ctx;
  46         size_t exp_len = xform->modex.exponent.length;
  47         size_t mod_len = xform->modex.modulus.length;
  48         uint8_t *exp = xform->modex.exponent.data;
  49         uint8_t *mod = xform->modex.modulus.data;
  50
  51         cnxk_ae_modex_param_normalize(&mod, &mod_len);
  52         cnxk_ae_modex_param_normalize(&exp, &exp_len);
  53
  54         if (unlikely(exp_len == 0 || mod_len == 0))
  55                 return -EINVAL;
  56
  57         if (unlikely(exp_len > mod_len))
  58                 return -ENOTSUP;
  59
  60         /* Allocate buffer to hold modexp params */
  61         ctx->modulus.data = rte_malloc(NULL, mod_len + exp_len, 0);
  62         if (ctx->modulus.data == NULL)
  63                 return -ENOMEM;
  64
  65         /* Set up modexp prime modulus and private exponent */
  66         memcpy(ctx->modulus.data, mod, mod_len);
  67         ctx->exponent.data = ctx->modulus.data + mod_len;
  68         memcpy(ctx->exponent.data, exp, exp_len);
  69
  70         ctx->modulus.length = mod_len;
  71         ctx->exponent.length = exp_len;
  72
  73         return 0;
  74 }
  75
  76 static __rte_always_inline int
  77 cnxk_ae_fill_rsa_params(struct cnxk_ae_sess *sess,
  78                         struct rte_crypto_asym_xform *xform)
  79 {
  80         struct rte_crypto_rsa_priv_key_qt qt = xform->rsa.qt;
  81         struct rte_crypto_rsa_xform *xfrm_rsa = &xform->rsa;
  82         struct rte_crypto_rsa_xform *rsa = &sess->rsa_ctx;
  83         size_t mod_len = xfrm_rsa->n.length;
  84         size_t exp_len = xfrm_rsa->e.length;
  85         size_t len = (mod_len / 2);
  86         uint64_t total_size;
  87
  88         /* Make sure key length used is not more than mod_len/2 */
  89         if (qt.p.data != NULL)
  90                 len = RTE_MIN(len, qt.p.length);
  91
  92         /* Total size required for RSA key params(n,e,(q,dQ,p,dP,qInv)) */
  93         total_size = mod_len + exp_len + 5 * len;
  94
  95         /* Allocate buffer to hold all RSA keys */
  96         rsa->n.data = rte_malloc(NULL, total_size, 0);
  97         if (rsa->n.data == NULL)
  98                 return -ENOMEM;
  99
 100         /* Set up RSA prime modulus and public key exponent */
 101         memcpy(rsa->n.data, xfrm_rsa->n.data, mod_len);
 102         rsa->e.data = rsa->n.data + mod_len;
 103         memcpy(rsa->e.data, xfrm_rsa->e.data, exp_len);
 104
 105         /* Private key in quintuple format */
 106         if (len != 0) {
 107                 rsa->qt.q.data = rsa->e.data + exp_len;
 108                 memcpy(rsa->qt.q.data, qt.q.data, qt.q.length);
 109                 rsa->qt.dQ.data = rsa->qt.q.data + qt.q.length;
 110                 memcpy(rsa->qt.dQ.data, qt.dQ.data, qt.dQ.length);
 111                 rsa->qt.p.data = rsa->qt.dQ.data + qt.dQ.length;
 112                 memcpy(rsa->qt.p.data, qt.p.data, qt.p.length);
 113                 rsa->qt.dP.data = rsa->qt.p.data + qt.p.length;
 114                 memcpy(rsa->qt.dP.data, qt.dP.data, qt.dP.length);
 115                 rsa->qt.qInv.data = rsa->qt.dP.data + qt.dP.length;
 116                 memcpy(rsa->qt.qInv.data, qt.qInv.data, qt.qInv.length);
 117
 118                 rsa->qt.q.length = qt.q.length;
 119                 rsa->qt.dQ.length = qt.dQ.length;
 120                 rsa->qt.p.length = qt.p.length;
 121                 rsa->qt.dP.length = qt.dP.length;
 122                 rsa->qt.qInv.length = qt.qInv.length;
 123         }
 124         rsa->n.length = mod_len;
 125         rsa->e.length = exp_len;
 126
 127         return 0;
 128 }
 129
 130 static __rte_always_inline int
 131 cnxk_ae_fill_ec_params(struct cnxk_ae_sess *sess,
 132                        struct rte_crypto_asym_xform *xform)
 133 {
 134         struct roc_ae_ec_ctx *ec = &sess->ec_ctx;
 135
 136         switch (xform->ec.curve_id) {
 137         case RTE_CRYPTO_EC_GROUP_SECP192R1:
 138                 ec->curveid = ROC_AE_EC_ID_P192;
 139                 break;
 140         case RTE_CRYPTO_EC_GROUP_SECP224R1:
 141                 ec->curveid = ROC_AE_EC_ID_P224;
 142                 break;
 143         case RTE_CRYPTO_EC_GROUP_SECP256R1:
 144                 ec->curveid = ROC_AE_EC_ID_P256;
 145                 break;
 146         case RTE_CRYPTO_EC_GROUP_SECP384R1:
 147                 ec->curveid = ROC_AE_EC_ID_P384;
 148                 break;
 149         case RTE_CRYPTO_EC_GROUP_SECP521R1:
 150                 ec->curveid = ROC_AE_EC_ID_P521;
 151                 break;
 152         default:
 153                 /* Only NIST curves (FIPS 186-4) are supported */
 154                 return -EINVAL;
 155         }
 156
 157         return 0;
 158 }
 159
 160 static __rte_always_inline int
 161 cnxk_ae_fill_session_parameters(struct cnxk_ae_sess *sess,
 162                                 struct rte_crypto_asym_xform *xform)
 163 {
 164         int ret;
 165
 166         sess->xfrm_type = xform->xform_type;
 167
 168         switch (xform->xform_type) {
 169         case RTE_CRYPTO_ASYM_XFORM_RSA:
 170                 ret = cnxk_ae_fill_rsa_params(sess, xform);
 171                 break;
 172         case RTE_CRYPTO_ASYM_XFORM_MODEX:
 173                 ret = cnxk_ae_fill_modex_params(sess, xform);
 174                 break;
 175         case RTE_CRYPTO_ASYM_XFORM_ECDSA:
 176                 /* Fall through */
 177         case RTE_CRYPTO_ASYM_XFORM_ECPM:
 178                 ret = cnxk_ae_fill_ec_params(sess, xform);
 179                 break;
 180         default:
 181                 return -ENOTSUP;
 182         }
 183         return ret;
 184 }
 185
 186 static inline void
 187 cnxk_ae_free_session_parameters(struct cnxk_ae_sess *sess)
 188 {
 189         struct rte_crypto_modex_xform *mod;
 190         struct rte_crypto_rsa_xform *rsa;
 191
 192         switch (sess->xfrm_type) {
 193         case RTE_CRYPTO_ASYM_XFORM_RSA:
 194                 rsa = &sess->rsa_ctx;
 195                 if (rsa->n.data)
 196                         rte_free(rsa->n.data);
 197                 break;
 198         case RTE_CRYPTO_ASYM_XFORM_MODEX:
 199                 mod = &sess->mod_ctx;
 200                 if (mod->modulus.data)
 201                         rte_free(mod->modulus.data);
 202                 break;
 203         case RTE_CRYPTO_ASYM_XFORM_ECDSA:
 204                 /* Fall through */
 205         case RTE_CRYPTO_ASYM_XFORM_ECPM:
 206                 break;
 207         default:
 208                 break;
 209         }
 210 }
 211
 212 static __rte_always_inline int
 213 cnxk_ae_modex_prep(struct rte_crypto_op *op, struct roc_ae_buf_ptr *meta_buf,
 214                    struct rte_crypto_modex_xform *mod, struct cpt_inst_s *inst)
 215 {
 216         uint32_t exp_len = mod->exponent.length;
 217         uint32_t mod_len = mod->modulus.length;
 218         struct rte_crypto_mod_op_param mod_op;
 219         uint64_t total_key_len;
 220         union cpt_inst_w4 w4;
 221         uint32_t base_len;
 222         uint32_t dlen;
 223         uint8_t *dptr;
 224
 225         mod_op = op->asym->modex;
 226
 227         base_len = mod_op.base.length;
 228         if (unlikely(base_len > mod_len)) {
 229                 op->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
 230                 return -ENOTSUP;
 231         }
 232
 233         total_key_len = mod_len + exp_len;
 234
 235         /* Input buffer */
 236         dptr = meta_buf->vaddr;
 237         inst->dptr = (uintptr_t)dptr;
 238         memcpy(dptr, mod->modulus.data, total_key_len);
 239         dptr += total_key_len;
 240         memcpy(dptr, mod_op.base.data, base_len);
 241         dptr += base_len;
 242         dlen = total_key_len + base_len;
 243
 244         /* Setup opcodes */
 245         w4.s.opcode_major = ROC_AE_MAJOR_OP_MODEX;
 246         w4.s.opcode_minor = ROC_AE_MINOR_OP_MODEX;
 247
 248         w4.s.param1 = mod_len;
 249         w4.s.param2 = exp_len;
 250         w4.s.dlen = dlen;
 251
 252         inst->w4.u64 = w4.u64;
 253         inst->rptr = (uintptr_t)dptr;
 254
 255         return 0;
 256 }
 257
 258 static __rte_always_inline void
 259 cnxk_ae_rsa_prep(struct rte_crypto_op *op, struct roc_ae_buf_ptr *meta_buf,
 260                  struct rte_crypto_rsa_xform *rsa,
 261                  rte_crypto_param *crypto_param, struct cpt_inst_s *inst)
 262 {
 263         struct rte_crypto_rsa_op_param rsa_op;
 264         uint32_t mod_len = rsa->n.length;
 265         uint32_t exp_len = rsa->e.length;
 266         uint64_t total_key_len;
 267         union cpt_inst_w4 w4;
 268         uint32_t in_size;
 269         uint32_t dlen;
 270         uint8_t *dptr;
 271
 272         rsa_op = op->asym->rsa;
 273         total_key_len = mod_len + exp_len;
 274
 275         /* Input buffer */
 276         dptr = meta_buf->vaddr;
 277         inst->dptr = (uintptr_t)dptr;
 278         memcpy(dptr, rsa->n.data, total_key_len);
 279         dptr += total_key_len;
 280
 281         in_size = crypto_param->length;
 282         memcpy(dptr, crypto_param->data, in_size);
 283
 284         dptr += in_size;
 285         dlen = total_key_len + in_size;
 286
 287         if (rsa_op.pad == RTE_CRYPTO_RSA_PADDING_NONE) {
 288                 /* Use mod_exp operation for no_padding type */
 289                 w4.s.opcode_minor = ROC_AE_MINOR_OP_MODEX;
 290                 w4.s.param2 = exp_len;
 291         } else {
 292                 if (rsa_op.op_type == RTE_CRYPTO_ASYM_OP_ENCRYPT) {
 293                         w4.s.opcode_minor = ROC_AE_MINOR_OP_PKCS_ENC;
 294                         /* Public key encrypt, use BT2*/
 295                         w4.s.param2 = ROC_AE_CPT_BLOCK_TYPE2 |
 296                                       ((uint16_t)(exp_len) << 1);
 297                 } else if (rsa_op.op_type == RTE_CRYPTO_ASYM_OP_VERIFY) {
 298                         w4.s.opcode_minor = ROC_AE_MINOR_OP_PKCS_DEC;
 299                         /* Public key decrypt, use BT1 */
 300                         w4.s.param2 = ROC_AE_CPT_BLOCK_TYPE1;
 301                 }
 302         }
 303
 304         w4.s.opcode_major = ROC_AE_MAJOR_OP_MODEX;
 305
 306         w4.s.param1 = mod_len;
 307         w4.s.dlen = dlen;
 308
 309         inst->w4.u64 = w4.u64;
 310         inst->rptr = (uintptr_t)dptr;
 311 }
 312
 313 static __rte_always_inline void
 314 cnxk_ae_rsa_crt_prep(struct rte_crypto_op *op, struct roc_ae_buf_ptr *meta_buf,
 315                      struct rte_crypto_rsa_xform *rsa,
 316                      rte_crypto_param *crypto_param, struct cpt_inst_s *inst)
 317 {
 318         uint32_t qInv_len = rsa->qt.qInv.length;
 319         struct rte_crypto_rsa_op_param rsa_op;
 320         uint32_t dP_len = rsa->qt.dP.length;
 321         uint32_t dQ_len = rsa->qt.dQ.length;
 322         uint32_t p_len = rsa->qt.p.length;
 323         uint32_t q_len = rsa->qt.q.length;
 324         uint32_t mod_len = rsa->n.length;
 325         uint64_t total_key_len;
 326         union cpt_inst_w4 w4;
 327         uint32_t in_size;
 328         uint32_t dlen;
 329         uint8_t *dptr;
 330
 331         rsa_op = op->asym->rsa;
 332         total_key_len = p_len + q_len + dP_len + dQ_len + qInv_len;
 333
 334         /* Input buffer */
 335         dptr = meta_buf->vaddr;
 336         inst->dptr = (uintptr_t)dptr;
 337         memcpy(dptr, rsa->qt.q.data, total_key_len);
 338         dptr += total_key_len;
 339
 340         in_size = crypto_param->length;
 341         memcpy(dptr, crypto_param->data, in_size);
 342
 343         dptr += in_size;
 344         dlen = total_key_len + in_size;
 345
 346         if (rsa_op.pad == RTE_CRYPTO_RSA_PADDING_NONE) {
 347                 /*Use mod_exp operation for no_padding type */
 348                 w4.s.opcode_minor = ROC_AE_MINOR_OP_MODEX_CRT;
 349         } else {
 350                 if (rsa_op.op_type == RTE_CRYPTO_ASYM_OP_SIGN) {
 351                         w4.s.opcode_minor = ROC_AE_MINOR_OP_PKCS_ENC_CRT;
 352                         /* Private encrypt, use BT1 */
 353                         w4.s.param2 = ROC_AE_CPT_BLOCK_TYPE1;
 354                 } else if (rsa_op.op_type == RTE_CRYPTO_ASYM_OP_DECRYPT) {
 355                         w4.s.opcode_minor = ROC_AE_MINOR_OP_PKCS_DEC_CRT;
 356                         /* Private decrypt, use BT2 */
 357                         w4.s.param2 = ROC_AE_CPT_BLOCK_TYPE2;
 358                 }
 359         }
 360
 361         w4.s.opcode_major = ROC_AE_MAJOR_OP_MODEX;
 362
 363         w4.s.param1 = mod_len;
 364         w4.s.dlen = dlen;
 365
 366         inst->w4.u64 = w4.u64;
 367         inst->rptr = (uintptr_t)dptr;
 368 }
 369
 370 static __rte_always_inline int __rte_hot
 371 cnxk_ae_enqueue_rsa_op(struct rte_crypto_op *op,
 372                        struct roc_ae_buf_ptr *meta_buf,
 373                        struct cnxk_ae_sess *sess, struct cpt_inst_s *inst)
 374 {
 375         struct rte_crypto_rsa_op_param *rsa = &op->asym->rsa;
 376
 377         switch (rsa->op_type) {
 378         case RTE_CRYPTO_ASYM_OP_VERIFY:
 379                 cnxk_ae_rsa_prep(op, meta_buf, &sess->rsa_ctx, &rsa->sign,
 380                                  inst);
 381                 break;
 382         case RTE_CRYPTO_ASYM_OP_ENCRYPT:
 383                 cnxk_ae_rsa_prep(op, meta_buf, &sess->rsa_ctx, &rsa->message,
 384                                  inst);
 385                 break;
 386         case RTE_CRYPTO_ASYM_OP_SIGN:
 387                 cnxk_ae_rsa_crt_prep(op, meta_buf, &sess->rsa_ctx,
 388                                      &rsa->message, inst);
 389                 break;
 390         case RTE_CRYPTO_ASYM_OP_DECRYPT:
 391                 cnxk_ae_rsa_crt_prep(op, meta_buf, &sess->rsa_ctx, &rsa->cipher,
 392                                      inst);
 393                 break;
 394         default:
 395                 op->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
 396                 return -EINVAL;
 397         }
 398         return 0;
 399 }
 400
 401 static __rte_always_inline void
 402 cnxk_ae_ecdsa_sign_prep(struct rte_crypto_ecdsa_op_param *ecdsa,
 403                         struct roc_ae_buf_ptr *meta_buf,
 404                         uint64_t fpm_table_iova, struct roc_ae_ec_group *ec_grp,
 405                         uint8_t curveid, struct cpt_inst_s *inst)
 406 {
 407         uint16_t message_len = ecdsa->message.length;
 408         uint16_t pkey_len = ecdsa->pkey.length;
 409         uint16_t p_align, k_align, m_align;
 410         uint16_t k_len = ecdsa->k.length;
 411         uint16_t order_len, prime_len;
 412         uint16_t o_offset, pk_offset;
 413         union cpt_inst_w4 w4;
 414         uint16_t dlen;
 415         uint8_t *dptr;
 416
 417         prime_len = ec_grp->prime.length;
 418         order_len = ec_grp->order.length;
 419
 420         /* Truncate input length to curve prime length */
 421         if (message_len > prime_len)
 422                 message_len = prime_len;
 423         m_align = RTE_ALIGN_CEIL(message_len, 8);
 424
 425         p_align = RTE_ALIGN_CEIL(prime_len, 8);
 426         k_align = RTE_ALIGN_CEIL(k_len, 8);
 427
 428         /* Set write offset for order and private key */
 429         o_offset = prime_len - order_len;
 430         pk_offset = prime_len - pkey_len;
 431
 432         /* Input buffer */
 433         dptr = meta_buf->vaddr;
 434         inst->dptr = (uintptr_t)dptr;
 435
 436         /*
 437          * Set dlen = sum(sizeof(fpm address), ROUNDUP8(scalar len, input len),
 438          * ROUNDUP8(priv key len, prime len, order len)).
 439          * Please note, private key, order cannot exceed prime
 440          * length i.e 3 * p_align.
 441          */
 442         dlen = sizeof(fpm_table_iova) + k_align + m_align + p_align * 3;
 443
 444         memset(dptr, 0, dlen);
 445
 446         *(uint64_t *)dptr = fpm_table_iova;
 447         dptr += sizeof(fpm_table_iova);
 448
 449         memcpy(dptr, ecdsa->k.data, k_len);
 450         dptr += k_align;
 451
 452         memcpy(dptr, ec_grp->prime.data, prime_len);
 453         dptr += p_align;
 454
 455         memcpy(dptr + o_offset, ec_grp->order.data, order_len);
 456         dptr += p_align;
 457
 458         memcpy(dptr + pk_offset, ecdsa->pkey.data, pkey_len);
 459         dptr += p_align;
 460
 461         memcpy(dptr, ecdsa->message.data, message_len);
 462         dptr += m_align;
 463
 464         /* Setup opcodes */
 465         w4.s.opcode_major = ROC_AE_MAJOR_OP_ECDSA;
 466         w4.s.opcode_minor = ROC_AE_MINOR_OP_ECDSA_SIGN;
 467
 468         w4.s.param1 = curveid | (message_len << 8);
 469         w4.s.param2 = k_len;
 470         w4.s.dlen = dlen;
 471
 472         inst->w4.u64 = w4.u64;
 473         inst->rptr = (uintptr_t)dptr;
 474 }
 475
 476 static __rte_always_inline void
 477 cnxk_ae_ecdsa_verify_prep(struct rte_crypto_ecdsa_op_param *ecdsa,
 478                           struct roc_ae_buf_ptr *meta_buf,
 479                           uint64_t fpm_table_iova,
 480                           struct roc_ae_ec_group *ec_grp, uint8_t curveid,
 481                           struct cpt_inst_s *inst)
 482 {
 483         uint32_t message_len = ecdsa->message.length;
 484         uint16_t o_offset, r_offset, s_offset;
 485         uint16_t qx_len = ecdsa->q.x.length;
 486         uint16_t qy_len = ecdsa->q.y.length;
 487         uint16_t r_len = ecdsa->r.length;
 488         uint16_t s_len = ecdsa->s.length;
 489         uint16_t order_len, prime_len;
 490         uint16_t qx_offset, qy_offset;
 491         uint16_t p_align, m_align;
 492         union cpt_inst_w4 w4;
 493         uint16_t dlen;
 494         uint8_t *dptr;
 495
 496         prime_len = ec_grp->prime.length;
 497         order_len = ec_grp->order.length;
 498
 499         /* Truncate input length to curve prime length */
 500         if (message_len > prime_len)
 501                 message_len = prime_len;
 502
 503         m_align = RTE_ALIGN_CEIL(message_len, 8);
 504         p_align = RTE_ALIGN_CEIL(prime_len, 8);
 505
 506         /* Set write offset for sign, order and public key coordinates */
 507         o_offset = prime_len - order_len;
 508         qx_offset = prime_len - qx_len;
 509         qy_offset = prime_len - qy_len;
 510         r_offset = prime_len - r_len;
 511         s_offset = prime_len - s_len;
 512
 513         /* Input buffer */
 514         dptr = meta_buf->vaddr;
 515         inst->dptr = (uintptr_t)dptr;
 516
 517         /*
 518          * Set dlen = sum(sizeof(fpm address), ROUNDUP8(message len),
 519          * ROUNDUP8(sign len(r and s), public key len(x and y coordinates),
 520          * prime len, order len)).
 521          * Please note sign, public key and order can not exceed prime length
 522          * i.e. 6 * p_align
 523          */
 524         dlen = sizeof(fpm_table_iova) + m_align + (6 * p_align);
 525
 526         memset(dptr, 0, dlen);
 527
 528         *(uint64_t *)dptr = fpm_table_iova;
 529         dptr += sizeof(fpm_table_iova);
 530
 531         memcpy(dptr + r_offset, ecdsa->r.data, r_len);
 532         dptr += p_align;
 533
 534         memcpy(dptr + s_offset, ecdsa->s.data, s_len);
 535         dptr += p_align;
 536
 537         memcpy(dptr, ecdsa->message.data, message_len);
 538         dptr += m_align;
 539
 540         memcpy(dptr + o_offset, ec_grp->order.data, order_len);
 541         dptr += p_align;
 542
 543         memcpy(dptr, ec_grp->prime.data, prime_len);
 544         dptr += p_align;
 545
 546         memcpy(dptr + qx_offset, ecdsa->q.x.data, qx_len);
 547         dptr += p_align;
 548
 549         memcpy(dptr + qy_offset, ecdsa->q.y.data, qy_len);
 550         dptr += p_align;
 551
 552         /* Setup opcodes */
 553         w4.s.opcode_major = ROC_AE_MAJOR_OP_ECDSA;
 554         w4.s.opcode_minor = ROC_AE_MINOR_OP_ECDSA_VERIFY;
 555
 556         w4.s.param1 = curveid | (message_len << 8);
 557         w4.s.param2 = 0;
 558         w4.s.dlen = dlen;
 559
 560         inst->w4.u64 = w4.u64;
 561         inst->rptr = (uintptr_t)dptr;
 562 }
 563
 564 static __rte_always_inline int __rte_hot
 565 cnxk_ae_enqueue_ecdsa_op(struct rte_crypto_op *op,
 566                          struct roc_ae_buf_ptr *meta_buf,
 567                          struct cnxk_ae_sess *sess, uint64_t *fpm_iova,
 568                          struct roc_ae_ec_group **ec_grp,
 569                          struct cpt_inst_s *inst)
 570 {
 571         struct rte_crypto_ecdsa_op_param *ecdsa = &op->asym->ecdsa;
 572         uint8_t curveid = sess->ec_ctx.curveid;
 573
 574         if (ecdsa->op_type == RTE_CRYPTO_ASYM_OP_SIGN)
 575                 cnxk_ae_ecdsa_sign_prep(ecdsa, meta_buf, fpm_iova[curveid],
 576                                         ec_grp[curveid], curveid, inst);
 577         else if (ecdsa->op_type == RTE_CRYPTO_ASYM_OP_VERIFY)
 578                 cnxk_ae_ecdsa_verify_prep(ecdsa, meta_buf, fpm_iova[curveid],
 579                                           ec_grp[curveid], curveid, inst);
 580         else {
 581                 op->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
 582                 return -EINVAL;
 583         }
 584         return 0;
 585 }
 586
 587 static __rte_always_inline int
 588 cnxk_ae_ecpm_prep(struct rte_crypto_ecpm_op_param *ecpm,
 589                   struct roc_ae_buf_ptr *meta_buf,
 590                   struct roc_ae_ec_group *ec_grp, uint8_t curveid,
 591                   struct cpt_inst_s *inst)
 592 {
 593         uint16_t x1_len = ecpm->p.x.length;
 594         uint16_t y1_len = ecpm->p.y.length;
 595         uint16_t scalar_align, p_align;
 596         uint16_t x1_offset, y1_offset;
 597         uint16_t dlen, prime_len;
 598         union cpt_inst_w4 w4;
 599         uint8_t *dptr;
 600
 601         prime_len = ec_grp->prime.length;
 602
 603         /* Input buffer */
 604         dptr = meta_buf->vaddr;
 605         inst->dptr = (uintptr_t)dptr;
 606
 607         p_align = RTE_ALIGN_CEIL(prime_len, 8);
 608         scalar_align = RTE_ALIGN_CEIL(ecpm->scalar.length, 8);
 609
 610         /*
 611          * Set dlen = sum(ROUNDUP8(input point(x and y coordinates), prime,
 612          * scalar length),
 613          * Please note point length is equivalent to prime of the curve
 614          */
 615         dlen = 3 * p_align + scalar_align;
 616
 617         x1_offset = prime_len - x1_len;
 618         y1_offset = prime_len - y1_len;
 619
 620         memset(dptr, 0, dlen);
 621
 622         /* Copy input point, scalar, prime */
 623         memcpy(dptr + x1_offset, ecpm->p.x.data, x1_len);
 624         dptr += p_align;
 625         memcpy(dptr + y1_offset, ecpm->p.y.data, y1_len);
 626         dptr += p_align;
 627         memcpy(dptr, ecpm->scalar.data, ecpm->scalar.length);
 628         dptr += scalar_align;
 629         memcpy(dptr, ec_grp->prime.data, ec_grp->prime.length);
 630         dptr += p_align;
 631
 632         /* Setup opcodes */
 633         w4.s.opcode_major = ROC_AE_MAJOR_OP_ECC;
 634         w4.s.opcode_minor = ROC_AE_MINOR_OP_ECC_UMP;
 635
 636         w4.s.param1 = curveid;
 637         w4.s.param2 = ecpm->scalar.length;
 638         w4.s.dlen = dlen;
 639
 640         inst->w4.u64 = w4.u64;
 641         inst->rptr = (uintptr_t)dptr;
 642
 643         return 0;
 644 }
 645
 646 static __rte_always_inline void
 647 cnxk_ae_dequeue_rsa_op(struct rte_crypto_op *cop, uint8_t *rptr,
 648                        struct rte_crypto_rsa_xform *rsa_ctx)
 649 {
 650         struct rte_crypto_rsa_op_param *rsa = &cop->asym->rsa;
 651
 652         switch (rsa->op_type) {
 653         case RTE_CRYPTO_ASYM_OP_ENCRYPT:
 654                 rsa->cipher.length = rsa_ctx->n.length;
 655                 memcpy(rsa->cipher.data, rptr, rsa->cipher.length);
 656                 break;
 657         case RTE_CRYPTO_ASYM_OP_DECRYPT:
 658                 if (rsa->pad == RTE_CRYPTO_RSA_PADDING_NONE) {
 659                         rsa->message.length = rsa_ctx->n.length;
 660                         memcpy(rsa->message.data, rptr, rsa->message.length);
 661                 } else {
 662                         /* Get length of decrypted output */
 663                         rsa->message.length =
 664                                 rte_cpu_to_be_16(*((uint16_t *)rptr));
 665                         /*
 666                          * Offset output data pointer by length field
 667                          * (2 bytes) and copy decrypted data.
 668                          */
 669                         memcpy(rsa->message.data, rptr + 2,
 670                                rsa->message.length);
 671                 }
 672                 break;
 673         case RTE_CRYPTO_ASYM_OP_SIGN:
 674                 rsa->sign.length = rsa_ctx->n.length;
 675                 memcpy(rsa->sign.data, rptr, rsa->sign.length);
 676                 break;
 677         case RTE_CRYPTO_ASYM_OP_VERIFY:
 678                 if (rsa->pad == RTE_CRYPTO_RSA_PADDING_NONE) {
 679                         rsa->sign.length = rsa_ctx->n.length;
 680                         memcpy(rsa->sign.data, rptr, rsa->sign.length);
 681                 } else {
 682                         /* Get length of signed output */
 683                         rsa->sign.length =
 684                                 rte_cpu_to_be_16(*((uint16_t *)rptr));
 685                         /*
 686                          * Offset output data pointer by length field
 687                          * (2 bytes) and copy signed data.
 688                          */
 689                         memcpy(rsa->sign.data, rptr + 2, rsa->sign.length);
 690                 }
 691                 if (memcmp(rsa->sign.data, rsa->message.data,
 692                            rsa->message.length)) {
 693                         cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
 694                 }
 695                 break;
 696         default:
 697                 cop->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
 698                 break;
 699         }
 700 }
 701
 702 static __rte_always_inline void
 703 cnxk_ae_dequeue_ecdsa_op(struct rte_crypto_ecdsa_op_param *ecdsa, uint8_t *rptr,
 704                          struct roc_ae_ec_ctx *ec,
 705                          struct roc_ae_ec_group **ec_grp)
 706 {
 707         int prime_len = ec_grp[ec->curveid]->prime.length;
 708
 709         if (ecdsa->op_type == RTE_CRYPTO_ASYM_OP_VERIFY)
 710                 return;
 711
 712         /* Separate out sign r and s components */
 713         memcpy(ecdsa->r.data, rptr, prime_len);
 714         memcpy(ecdsa->s.data, rptr + RTE_ALIGN_CEIL(prime_len, 8), prime_len);
 715         ecdsa->r.length = prime_len;
 716         ecdsa->s.length = prime_len;
 717 }
 718
 719 static __rte_always_inline void
 720 cnxk_ae_dequeue_ecpm_op(struct rte_crypto_ecpm_op_param *ecpm, uint8_t *rptr,
 721                         struct roc_ae_ec_ctx *ec,
 722                         struct roc_ae_ec_group **ec_grp)
 723 {
 724         int prime_len = ec_grp[ec->curveid]->prime.length;
 725
 726         memcpy(ecpm->r.x.data, rptr, prime_len);
 727         memcpy(ecpm->r.y.data, rptr + RTE_ALIGN_CEIL(prime_len, 8), prime_len);
 728         ecpm->r.x.length = prime_len;
 729         ecpm->r.y.length = prime_len;
 730 }
 731
 732 static __rte_always_inline void *
 733 cnxk_ae_alloc_meta(struct roc_ae_buf_ptr *buf,
 734                    struct rte_mempool *cpt_meta_pool,
 735                    struct cpt_inflight_req *infl_req)
 736 {
 737         uint8_t *mdata;
 738
 739         if (unlikely(rte_mempool_get(cpt_meta_pool, (void **)&mdata) < 0))
 740                 return NULL;
 741
 742         buf->vaddr = mdata;
 743
 744         infl_req->mdata = mdata;
 745         infl_req->op_flags |= CPT_OP_FLAGS_METABUF;
 746
 747         return mdata;
 748 }
 749
 750 static __rte_always_inline int32_t __rte_hot
 751 cnxk_ae_enqueue(struct cnxk_cpt_qp *qp, struct rte_crypto_op *op,
 752                 struct cpt_inflight_req *infl_req, struct cpt_inst_s *inst,
 753                 struct cnxk_ae_sess *sess)
 754 {
 755         struct cpt_qp_meta_info *minfo = &qp->meta_info;
 756         struct rte_crypto_asym_op *asym_op = op->asym;
 757         struct roc_ae_buf_ptr meta_buf;
 758         uint64_t *mop;
 759         void *mdata;
 760         int ret;
 761
 762         mdata = cnxk_ae_alloc_meta(&meta_buf, minfo->pool, infl_req);
 763         if (mdata == NULL)
 764                 return -ENOMEM;
 765
 766         /* Reserve 8B for RPTR */
 767         meta_buf.vaddr = PLT_PTR_ADD(mdata, sizeof(uint64_t));
 768
 769         switch (sess->xfrm_type) {
 770         case RTE_CRYPTO_ASYM_XFORM_MODEX:
 771                 ret = cnxk_ae_modex_prep(op, &meta_buf, &sess->mod_ctx, inst);
 772                 if (unlikely(ret))
 773                         goto req_fail;
 774                 break;
 775         case RTE_CRYPTO_ASYM_XFORM_RSA:
 776                 ret = cnxk_ae_enqueue_rsa_op(op, &meta_buf, sess, inst);
 777                 if (unlikely(ret))
 778                         goto req_fail;
 779                 break;
 780         case RTE_CRYPTO_ASYM_XFORM_ECDSA:
 781                 ret = cnxk_ae_enqueue_ecdsa_op(op, &meta_buf, sess,
 782                                                sess->cnxk_fpm_iova,
 783                                                sess->ec_grp, inst);
 784                 if (unlikely(ret))
 785                         goto req_fail;
 786                 break;
 787         case RTE_CRYPTO_ASYM_XFORM_ECPM:
 788                 ret = cnxk_ae_ecpm_prep(&asym_op->ecpm, &meta_buf,
 789                                         sess->ec_grp[sess->ec_ctx.curveid],
 790                                         sess->ec_ctx.curveid, inst);
 791                 if (unlikely(ret))
 792                         goto req_fail;
 793                 break;
 794         default:
 795                 op->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
 796                 ret = -EINVAL;
 797                 goto req_fail;
 798         }
 799
 800         mop = mdata;
 801         mop[0] = inst->rptr;
 802         return 0;
 803
 804 req_fail:
 805         rte_mempool_put(minfo->pool, infl_req->mdata);
 806         return ret;
 807 }
 808
 809 static __rte_always_inline void
 810 cnxk_ae_post_process(struct rte_crypto_op *cop, struct cnxk_ae_sess *sess,
 811                      uint8_t *rptr)
 812 {
 813         struct rte_crypto_asym_op *op = cop->asym;
 814
 815         switch (sess->xfrm_type) {
 816         case RTE_CRYPTO_ASYM_XFORM_RSA:
 817                 cnxk_ae_dequeue_rsa_op(cop, rptr, &sess->rsa_ctx);
 818                 break;
 819         case RTE_CRYPTO_ASYM_XFORM_MODEX:
 820                 op->modex.result.length = sess->mod_ctx.modulus.length;
 821                 memcpy(op->modex.result.data, rptr, op->modex.result.length);
 822                 break;
 823         case RTE_CRYPTO_ASYM_XFORM_ECDSA:
 824                 cnxk_ae_dequeue_ecdsa_op(&op->ecdsa, rptr, &sess->ec_ctx,
 825                                          sess->ec_grp);
 826                 break;
 827         case RTE_CRYPTO_ASYM_XFORM_ECPM:
 828                 cnxk_ae_dequeue_ecpm_op(&op->ecpm, rptr, &sess->ec_ctx,
 829                                         sess->ec_grp);
 830                 break;
 831         default:
 832                 cop->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
 833                 break;
 834         }
 835 }
 836 #endif /* _CNXK_AE_H_ */