drivers/crypto/qat/qat_asym_capabilities.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2019 Intel Corporation
   3  */
   4
   5 #ifndef _QAT_ASYM_CAPABILITIES_H_
   6 #define _QAT_ASYM_CAPABILITIES_H_
   7
   8 #define QAT_BASE_GEN1_ASYM_CAPABILITIES                                         \
   9         {       /* modexp */                                                    \
  10                 .op = RTE_CRYPTO_OP_TYPE_ASYMMETRIC,                            \
  11                 {.asym = {                                                      \
  12                         .xform_capa = {                                         \
  13                                 .xform_type = RTE_CRYPTO_ASYM_XFORM_MODEX,      \
  14                                 .op_types = 0,                                  \
  15                                 {                                               \
  16                                 .modlen = {                                     \
  17                                 .min = 1,                                       \
  18                                 .max = 512,                                     \
  19                                 .increment = 1                                  \
  20                                 }, }                                            \
  21                         }                                                       \
  22                 },                                                              \
  23                 }                                                               \
  24         },                                                                      \
  25         {       /* modinv */                                                    \
  26                 .op = RTE_CRYPTO_OP_TYPE_ASYMMETRIC,                            \
  27                 {.asym = {                                                      \
  28                         .xform_capa = {                                         \
  29                                 .xform_type = RTE_CRYPTO_ASYM_XFORM_MODINV,     \
  30                                 .op_types = 0,                                  \
  31                                 {                                               \
  32                                 .modlen = {                                     \
  33                                 .min = 1,                                       \
  34                                 .max = 512,                                     \
  35                                 .increment = 1                                  \
  36                                 }, }                                            \
  37                         }                                                       \
  38                 },                                                              \
  39                 }                                                               \
  40         },                                                                      \
  41         {       /* RSA */                                                       \
  42                 .op = RTE_CRYPTO_OP_TYPE_ASYMMETRIC,                            \
  43                 {.asym = {                                                      \
  44                         .xform_capa = {                                         \
  45                                 .xform_type = RTE_CRYPTO_ASYM_XFORM_RSA,        \
  46                                 .op_types = ((1 << RTE_CRYPTO_ASYM_OP_SIGN) |   \
  47                                         (1 << RTE_CRYPTO_ASYM_OP_VERIFY) |      \
  48                                         (1 << RTE_CRYPTO_ASYM_OP_ENCRYPT) |     \
  49                                         (1 << RTE_CRYPTO_ASYM_OP_DECRYPT)),     \
  50                                 {                                               \
  51                                 .modlen = {                                     \
  52                                 /* min length is based on openssl rsa keygen */ \
  53                                 .min = 64,                                      \
  54                                 /* value 0 symbolizes no limit on max length */ \
  55                                 .max = 512,                                     \
  56                                 .increment = 64                                 \
  57                                 }, }                                            \
  58                         }                                                       \
  59                 },                                                              \
  60                 }                                                               \
  61         }                                                                       \
  62
  63 #endif /* _QAT_ASYM_CAPABILITIES_H_ */