sal_compression.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /* SPDX-License-Identifier: BSD-3-Clause */
    2 /* Copyright(c) 2007-2022 Intel Corporation */
    3 /* $FreeBSD$ */
    4 /**
    5  *****************************************************************************
    6  * @file sal_compression.c
    7  *
    8  * @ingroup SalCtrl
    9  *
   10  * @description
   11  *    This file contains the sal implementation for compression.
   12  *
   13  *****************************************************************************/
   14 
   15 /* QAT-API includes */
   16 #include "cpa.h"
   17 #include "cpa_dc.h"
   18 
   19 /* QAT utils includes */
   20 #include "qat_utils.h"
   21 
   22 /* ADF includes */
   23 #include "icp_adf_init.h"
   24 #include "icp_adf_transport.h"
   25 #include "icp_accel_devices.h"
   26 #include "icp_adf_cfg.h"
   27 #include "icp_adf_accel_mgr.h"
   28 #include "icp_adf_poll.h"
   29 #include "icp_adf_debug.h"
   30 #include "icp_adf_esram.h"
   31 #include "icp_qat_hw.h"
   32 
   33 /* SAL includes */
   34 #include "lac_mem.h"
   35 #include "lac_common.h"
   36 #include "lac_mem_pools.h"
   37 #include "sal_statistics.h"
   38 #include "lac_list.h"
   39 #include "icp_sal_poll.h"
   40 #include "sal_types_compression.h"
   41 #include "dc_session.h"
   42 #include "dc_datapath.h"
   43 #include "dc_stats.h"
   44 #include "lac_sal.h"
   45 #include "lac_sal_ctrl.h"
   46 #include "sal_string_parse.h"
   47 #include "sal_service_state.h"
   48 #include "lac_buffer_desc.h"
   49 #include "icp_qat_fw_comp.h"
   50 #include "icp_qat_hw_20_comp_defs.h"
   51 #include "icp_sal_versions.h"
   52 
   53 /* C string null terminator size */
   54 #define SAL_NULL_TERM_SIZE 1
   55 
   56 /* Type to access extended features bit fields */
   57 typedef struct dc_extended_features_s {
   58         unsigned is_cnv : 1; /* Bit<0> */
   59         unsigned padding : 7;
   60         unsigned is_cnvnr : 1; /* Bit<8> */
   61         unsigned not_used : 23;
   62 } dc_extd_ftrs_t;
   63 
   64 /*
   65  * Prints statistics for a compression instance
   66  */
   67 static int
   68 SalCtrl_CompresionDebug(void *private_data, char *data, int size, int offset)
   69 {
   70         sal_compression_service_t *pCompressionService =
   71             (sal_compression_service_t *)private_data;
   72         CpaStatus status = CPA_STATUS_SUCCESS;
   73         CpaDcStats dcStats = { 0 };
   74         Cpa32S len = 0;
   75 
   76         status = cpaDcGetStats(pCompressionService, &dcStats);
   77         if (status != CPA_STATUS_SUCCESS) {
   78                 QAT_UTILS_LOG("cpaDcGetStats returned error.\n");
   79                 return (-1);
   80         }
   81 
   82         /* Engine Info */
   83         if (NULL != pCompressionService->debug_file) {
   84                 len += snprintf(data + len,
   85                                 size - len,
   86                                 SEPARATOR BORDER
   87                                 " Statistics for Instance %24s | \n" SEPARATOR,
   88                                 pCompressionService->debug_file->name);
   89         }
   90 
   91         /* Perform Info */
   92         len += snprintf(data + len,
   93                         size - len,
   94                         BORDER " DC comp Requests:               %16llu " BORDER
   95                                "\n" BORDER
   96                                " DC comp Request Errors:         %16llu " BORDER
   97                                "\n" BORDER
   98                                " DC comp Completed:              %16llu " BORDER
   99                                "\n" BORDER
  100                                " DC comp Completed Errors:       %16llu " BORDER
  101                                "\n" SEPARATOR,
  102                         (long long unsigned int)dcStats.numCompRequests,
  103                         (long long unsigned int)dcStats.numCompRequestsErrors,
  104                         (long long unsigned int)dcStats.numCompCompleted,
  105                         (long long unsigned int)dcStats.numCompCompletedErrors);
  106 
  107         /* Perform Info */
  108         len += snprintf(
  109             data + len,
  110             size - len,
  111             BORDER " DC decomp Requests:             %16llu " BORDER "\n" BORDER
  112                    " DC decomp Request Errors:       %16llu " BORDER "\n" BORDER
  113                    " DC decomp Completed:            %16llu " BORDER "\n" BORDER
  114                    " DC decomp Completed Errors:     %16llu " BORDER
  115                    "\n" SEPARATOR,
  116             (long long unsigned int)dcStats.numDecompRequests,
  117             (long long unsigned int)dcStats.numDecompRequestsErrors,
  118             (long long unsigned int)dcStats.numDecompCompleted,
  119             (long long unsigned int)dcStats.numDecompCompletedErrors);
  120         return 0;
  121 }
  122 
  123 /* Initialise device specific information needed by compression service */
  124 static CpaStatus
  125 SalCtrl_CompressionInit_CompData(icp_accel_dev_t *device,
  126                                  sal_compression_service_t *pCompService)
  127 {
  128         int level = 0;
  129 
  130         pCompService->comp_device_data.uniqueCompressionLevels[0] = CPA_FALSE;
  131 
  132         switch (device->deviceType) {
  133         case DEVICE_DH895XCC:
  134         case DEVICE_DH895XCCVF:
  135                 pCompService->generic_service_info.integrityCrcCheck =
  136                     CPA_FALSE;
  137                 pCompService->numInterBuffs =
  138                     DC_QAT_MAX_NUM_INTER_BUFFERS_6COMP_SLICES;
  139                 pCompService->comp_device_data.minOutputBuffSize =
  140                     DC_DEST_BUFFER_STA_MIN_SIZE;
  141                 pCompService->comp_device_data.oddByteDecompNobFinal = CPA_TRUE;
  142                 pCompService->comp_device_data.oddByteDecompInterim = CPA_FALSE;
  143                 pCompService->comp_device_data.translatorOverflow = CPA_FALSE;
  144                 pCompService->comp_device_data.useDevRam =
  145                     ICP_QAT_FW_COMP_ENABLE_SECURE_RAM_USED_AS_INTMD_BUF;
  146                 pCompService->comp_device_data.enableDmm =
  147                     ICP_QAT_HW_COMPRESSION_DELAYED_MATCH_DISABLED;
  148 
  149                 pCompService->comp_device_data.inflateContextSize =
  150                     DC_INFLATE_CONTEXT_SIZE;
  151                 pCompService->comp_device_data.highestHwCompressionDepth =
  152                     ICP_QAT_HW_COMPRESSION_DEPTH_16;
  153 
  154                 pCompService->comp_device_data.windowSizeMask =
  155                     (1 << DC_8K_WINDOW_SIZE | 1 << DC_32K_WINDOW_SIZE);
  156                 pCompService->comp_device_data.cnvnrSupported = CPA_FALSE;
  157                 break;
  158         case DEVICE_C3XXX:
  159         case DEVICE_C3XXXVF:
  160         case DEVICE_200XX:
  161         case DEVICE_200XXVF:
  162                 pCompService->generic_service_info.integrityCrcCheck =
  163                     CPA_FALSE;
  164                 pCompService->numInterBuffs =
  165                     DC_QAT_MAX_NUM_INTER_BUFFERS_6COMP_SLICES;
  166                 pCompService->comp_device_data.oddByteDecompNobFinal =
  167                     CPA_FALSE;
  168                 pCompService->comp_device_data.oddByteDecompInterim = CPA_TRUE;
  169                 pCompService->comp_device_data.translatorOverflow = CPA_FALSE;
  170                 pCompService->comp_device_data.useDevRam =
  171                     ICP_QAT_FW_COMP_DISABLE_SECURE_RAM_USED_AS_INTMD_BUF;
  172                 pCompService->comp_device_data.inflateContextSize =
  173                     DC_INFLATE_EH_CONTEXT_SIZE;
  174                 pCompService->comp_device_data.highestHwCompressionDepth =
  175                     ICP_QAT_HW_COMPRESSION_DEPTH_16;
  176                 pCompService->comp_device_data.windowSizeMask =
  177                     (1 << DC_16K_WINDOW_SIZE | 1 << DC_32K_WINDOW_SIZE);
  178                 pCompService->comp_device_data.minOutputBuffSize =
  179                     DC_DEST_BUFFER_STA_MIN_SIZE;
  180                 pCompService->comp_device_data.enableDmm =
  181                     ICP_QAT_HW_COMPRESSION_DELAYED_MATCH_ENABLED;
  182 
  183                 pCompService->comp_device_data.cnvnrSupported = CPA_TRUE;
  184                 break;
  185         case DEVICE_C62X:
  186         case DEVICE_C62XVF:
  187                 pCompService->generic_service_info.integrityCrcCheck =
  188                     CPA_FALSE;
  189                 pCompService->numInterBuffs =
  190                     DC_QAT_MAX_NUM_INTER_BUFFERS_10COMP_SLICES;
  191                 pCompService->comp_device_data.oddByteDecompNobFinal =
  192                     CPA_FALSE;
  193                 pCompService->comp_device_data.oddByteDecompInterim = CPA_TRUE;
  194                 pCompService->comp_device_data.translatorOverflow = CPA_FALSE;
  195                 pCompService->comp_device_data.useDevRam =
  196                     ICP_QAT_FW_COMP_ENABLE_SECURE_RAM_USED_AS_INTMD_BUF;
  197                 pCompService->comp_device_data.inflateContextSize =
  198                     DC_INFLATE_EH_CONTEXT_SIZE;
  199                 pCompService->comp_device_data.highestHwCompressionDepth =
  200                     ICP_QAT_HW_COMPRESSION_DEPTH_16;
  201                 pCompService->comp_device_data.windowSizeMask =
  202                     (1 << DC_4K_WINDOW_SIZE | 1 << DC_8K_WINDOW_SIZE |
  203                      1 << DC_16K_WINDOW_SIZE | 1 << DC_32K_WINDOW_SIZE);
  204                 pCompService->comp_device_data.minOutputBuffSize =
  205                     DC_DEST_BUFFER_STA_MIN_SIZE;
  206                 pCompService->comp_device_data.minOutputBuffSizeDynamic =
  207                     pCompService->comp_device_data.minOutputBuffSize;
  208                 pCompService->comp_device_data.enableDmm =
  209                     ICP_QAT_HW_COMPRESSION_DELAYED_MATCH_ENABLED;
  210                 pCompService->comp_device_data.cnvnrSupported = CPA_TRUE;
  211 
  212                 for (level = CPA_DC_L1; level <= CPA_DC_L9; level++) {
  213                         switch (level) {
  214                         case CPA_DC_L1:
  215                         case CPA_DC_L2:
  216                         case CPA_DC_L3:
  217                         case CPA_DC_L4:
  218                                 pCompService->comp_device_data
  219                                     .uniqueCompressionLevels[level] = CPA_TRUE;
  220                                 break;
  221                         default:
  222                                 pCompService->comp_device_data
  223                                     .uniqueCompressionLevels[level] = CPA_FALSE;
  224                                 break;
  225                         }
  226                 }
  227                 pCompService->comp_device_data.numCompressionLevels =
  228                     DC_NUM_COMPRESSION_LEVELS;
  229                 break;
  230         case DEVICE_C4XXX:
  231         case DEVICE_C4XXXVF:
  232                 pCompService->generic_service_info.integrityCrcCheck = CPA_TRUE;
  233                 pCompService->numInterBuffs =
  234                     DC_QAT_MAX_NUM_INTER_BUFFERS_24COMP_SLICES;
  235                 pCompService->comp_device_data.minOutputBuffSize =
  236                     DC_DEST_BUFFER_MIN_SIZE;
  237                 pCompService->comp_device_data.oddByteDecompNobFinal = CPA_TRUE;
  238                 pCompService->comp_device_data.oddByteDecompInterim = CPA_TRUE;
  239                 pCompService->comp_device_data.translatorOverflow = CPA_TRUE;
  240                 if (pCompService->generic_service_info.capabilitiesMask &
  241                     ICP_ACCEL_CAPABILITIES_INLINE) {
  242                         pCompService->comp_device_data.useDevRam =
  243                             ICP_QAT_FW_COMP_DISABLE_SECURE_RAM_USED_AS_INTMD_BUF;
  244                 } else {
  245                         pCompService->comp_device_data.useDevRam =
  246                             ICP_QAT_FW_COMP_ENABLE_SECURE_RAM_USED_AS_INTMD_BUF;
  247                 }
  248                 pCompService->comp_device_data.enableDmm =
  249                     ICP_QAT_HW_COMPRESSION_DELAYED_MATCH_ENABLED;
  250                 pCompService->comp_device_data.inflateContextSize =
  251                     DC_INFLATE_EH_CONTEXT_SIZE;
  252                 pCompService->comp_device_data.highestHwCompressionDepth =
  253                     ICP_QAT_HW_COMPRESSION_DEPTH_128;
  254                 pCompService->comp_device_data.windowSizeMask =
  255                     (1 << DC_16K_WINDOW_SIZE | 1 << DC_32K_WINDOW_SIZE);
  256                 pCompService->comp_device_data.cnvnrSupported = CPA_TRUE;
  257                 break;
  258         case DEVICE_GEN4:
  259                 pCompService->generic_service_info.integrityCrcCheck = CPA_TRUE;
  260                 pCompService->numInterBuffs = 0;
  261                 pCompService->comp_device_data.minOutputBuffSize =
  262                     DC_DEST_BUFFER_STA_MIN_SIZE_GEN4;
  263                 pCompService->comp_device_data.minOutputBuffSizeDynamic =
  264                     DC_DEST_BUFFER_DYN_MIN_SIZE_GEN4;
  265                 pCompService->comp_device_data.oddByteDecompNobFinal = CPA_TRUE;
  266                 pCompService->comp_device_data.oddByteDecompInterim = CPA_FALSE;
  267                 pCompService->comp_device_data.translatorOverflow = CPA_TRUE;
  268                 pCompService->comp_device_data.useDevRam =
  269                     ICP_QAT_FW_COMP_ENABLE_SECURE_RAM_USED_AS_INTMD_BUF;
  270                 pCompService->comp_device_data.enableDmm =
  271                     ICP_QAT_HW_COMPRESSION_DELAYED_MATCH_ENABLED;
  272 
  273                 pCompService->comp_device_data.inflateContextSize =
  274                     DC_INFLATE_CONTEXT_SIZE;
  275                 pCompService->comp_device_data.highestHwCompressionDepth =
  276                     ICP_QAT_HW_COMP_20_SEARCH_DEPTH_LEVEL_9;
  277                 pCompService->comp_device_data.windowSizeMask =
  278                     (1 << DC_4K_WINDOW_SIZE | 1 << DC_8K_WINDOW_SIZE |
  279                      1 << DC_16K_WINDOW_SIZE | 1 << DC_32K_WINDOW_SIZE);
  280                 for (level = CPA_DC_L1; level <= CPA_DC_L9; level++) {
  281                         switch (level) {
  282                         case CPA_DC_L1:
  283                         case CPA_DC_L6:
  284                         case CPA_DC_L9:
  285                                 pCompService->comp_device_data
  286                                     .uniqueCompressionLevels[level] = CPA_TRUE;
  287                                 break;
  288                         default:
  289                                 pCompService->comp_device_data
  290                                     .uniqueCompressionLevels[level] = CPA_FALSE;
  291                                 break;
  292                         }
  293                 }
  294                 pCompService->comp_device_data.numCompressionLevels =
  295                     DC_NUM_COMPRESSION_LEVELS;
  296                 break;
  297         default:
  298                 QAT_UTILS_LOG("Unknown device type! - %d.\n",
  299                               device->deviceType);
  300                 return CPA_STATUS_FAIL;
  301         }
  302         return CPA_STATUS_SUCCESS;
  303 }
  304 
  305 CpaStatus
  306 SalCtrl_CompressionInit(icp_accel_dev_t *device, sal_service_t *service)
  307 {
  308         CpaStatus status = CPA_STATUS_SUCCESS;
  309         Cpa32U numCompConcurrentReq = 0;
  310         Cpa32U request_ring_id = 0;
  311         Cpa32U response_ring_id = 0;
  312 
  313         char adfGetParam[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
  314         char compMemPool[SAL_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
  315         char temp_string[SAL_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
  316         char temp_string2[SAL_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
  317         char *instance_name = NULL;
  318         sal_statistics_collection_t *pStatsCollection =
  319             (sal_statistics_collection_t *)device->pQatStats;
  320         icp_resp_deliv_method rx_resp_type = ICP_RESP_TYPE_IRQ;
  321         sal_compression_service_t *pCompressionService =
  322             (sal_compression_service_t *)service;
  323         Cpa32U msgSize = 0;
  324         char *section = DYN_SEC;
  325 
  326         SAL_SERVICE_GOOD_FOR_INIT(pCompressionService);
  327 
  328         pCompressionService->generic_service_info.state =
  329             SAL_SERVICE_STATE_INITIALIZING;
  330 
  331         if (CPA_FALSE == pCompressionService->generic_service_info.is_dyn) {
  332                 section = icpGetProcessName();
  333         }
  334 
  335         if (pStatsCollection == NULL) {
  336                 return CPA_STATUS_FAIL;
  337         }
  338 
  339         /* Get Config Info: Accel Num, bank Num, packageID,
  340                                     coreAffinity, nodeAffinity and response mode
  341            */
  342 
  343         pCompressionService->acceleratorNum = 0;
  344 
  345         /* Initialise device specific compression data */
  346         SalCtrl_CompressionInit_CompData(device, pCompressionService);
  347 
  348         status = Sal_StringParsing(
  349             "Dc",
  350             pCompressionService->generic_service_info.instance,
  351             "BankNumber",
  352             temp_string);
  353         LAC_CHECK_STATUS(status);
  354         status =
  355             icp_adf_cfgGetParamValue(device, section, temp_string, adfGetParam);
  356         if (CPA_STATUS_SUCCESS != status) {
  357                 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
  358                               temp_string);
  359                 return status;
  360         }
  361 
  362         pCompressionService->bankNum =
  363             Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
  364 
  365         status = Sal_StringParsing(
  366             "Dc",
  367             pCompressionService->generic_service_info.instance,
  368             "IsPolled",
  369             temp_string);
  370         LAC_CHECK_STATUS(status);
  371         status =
  372             icp_adf_cfgGetParamValue(device, section, temp_string, adfGetParam);
  373         if (CPA_STATUS_SUCCESS != status) {
  374                 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
  375                               temp_string);
  376                 return status;
  377         }
  378         pCompressionService->isPolled =
  379             (Cpa8U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
  380 
  381         /* User instances only support poll and epoll mode */
  382         if (SAL_RESP_POLL_CFG_FILE != pCompressionService->isPolled) {
  383                 QAT_UTILS_LOG(
  384                     "IsPolled %u is not supported for user instance %s.\n",
  385                     pCompressionService->isPolled,
  386                     temp_string);
  387                 return CPA_STATUS_FAIL;
  388         }
  389 
  390         if (SAL_RESP_POLL_CFG_FILE == pCompressionService->isPolled) {
  391                 rx_resp_type = ICP_RESP_TYPE_POLL;
  392         }
  393 
  394         status = icp_adf_cfgGetParamValue(device,
  395                                           LAC_CFG_SECTION_GENERAL,
  396                                           ADF_DEV_PKG_ID,
  397                                           adfGetParam);
  398         if (CPA_STATUS_SUCCESS != status) {
  399                 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
  400                               ADF_DEV_PKG_ID);
  401                 return status;
  402         }
  403         pCompressionService->pkgID =
  404             (Cpa16U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
  405 
  406         status = icp_adf_cfgGetParamValue(device,
  407                                           LAC_CFG_SECTION_GENERAL,
  408                                           ADF_DEV_NODE_ID,
  409                                           adfGetParam);
  410         if (CPA_STATUS_SUCCESS != status) {
  411                 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
  412                               ADF_DEV_NODE_ID);
  413                 return status;
  414         }
  415         pCompressionService->nodeAffinity =
  416             (Cpa32U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
  417 
  418         /* In case of interrupt instance, use the bank affinity set by adf_ctl
  419          * Otherwise, use the instance affinity for backwards compatibility */
  420         if (SAL_RESP_POLL_CFG_FILE != pCompressionService->isPolled) {
  421                 /* Next need to read the [AcceleratorX] section of the config
  422                  * file */
  423                 status = Sal_StringParsing("Accelerator",
  424                                            pCompressionService->acceleratorNum,
  425                                            "",
  426                                            temp_string2);
  427                 LAC_CHECK_STATUS(status);
  428 
  429                 status = Sal_StringParsing("Bank",
  430                                            pCompressionService->bankNum,
  431                                            "CoreAffinity",
  432                                            temp_string);
  433                 LAC_CHECK_STATUS(status);
  434         } else {
  435                 strncpy(temp_string2,
  436                         section,
  437                         sizeof(temp_string2) - SAL_NULL_TERM_SIZE);
  438                 temp_string2[SAL_CFG_MAX_VAL_LEN_IN_BYTES -
  439                              SAL_NULL_TERM_SIZE] = '\0';
  440 
  441                 status = Sal_StringParsing(
  442                     "Dc",
  443                     pCompressionService->generic_service_info.instance,
  444                     "CoreAffinity",
  445                     temp_string);
  446                 LAC_CHECK_STATUS(status);
  447         }
  448 
  449         status = icp_adf_cfgGetParamValue(device,
  450                                           temp_string2,
  451                                           temp_string,
  452                                           adfGetParam);
  453         if (CPA_STATUS_SUCCESS != status) {
  454                 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
  455                               temp_string);
  456                 return status;
  457         }
  458         pCompressionService->coreAffinity =
  459             (Cpa32U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
  460 
  461         status = Sal_StringParsing(
  462             "Dc",
  463             pCompressionService->generic_service_info.instance,
  464             "NumConcurrentRequests",
  465             temp_string);
  466         LAC_CHECK_STATUS(status);
  467         status =
  468             icp_adf_cfgGetParamValue(device, section, temp_string, adfGetParam);
  469         if (CPA_STATUS_SUCCESS != status) {
  470                 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
  471                               temp_string);
  472                 return status;
  473         }
  474 
  475         numCompConcurrentReq =
  476             (Cpa32U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
  477         if (validateConcurrRequest(numCompConcurrentReq)) {
  478                 QAT_UTILS_LOG(
  479                     "Invalid NumConcurrentRequests, valid values are: {64, 128, 256, ... 32768, 65536}.\n");
  480                 return CPA_STATUS_FAIL;
  481         }
  482 
  483         /* ADF does not allow us to completely fill the ring for batch requests
  484          */
  485         pCompressionService->maxNumCompConcurrentReq =
  486             (numCompConcurrentReq - SAL_BATCH_SUBMIT_FREE_SPACE);
  487 
  488         /* 1. Create transport handles */
  489         status = Sal_StringParsing(
  490             "Dc",
  491             pCompressionService->generic_service_info.instance,
  492             "RingTx",
  493             temp_string);
  494         LAC_CHECK_STATUS(status);
  495 
  496         msgSize = LAC_QAT_DC_REQ_SZ_LW * LAC_LONG_WORD_IN_BYTES;
  497         status = icp_adf_transCreateHandle(
  498             device,
  499             ICP_TRANS_TYPE_ETR,
  500             section,
  501             pCompressionService->acceleratorNum,
  502             pCompressionService->bankNum,
  503             temp_string,
  504             lac_getRingType(SAL_RING_TYPE_DC),
  505             NULL,
  506             ICP_RESP_TYPE_NONE,
  507             numCompConcurrentReq,
  508             msgSize,
  509             (icp_comms_trans_handle *)&(
  510                 pCompressionService->trans_handle_compression_tx));
  511         LAC_CHECK_STATUS(status);
  512 
  513         if (icp_adf_transGetRingNum(
  514                 pCompressionService->trans_handle_compression_tx,
  515                 &request_ring_id) != CPA_STATUS_SUCCESS) {
  516                 icp_adf_transReleaseHandle(
  517                     pCompressionService->trans_handle_compression_tx);
  518 
  519                 QAT_UTILS_LOG("Failed to get DC TX ring number.\n");
  520                 return CPA_STATUS_FAIL;
  521         }
  522 
  523         status = Sal_StringParsing(
  524             "Dc",
  525             pCompressionService->generic_service_info.instance,
  526             "RingRx",
  527             temp_string);
  528         if (CPA_STATUS_SUCCESS != status) {
  529                 icp_adf_transReleaseHandle(
  530                     pCompressionService->trans_handle_compression_tx);
  531                 return status;
  532         }
  533 
  534         msgSize = LAC_QAT_DC_RESP_SZ_LW * LAC_LONG_WORD_IN_BYTES;
  535         status = icp_adf_transCreateHandle(
  536             device,
  537             ICP_TRANS_TYPE_ETR,
  538             section,
  539             pCompressionService->acceleratorNum,
  540             pCompressionService->bankNum,
  541             temp_string,
  542             lac_getRingType(SAL_RING_TYPE_NONE),
  543             (icp_trans_callback)dcCompression_ProcessCallback,
  544             rx_resp_type,
  545             numCompConcurrentReq,
  546             msgSize,
  547             (icp_comms_trans_handle *)&(
  548                 pCompressionService->trans_handle_compression_rx));
  549         if (CPA_STATUS_SUCCESS != status) {
  550                 icp_adf_transReleaseHandle(
  551                     pCompressionService->trans_handle_compression_tx);
  552                 return status;
  553         }
  554 
  555         if (icp_adf_transGetRingNum(
  556                 pCompressionService->trans_handle_compression_rx,
  557                 &response_ring_id) != CPA_STATUS_SUCCESS) {
  558                 icp_adf_transReleaseHandle(
  559                     pCompressionService->trans_handle_compression_tx);
  560 
  561                 icp_adf_transReleaseHandle(
  562                     pCompressionService->trans_handle_compression_rx);
  563 
  564                 QAT_UTILS_LOG("Failed to get DC RX ring number.\n");
  565                 return CPA_STATUS_FAIL;
  566         }
  567 
  568         /* 2. Allocates memory pools */
  569 
  570         /* Valid initialisation value for a pool ID */
  571         pCompressionService->compression_mem_pool = LAC_MEM_POOL_INIT_POOL_ID;
  572 
  573         status = Sal_StringParsing(
  574             "Comp",
  575             pCompressionService->generic_service_info.instance,
  576             "_MemPool",
  577             compMemPool);
  578         if (CPA_STATUS_SUCCESS != status) {
  579                 icp_adf_transReleaseHandle(
  580                     pCompressionService->trans_handle_compression_tx);
  581 
  582                 icp_adf_transReleaseHandle(
  583                     pCompressionService->trans_handle_compression_rx);
  584 
  585                 return status;
  586         }
  587 
  588         status = Lac_MemPoolCreate(&pCompressionService->compression_mem_pool,
  589                                    compMemPool,
  590                                    (numCompConcurrentReq + 1),
  591                                    sizeof(dc_compression_cookie_t),
  592                                    LAC_64BYTE_ALIGNMENT,
  593                                    CPA_FALSE,
  594                                    pCompressionService->nodeAffinity);
  595         if (CPA_STATUS_SUCCESS != status) {
  596                 icp_adf_transReleaseHandle(
  597                     pCompressionService->trans_handle_compression_tx);
  598 
  599                 icp_adf_transReleaseHandle(
  600                     pCompressionService->trans_handle_compression_rx);
  601 
  602                 return status;
  603         }
  604 
  605         /* Init compression statistics */
  606         status = dcStatsInit(pCompressionService);
  607         if (CPA_STATUS_SUCCESS != status) {
  608                 Lac_MemPoolDestroy(pCompressionService->compression_mem_pool);
  609 
  610                 icp_adf_transReleaseHandle(
  611                     pCompressionService->trans_handle_compression_tx);
  612 
  613                 icp_adf_transReleaseHandle(
  614                     pCompressionService->trans_handle_compression_rx);
  615 
  616                 return status;
  617         }
  618         if (CPA_TRUE == pStatsCollection->bDcStatsEnabled) {
  619                 /* Get instance name for stats */
  620                 instance_name = LAC_OS_MALLOC(ADF_CFG_MAX_VAL_LEN_IN_BYTES);
  621                 if (NULL == instance_name) {
  622                         Lac_MemPoolDestroy(
  623                             pCompressionService->compression_mem_pool);
  624 
  625                         icp_adf_transReleaseHandle(
  626                             pCompressionService->trans_handle_compression_tx);
  627 
  628                         icp_adf_transReleaseHandle(
  629                             pCompressionService->trans_handle_compression_rx);
  630 
  631                         return CPA_STATUS_RESOURCE;
  632                 }
  633 
  634                 status = Sal_StringParsing(
  635                     "Dc",
  636                     pCompressionService->generic_service_info.instance,
  637                     "Name",
  638                     temp_string);
  639                 if (CPA_STATUS_SUCCESS != status) {
  640                         Lac_MemPoolDestroy(
  641                             pCompressionService->compression_mem_pool);
  642 
  643                         icp_adf_transReleaseHandle(
  644                             pCompressionService->trans_handle_compression_tx);
  645 
  646                         icp_adf_transReleaseHandle(
  647                             pCompressionService->trans_handle_compression_rx);
  648                         LAC_OS_FREE(instance_name);
  649                         return status;
  650                 }
  651                 status = icp_adf_cfgGetParamValue(device,
  652                                                   section,
  653                                                   temp_string,
  654                                                   adfGetParam);
  655                 if (CPA_STATUS_SUCCESS != status) {
  656                         QAT_UTILS_LOG("Failed to get %s from configuration.\n",
  657                                       temp_string);
  658 
  659                         Lac_MemPoolDestroy(
  660                             pCompressionService->compression_mem_pool);
  661 
  662                         icp_adf_transReleaseHandle(
  663                             pCompressionService->trans_handle_compression_tx);
  664 
  665                         icp_adf_transReleaseHandle(
  666                             pCompressionService->trans_handle_compression_rx);
  667                         LAC_OS_FREE(instance_name);
  668                         return status;
  669                 }
  670 
  671                 snprintf(instance_name,
  672                          ADF_CFG_MAX_VAL_LEN_IN_BYTES,
  673                          "%s",
  674                          adfGetParam);
  675 
  676                 pCompressionService->debug_file =
  677                     LAC_OS_MALLOC(sizeof(debug_file_info_t));
  678                 if (NULL == pCompressionService->debug_file) {
  679                         Lac_MemPoolDestroy(
  680                             pCompressionService->compression_mem_pool);
  681 
  682                         icp_adf_transReleaseHandle(
  683                             pCompressionService->trans_handle_compression_tx);
  684 
  685                         icp_adf_transReleaseHandle(
  686                             pCompressionService->trans_handle_compression_rx);
  687                         LAC_OS_FREE(instance_name);
  688                         return CPA_STATUS_RESOURCE;
  689                 }
  690 
  691                 memset(pCompressionService->debug_file,
  692                        0,
  693                        sizeof(debug_file_info_t));
  694                 pCompressionService->debug_file->name = instance_name;
  695                 pCompressionService->debug_file->seq_read =
  696                     SalCtrl_CompresionDebug;
  697                 pCompressionService->debug_file->private_data =
  698                     pCompressionService;
  699                 pCompressionService->debug_file->parent =
  700                     pCompressionService->generic_service_info.debug_parent_dir;
  701 
  702                 status = icp_adf_debugAddFile(device,
  703                                               pCompressionService->debug_file);
  704                 if (CPA_STATUS_SUCCESS != status) {
  705                         Lac_MemPoolDestroy(
  706                             pCompressionService->compression_mem_pool);
  707 
  708                         icp_adf_transReleaseHandle(
  709                             pCompressionService->trans_handle_compression_tx);
  710 
  711                         icp_adf_transReleaseHandle(
  712                             pCompressionService->trans_handle_compression_rx);
  713                         LAC_OS_FREE(instance_name);
  714                         LAC_OS_FREE(pCompressionService->debug_file);
  715                         return status;
  716                 }
  717         }
  718         pCompressionService->generic_service_info.stats = pStatsCollection;
  719         pCompressionService->generic_service_info.state =
  720             SAL_SERVICE_STATE_INITIALIZED;
  721 
  722         return status;
  723 }
  724 
  725 CpaStatus
  726 SalCtrl_CompressionStart(icp_accel_dev_t *device, sal_service_t *service)
  727 {
  728         CpaStatus status = CPA_STATUS_SUCCESS;
  729 
  730         sal_compression_service_t *pCompressionService =
  731             (sal_compression_service_t *)service;
  732 
  733         if (SAL_SERVICE_STATE_INITIALIZED !=
  734             pCompressionService->generic_service_info.state) {
  735                 QAT_UTILS_LOG("Not in the correct state to call start.\n");
  736                 return CPA_STATUS_FAIL;
  737         }
  738         /**************************************************************/
  739         /* Obtain Extended Features. I.e. Compress And Verify         */
  740         /**************************************************************/
  741         pCompressionService->generic_service_info.dcExtendedFeatures =
  742             device->dcExtendedFeatures;
  743         pCompressionService->generic_service_info.state =
  744             SAL_SERVICE_STATE_RUNNING;
  745 
  746         return status;
  747 }
  748 
  749 CpaStatus
  750 SalCtrl_CompressionStop(icp_accel_dev_t *device, sal_service_t *service)
  751 {
  752         sal_compression_service_t *pCompressionService =
  753             (sal_compression_service_t *)service;
  754 
  755         if (SAL_SERVICE_STATE_RUNNING !=
  756             pCompressionService->generic_service_info.state) {
  757                 QAT_UTILS_LOG("Not in the correct state to call stop.\n");
  758                 return CPA_STATUS_FAIL;
  759         }
  760 
  761         if (icp_adf_is_dev_in_reset(device)) {
  762                 pCompressionService->generic_service_info.state =
  763                     SAL_SERVICE_STATE_RESTARTING;
  764                 return CPA_STATUS_SUCCESS;
  765         }
  766 
  767         pCompressionService->generic_service_info.state =
  768             SAL_SERVICE_STATE_SHUTTING_DOWN;
  769         return CPA_STATUS_RETRY;
  770 }
  771 
  772 CpaStatus
  773 SalCtrl_CompressionShutdown(icp_accel_dev_t *device, sal_service_t *service)
  774 {
  775         CpaStatus status = CPA_STATUS_SUCCESS;
  776 
  777         sal_compression_service_t *pCompressionService =
  778             (sal_compression_service_t *)service;
  779         sal_statistics_collection_t *pStatsCollection =
  780             (sal_statistics_collection_t *)device->pQatStats;
  781 
  782         if ((SAL_SERVICE_STATE_INITIALIZED !=
  783              pCompressionService->generic_service_info.state) &&
  784             (SAL_SERVICE_STATE_SHUTTING_DOWN !=
  785              pCompressionService->generic_service_info.state) &&
  786             (SAL_SERVICE_STATE_RESTARTING !=
  787              pCompressionService->generic_service_info.state)) {
  788                 QAT_UTILS_LOG("Not in the correct state to call shutdown.\n");
  789                 return CPA_STATUS_FAIL;
  790         }
  791 
  792         Lac_MemPoolDestroy(pCompressionService->compression_mem_pool);
  793 
  794         status = icp_adf_transReleaseHandle(
  795             pCompressionService->trans_handle_compression_tx);
  796         LAC_CHECK_STATUS(status);
  797 
  798         status = icp_adf_transReleaseHandle(
  799             pCompressionService->trans_handle_compression_rx);
  800         LAC_CHECK_STATUS(status);
  801 
  802         if (CPA_TRUE == pStatsCollection->bDcStatsEnabled) {
  803                 /* Clean stats */
  804                 if (NULL != pCompressionService->debug_file) {
  805                         icp_adf_debugRemoveFile(
  806                             pCompressionService->debug_file);
  807                         LAC_OS_FREE(pCompressionService->debug_file->name);
  808                         LAC_OS_FREE(pCompressionService->debug_file);
  809                         pCompressionService->debug_file = NULL;
  810                 }
  811         }
  812         pCompressionService->generic_service_info.stats = NULL;
  813         dcStatsFree(pCompressionService);
  814 
  815         if (icp_adf_is_dev_in_reset(device)) {
  816                 pCompressionService->generic_service_info.state =
  817                     SAL_SERVICE_STATE_RESTARTING;
  818                 return CPA_STATUS_SUCCESS;
  819         }
  820         pCompressionService->generic_service_info.state =
  821             SAL_SERVICE_STATE_SHUTDOWN;
  822         return status;
  823 }
  824 
  825 CpaStatus
  826 cpaDcGetStatusText(const CpaInstanceHandle dcInstance,
  827                    const CpaStatus errStatus,
  828                    Cpa8S *pStatusText)
  829 {
  830         CpaStatus status = CPA_STATUS_SUCCESS;
  831 
  832         LAC_CHECK_NULL_PARAM(pStatusText);
  833 
  834         switch (errStatus) {
  835         case CPA_STATUS_SUCCESS:
  836                 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_SUCCESS);
  837                 break;
  838         case CPA_STATUS_FAIL:
  839                 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_FAIL);
  840                 break;
  841         case CPA_STATUS_RETRY:
  842                 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_RETRY);
  843                 break;
  844         case CPA_STATUS_RESOURCE:
  845                 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_RESOURCE);
  846                 break;
  847         case CPA_STATUS_INVALID_PARAM:
  848                 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_INVALID_PARAM);
  849                 break;
  850         case CPA_STATUS_FATAL:
  851                 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_FATAL);
  852                 break;
  853         case CPA_STATUS_UNSUPPORTED:
  854                 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_UNSUPPORTED);
  855                 break;
  856         default:
  857                 status = CPA_STATUS_INVALID_PARAM;
  858                 break;
  859         }
  860 
  861         return status;
  862 }
  863 
  864 CpaStatus
  865 cpaDcGetNumIntermediateBuffers(CpaInstanceHandle dcInstance,
  866                                Cpa16U *pNumBuffers)
  867 {
  868         CpaInstanceHandle insHandle = NULL;
  869         sal_compression_service_t *pService = NULL;
  870 
  871         if (CPA_INSTANCE_HANDLE_SINGLE == dcInstance) {
  872                 insHandle = dcGetFirstHandle();
  873         } else {
  874                 insHandle = dcInstance;
  875         }
  876 
  877         LAC_CHECK_NULL_PARAM(insHandle);
  878         LAC_CHECK_NULL_PARAM(pNumBuffers);
  879 
  880         pService = (sal_compression_service_t *)insHandle;
  881         *pNumBuffers = pService->numInterBuffs;
  882 
  883         return CPA_STATUS_SUCCESS;
  884 }
  885 
  886 CpaStatus
  887 cpaDcStartInstance(CpaInstanceHandle instanceHandle,
  888                    Cpa16U numBuffers,
  889                    CpaBufferList **pIntermediateBufferPtrsArray)
  890 {
  891         icp_qat_addr_width_t *pInterBuffPtrsArray = NULL;
  892         icp_qat_addr_width_t pArrayBufferListDescPhyAddr = 0;
  893         icp_qat_addr_width_t bufListDescPhyAddr;
  894         icp_qat_addr_width_t bufListAlignedPhyAddr;
  895         CpaFlatBuffer *pClientCurrFlatBuffer = NULL;
  896         icp_buffer_list_desc_t *pBufferListDesc = NULL;
  897         icp_flat_buffer_desc_t *pCurrFlatBufDesc = NULL;
  898         CpaInstanceInfo2 info = { 0 };
  899         icp_accel_dev_t *dev = NULL;
  900         CpaStatus status = CPA_STATUS_SUCCESS;
  901         sal_compression_service_t *pService = NULL;
  902         CpaInstanceHandle insHandle = NULL;
  903         Cpa16U bufferIndex = 0;
  904         Cpa32U numFlatBuffers = 0;
  905         Cpa64U clientListSize = 0;
  906         CpaBufferList *pClientCurrentIntermediateBuffer = NULL;
  907         Cpa32U bufferIndex2 = 0;
  908         CpaBufferList **pTempIntermediateBufferPtrsArray;
  909         Cpa64U lastClientListSize = 0;
  910 
  911         if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle) {
  912                 insHandle = dcGetFirstHandle();
  913         } else {
  914                 insHandle = instanceHandle;
  915         }
  916         LAC_CHECK_NULL_PARAM(insHandle);
  917 
  918         status = cpaDcInstanceGetInfo2(insHandle, &info);
  919         if (CPA_STATUS_SUCCESS != status) {
  920                 QAT_UTILS_LOG("Can not get instance info.\n");
  921                 return status;
  922         }
  923 
  924         dev = icp_adf_getAccelDevByAccelId(info.physInstId.packageId);
  925         if (NULL == dev) {
  926                 QAT_UTILS_LOG("Can not find device for the instance\n");
  927                 return CPA_STATUS_FAIL;
  928         }
  929 
  930         if (NULL == pIntermediateBufferPtrsArray) {
  931                 /* Increment dev ref counter and return - DRAM is not used */
  932                 icp_qa_dev_get(dev);
  933                 return CPA_STATUS_SUCCESS;
  934         }
  935 
  936         if (0 == numBuffers) {
  937                 /* Increment dev ref counter and return - DRAM is not used */
  938                 icp_qa_dev_get(dev);
  939                 return CPA_STATUS_SUCCESS;
  940         }
  941 
  942         pService = (sal_compression_service_t *)insHandle;
  943 
  944         LAC_CHECK_NULL_PARAM(insHandle);
  945 
  946         if ((numBuffers > 0) && (NULL == pIntermediateBufferPtrsArray)) {
  947                 QAT_UTILS_LOG("Invalid Intermediate Buffers Array pointer\n");
  948                 return CPA_STATUS_INVALID_PARAM;
  949         }
  950 
  951         /* Check number of intermediate buffers allocated by user */
  952         if ((pService->numInterBuffs != numBuffers)) {
  953                 QAT_UTILS_LOG("Invalid number of buffers\n");
  954                 return CPA_STATUS_INVALID_PARAM;
  955         }
  956 
  957         pTempIntermediateBufferPtrsArray = pIntermediateBufferPtrsArray;
  958         for (bufferIndex = 0; bufferIndex < numBuffers; bufferIndex++) {
  959                 if (NULL == *pTempIntermediateBufferPtrsArray) {
  960                         QAT_UTILS_LOG(
  961                             "Intermediate Buffer - Invalid Buffer List pointer\n");
  962                         return CPA_STATUS_INVALID_PARAM;
  963                 }
  964 
  965                 if (NULL == (*pTempIntermediateBufferPtrsArray)->pBuffers) {
  966                         QAT_UTILS_LOG(
  967                             "Intermediate Buffer - Invalid Flat Buffer descriptor pointer\n");
  968                         return CPA_STATUS_INVALID_PARAM;
  969                 }
  970 
  971                 if (NULL ==
  972                     (*pTempIntermediateBufferPtrsArray)->pPrivateMetaData) {
  973                         QAT_UTILS_LOG(
  974                             "Intermediate Buffer - Invalid Private MetaData descriptor pointer\n");
  975                         return CPA_STATUS_INVALID_PARAM;
  976                 }
  977 
  978                 clientListSize = 0;
  979                 for (bufferIndex2 = 0; bufferIndex2 <
  980                      (*pTempIntermediateBufferPtrsArray)->numBuffers;
  981                      bufferIndex2++) {
  982 
  983                         if ((0 !=
  984                              (*pTempIntermediateBufferPtrsArray)
  985                                  ->pBuffers[bufferIndex2]
  986                                  .dataLenInBytes) &&
  987                             NULL ==
  988                                 (*pTempIntermediateBufferPtrsArray)
  989                                     ->pBuffers[bufferIndex2]
  990                                     .pData) {
  991                                 QAT_UTILS_LOG(
  992                                     "Intermediate Buffer - Invalid Flat Buffer pointer\n");
  993                                 return CPA_STATUS_INVALID_PARAM;
  994                         }
  995 
  996                         clientListSize += (*pTempIntermediateBufferPtrsArray)
  997                                               ->pBuffers[bufferIndex2]
  998                                               .dataLenInBytes;
  999                 }
 1000 
 1001                 if (bufferIndex != 0) {
 1002                         if (lastClientListSize != clientListSize) {
 1003                                 QAT_UTILS_LOG(
 1004                                     "SGLs have to be of the same size.\n");
 1005                                 return CPA_STATUS_INVALID_PARAM;
 1006                         }
 1007                 } else {
 1008                         lastClientListSize = clientListSize;
 1009                 }
 1010                 pTempIntermediateBufferPtrsArray++;
 1011         }
 1012 
 1013         /* Allocate array of physical pointers to icp_buffer_list_desc_t */
 1014         status = LAC_OS_CAMALLOC(&pInterBuffPtrsArray,
 1015                                  (numBuffers * sizeof(icp_qat_addr_width_t)),
 1016                                  LAC_64BYTE_ALIGNMENT,
 1017                                  pService->nodeAffinity);
 1018         if (CPA_STATUS_SUCCESS != status) {
 1019                 QAT_UTILS_LOG("Can not allocate Intermediate Buffers array.\n");
 1020                 return status;
 1021         }
 1022 
 1023         /* Get physical address of the intermediate buffer pointers array */
 1024         pArrayBufferListDescPhyAddr = LAC_MEM_CAST_PTR_TO_UINT64(
 1025             LAC_OS_VIRT_TO_PHYS_INTERNAL(pInterBuffPtrsArray));
 1026 
 1027         pService->pInterBuffPtrsArray = pInterBuffPtrsArray;
 1028         pService->pInterBuffPtrsArrayPhyAddr = pArrayBufferListDescPhyAddr;
 1029 
 1030         /* Get the full size of the buffer list */
 1031         /* Assumption: all the SGLs allocated by the user have the same size */
 1032         clientListSize = 0;
 1033         for (bufferIndex = 0;
 1034              bufferIndex < (*pIntermediateBufferPtrsArray)->numBuffers;
 1035              bufferIndex++) {
 1036                 clientListSize += ((*pIntermediateBufferPtrsArray)
 1037                                        ->pBuffers[bufferIndex]
 1038                                        .dataLenInBytes);
 1039         }
 1040         pService->minInterBuffSizeInBytes = clientListSize;
 1041 
 1042         for (bufferIndex = 0; bufferIndex < numBuffers; bufferIndex++) {
 1043 
 1044                 /* Get pointer to the client Intermediate Buffer List
 1045                  * (CpaBufferList) */
 1046                 pClientCurrentIntermediateBuffer =
 1047                     *pIntermediateBufferPtrsArray;
 1048 
 1049                 /* Get number of flat buffers in the buffer list */
 1050                 numFlatBuffers = pClientCurrentIntermediateBuffer->numBuffers;
 1051 
 1052                 /* Get pointer to the client array of CpaFlatBuffers */
 1053                 pClientCurrFlatBuffer =
 1054                     pClientCurrentIntermediateBuffer->pBuffers;
 1055 
 1056                 /* Calculate Physical address of current private SGL */
 1057                 bufListDescPhyAddr = LAC_OS_VIRT_TO_PHYS_EXTERNAL(
 1058                     (*pService),
 1059                     pClientCurrentIntermediateBuffer->pPrivateMetaData);
 1060                 if (bufListDescPhyAddr == 0) {
 1061                         QAT_UTILS_LOG(
 1062                             "Unable to get the physical address of the metadata.\n");
 1063                         return CPA_STATUS_FAIL;
 1064                 }
 1065 
 1066                 /* Align SGL physical address */
 1067                 bufListAlignedPhyAddr =
 1068                     LAC_ALIGN_POW2_ROUNDUP(bufListDescPhyAddr,
 1069                                            ICP_DESCRIPTOR_ALIGNMENT_BYTES);
 1070 
 1071                 /* Set physical address of the Intermediate Buffer SGL in the
 1072                  * SGLs array
 1073                  */
 1074                 *pInterBuffPtrsArray =
 1075                     LAC_MEM_CAST_PTR_TO_UINT64(bufListAlignedPhyAddr);
 1076 
 1077                 /* Calculate (virtual) offset to the buffer list descriptor */
 1078                 pBufferListDesc =
 1079                     (icp_buffer_list_desc_t
 1080                          *)((LAC_ARCH_UINT)pClientCurrentIntermediateBuffer
 1081                                 ->pPrivateMetaData +
 1082                             (LAC_ARCH_UINT)(bufListAlignedPhyAddr -
 1083                                             bufListDescPhyAddr));
 1084 
 1085                 /* Set number of flat buffers in the physical Buffer List
 1086                  * descriptor */
 1087                 pBufferListDesc->numBuffers = numFlatBuffers;
 1088 
 1089                 /* Go past the Buffer List descriptor to the list of buffer
 1090                  * descriptors
 1091                  */
 1092                 pCurrFlatBufDesc =
 1093                     (icp_flat_buffer_desc_t *)((pBufferListDesc->phyBuffers));
 1094 
 1095                 /* Loop for each flat buffer in the SGL */
 1096                 while (0 != numFlatBuffers) {
 1097                         /* Set length of the current flat buffer */
 1098                         pCurrFlatBufDesc->dataLenInBytes =
 1099                             pClientCurrFlatBuffer->dataLenInBytes;
 1100 
 1101                         /* Set physical address of the flat buffer */
 1102                         pCurrFlatBufDesc->phyBuffer =
 1103                             LAC_MEM_CAST_PTR_TO_UINT64(
 1104                                 LAC_OS_VIRT_TO_PHYS_EXTERNAL(
 1105                                     (*pService), pClientCurrFlatBuffer->pData));
 1106 
 1107                         if (pCurrFlatBufDesc->phyBuffer == 0) {
 1108                                 QAT_UTILS_LOG(
 1109                                     "Unable to get the physical address of the flat buffer.\n");
 1110                                 return CPA_STATUS_FAIL;
 1111                         }
 1112 
 1113                         pCurrFlatBufDesc++;
 1114                         pClientCurrFlatBuffer++;
 1115                         numFlatBuffers--;
 1116                 }
 1117                 pIntermediateBufferPtrsArray++;
 1118                 pInterBuffPtrsArray++;
 1119         }
 1120 
 1121         pService->generic_service_info.isInstanceStarted = CPA_TRUE;
 1122 
 1123         /* Increment dev ref counter */
 1124         icp_qa_dev_get(dev);
 1125         return CPA_STATUS_SUCCESS;
 1126 }
 1127 
 1128 CpaStatus
 1129 cpaDcStopInstance(CpaInstanceHandle instanceHandle)
 1130 {
 1131         CpaInstanceHandle insHandle = NULL;
 1132         CpaInstanceInfo2 info = { 0 };
 1133         icp_accel_dev_t *dev = NULL;
 1134         CpaStatus status = CPA_STATUS_SUCCESS;
 1135         sal_compression_service_t *pService = NULL;
 1136 
 1137         if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle) {
 1138                 insHandle = dcGetFirstHandle();
 1139         } else {
 1140                 insHandle = instanceHandle;
 1141         }
 1142 
 1143         LAC_CHECK_NULL_PARAM(insHandle);
 1144         pService = (sal_compression_service_t *)insHandle;
 1145 
 1146         /* Free Intermediate Buffer Pointers Array */
 1147         if (pService->pInterBuffPtrsArray != NULL) {
 1148                 LAC_OS_CAFREE(pService->pInterBuffPtrsArray);
 1149                 pService->pInterBuffPtrsArray = 0;
 1150         }
 1151 
 1152         pService->pInterBuffPtrsArrayPhyAddr = 0;
 1153 
 1154         status = cpaDcInstanceGetInfo2(insHandle, &info);
 1155         if (CPA_STATUS_SUCCESS != status) {
 1156                 QAT_UTILS_LOG("Can not get instance info.\n");
 1157                 return status;
 1158         }
 1159         dev = icp_adf_getAccelDevByAccelId(info.physInstId.packageId);
 1160         if (NULL == dev) {
 1161                 QAT_UTILS_LOG("Can not find device for the instance.\n");
 1162                 return CPA_STATUS_FAIL;
 1163         }
 1164 
 1165         pService->generic_service_info.isInstanceStarted = CPA_FALSE;
 1166 
 1167         /* Decrement dev ref counter */
 1168         icp_qa_dev_put(dev);
 1169         return CPA_STATUS_SUCCESS;
 1170 }
 1171 
 1172 CpaStatus
 1173 cpaDcGetNumInstances(Cpa16U *pNumInstances)
 1174 {
 1175         CpaStatus status = CPA_STATUS_SUCCESS;
 1176         icp_accel_dev_t **pAdfInsts = NULL;
 1177         icp_accel_dev_t *dev_addr = NULL;
 1178         sal_t *base_addr = NULL;
 1179         sal_list_t *list_temp = NULL;
 1180         Cpa16U num_accel_dev = 0;
 1181         Cpa16U num = 0;
 1182         Cpa16U i = 0;
 1183 
 1184         LAC_CHECK_NULL_PARAM(pNumInstances);
 1185 
 1186         /* Get the number of accel_dev in the system */
 1187         status = icp_amgr_getNumInstances(&num_accel_dev);
 1188         LAC_CHECK_STATUS(status);
 1189 
 1190         /* Allocate memory to store addr of accel_devs */
 1191         pAdfInsts =
 1192             malloc(num_accel_dev * sizeof(icp_accel_dev_t *), M_QAT, M_WAITOK);
 1193         num_accel_dev = 0;
 1194 
 1195         /* Get ADF to return accel_devs with dc enabled */
 1196         status = icp_amgr_getAllAccelDevByCapabilities(
 1197             ICP_ACCEL_CAPABILITIES_COMPRESSION, pAdfInsts, &num_accel_dev);
 1198         if (CPA_STATUS_SUCCESS == status) {
 1199                 for (i = 0; i < num_accel_dev; i++) {
 1200                         dev_addr = (icp_accel_dev_t *)pAdfInsts[i];
 1201                         if (NULL != dev_addr) {
 1202                                 base_addr = dev_addr->pSalHandle;
 1203                                 if (NULL != base_addr) {
 1204                                         list_temp =
 1205                                             base_addr->compression_services;
 1206                                         while (NULL != list_temp) {
 1207                                                 num++;
 1208                                                 list_temp =
 1209                                                     SalList_next(list_temp);
 1210                                         }
 1211                                 }
 1212                         }
 1213                 }
 1214 
 1215                 *pNumInstances = num;
 1216         }
 1217 
 1218         free(pAdfInsts, M_QAT);
 1219 
 1220         return status;
 1221 }
 1222 
 1223 CpaStatus
 1224 cpaDcGetInstances(Cpa16U numInstances, CpaInstanceHandle *dcInstances)
 1225 {
 1226         CpaStatus status = CPA_STATUS_SUCCESS;
 1227         icp_accel_dev_t **pAdfInsts = NULL;
 1228         icp_accel_dev_t *dev_addr = NULL;
 1229         sal_t *base_addr = NULL;
 1230         sal_list_t *list_temp = NULL;
 1231         Cpa16U num_accel_dev = 0;
 1232         Cpa16U index = 0;
 1233         Cpa16U i = 0;
 1234 
 1235         LAC_CHECK_NULL_PARAM(dcInstances);
 1236         if (0 == numInstances) {
 1237                 QAT_UTILS_LOG("numInstances is 0.\n");
 1238                 return CPA_STATUS_INVALID_PARAM;
 1239         }
 1240 
 1241         /* Get the number of accel_dev in the system */
 1242         status = icp_amgr_getNumInstances(&num_accel_dev);
 1243         LAC_CHECK_STATUS(status);
 1244 
 1245         /* Allocate memory to store addr of accel_devs */
 1246         pAdfInsts =
 1247             malloc(num_accel_dev * sizeof(icp_accel_dev_t *), M_QAT, M_WAITOK);
 1248 
 1249         num_accel_dev = 0;
 1250         /* Get ADF to return accel_devs with dc enabled */
 1251         status = icp_amgr_getAllAccelDevByCapabilities(
 1252             ICP_ACCEL_CAPABILITIES_COMPRESSION, pAdfInsts, &num_accel_dev);
 1253 
 1254         if (CPA_STATUS_SUCCESS == status) {
 1255                 /* First check the number of instances in the system */
 1256                 for (i = 0; i < num_accel_dev; i++) {
 1257                         dev_addr = (icp_accel_dev_t *)pAdfInsts[i];
 1258                         if (NULL != dev_addr) {
 1259                                 base_addr = dev_addr->pSalHandle;
 1260                                 if (NULL != base_addr) {
 1261                                         list_temp =
 1262                                             base_addr->compression_services;
 1263                                         while (NULL != list_temp) {
 1264                                                 if (index >
 1265                                                     (numInstances - 1)) {
 1266                                                         break;
 1267                                                 }
 1268 
 1269                                                 dcInstances[index] =
 1270                                                     SalList_getObject(
 1271                                                         list_temp);
 1272                                                 list_temp =
 1273                                                     SalList_next(list_temp);
 1274                                                 index++;
 1275                                         }
 1276                                 }
 1277                         }
 1278                 }
 1279 
 1280                 if (numInstances > index) {
 1281                         QAT_UTILS_LOG("Only %d dc instances available.\n",
 1282                                       index);
 1283                         status = CPA_STATUS_RESOURCE;
 1284                 }
 1285         }
 1286 
 1287         if (CPA_STATUS_SUCCESS == status) {
 1288                 index = 0;
 1289                 for (i = 0; i < num_accel_dev; i++) {
 1290                         dev_addr = (icp_accel_dev_t *)pAdfInsts[i];
 1291                         /* Note dev_addr cannot be NULL here as numInstances=0
 1292                            is not valid and if dev_addr=NULL then index=0 (which
 1293                            is less than numInstances and status is set to
 1294                            _RESOURCE
 1295                            above */
 1296                         base_addr = dev_addr->pSalHandle;
 1297                         if (NULL != base_addr) {
 1298                                 list_temp = base_addr->compression_services;
 1299                                 while (NULL != list_temp) {
 1300                                         if (index > (numInstances - 1)) {
 1301                                                 break;
 1302                                         }
 1303 
 1304                                         dcInstances[index] =
 1305                                             SalList_getObject(list_temp);
 1306                                         list_temp = SalList_next(list_temp);
 1307                                         index++;
 1308                                 }
 1309                         }
 1310                 }
 1311         }
 1312 
 1313         free(pAdfInsts, M_QAT);
 1314 
 1315         return status;
 1316 }
 1317 
 1318 CpaStatus
 1319 cpaDcInstanceGetInfo2(const CpaInstanceHandle instanceHandle,
 1320                       CpaInstanceInfo2 *pInstanceInfo2)
 1321 {
 1322         sal_compression_service_t *pCompressionService = NULL;
 1323         CpaInstanceHandle insHandle = NULL;
 1324         icp_accel_dev_t *dev = NULL;
 1325         CpaStatus status = CPA_STATUS_SUCCESS;
 1326         char keyStr[ADF_CFG_MAX_KEY_LEN_IN_BYTES] = { 0 };
 1327         char valStr[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
 1328         char *section = DYN_SEC;
 1329 
 1330         if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle) {
 1331                 insHandle = dcGetFirstHandle();
 1332         } else {
 1333                 insHandle = instanceHandle;
 1334         }
 1335 
 1336         LAC_CHECK_NULL_PARAM(insHandle);
 1337         SAL_CHECK_INSTANCE_TYPE(insHandle, SAL_SERVICE_TYPE_COMPRESSION);
 1338         LAC_CHECK_NULL_PARAM(pInstanceInfo2);
 1339 
 1340         LAC_OS_BZERO(pInstanceInfo2, sizeof(CpaInstanceInfo2));
 1341         pInstanceInfo2->accelerationServiceType =
 1342             CPA_ACC_SVC_TYPE_DATA_COMPRESSION;
 1343 
 1344         snprintf((char *)pInstanceInfo2->vendorName,
 1345                  CPA_INST_VENDOR_NAME_SIZE,
 1346                  "%s",
 1347                  SAL_INFO2_VENDOR_NAME);
 1348         pInstanceInfo2->vendorName[CPA_INST_VENDOR_NAME_SIZE - 1] = '\0';
 1349 
 1350         snprintf((char *)pInstanceInfo2->swVersion,
 1351                  CPA_INST_SW_VERSION_SIZE,
 1352                  "Version %d.%d",
 1353                  SAL_INFO2_DRIVER_SW_VERSION_MAJ_NUMBER,
 1354                  SAL_INFO2_DRIVER_SW_VERSION_MIN_NUMBER);
 1355         pInstanceInfo2->swVersion[CPA_INST_SW_VERSION_SIZE - 1] = '\0';
 1356 
 1357         /* Note we can safely read the contents of the compression service
 1358            instance
 1359            here because icp_amgr_getAccelDevByCapabilities() only returns devs
 1360            that have started */
 1361         pCompressionService = (sal_compression_service_t *)insHandle;
 1362         pInstanceInfo2->physInstId.packageId = pCompressionService->pkgID;
 1363         pInstanceInfo2->physInstId.acceleratorId =
 1364             pCompressionService->acceleratorNum;
 1365         pInstanceInfo2->physInstId.executionEngineId = 0;
 1366         pInstanceInfo2->physInstId.busAddress =
 1367             icp_adf_get_busAddress(pInstanceInfo2->physInstId.packageId);
 1368 
 1369         /* set coreAffinity to zero before use */
 1370         LAC_OS_BZERO(pInstanceInfo2->coreAffinity,
 1371                      sizeof(pInstanceInfo2->coreAffinity));
 1372         CPA_BITMAP_BIT_SET(pInstanceInfo2->coreAffinity,
 1373                            pCompressionService->coreAffinity);
 1374 
 1375         pInstanceInfo2->nodeAffinity = pCompressionService->nodeAffinity;
 1376 
 1377         if (CPA_TRUE ==
 1378             pCompressionService->generic_service_info.isInstanceStarted) {
 1379                 pInstanceInfo2->operState = CPA_OPER_STATE_UP;
 1380         } else {
 1381                 pInstanceInfo2->operState = CPA_OPER_STATE_DOWN;
 1382         }
 1383 
 1384         pInstanceInfo2->requiresPhysicallyContiguousMemory = CPA_TRUE;
 1385 
 1386         if (SAL_RESP_POLL_CFG_FILE == pCompressionService->isPolled) {
 1387                 pInstanceInfo2->isPolled = CPA_TRUE;
 1388         } else {
 1389                 pInstanceInfo2->isPolled = CPA_FALSE;
 1390         }
 1391 
 1392         pInstanceInfo2->isOffloaded = CPA_TRUE;
 1393         /* Get the instance name and part name from the config file */
 1394         dev = icp_adf_getAccelDevByAccelId(pCompressionService->pkgID);
 1395         if (NULL == dev) {
 1396                 QAT_UTILS_LOG("Can not find device for the instance.\n");
 1397                 LAC_OS_BZERO(pInstanceInfo2, sizeof(CpaInstanceInfo2));
 1398                 return CPA_STATUS_FAIL;
 1399         }
 1400         snprintf((char *)pInstanceInfo2->partName,
 1401                  CPA_INST_PART_NAME_SIZE,
 1402                  SAL_INFO2_PART_NAME,
 1403                  dev->deviceName);
 1404         pInstanceInfo2->partName[CPA_INST_PART_NAME_SIZE - 1] = '\0';
 1405 
 1406         if (CPA_FALSE == pCompressionService->generic_service_info.is_dyn) {
 1407                 section = icpGetProcessName();
 1408         }
 1409 
 1410         status = Sal_StringParsing(
 1411             "Dc",
 1412             pCompressionService->generic_service_info.instance,
 1413             "Name",
 1414             keyStr);
 1415         LAC_CHECK_STATUS(status);
 1416         status = icp_adf_cfgGetParamValue(dev, section, keyStr, valStr);
 1417         LAC_CHECK_STATUS(status);
 1418         strncpy((char *)pInstanceInfo2->instName,
 1419                 valStr,
 1420                 sizeof(pInstanceInfo2->instName) - 1);
 1421         pInstanceInfo2->instName[CPA_INST_NAME_SIZE - 1] = '\0';
 1422 
 1423 #if __GNUC__ >= 7
 1424 #pragma GCC diagnostic push
 1425 #pragma GCC diagnostic ignored "-Wformat-truncation"
 1426 #endif
 1427         snprintf((char *)pInstanceInfo2->instID,
 1428                  CPA_INST_ID_SIZE,
 1429                  "%s_%s",
 1430                  section,
 1431                  valStr);
 1432 #if __GNUC__ >= 7
 1433 #pragma GCC diagnostic pop
 1434 #endif
 1435 
 1436         return CPA_STATUS_SUCCESS;
 1437 }
 1438 
 1439 CpaStatus
 1440 cpaDcQueryCapabilities(CpaInstanceHandle dcInstance,
 1441                        CpaDcInstanceCapabilities *pInstanceCapabilities)
 1442 {
 1443         CpaInstanceHandle insHandle = NULL;
 1444         sal_compression_service_t *pService = NULL;
 1445         Cpa32U capabilitiesMask = 0;
 1446         dc_extd_ftrs_t *pExtendedFtrs = NULL;
 1447 
 1448         if (CPA_INSTANCE_HANDLE_SINGLE == dcInstance) {
 1449                 insHandle = dcGetFirstHandle();
 1450                 if (NULL == insHandle) {
 1451                         QAT_UTILS_LOG("Can not get the instance.\n");
 1452                         return CPA_STATUS_FAIL;
 1453                 }
 1454         } else {
 1455                 insHandle = dcInstance;
 1456         }
 1457 
 1458         pService = (sal_compression_service_t *)insHandle;
 1459 
 1460         LAC_CHECK_NULL_PARAM(insHandle);
 1461         SAL_CHECK_INSTANCE_TYPE(insHandle, SAL_SERVICE_TYPE_COMPRESSION);
 1462         LAC_CHECK_NULL_PARAM(pInstanceCapabilities);
 1463 
 1464         memset(pInstanceCapabilities, 0, sizeof(CpaDcInstanceCapabilities));
 1465 
 1466         capabilitiesMask = pService->generic_service_info.capabilitiesMask;
 1467 
 1468         /* Set compression capabilities */
 1469         if (capabilitiesMask & ICP_ACCEL_CAPABILITIES_CNV_INTEGRITY) {
 1470                 pInstanceCapabilities->integrityCrcs = CPA_TRUE;
 1471         }
 1472 
 1473         pInstanceCapabilities->endOfLastBlock = CPA_TRUE;
 1474         pInstanceCapabilities->statefulDeflateCompression = CPA_FALSE;
 1475         pInstanceCapabilities->statefulDeflateDecompression = CPA_TRUE;
 1476         pInstanceCapabilities->statelessDeflateCompression = CPA_TRUE;
 1477         pInstanceCapabilities->statelessDeflateDecompression = CPA_TRUE;
 1478         pInstanceCapabilities->checksumCRC32 = CPA_TRUE;
 1479         pInstanceCapabilities->checksumAdler32 = CPA_TRUE;
 1480         pInstanceCapabilities->dynamicHuffman = CPA_TRUE;
 1481         pInstanceCapabilities->precompiledHuffman = CPA_FALSE;
 1482         pInstanceCapabilities->dynamicHuffmanBufferReq = CPA_TRUE;
 1483         pInstanceCapabilities->autoSelectBestHuffmanTree = CPA_TRUE;
 1484 
 1485         pInstanceCapabilities->validWindowSizeMaskCompression =
 1486             pService->comp_device_data.windowSizeMask;
 1487         pInstanceCapabilities->validWindowSizeMaskDecompression =
 1488             pService->comp_device_data.windowSizeMask;
 1489         pExtendedFtrs = (dc_extd_ftrs_t *)&(
 1490             ((sal_service_t *)insHandle)->dcExtendedFeatures);
 1491         pInstanceCapabilities->batchAndPack = CPA_FALSE;
 1492         pInstanceCapabilities->compressAndVerify =
 1493             (CpaBoolean)pExtendedFtrs->is_cnv;
 1494         pInstanceCapabilities->compressAndVerifyStrict = CPA_TRUE;
 1495         pInstanceCapabilities->compressAndVerifyAndRecover =
 1496             (CpaBoolean)pExtendedFtrs->is_cnvnr;
 1497         return CPA_STATUS_SUCCESS;
 1498 }
 1499 
 1500 CpaStatus
 1501 cpaDcSetAddressTranslation(const CpaInstanceHandle instanceHandle,
 1502                            CpaVirtualToPhysical virtual2Physical)
 1503 {
 1504         sal_service_t *pService = NULL;
 1505         CpaInstanceHandle insHandle = NULL;
 1506 
 1507         if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle) {
 1508                 insHandle = dcGetFirstHandle();
 1509         } else {
 1510                 insHandle = instanceHandle;
 1511         }
 1512 
 1513         LAC_CHECK_NULL_PARAM(insHandle);
 1514         SAL_CHECK_INSTANCE_TYPE(insHandle, SAL_SERVICE_TYPE_COMPRESSION);
 1515         LAC_CHECK_NULL_PARAM(virtual2Physical);
 1516 
 1517         pService = (sal_service_t *)insHandle;
 1518 
 1519         pService->virt2PhysClient = virtual2Physical;
 1520 
 1521         return CPA_STATUS_SUCCESS;
 1522 }
 1523 
 1524 /**
 1525  ******************************************************************************
 1526  * @ingroup cpaDcCommon
 1527  * Data compression specific polling function which polls a DC instance.
 1528  *****************************************************************************/
 1529 
 1530 CpaStatus
 1531 icp_sal_DcPollInstance(CpaInstanceHandle instanceHandle_in,
 1532                        Cpa32U response_quota)
 1533 {
 1534         CpaStatus status = CPA_STATUS_SUCCESS;
 1535         sal_compression_service_t *dc_handle = NULL;
 1536         sal_service_t *gen_handle = NULL;
 1537         icp_comms_trans_handle trans_hndTable[DC_NUM_RX_RINGS];
 1538 
 1539         if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) {
 1540                 dc_handle = (sal_compression_service_t *)dcGetFirstHandle();
 1541         } else {
 1542                 dc_handle = (sal_compression_service_t *)instanceHandle_in;
 1543         }
 1544 
 1545         LAC_CHECK_NULL_PARAM(dc_handle);
 1546         SAL_RUNNING_CHECK(dc_handle);
 1547 
 1548         gen_handle = &(dc_handle->generic_service_info);
 1549         if (SAL_SERVICE_TYPE_COMPRESSION != gen_handle->type) {
 1550                 QAT_UTILS_LOG("Instance handle type is incorrect.\n");
 1551                 return CPA_STATUS_FAIL;
 1552         }
 1553 
 1554         /*
 1555          * From the instanceHandle we must get the trans_handle and send
 1556          * down to adf for polling.
 1557          * Populate our trans handle table with the appropriate handles.
 1558          */
 1559         trans_hndTable[0] = dc_handle->trans_handle_compression_rx;
 1560 
 1561         /* Call adf to do the polling. */
 1562         status = icp_adf_pollInstance(trans_hndTable,
 1563                                       DC_NUM_RX_RINGS,
 1564                                       response_quota);
 1565         return status;
 1566 }
 1567 
 1568 /**
 1569  ******************************************************************************
 1570  * @ingroup cpaDcCommon
 1571  *****************************************************************************/
 1572 CpaStatus
 1573 cpaDcInstanceSetNotificationCb(
 1574     const CpaInstanceHandle instanceHandle,
 1575     const CpaDcInstanceNotificationCbFunc pInstanceNotificationCb,
 1576     void *pCallbackTag)
 1577 {
 1578         CpaStatus status = CPA_STATUS_SUCCESS;
 1579         sal_service_t *gen_handle = instanceHandle;
 1580 
 1581         LAC_CHECK_NULL_PARAM(gen_handle);
 1582         gen_handle->notification_cb = pInstanceNotificationCb;
 1583         gen_handle->cb_tag = pCallbackTag;
 1584         return status;
 1585 }
 1586 
 1587 CpaInstanceHandle
 1588 dcGetFirstHandle(void)
 1589 {
 1590         CpaStatus status = CPA_STATUS_SUCCESS;
 1591         static icp_accel_dev_t *adfInsts[ADF_MAX_DEVICES] = { 0 };
 1592         CpaInstanceHandle dcInst = NULL;
 1593         icp_accel_dev_t *dev_addr = NULL;
 1594         sal_t *base_addr = NULL;
 1595         sal_list_t *list_temp = NULL;
 1596         Cpa16U i, num_dc = 0;
 1597 
 1598         /* Only need 1 dev with compression enabled - so check all devices */
 1599         status = icp_amgr_getAllAccelDevByCapabilities(
 1600             ICP_ACCEL_CAPABILITIES_COMPRESSION, adfInsts, &num_dc);
 1601         if ((0 == num_dc) || (CPA_STATUS_SUCCESS != status)) {
 1602                 QAT_UTILS_LOG(
 1603                     "No compression devices enabled in the system.\n");
 1604                 return dcInst;
 1605         }
 1606 
 1607         for (i = 0; i < num_dc; i++) {
 1608                 dev_addr = (icp_accel_dev_t *)adfInsts[i];
 1609                 if (NULL != dev_addr) {
 1610                         base_addr = dev_addr->pSalHandle;
 1611                         if (NULL != base_addr) {
 1612                                 list_temp = base_addr->compression_services;
 1613                                 if (NULL != list_temp) {
 1614                                         dcInst = SalList_getObject(list_temp);
 1615                                         break;
 1616                                 }
 1617                         }
 1618                 }
 1619         }
 1620         return dcInst;
 1621 }
Cache object: f8514218daad4c058600deefcad3ca69
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/dev/qat/qat_api/common/ctrl/sal_compression.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/qat/qat_api/common/ctrl/sal_compression.c
