drivers/crypto/qat/qat_common.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Intel Corporation
   3  */
   4
   5 #include "qat_common.h"
   6 #include "qat_device.h"
   7 #include "qat_logs.h"
   8
   9 int
  10 qat_sgl_fill_array(struct rte_mbuf *buf, uint64_t buf_start,
  11                 struct qat_sgl *list, uint32_t data_len)
  12 {
  13         int nr = 1;
  14
  15         uint32_t buf_len = rte_pktmbuf_iova(buf) -
  16                         buf_start + rte_pktmbuf_data_len(buf);
  17
  18         list->buffers[0].addr = buf_start;
  19         list->buffers[0].resrvd = 0;
  20         list->buffers[0].len = buf_len;
  21
  22         if (data_len <= buf_len) {
  23                 list->num_bufs = nr;
  24                 list->buffers[0].len = data_len;
  25                 return 0;
  26         }
  27
  28         buf = buf->next;
  29         while (buf) {
  30                 if (unlikely(nr == QAT_SGL_MAX_NUMBER)) {
  31                         PMD_DRV_LOG(ERR,
  32                                 "QAT PMD exceeded size of QAT SGL entry(%u)",
  33                                         QAT_SGL_MAX_NUMBER);
  34                         return -EINVAL;
  35                 }
  36
  37                 list->buffers[nr].len = rte_pktmbuf_data_len(buf);
  38                 list->buffers[nr].resrvd = 0;
  39                 list->buffers[nr].addr = rte_pktmbuf_iova(buf);
  40
  41                 buf_len += list->buffers[nr].len;
  42                 buf = buf->next;
  43
  44                 if (buf_len > data_len) {
  45                         list->buffers[nr].len -=
  46                                 buf_len - data_len;
  47                         buf = NULL;
  48                 }
  49                 ++nr;
  50         }
  51         list->num_bufs = nr;
  52
  53         return 0;
  54 }
  55
  56 void qat_stats_get(struct qat_pci_device *dev,
  57                 struct qat_common_stats *stats,
  58                 enum qat_service_type service)
  59 {
  60         int i;
  61         struct qat_qp **qp;
  62
  63         if (stats == NULL || dev == NULL || service >= QAT_SERVICE_INVALID) {
  64                 PMD_DRV_LOG(ERR, "invalid param: stats %p, dev %p, service %d",
  65                                 stats, dev, service);
  66                 return;
  67         }
  68
  69         qp = dev->qps_in_use[service];
  70         for (i = 0; i < ADF_MAX_QPS_ON_ANY_SERVICE; i++) {
  71                 if (qp[i] == NULL) {
  72                         PMD_DRV_LOG(DEBUG, "Service %d Uninitialised qp %d",
  73                                         service, i);
  74                         continue;
  75                 }
  76
  77                 stats->enqueued_count += qp[i]->stats.enqueued_count;
  78                 stats->dequeued_count += qp[i]->stats.dequeued_count;
  79                 stats->enqueue_err_count += qp[i]->stats.enqueue_err_count;
  80                 stats->dequeue_err_count += qp[i]->stats.dequeue_err_count;
  81         }
  82 }
  83
  84 void qat_stats_reset(struct qat_pci_device *dev,
  85                 enum qat_service_type service)
  86 {
  87         int i;
  88         struct qat_qp **qp;
  89
  90         if (dev == NULL || service >= QAT_SERVICE_INVALID) {
  91                 PMD_DRV_LOG(ERR, "invalid param: dev %p, service %d",
  92                                 dev, service);
  93                 return;
  94         }
  95
  96         qp = dev->qps_in_use[service];
  97         for (i = 0; i < ADF_MAX_QPS_ON_ANY_SERVICE; i++) {
  98                 if (qp[i] == NULL) {
  99                         PMD_DRV_LOG(DEBUG, "Service %d Uninitialised qp %d",
 100                                         service, i);
 101                         continue;
 102                 }
 103                 memset(&(qp[i]->stats), 0, sizeof(qp[i]->stats));
 104         }
 105
 106         PMD_DRV_LOG(DEBUG, "QAT: %d stats cleared", service);
 107 }