Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(c) 2021 Intel Corporation
       3                 :            :  */
       4                 :            : 
       5                 :            : #include "qat_device.h"
       6                 :            : #include "qat_qp.h"
       7                 :            : #include "qat_crypto.h"
       8                 :            : #include "qat_sym.h"
       9                 :            : #include "qat_asym.h"
      10                 :            : 
      11                 :            : int
      12                 :          0 : qat_cryptodev_config(__rte_unused struct rte_cryptodev *dev,
      13                 :            :                 __rte_unused struct rte_cryptodev_config *config)
      14                 :            : {
      15                 :          0 :         return 0;
      16                 :            : }
      17                 :            : 
      18                 :            : int
      19                 :          0 : qat_cryptodev_start(__rte_unused struct rte_cryptodev *dev)
      20                 :            : {
      21                 :          0 :         return 0;
      22                 :            : }
      23                 :            : 
      24                 :            : void
      25                 :          0 : qat_cryptodev_stop(__rte_unused struct rte_cryptodev *dev)
      26                 :            : {
      27                 :          0 : }
      28                 :            : 
      29                 :            : int
      30                 :          0 : qat_cryptodev_close(struct rte_cryptodev *dev)
      31                 :            : {
      32                 :            :         int i, ret;
      33                 :            : 
      34         [ #  # ]:          0 :         for (i = 0; i < dev->data->nb_queue_pairs; i++) {
      35                 :          0 :                 ret = dev->dev_ops->queue_pair_release(dev, i);
      36         [ #  # ]:          0 :                 if (ret < 0)
      37                 :          0 :                         return ret;
      38                 :            :         }
      39                 :            : 
      40                 :            :         return 0;
      41                 :            : }
      42                 :            : 
      43                 :            : void
      44                 :          0 : qat_cryptodev_info_get(struct rte_cryptodev *dev,
      45                 :            :                 struct rte_cryptodev_info *info)
      46                 :            : {
      47                 :          0 :         struct qat_cryptodev_private *qat_private = dev->data->dev_private;
      48                 :          0 :         struct qat_pci_device *qat_dev = qat_private->qat_dev;
      49                 :          0 :         enum qat_service_type service_type = qat_private->service_type;
      50                 :            : 
      51         [ #  # ]:          0 :         if (info != NULL) {
      52                 :          0 :                 info->max_nb_queue_pairs =
      53                 :          0 :                         qat_qps_per_service(qat_dev, service_type);
      54                 :          0 :                 info->feature_flags = dev->feature_flags;
      55                 :          0 :                 info->capabilities = qat_private->qat_dev_capabilities;
      56         [ #  # ]:          0 :                 if (service_type == QAT_SERVICE_ASYMMETRIC)
      57                 :          0 :                         info->driver_id = qat_asym_driver_id;
      58                 :            : 
      59         [ #  # ]:          0 :                 if (service_type == QAT_SERVICE_SYMMETRIC)
      60                 :          0 :                         info->driver_id = qat_sym_driver_id;
      61                 :            :                 /* No limit of number of sessions */
      62                 :          0 :                 info->sym.max_nb_sessions = 0;
      63                 :            :         }
      64                 :          0 : }
      65                 :            : 
      66                 :            : void
      67                 :          0 : qat_cryptodev_stats_get(struct rte_cryptodev *dev,
      68                 :            :                 struct rte_cryptodev_stats *stats)
      69                 :            : {
      70                 :          0 :         struct qat_common_stats qat_stats = {0};
      71                 :            :         struct qat_cryptodev_private *qat_priv;
      72                 :            : 
      73         [ #  # ]:          0 :         if (stats == NULL || dev == NULL) {
      74                 :          0 :                 QAT_LOG(ERR, "invalid ptr: stats %p, dev %p", stats, dev);
      75                 :          0 :                 return;
      76                 :            :         }
      77                 :          0 :         qat_priv = dev->data->dev_private;
      78                 :            : 
      79                 :          0 :         qat_stats_get(qat_priv->qat_dev, &qat_stats, qat_priv->service_type);
      80                 :          0 :         stats->enqueued_count = qat_stats.enqueued_count;
      81                 :          0 :         stats->dequeued_count = qat_stats.dequeued_count;
      82                 :          0 :         stats->enqueue_err_count = qat_stats.enqueue_err_count;
      83                 :          0 :         stats->dequeue_err_count = qat_stats.dequeue_err_count;
      84                 :            : }
      85                 :            : 
      86                 :            : void
      87                 :          0 : qat_cryptodev_stats_reset(struct rte_cryptodev *dev)
      88                 :            : {
      89                 :            :         struct qat_cryptodev_private *qat_priv;
      90                 :            : 
      91         [ #  # ]:          0 :         if (dev == NULL) {
      92                 :          0 :                 QAT_LOG(ERR, "invalid cryptodev ptr %p", dev);
      93                 :          0 :                 return;
      94                 :            :         }
      95                 :          0 :         qat_priv = dev->data->dev_private;
      96                 :            : 
      97                 :          0 :         qat_stats_reset(qat_priv->qat_dev, qat_priv->service_type);
      98                 :            : 
      99                 :            : }
     100                 :            : 
     101                 :            : int
     102                 :          0 : qat_cryptodev_qp_release(struct rte_cryptodev *dev, uint16_t queue_pair_id)
     103                 :            : {
     104                 :          0 :         struct qat_cryptodev_private *qat_private = dev->data->dev_private;
     105                 :          0 :         struct qat_pci_device *qat_dev = qat_private->qat_dev;
     106                 :          0 :         enum qat_device_gen qat_dev_gen = qat_dev->qat_dev_gen;
     107                 :          0 :         enum qat_service_type service_type = qat_private->service_type;
     108                 :            : 
     109                 :          0 :         QAT_LOG(DEBUG, "Release %s qp %u on device %d",
     110                 :            :                         qat_service_get_str(service_type),
     111                 :            :                         queue_pair_id, dev->data->dev_id);
     112                 :            : 
     113                 :          0 :         qat_private->qat_dev->qps_in_use[service_type][queue_pair_id] = NULL;
     114                 :            : 
     115                 :          0 :         return qat_qp_release(qat_dev_gen, (struct qat_qp **)
     116                 :          0 :                         &(dev->data->queue_pairs[queue_pair_id]));
     117                 :            : }
     118                 :            : 
     119                 :            : int
     120                 :          0 : qat_cryptodev_qp_setup(struct rte_cryptodev *dev, uint16_t qp_id,
     121                 :            :         const struct rte_cryptodev_qp_conf *qp_conf, int socket_id)
     122                 :            : {
     123                 :          0 :         struct qat_qp **qp_addr =
     124                 :          0 :                         (struct qat_qp **)&(dev->data->queue_pairs[qp_id]);
     125                 :          0 :         struct qat_cryptodev_private *qat_private = dev->data->dev_private;
     126                 :          0 :         struct qat_pci_device *qat_dev = qat_private->qat_dev;
     127                 :          0 :         enum qat_service_type service_type = qat_private->service_type;
     128                 :          0 :         struct qat_qp_config qat_qp_conf = {0};
     129                 :            :         struct qat_qp *qp;
     130                 :            :         int ret = 0;
     131                 :            :         uint32_t i;
     132                 :            : 
     133                 :            :         /* If qp is already in use free ring memory and qp metadata. */
     134         [ #  # ]:          0 :         if (*qp_addr != NULL) {
     135                 :          0 :                 ret = dev->dev_ops->queue_pair_release(dev, qp_id);
     136         [ #  # ]:          0 :                 if (ret < 0)
     137                 :            :                         return -EBUSY;
     138                 :            :         }
     139         [ #  # ]:          0 :         if (qp_id >= qat_qps_per_service(qat_dev, service_type)) {
     140                 :          0 :                 QAT_LOG(ERR, "qp_id %u invalid for this device", qp_id);
     141                 :          0 :                 return -EINVAL;
     142                 :            :         }
     143                 :            : 
     144                 :          0 :         qat_qp_conf.hw = qat_qp_get_hw_data(qat_dev, service_type,
     145                 :            :                         qp_id);
     146         [ #  # ]:          0 :         if (qat_qp_conf.hw == NULL) {
     147                 :          0 :                 QAT_LOG(ERR, "qp_id %u invalid for this device", qp_id);
     148                 :          0 :                 return -EINVAL;
     149                 :            :         }
     150                 :            : 
     151         [ #  # ]:          0 :         qat_qp_conf.cookie_size = service_type == QAT_SERVICE_SYMMETRIC ?
     152                 :            :                         sizeof(struct qat_sym_op_cookie) :
     153                 :            :                         sizeof(struct qat_asym_op_cookie);
     154                 :          0 :         qat_qp_conf.nb_descriptors = qp_conf->nb_descriptors;
     155                 :          0 :         qat_qp_conf.socket_id = socket_id;
     156                 :          0 :         qat_qp_conf.service_str = qat_service_get_str(service_type);
     157                 :            : 
     158                 :          0 :         ret = qat_qp_setup(qat_dev, qp_addr, qp_id, &qat_qp_conf);
     159         [ #  # ]:          0 :         if (ret != 0)
     160                 :            :                 return ret;
     161                 :            : 
     162                 :            :         /* store a link to the qp in the qat_pci_device */
     163                 :          0 :         qat_dev->qps_in_use[service_type][qp_id] = *qp_addr;
     164                 :            : 
     165                 :            :         qp = (struct qat_qp *)*qp_addr;
     166                 :          0 :         qp->min_enq_burst_threshold = qat_private->min_enq_burst_threshold;
     167                 :            : 
     168         [ #  # ]:          0 :         for (i = 0; i < qp->nb_descriptors; i++) {
     169         [ #  # ]:          0 :                 if (service_type == QAT_SERVICE_SYMMETRIC)
     170                 :          0 :                         qat_sym_init_op_cookie(qp->op_cookies[i]);
     171                 :            :                 else
     172                 :          0 :                         qat_asym_init_op_cookie(qp->op_cookies[i]);
     173                 :            :         }
     174                 :            : 
     175         [ #  # ]:          0 :         if (qat_private->cipher_crc_offload_enable) {
     176                 :          0 :                 ret = qat_cq_get_fw_cipher_crc_cap(qp);
     177         [ #  # ]:          0 :                 if (ret < 0) {
     178                 :          0 :                         qat_cryptodev_qp_release(dev, qp_id);
     179                 :          0 :                         return ret;
     180                 :            :                 }
     181                 :            : 
     182         [ #  # ]:          0 :                 if (ret != 0)
     183                 :          0 :                         QAT_LOG(DEBUG, "Cipher CRC supported on QAT device");
     184                 :            :                 else
     185                 :          0 :                         QAT_LOG(DEBUG, "Cipher CRC not supported on QAT device");
     186                 :            : 
     187                 :            :                 /* Only send the cipher crc offload capability message once */
     188                 :          0 :                 qat_private->cipher_crc_offload_enable = 0;
     189                 :            :                 /* Set cipher crc offload indicator */
     190         [ #  # ]:          0 :                 if (ret)
     191                 :          0 :                         qat_private->internal_capabilities |=
     192                 :            :                                                 QAT_SYM_CAP_CIPHER_CRC;
     193                 :            :         }
     194                 :            : 
     195                 :            :         return 0;
     196                 :            : }