drivers/crypto/dpaa2_sec/dpaa2_sec_priv.h

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright (c) 2016 Freescale Semiconductor, Inc. All rights reserved.
   5  *   Copyright (c) 2016 NXP. All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of  Freescale Semiconductor, Inc nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #ifndef _RTE_DPAA2_SEC_PMD_PRIVATE_H_
  35 #define _RTE_DPAA2_SEC_PMD_PRIVATE_H_
  36
  37 /** private data structure for each DPAA2_SEC device */
  38 struct dpaa2_sec_dev_private {
  39         void *mc_portal; /**< MC Portal for configuring this device */
  40         void *hw; /**< Hardware handle for this device.Used by NADK framework */
  41         int32_t hw_id; /**< An unique ID of this device instance */
  42         int32_t vfio_fd; /**< File descriptor received via VFIO */
  43         uint16_t token; /**< Token required by DPxxx objects */
  44         unsigned int max_nb_queue_pairs;
  45         /**< Max number of queue pairs supported by device */
  46         unsigned int max_nb_sessions;
  47         /**< Max number of sessions supported by device */
  48 };
  49
  50 struct dpaa2_sec_qp {
  51         struct dpaa2_queue rx_vq;
  52         struct dpaa2_queue tx_vq;
  53 };
  54
  55 static const struct rte_cryptodev_capabilities dpaa2_sec_capabilities[] = {
  56         {       /* MD5 HMAC */
  57                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
  58                 {.sym = {
  59                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
  60                         {.auth = {
  61                                 .algo = RTE_CRYPTO_AUTH_MD5_HMAC,
  62                                 .block_size = 64,
  63                                 .key_size = {
  64                                         .min = 64,
  65                                         .max = 64,
  66                                         .increment = 0
  67                                 },
  68                                 .digest_size = {
  69                                         .min = 16,
  70                                         .max = 16,
  71                                         .increment = 0
  72                                 },
  73                                 .aad_size = { 0 }
  74                         }, }
  75                 }, }
  76         },
  77         {       /* SHA1 HMAC */
  78                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
  79                 {.sym = {
  80                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
  81                         {.auth = {
  82                                 .algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
  83                                 .block_size = 64,
  84                                 .key_size = {
  85                                         .min = 64,
  86                                         .max = 64,
  87                                         .increment = 0
  88                                 },
  89                                 .digest_size = {
  90                                         .min = 20,
  91                                         .max = 20,
  92                                         .increment = 0
  93                                 },
  94                                 .aad_size = { 0 }
  95                         }, }
  96                 }, }
  97         },
  98         {       /* SHA224 HMAC */
  99                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 100                 {.sym = {
 101                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 102                         {.auth = {
 103                                 .algo = RTE_CRYPTO_AUTH_SHA224_HMAC,
 104                                 .block_size = 64,
 105                                 .key_size = {
 106                                         .min = 64,
 107                                         .max = 64,
 108                                         .increment = 0
 109                                 },
 110                                 .digest_size = {
 111                                         .min = 28,
 112                                         .max = 28,
 113                                         .increment = 0
 114                                 },
 115                                 .aad_size = { 0 }
 116                         }, }
 117                 }, }
 118         },
 119         {       /* SHA256 HMAC */
 120                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 121                 {.sym = {
 122                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 123                         {.auth = {
 124                                 .algo = RTE_CRYPTO_AUTH_SHA256_HMAC,
 125                                 .block_size = 64,
 126                                 .key_size = {
 127                                         .min = 64,
 128                                         .max = 64,
 129                                         .increment = 0
 130                                 },
 131                                 .digest_size = {
 132                                                 .min = 32,
 133                                                 .max = 32,
 134                                                 .increment = 0
 135                                         },
 136                                         .aad_size = { 0 }
 137                                 }, }
 138                         }, }
 139                 },
 140         {       /* SHA384 HMAC */
 141                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 142                 {.sym = {
 143                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 144                         {.auth = {
 145                                 .algo = RTE_CRYPTO_AUTH_SHA384_HMAC,
 146                                 .block_size = 128,
 147                                 .key_size = {
 148                                         .min = 128,
 149                                         .max = 128,
 150                                         .increment = 0
 151                                 },
 152                                 .digest_size = {
 153                                         .min = 48,
 154                                         .max = 48,
 155                                         .increment = 0
 156                                 },
 157                                 .aad_size = { 0 }
 158                         }, }
 159                 }, }
 160         },
 161         {       /* SHA512 HMAC */
 162                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 163                 {.sym = {
 164                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 165                         {.auth = {
 166                                 .algo = RTE_CRYPTO_AUTH_SHA512_HMAC,
 167                                 .block_size = 128,
 168                                 .key_size = {
 169                                         .min = 128,
 170                                         .max = 128,
 171                                         .increment = 0
 172                                 },
 173                                 .digest_size = {
 174                                         .min = 64,
 175                                         .max = 64,
 176                                         .increment = 0
 177                                 },
 178                                 .aad_size = { 0 }
 179                         }, }
 180                 }, }
 181         },
 182         {       /* AES CBC */
 183                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 184                 {.sym = {
 185                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 186                         {.cipher = {
 187                                 .algo = RTE_CRYPTO_CIPHER_AES_CBC,
 188                                 .block_size = 16,
 189                                 .key_size = {
 190                                         .min = 16,
 191                                         .max = 32,
 192                                         .increment = 8
 193                                 },
 194                                 .iv_size = {
 195                                         .min = 16,
 196                                         .max = 16,
 197                                         .increment = 0
 198                                 }
 199                         }, }
 200                 }, }
 201         },
 202         {       /* 3DES CBC */
 203                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 204                 {.sym = {
 205                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 206                         {.cipher = {
 207                                 .algo = RTE_CRYPTO_CIPHER_3DES_CBC,
 208                                 .block_size = 8,
 209                                 .key_size = {
 210                                         .min = 16,
 211                                         .max = 24,
 212                                         .increment = 8
 213                                 },
 214                                 .iv_size = {
 215                                         .min = 8,
 216                                         .max = 8,
 217                                         .increment = 0
 218                                 }
 219                         }, }
 220                 }, }
 221         },
 222
 223         RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST()
 224 };
 225 #endif /* _RTE_DPAA2_SEC_PMD_PRIVATE_H_ */