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