1 /* SPDX-License-Identifier: BSD-3-Clause */ 2 /* Copyright(c) 2007-2025 Intel Corporation */ 3 4 /** 5 *************************************************************************** 6 * @file sal_crypto.c Instance handling functions for crypto 7 * 8 * @ingroup SalCtrl 9 * 10 ***************************************************************************/ 11 12 /* 13 ******************************************************************************* 14 * Include public/global header files 15 ******************************************************************************* 16 */ 17 18 /* QAT-API includes */ 19 #include "cpa.h" 20 #include "cpa_types.h" 21 #include "cpa_cy_common.h" 22 #include "cpa_cy_im.h" 23 #include "cpa_cy_key.h" 24 #include "cpa_cy_sym.h" 25 26 #include "qat_utils.h" 27 28 /* ADF includes */ 29 #include "icp_adf_init.h" 30 #include "icp_adf_transport.h" 31 #include "icp_accel_devices.h" 32 #include "icp_adf_cfg.h" 33 #include "icp_adf_accel_mgr.h" 34 #include "icp_adf_poll.h" 35 #include "icp_adf_debug.h" 36 37 /* SAL includes */ 38 #include "lac_log.h" 39 #include "lac_mem.h" 40 #include "lac_mem_pools.h" 41 #include "sal_statistics.h" 42 #include "lac_common.h" 43 #include "lac_list.h" 44 #include "lac_hooks.h" 45 #include "lac_sym_qat_hash_defs_lookup.h" 46 #include "lac_sym.h" 47 #include "lac_sym_key.h" 48 #include "lac_sym_hash.h" 49 #include "lac_sym_cb.h" 50 #include "lac_sym_stats.h" 51 #include "lac_sal_types_crypto.h" 52 #include "lac_sal.h" 53 #include "lac_sal_ctrl.h" 54 #include "sal_string_parse.h" 55 #include "sal_service_state.h" 56 #include "icp_sal_poll.h" 57 #include "lac_sync.h" 58 #include "lac_sym_qat.h" 59 #include "icp_sal_versions.h" 60 #include "icp_sal_user.h" 61 #include "sal_hw_gen.h" 62 63 #define HMAC_MODE_1 1 64 #define HMAC_MODE_2 2 65 #define TH_CY_RX_0 0 66 #define TH_CY_RX_1 1 67 #define MAX_CY_RX_RINGS 2 68 69 #define DOUBLE_INCR 2 70 71 #define TH_SINGLE_RX 0 72 #define NUM_CRYPTO_SYM_RX_RINGS 1 73 #define NUM_CRYPTO_ASYM_RX_RINGS 1 74 #define NUM_CRYPTO_NRBG_RX_RINGS 1 75 76 CpaStatus Lac_GetCyInstancesByType( 77 const CpaAccelerationServiceType accelerationServiceType, 78 Cpa16U numInstances, 79 CpaInstanceHandle *pInstances); 80 81 CpaStatus Lac_GetCyNumInstancesByType( 82 const CpaAccelerationServiceType accelerationServiceType, 83 Cpa16U *pNumInstances); 84 85 static CpaInstanceHandle 86 Lac_CryptoGetFirstHandle(void) 87 { 88 CpaInstanceHandle instHandle; 89 instHandle = Lac_GetFirstHandle(SAL_SERVICE_TYPE_CRYPTO); 90 if (!instHandle) { 91 instHandle = Lac_GetFirstHandle(SAL_SERVICE_TYPE_CRYPTO_SYM); 92 if (!instHandle) { 93 instHandle = 94 Lac_GetFirstHandle(SAL_SERVICE_TYPE_CRYPTO_ASYM); 95 } 96 } 97 return instHandle; 98 } 99 100 /* Function to release the sym handles. */ 101 static CpaStatus 102 SalCtrl_SymReleaseTransHandle(sal_service_t *service) 103 { 104 105 CpaStatus status = CPA_STATUS_SUCCESS; 106 CpaStatus ret_status = CPA_STATUS_SUCCESS; 107 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service; 108 109 if (NULL != pCryptoService->trans_handle_sym_tx) { 110 status = icp_adf_transReleaseHandle( 111 pCryptoService->trans_handle_sym_tx); 112 if (CPA_STATUS_SUCCESS != status) { 113 ret_status = status; 114 } 115 } 116 if (NULL != pCryptoService->trans_handle_sym_rx) { 117 status = icp_adf_transReleaseHandle( 118 pCryptoService->trans_handle_sym_rx); 119 if (CPA_STATUS_SUCCESS != status) { 120 ret_status = status; 121 } 122 } 123 124 return ret_status; 125 } 126 127 /* 128 * @ingroup sal_crypto 129 * Frees resources (memory and transhandles) if allocated 130 * 131 * @param[in] pCryptoService Pointer to sym service instance 132 * @retval SUCCESS if transhandles released 133 * successfully. 134 */ 135 static CpaStatus 136 SalCtrl_SymFreeResources(sal_crypto_service_t *pCryptoService) 137 { 138 139 CpaStatus status = CPA_STATUS_SUCCESS; 140 141 /* Free memory pools if not NULL */ 142 Lac_MemPoolDestroy(pCryptoService->lac_sym_cookie_pool); 143 144 /* Free misc memory if allocated */ 145 /* Frees memory allocated for Hmac precomputes */ 146 LacSymHash_HmacPrecompShutdown(pCryptoService); 147 /* Free memory allocated for key labels 148 Also clears key stats */ 149 LacSymKey_Shutdown(pCryptoService); 150 /* Free hash lookup table if allocated */ 151 if (NULL != pCryptoService->pLacHashLookupDefs) { 152 LAC_OS_FREE(pCryptoService->pLacHashLookupDefs); 153 } 154 155 /* Free statistics */ 156 LacSym_StatsFree(pCryptoService); 157 158 /* Free transport handles */ 159 status = SalCtrl_SymReleaseTransHandle((sal_service_t *)pCryptoService); 160 return status; 161 } 162 163 /** 164 *********************************************************************** 165 * @ingroup SalCtrl 166 * This macro verifies that the status is _SUCCESS 167 * If status is not _SUCCESS then Sym Instance resources are 168 * freed before the function returns the error 169 * 170 * @param[in] status status we are checking 171 * 172 * @return void status is ok (CPA_STATUS_SUCCESS) 173 * @return status The value in the status parameter is an error one 174 * 175 ****************************************************************************/ 176 #define LAC_CHECK_STATUS_SYM_INIT(status) \ 177 do { \ 178 if (CPA_STATUS_SUCCESS != status) { \ 179 SalCtrl_SymFreeResources(pCryptoService); \ 180 return status; \ 181 } \ 182 } while (0) 183 184 /* Function that creates the Sym Handles. */ 185 static CpaStatus 186 SalCtrl_SymCreateTransHandle(icp_accel_dev_t *device, 187 sal_service_t *service, 188 Cpa32U numSymRequests, 189 char *section) 190 { 191 CpaStatus status = CPA_STATUS_SUCCESS; 192 char temp_string[SAL_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 }; 193 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service; 194 icp_resp_deliv_method rx_resp_type = ICP_RESP_TYPE_IRQ; 195 Cpa32U msgSize = 0; 196 197 if (SAL_RESP_POLL_CFG_FILE == pCryptoService->isPolled) { 198 rx_resp_type = ICP_RESP_TYPE_POLL; 199 } 200 201 if (CPA_FALSE == pCryptoService->generic_service_info.is_dyn) { 202 section = icpGetProcessName(); 203 } 204 205 /* Parse Sym ring details */ 206 status = 207 Sal_StringParsing("Cy", 208 pCryptoService->generic_service_info.instance, 209 "RingSymTx", 210 temp_string); 211 212 /* Need to free resources in case not _SUCCESS from here */ 213 LAC_CHECK_STATUS_SYM_INIT(status); 214 215 msgSize = LAC_QAT_SYM_REQ_SZ_LW * LAC_LONG_WORD_IN_BYTES; 216 status = 217 icp_adf_transCreateHandle(device, 218 ICP_TRANS_TYPE_ETR, 219 section, 220 pCryptoService->acceleratorNum, 221 pCryptoService->bankNumSym, 222 temp_string, 223 lac_getRingType(SAL_RING_TYPE_A_SYM_HI), 224 NULL, 225 ICP_RESP_TYPE_NONE, 226 numSymRequests, 227 msgSize, 228 (icp_comms_trans_handle *)&( 229 pCryptoService->trans_handle_sym_tx)); 230 LAC_CHECK_STATUS_SYM_INIT(status); 231 232 status = 233 Sal_StringParsing("Cy", 234 pCryptoService->generic_service_info.instance, 235 "RingSymRx", 236 temp_string); 237 LAC_CHECK_STATUS_SYM_INIT(status); 238 239 msgSize = LAC_QAT_SYM_RESP_SZ_LW * LAC_LONG_WORD_IN_BYTES; 240 status = icp_adf_transCreateHandle( 241 device, 242 ICP_TRANS_TYPE_ETR, 243 section, 244 pCryptoService->acceleratorNum, 245 pCryptoService->bankNumSym, 246 temp_string, 247 lac_getRingType(SAL_RING_TYPE_NONE), 248 (icp_trans_callback)LacSymQat_SymRespHandler, 249 rx_resp_type, 250 numSymRequests, 251 msgSize, 252 (icp_comms_trans_handle *)&(pCryptoService->trans_handle_sym_rx)); 253 LAC_CHECK_STATUS_SYM_INIT(status); 254 255 return status; 256 } 257 258 static int 259 SalCtrl_CryptoDebug(void *private_data, char *data, int size, int offset) 260 { 261 CpaStatus status = CPA_STATUS_SUCCESS; 262 Cpa32U len = 0; 263 sal_crypto_service_t *pCryptoService = 264 (sal_crypto_service_t *)private_data; 265 266 switch (offset) { 267 case SAL_STATS_SYM: { 268 CpaCySymStats64 symStats = { 0 }; 269 if (CPA_TRUE != 270 pCryptoService->generic_service_info.stats 271 ->bSymStatsEnabled) { 272 break; 273 } 274 status = cpaCySymQueryStats64(pCryptoService, &symStats); 275 if (status != CPA_STATUS_SUCCESS) { 276 LAC_LOG_ERROR("cpaCySymQueryStats64 returned error\n"); 277 return 0; 278 } 279 280 /* Engine Info */ 281 len += snprintf( 282 data + len, 283 size - len, 284 SEPARATOR BORDER 285 " Statistics for Instance %24s |\n" BORDER 286 " Symmetric Stats " BORDER 287 "\n" SEPARATOR, 288 pCryptoService->debug_file->name); 289 290 /* Session Info */ 291 len += snprintf( 292 data + len, 293 size - len, 294 BORDER " Sessions Initialized: %16llu " BORDER 295 "\n" BORDER 296 " Sessions Removed: %16llu " BORDER 297 "\n" BORDER 298 " Session Errors: %16llu " BORDER 299 "\n" SEPARATOR, 300 (long long unsigned int)symStats.numSessionsInitialized, 301 (long long unsigned int)symStats.numSessionsRemoved, 302 (long long unsigned int)symStats.numSessionErrors); 303 304 /* Session info */ 305 len += snprintf( 306 data + len, 307 size - len, 308 BORDER " Symmetric Requests: %16llu " BORDER 309 "\n" BORDER 310 " Symmetric Request Errors: %16llu " BORDER 311 "\n" BORDER 312 " Symmetric Completed: %16llu " BORDER 313 "\n" BORDER 314 " Symmetric Completed Errors: %16llu " BORDER 315 "\n" BORDER 316 " Symmetric Verify Failures: %16llu " BORDER 317 "\n", 318 (long long unsigned int)symStats.numSymOpRequests, 319 (long long unsigned int)symStats.numSymOpRequestErrors, 320 (long long unsigned int)symStats.numSymOpCompleted, 321 (long long unsigned int)symStats.numSymOpCompletedErrors, 322 (long long unsigned int)symStats.numSymOpVerifyFailures); 323 break; 324 } 325 default: { 326 len += snprintf(data + len, size - len, SEPARATOR); 327 return 0; 328 } 329 } 330 return ++offset; 331 } 332 333 static CpaStatus 334 SalCtrl_SymInit(icp_accel_dev_t *device, sal_service_t *service) 335 { 336 CpaStatus status = CPA_STATUS_SUCCESS; 337 Cpa32U qatHmacMode = 0; 338 Cpa32U numSymConcurrentReq = 0; 339 char adfGetParam[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 }; 340 char temp_string[SAL_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 }; 341 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service; 342 char *section = DYN_SEC; 343 344 /*Instance may not in the DYN section*/ 345 if (CPA_FALSE == pCryptoService->generic_service_info.is_dyn) { 346 section = icpGetProcessName(); 347 } 348 349 /* Register callbacks for the symmetric services 350 * (Hash, Cipher, Algorithm-Chaining) (returns void)*/ 351 LacSymCb_CallbacksRegister(); 352 353 qatHmacMode = (Cpa32U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC); 354 switch (qatHmacMode) { 355 case HMAC_MODE_1: 356 pCryptoService->qatHmacMode = ICP_QAT_HW_AUTH_MODE1; 357 break; 358 case HMAC_MODE_2: 359 pCryptoService->qatHmacMode = ICP_QAT_HW_AUTH_MODE2; 360 break; 361 default: 362 pCryptoService->qatHmacMode = ICP_QAT_HW_AUTH_MODE1; 363 break; 364 } 365 366 /* Get num concurrent requests from config file */ 367 status = 368 Sal_StringParsing("Cy", 369 pCryptoService->generic_service_info.instance, 370 "NumConcurrentSymRequests", 371 temp_string); 372 LAC_CHECK_STATUS(status); 373 status = 374 icp_adf_cfgGetParamValue(device, section, temp_string, adfGetParam); 375 if (CPA_STATUS_SUCCESS != status) { 376 QAT_UTILS_LOG("Failed to get %s from configuration file\n", 377 temp_string); 378 return status; 379 } 380 381 numSymConcurrentReq = 382 (Cpa32U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC); 383 if (CPA_STATUS_FAIL == validateConcurrRequest(numSymConcurrentReq)) { 384 LAC_LOG_ERROR("Invalid NumConcurrentSymRequests, valid " 385 "values {64, 128, 256, ... 32768, 65536}"); 386 return CPA_STATUS_FAIL; 387 } 388 389 /* ADF does not allow us to completely fill the ring for batch requests 390 */ 391 pCryptoService->maxNumSymReqBatch = 392 (numSymConcurrentReq - SAL_BATCH_SUBMIT_FREE_SPACE); 393 394 /* Create transport handles */ 395 status = SalCtrl_SymCreateTransHandle(device, 396 service, 397 numSymConcurrentReq, 398 section); 399 LAC_CHECK_STATUS(status); 400 401 /* Allocates memory pools */ 402 403 /* Create and initialise symmetric cookie memory pool */ 404 pCryptoService->lac_sym_cookie_pool = LAC_MEM_POOL_INIT_POOL_ID; 405 status = 406 Sal_StringParsing("Cy", 407 pCryptoService->generic_service_info.instance, 408 "SymPool", 409 temp_string); 410 LAC_CHECK_STATUS_SYM_INIT(status); 411 /* Note we need twice (i.e. <<1) the number of sym cookies to 412 support sym ring pairs (and some, for partials) */ 413 status = 414 Lac_MemPoolCreate(&pCryptoService->lac_sym_cookie_pool, 415 temp_string, 416 ((numSymConcurrentReq + numSymConcurrentReq + 1) 417 << 1), 418 sizeof(lac_sym_cookie_t), 419 LAC_64BYTE_ALIGNMENT, 420 CPA_FALSE, 421 pCryptoService->nodeAffinity); 422 LAC_CHECK_STATUS_SYM_INIT(status); 423 /* For all sym cookies fill out the physical address of data that 424 will be set to QAT */ 425 Lac_MemPoolInitSymCookiesPhyAddr(pCryptoService->lac_sym_cookie_pool); 426 427 /* Clear stats */ 428 /* Clears Key stats and allocate memory of SSL and TLS labels 429 These labels are initialised to standard values */ 430 status = LacSymKey_Init(pCryptoService); 431 LAC_CHECK_STATUS_SYM_INIT(status); 432 433 /* Initialises the hash lookup table*/ 434 status = LacSymQat_Init(pCryptoService); 435 LAC_CHECK_STATUS_SYM_INIT(status); 436 437 /* Fills out content descriptor for precomputes and registers the 438 hash precompute callback */ 439 status = LacSymHash_HmacPrecompInit(pCryptoService); 440 LAC_CHECK_STATUS_SYM_INIT(status); 441 442 /* Init the Sym stats */ 443 status = LacSym_StatsInit(pCryptoService); 444 LAC_CHECK_STATUS_SYM_INIT(status); 445 446 return status; 447 } 448 449 static void 450 SalCtrl_DebugShutdown(icp_accel_dev_t *device, sal_service_t *service) 451 { 452 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service; 453 sal_statistics_collection_t *pStatsCollection = 454 (sal_statistics_collection_t *)device->pQatStats; 455 456 if (CPA_TRUE == pStatsCollection->bStatsEnabled) { 457 /* Clean stats */ 458 if (NULL != pCryptoService->debug_file) { 459 icp_adf_debugRemoveFile(pCryptoService->debug_file); 460 LAC_OS_FREE(pCryptoService->debug_file->name); 461 LAC_OS_FREE(pCryptoService->debug_file); 462 pCryptoService->debug_file = NULL; 463 } 464 } 465 pCryptoService->generic_service_info.stats = NULL; 466 } 467 468 static CpaStatus 469 SalCtrl_DebugInit(icp_accel_dev_t *device, sal_service_t *service) 470 { 471 char adfGetParam[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 }; 472 char temp_string[SAL_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 }; 473 char *instance_name = NULL; 474 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service; 475 sal_statistics_collection_t *pStatsCollection = 476 (sal_statistics_collection_t *)device->pQatStats; 477 CpaStatus status = CPA_STATUS_SUCCESS; 478 char *section = DYN_SEC; 479 480 /*Instance may not in the DYN section*/ 481 if (CPA_FALSE == pCryptoService->generic_service_info.is_dyn) { 482 section = icpGetProcessName(); 483 } 484 485 if (CPA_TRUE == pStatsCollection->bStatsEnabled) { 486 /* Get instance name for stats */ 487 instance_name = LAC_OS_MALLOC(ADF_CFG_MAX_VAL_LEN_IN_BYTES); 488 if (NULL == instance_name) { 489 return CPA_STATUS_RESOURCE; 490 } 491 492 status = Sal_StringParsing( 493 "Cy", 494 pCryptoService->generic_service_info.instance, 495 "Name", 496 temp_string); 497 if (CPA_STATUS_SUCCESS != status) { 498 LAC_OS_FREE(instance_name); 499 return status; 500 } 501 status = icp_adf_cfgGetParamValue(device, 502 section, 503 temp_string, 504 adfGetParam); 505 if (CPA_STATUS_SUCCESS != status) { 506 QAT_UTILS_LOG( 507 "Failed to get %s from configuration file\n", 508 temp_string); 509 LAC_OS_FREE(instance_name); 510 return status; 511 } 512 snprintf(instance_name, 513 ADF_CFG_MAX_VAL_LEN_IN_BYTES, 514 "%s", 515 adfGetParam); 516 517 pCryptoService->debug_file = 518 LAC_OS_MALLOC(sizeof(debug_file_info_t)); 519 if (NULL == pCryptoService->debug_file) { 520 LAC_OS_FREE(instance_name); 521 return CPA_STATUS_RESOURCE; 522 } 523 524 memset(pCryptoService->debug_file, 525 0, 526 sizeof(debug_file_info_t)); 527 pCryptoService->debug_file->name = instance_name; 528 pCryptoService->debug_file->seq_read = SalCtrl_CryptoDebug; 529 pCryptoService->debug_file->private_data = pCryptoService; 530 pCryptoService->debug_file->parent = 531 pCryptoService->generic_service_info.debug_parent_dir; 532 533 status = 534 icp_adf_debugAddFile(device, pCryptoService->debug_file); 535 if (CPA_STATUS_SUCCESS != status) { 536 LAC_OS_FREE(instance_name); 537 LAC_OS_FREE(pCryptoService->debug_file); 538 return status; 539 } 540 } 541 pCryptoService->generic_service_info.stats = pStatsCollection; 542 543 return status; 544 } 545 546 static CpaStatus 547 SalCtrl_GetBankNum(icp_accel_dev_t *device, 548 Cpa32U inst, 549 char *section, 550 char *bank_name, 551 Cpa16U *bank) 552 { 553 char adfParamValue[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 }; 554 char adfParamName[SAL_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 }; 555 CpaStatus status = CPA_STATUS_SUCCESS; 556 557 status = Sal_StringParsing("Cy", inst, bank_name, adfParamName); 558 LAC_CHECK_STATUS(status); 559 status = icp_adf_cfgGetParamValue(device, 560 section, 561 adfParamName, 562 adfParamValue); 563 if (CPA_STATUS_SUCCESS != status) { 564 QAT_UTILS_LOG("Failed to get %s from configuration file\n", 565 adfParamName); 566 return status; 567 } 568 *bank = (Cpa16U)Sal_Strtoul(adfParamValue, NULL, SAL_CFG_BASE_DEC); 569 return status; 570 } 571 572 static CpaStatus 573 SalCtr_InstInit(icp_accel_dev_t *device, sal_service_t *service) 574 { 575 char adfGetParam[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 }; 576 char temp_string[SAL_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 }; 577 char temp_string2[SAL_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 }; 578 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service; 579 CpaStatus status = CPA_STATUS_SUCCESS; 580 char *section = DYN_SEC; 581 582 /*Instance may not in the DYN section*/ 583 if (CPA_FALSE == pCryptoService->generic_service_info.is_dyn) { 584 section = icpGetProcessName(); 585 } 586 587 /* Get Config Info: Accel Num, bank Num, packageID, 588 coreAffinity, nodeAffinity and response mode */ 589 590 pCryptoService->acceleratorNum = 0; 591 592 /* Gen4, a bank only has 2 rings (1 ring pair), only one type of service 593 can be assigned one time. asym and sym will be in different bank*/ 594 if (isCyGen4x(pCryptoService)) { 595 switch (service->type) { 596 case SAL_SERVICE_TYPE_CRYPTO_ASYM: 597 status = SalCtrl_GetBankNum( 598 device, 599 pCryptoService->generic_service_info.instance, 600 section, 601 "BankNumberAsym", 602 &pCryptoService->bankNumAsym); 603 if (CPA_STATUS_SUCCESS != status) 604 return status; 605 break; 606 case SAL_SERVICE_TYPE_CRYPTO_SYM: 607 status = SalCtrl_GetBankNum( 608 device, 609 pCryptoService->generic_service_info.instance, 610 section, 611 "BankNumberSym", 612 &pCryptoService->bankNumSym); 613 if (CPA_STATUS_SUCCESS != status) 614 return status; 615 break; 616 case SAL_SERVICE_TYPE_CRYPTO: 617 status = SalCtrl_GetBankNum( 618 device, 619 pCryptoService->generic_service_info.instance, 620 section, 621 "BankNumberAsym", 622 &pCryptoService->bankNumAsym); 623 if (CPA_STATUS_SUCCESS != status) 624 return status; 625 status = SalCtrl_GetBankNum( 626 device, 627 pCryptoService->generic_service_info.instance, 628 section, 629 "BankNumberSym", 630 &pCryptoService->bankNumSym); 631 if (CPA_STATUS_SUCCESS != status) 632 return status; 633 break; 634 default: 635 return CPA_STATUS_FAIL; 636 } 637 } else { 638 status = SalCtrl_GetBankNum( 639 device, 640 pCryptoService->generic_service_info.instance, 641 section, 642 "BankNumber", 643 &pCryptoService->bankNumSym); 644 if (CPA_STATUS_SUCCESS != status) 645 return status; 646 pCryptoService->bankNumAsym = pCryptoService->bankNumSym; 647 } 648 649 status = 650 Sal_StringParsing("Cy", 651 pCryptoService->generic_service_info.instance, 652 "IsPolled", 653 temp_string); 654 LAC_CHECK_STATUS(status); 655 status = 656 icp_adf_cfgGetParamValue(device, section, temp_string, adfGetParam); 657 if (CPA_STATUS_SUCCESS != status) { 658 QAT_UTILS_LOG("Failed to get %s from configuration file\n", 659 temp_string); 660 return status; 661 } 662 pCryptoService->isPolled = 663 (Cpa8U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC); 664 665 /* Kernel instances do not support epoll mode */ 666 if (SAL_RESP_EPOLL_CFG_FILE == pCryptoService->isPolled) { 667 QAT_UTILS_LOG( 668 "IsPolled %u is not supported for kernel instance %s", 669 pCryptoService->isPolled, 670 temp_string); 671 return CPA_STATUS_FAIL; 672 } 673 674 status = icp_adf_cfgGetParamValue(device, 675 LAC_CFG_SECTION_GENERAL, 676 ADF_DEV_PKG_ID, 677 adfGetParam); 678 if (CPA_STATUS_SUCCESS != status) { 679 QAT_UTILS_LOG("Failed to get %s from configuration file\n", 680 ADF_DEV_PKG_ID); 681 return status; 682 } 683 pCryptoService->pkgID = 684 (Cpa16U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC); 685 686 status = icp_adf_cfgGetParamValue(device, 687 LAC_CFG_SECTION_GENERAL, 688 ADF_DEV_NODE_ID, 689 adfGetParam); 690 if (CPA_STATUS_SUCCESS != status) { 691 QAT_UTILS_LOG("Failed to get %s from configuration file\n", 692 ADF_DEV_NODE_ID); 693 return status; 694 } 695 pCryptoService->nodeAffinity = 696 (Cpa32U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC); 697 /* In case of interrupt instance, use the bank affinity set by adf_ctl 698 * Otherwise, use the instance affinity for backwards compatibility */ 699 if (SAL_RESP_POLL_CFG_FILE != pCryptoService->isPolled) { 700 /* Next need to read the [AcceleratorX] section of the config 701 * file */ 702 status = Sal_StringParsing("Accelerator", 703 pCryptoService->acceleratorNum, 704 "", 705 temp_string2); 706 LAC_CHECK_STATUS(status); 707 if (service->type == SAL_SERVICE_TYPE_CRYPTO_ASYM) 708 status = Sal_StringParsing("Bank", 709 pCryptoService->bankNumAsym, 710 "CoreAffinity", 711 temp_string); 712 else 713 /* For cy service, asym bank and sym bank will set the 714 same core affinity. So Just read one*/ 715 status = Sal_StringParsing("Bank", 716 pCryptoService->bankNumSym, 717 "CoreAffinity", 718 temp_string); 719 LAC_CHECK_STATUS(status); 720 } else { 721 strncpy(temp_string2, section, (strlen(section) + 1)); 722 status = Sal_StringParsing( 723 "Cy", 724 pCryptoService->generic_service_info.instance, 725 "CoreAffinity", 726 temp_string); 727 LAC_CHECK_STATUS(status); 728 } 729 730 status = icp_adf_cfgGetParamValue(device, 731 temp_string2, 732 temp_string, 733 adfGetParam); 734 if (CPA_STATUS_SUCCESS != status) { 735 QAT_UTILS_LOG("Failed to get %s from configuration file\n", 736 temp_string); 737 return status; 738 } 739 pCryptoService->coreAffinity = 740 (Cpa32U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC); 741 742 /*No Execution Engine in DH895xcc, so make sure it is zero*/ 743 pCryptoService->executionEngine = 0; 744 745 return status; 746 } 747 748 /* This function: 749 * 1. Creates sym and asym transport handles 750 * 2. Allocates memory pools required by sym and asym services 751 .* 3. Clears the sym and asym stats counters 752 * 4. In case service asym or sym is enabled then this function 753 * only allocates resources for these services. i.e if the 754 * service asym is enabled then only asym transport handles 755 * are created and vice versa. 756 */ 757 CpaStatus 758 SalCtrl_CryptoInit(icp_accel_dev_t *device, sal_service_t *service) 759 { 760 CpaStatus status = CPA_STATUS_SUCCESS; 761 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service; 762 sal_service_type_t svc_type = service->type; 763 764 SAL_SERVICE_GOOD_FOR_INIT(pCryptoService); 765 pCryptoService->generic_service_info.state = 766 SAL_SERVICE_STATE_INITIALIZING; 767 768 /* Set up the instance parameters such as bank number, 769 * coreAffinity, pkgId and node affinity etc 770 */ 771 status = SalCtr_InstInit(device, service); 772 LAC_CHECK_STATUS(status); 773 /* Create debug directory for service */ 774 status = SalCtrl_DebugInit(device, service); 775 LAC_CHECK_STATUS(status); 776 777 switch (svc_type) { 778 case SAL_SERVICE_TYPE_CRYPTO_ASYM: 779 break; 780 case SAL_SERVICE_TYPE_CRYPTO_SYM: 781 status = SalCtrl_SymInit(device, service); 782 if (CPA_STATUS_SUCCESS != status) { 783 SalCtrl_DebugShutdown(device, service); 784 return status; 785 } 786 break; 787 case SAL_SERVICE_TYPE_CRYPTO: 788 status = SalCtrl_SymInit(device, service); 789 if (CPA_STATUS_SUCCESS != status) { 790 SalCtrl_DebugShutdown(device, service); 791 return status; 792 } 793 break; 794 default: 795 LAC_LOG_ERROR("Invalid service type\n"); 796 status = CPA_STATUS_FAIL; 797 break; 798 } 799 800 pCryptoService->generic_service_info.state = 801 SAL_SERVICE_STATE_INITIALIZED; 802 803 return status; 804 } 805 806 CpaStatus 807 SalCtrl_CryptoStart(icp_accel_dev_t *device, sal_service_t *service) 808 { 809 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service; 810 CpaStatus status = CPA_STATUS_SUCCESS; 811 812 if (pCryptoService->generic_service_info.state != 813 SAL_SERVICE_STATE_INITIALIZED) { 814 LAC_LOG_ERROR("Not in the correct state to call start\n"); 815 return CPA_STATUS_FAIL; 816 } 817 818 pCryptoService->generic_service_info.state = SAL_SERVICE_STATE_RUNNING; 819 return status; 820 } 821 822 CpaStatus 823 SalCtrl_CryptoStop(icp_accel_dev_t *device, sal_service_t *service) 824 { 825 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service; 826 827 if (SAL_SERVICE_STATE_RUNNING != 828 pCryptoService->generic_service_info.state) { 829 LAC_LOG_ERROR("Not in the correct state to call stop"); 830 } 831 832 pCryptoService->generic_service_info.state = 833 SAL_SERVICE_STATE_SHUTTING_DOWN; 834 return CPA_STATUS_SUCCESS; 835 } 836 837 CpaStatus 838 SalCtrl_CryptoShutdown(icp_accel_dev_t *device, sal_service_t *service) 839 { 840 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service; 841 CpaStatus status = CPA_STATUS_SUCCESS; 842 sal_service_type_t svc_type = service->type; 843 844 if ((SAL_SERVICE_STATE_INITIALIZED != 845 pCryptoService->generic_service_info.state) && 846 (SAL_SERVICE_STATE_SHUTTING_DOWN != 847 pCryptoService->generic_service_info.state)) { 848 LAC_LOG_ERROR("Not in the correct state to call shutdown \n"); 849 return CPA_STATUS_FAIL; 850 } 851 852 /* Free memory and transhandles */ 853 switch (svc_type) { 854 case SAL_SERVICE_TYPE_CRYPTO_ASYM: 855 break; 856 case SAL_SERVICE_TYPE_CRYPTO_SYM: 857 if (SalCtrl_SymFreeResources(pCryptoService)) { 858 status = CPA_STATUS_FAIL; 859 } 860 break; 861 case SAL_SERVICE_TYPE_CRYPTO: 862 if (SalCtrl_SymFreeResources(pCryptoService)) { 863 status = CPA_STATUS_FAIL; 864 } 865 break; 866 default: 867 LAC_LOG_ERROR("Invalid service type\n"); 868 status = CPA_STATUS_FAIL; 869 break; 870 } 871 872 SalCtrl_DebugShutdown(device, service); 873 874 pCryptoService->generic_service_info.state = SAL_SERVICE_STATE_SHUTDOWN; 875 876 return status; 877 } 878 879 /** 880 ****************************************************************************** 881 * @ingroup cpaCyCommon 882 *****************************************************************************/ 883 CpaStatus 884 cpaCyGetStatusText(const CpaInstanceHandle instanceHandle, 885 CpaStatus errStatus, 886 Cpa8S *pStatusText) 887 { 888 CpaStatus status = CPA_STATUS_SUCCESS; 889 890 LAC_CHECK_NULL_PARAM(pStatusText); 891 892 switch (errStatus) { 893 case CPA_STATUS_SUCCESS: 894 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_SUCCESS); 895 break; 896 case CPA_STATUS_FAIL: 897 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_FAIL); 898 break; 899 case CPA_STATUS_RETRY: 900 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_RETRY); 901 break; 902 case CPA_STATUS_RESOURCE: 903 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_RESOURCE); 904 break; 905 case CPA_STATUS_INVALID_PARAM: 906 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_INVALID_PARAM); 907 break; 908 case CPA_STATUS_FATAL: 909 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_FATAL); 910 break; 911 case CPA_STATUS_UNSUPPORTED: 912 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_UNSUPPORTED); 913 break; 914 default: 915 status = CPA_STATUS_INVALID_PARAM; 916 break; 917 } 918 return status; 919 } 920 921 void 922 SalCtrl_CyQueryCapabilities(sal_service_t *pGenericService, 923 CpaCyCapabilitiesInfo *pCapInfo) 924 { 925 memset(pCapInfo, 0, sizeof(CpaCyCapabilitiesInfo)); 926 927 if (SAL_SERVICE_TYPE_CRYPTO == pGenericService->type || 928 SAL_SERVICE_TYPE_CRYPTO_SYM == pGenericService->type) { 929 pCapInfo->symSupported = CPA_TRUE; 930 if (pGenericService->capabilitiesMask & 931 ICP_ACCEL_CAPABILITIES_EXT_ALGCHAIN) { 932 pCapInfo->extAlgchainSupported = CPA_TRUE; 933 } 934 935 if (pGenericService->capabilitiesMask & 936 ICP_ACCEL_CAPABILITIES_HKDF) { 937 pCapInfo->hkdfSupported = CPA_TRUE; 938 } 939 } 940 941 if (pGenericService->capabilitiesMask & 942 ICP_ACCEL_CAPABILITIES_ECEDMONT) { 943 pCapInfo->ecEdMontSupported = CPA_TRUE; 944 } 945 946 if (pGenericService->capabilitiesMask & 947 ICP_ACCEL_CAPABILITIES_RANDOM_NUMBER) { 948 pCapInfo->nrbgSupported = CPA_TRUE; 949 } 950 951 pCapInfo->drbgSupported = CPA_FALSE; 952 pCapInfo->randSupported = CPA_FALSE; 953 pCapInfo->nrbgSupported = CPA_FALSE; 954 } 955 956 /** 957 ****************************************************************************** 958 * @ingroup cpaCyCommon 959 *****************************************************************************/ 960 CpaStatus 961 cpaCyStartInstance(CpaInstanceHandle instanceHandle_in) 962 { 963 CpaInstanceHandle instanceHandle = NULL; 964 /* Structure initializer is supported by C99, but it is 965 * not supported by some former Intel compilers. 966 */ 967 CpaInstanceInfo2 info = { 0 }; 968 icp_accel_dev_t *dev = NULL; 969 CpaStatus status = CPA_STATUS_SUCCESS; 970 sal_crypto_service_t *pService = NULL; 971 972 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) { 973 instanceHandle = Lac_GetFirstHandle(SAL_SERVICE_TYPE_CRYPTO); 974 if (!instanceHandle) { 975 instanceHandle = 976 Lac_GetFirstHandle(SAL_SERVICE_TYPE_CRYPTO_SYM); 977 } 978 } else { 979 instanceHandle = instanceHandle_in; 980 } 981 LAC_CHECK_NULL_PARAM(instanceHandle); 982 SAL_CHECK_INSTANCE_TYPE(instanceHandle, 983 (SAL_SERVICE_TYPE_CRYPTO | 984 SAL_SERVICE_TYPE_CRYPTO_ASYM | 985 SAL_SERVICE_TYPE_CRYPTO_SYM)); 986 987 pService = (sal_crypto_service_t *)instanceHandle; 988 989 status = cpaCyInstanceGetInfo2(instanceHandle, &info); 990 if (CPA_STATUS_SUCCESS != status) { 991 LAC_LOG_ERROR("Can not get instance info\n"); 992 return status; 993 } 994 dev = icp_adf_getAccelDevByAccelId(info.physInstId.packageId); 995 if (NULL == dev) { 996 LAC_LOG_ERROR("Can not find device for the instance\n"); 997 return CPA_STATUS_FAIL; 998 } 999 1000 pService->generic_service_info.isInstanceStarted = CPA_TRUE; 1001 1002 /* Increment dev ref counter */ 1003 icp_qa_dev_get(dev); 1004 return CPA_STATUS_SUCCESS; 1005 } 1006 1007 /** 1008 ****************************************************************************** 1009 * @ingroup cpaCyCommon 1010 *****************************************************************************/ 1011 CpaStatus 1012 cpaCyStopInstance(CpaInstanceHandle instanceHandle_in) 1013 { 1014 CpaInstanceHandle instanceHandle = NULL; 1015 /* Structure initializer is supported by C99, but it is 1016 * not supported by some former Intel compilers. 1017 */ 1018 CpaInstanceInfo2 info = { 0 }; 1019 icp_accel_dev_t *dev = NULL; 1020 CpaStatus status = CPA_STATUS_SUCCESS; 1021 sal_crypto_service_t *pService = NULL; 1022 1023 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) { 1024 instanceHandle = Lac_CryptoGetFirstHandle(); 1025 } else { 1026 instanceHandle = instanceHandle_in; 1027 } 1028 LAC_CHECK_NULL_PARAM(instanceHandle); 1029 SAL_CHECK_INSTANCE_TYPE(instanceHandle, 1030 (SAL_SERVICE_TYPE_CRYPTO | 1031 SAL_SERVICE_TYPE_CRYPTO_ASYM | 1032 SAL_SERVICE_TYPE_CRYPTO_SYM)); 1033 1034 status = cpaCyInstanceGetInfo2(instanceHandle, &info); 1035 if (CPA_STATUS_SUCCESS != status) { 1036 LAC_LOG_ERROR("Can not get instance info\n"); 1037 return status; 1038 } 1039 dev = icp_adf_getAccelDevByAccelId(info.physInstId.packageId); 1040 if (NULL == dev) { 1041 LAC_LOG_ERROR("Can not find device for the instance\n"); 1042 return CPA_STATUS_FAIL; 1043 } 1044 1045 pService = (sal_crypto_service_t *)instanceHandle; 1046 1047 pService->generic_service_info.isInstanceStarted = CPA_FALSE; 1048 1049 /* Decrement dev ref counter */ 1050 icp_qa_dev_put(dev); 1051 return CPA_STATUS_SUCCESS; 1052 } 1053 1054 /** 1055 ****************************************************************************** 1056 * @ingroup cpaCyCommon 1057 *****************************************************************************/ 1058 CpaStatus 1059 cpaCyInstanceSetNotificationCb( 1060 const CpaInstanceHandle instanceHandle, 1061 const CpaCyInstanceNotificationCbFunc pInstanceNotificationCb, 1062 void *pCallbackTag) 1063 { 1064 CpaStatus status = CPA_STATUS_SUCCESS; 1065 sal_service_t *gen_handle = instanceHandle; 1066 1067 LAC_CHECK_NULL_PARAM(gen_handle); 1068 gen_handle->notification_cb = pInstanceNotificationCb; 1069 gen_handle->cb_tag = pCallbackTag; 1070 return status; 1071 } 1072 1073 /** 1074 ****************************************************************************** 1075 * @ingroup cpaCyCommon 1076 *****************************************************************************/ 1077 CpaStatus 1078 cpaCyGetNumInstances(Cpa16U *pNumInstances) 1079 { 1080 return Lac_GetCyNumInstancesByType(CPA_ACC_SVC_TYPE_CRYPTO, 1081 pNumInstances); 1082 } 1083 1084 /** 1085 ****************************************************************************** 1086 * @ingroup cpaCyCommon 1087 *****************************************************************************/ 1088 CpaStatus 1089 cpaCyGetInstances(Cpa16U numInstances, CpaInstanceHandle *pCyInstances) 1090 { 1091 return Lac_GetCyInstancesByType(CPA_ACC_SVC_TYPE_CRYPTO, 1092 numInstances, 1093 pCyInstances); 1094 } 1095 1096 /** 1097 ****************************************************************************** 1098 * @ingroup cpaCyCommon 1099 *****************************************************************************/ 1100 CpaStatus 1101 cpaCyInstanceGetInfo(const CpaInstanceHandle instanceHandle_in, 1102 struct _CpaInstanceInfo *pInstanceInfo) 1103 { 1104 CpaInstanceHandle instanceHandle = NULL; 1105 sal_crypto_service_t *pCryptoService = NULL; 1106 sal_service_t *pGenericService = NULL; 1107 1108 Cpa8U name[CPA_INST_NAME_SIZE] = 1109 "Intel(R) DH89XXCC instance number: %02x, type: Crypto"; 1110 1111 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) { 1112 instanceHandle = Lac_CryptoGetFirstHandle(); 1113 } else { 1114 instanceHandle = instanceHandle_in; 1115 } 1116 1117 LAC_CHECK_NULL_PARAM(instanceHandle); 1118 LAC_CHECK_NULL_PARAM(pInstanceInfo); 1119 SAL_CHECK_INSTANCE_TYPE(instanceHandle, 1120 (SAL_SERVICE_TYPE_CRYPTO | 1121 SAL_SERVICE_TYPE_CRYPTO_ASYM | 1122 SAL_SERVICE_TYPE_CRYPTO_SYM)); 1123 1124 pCryptoService = (sal_crypto_service_t *)instanceHandle; 1125 1126 pInstanceInfo->type = CPA_INSTANCE_TYPE_CRYPTO; 1127 1128 /* According to cpa.h instance state is initialized and ready for use 1129 * or shutdown. Therefore need to map our running state to initialised 1130 * or shutdown */ 1131 if (SAL_SERVICE_STATE_RUNNING == 1132 pCryptoService->generic_service_info.state) { 1133 pInstanceInfo->state = CPA_INSTANCE_STATE_INITIALISED; 1134 } else { 1135 pInstanceInfo->state = CPA_INSTANCE_STATE_SHUTDOWN; 1136 } 1137 1138 pGenericService = (sal_service_t *)instanceHandle; 1139 snprintf((char *)pInstanceInfo->name, 1140 CPA_INST_NAME_SIZE, 1141 (char *)name, 1142 pGenericService->instance); 1143 1144 pInstanceInfo->name[CPA_INST_NAME_SIZE - 1] = '\0'; 1145 1146 snprintf((char *)pInstanceInfo->version, 1147 CPA_INSTANCE_MAX_NAME_SIZE_IN_BYTES, 1148 "%d.%d", 1149 CPA_CY_API_VERSION_NUM_MAJOR, 1150 CPA_CY_API_VERSION_NUM_MINOR); 1151 1152 pInstanceInfo->version[CPA_INSTANCE_MAX_VERSION_SIZE_IN_BYTES - 1] = 1153 '\0'; 1154 return CPA_STATUS_SUCCESS; 1155 } 1156 1157 /** 1158 ****************************************************************************** 1159 * @ingroup cpaCyCommon 1160 *****************************************************************************/ 1161 CpaStatus 1162 cpaCyInstanceGetInfo2(const CpaInstanceHandle instanceHandle_in, 1163 CpaInstanceInfo2 *pInstanceInfo2) 1164 { 1165 CpaInstanceHandle instanceHandle = NULL; 1166 sal_crypto_service_t *pCryptoService = NULL; 1167 icp_accel_dev_t *dev = NULL; 1168 CpaStatus status = CPA_STATUS_SUCCESS; 1169 char keyStr[ADF_CFG_MAX_KEY_LEN_IN_BYTES] = { 0 }; 1170 char valStr[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 }; 1171 char *section = DYN_SEC; 1172 1173 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) { 1174 instanceHandle = Lac_CryptoGetFirstHandle(); 1175 } else { 1176 instanceHandle = instanceHandle_in; 1177 } 1178 1179 LAC_CHECK_NULL_PARAM(instanceHandle); 1180 LAC_CHECK_NULL_PARAM(pInstanceInfo2); 1181 SAL_CHECK_INSTANCE_TYPE(instanceHandle, 1182 (SAL_SERVICE_TYPE_CRYPTO | 1183 SAL_SERVICE_TYPE_CRYPTO_ASYM | 1184 SAL_SERVICE_TYPE_CRYPTO_SYM)); 1185 1186 LAC_OS_BZERO(pInstanceInfo2, sizeof(CpaInstanceInfo2)); 1187 pInstanceInfo2->accelerationServiceType = CPA_ACC_SVC_TYPE_CRYPTO; 1188 snprintf((char *)pInstanceInfo2->vendorName, 1189 CPA_INST_VENDOR_NAME_SIZE, 1190 "%s", 1191 SAL_INFO2_VENDOR_NAME); 1192 pInstanceInfo2->vendorName[CPA_INST_VENDOR_NAME_SIZE - 1] = '\0'; 1193 1194 snprintf((char *)pInstanceInfo2->swVersion, 1195 CPA_INST_SW_VERSION_SIZE, 1196 "Version %d.%d", 1197 SAL_INFO2_DRIVER_SW_VERSION_MAJ_NUMBER, 1198 SAL_INFO2_DRIVER_SW_VERSION_MIN_NUMBER); 1199 pInstanceInfo2->swVersion[CPA_INST_SW_VERSION_SIZE - 1] = '\0'; 1200 1201 /* Note we can safely read the contents of the crypto service instance 1202 here because icp_amgr_getAllAccelDevByCapabilities() only returns 1203 devs 1204 that have started */ 1205 pCryptoService = (sal_crypto_service_t *)instanceHandle; 1206 pInstanceInfo2->physInstId.packageId = pCryptoService->pkgID; 1207 pInstanceInfo2->physInstId.acceleratorId = 1208 pCryptoService->acceleratorNum; 1209 pInstanceInfo2->physInstId.executionEngineId = 1210 pCryptoService->executionEngine; 1211 pInstanceInfo2->physInstId.busAddress = 1212 icp_adf_get_busAddress(pInstanceInfo2->physInstId.packageId); 1213 1214 /*set coreAffinity to zero before use */ 1215 LAC_OS_BZERO(pInstanceInfo2->coreAffinity, 1216 sizeof(pInstanceInfo2->coreAffinity)); 1217 CPA_BITMAP_BIT_SET(pInstanceInfo2->coreAffinity, 1218 pCryptoService->coreAffinity); 1219 pInstanceInfo2->nodeAffinity = pCryptoService->nodeAffinity; 1220 1221 if (SAL_SERVICE_STATE_RUNNING == 1222 pCryptoService->generic_service_info.state) { 1223 pInstanceInfo2->operState = CPA_OPER_STATE_UP; 1224 } else { 1225 pInstanceInfo2->operState = CPA_OPER_STATE_DOWN; 1226 } 1227 1228 pInstanceInfo2->requiresPhysicallyContiguousMemory = CPA_TRUE; 1229 if (SAL_RESP_POLL_CFG_FILE == pCryptoService->isPolled) { 1230 pInstanceInfo2->isPolled = CPA_TRUE; 1231 } else { 1232 pInstanceInfo2->isPolled = CPA_FALSE; 1233 } 1234 pInstanceInfo2->isOffloaded = CPA_TRUE; 1235 1236 /* Get the instance name and part name */ 1237 dev = icp_adf_getAccelDevByAccelId(pCryptoService->pkgID); 1238 if (NULL == dev || 1239 0 == strnlen(dev->deviceName, ADF_DEVICE_TYPE_LENGTH + 1)) { 1240 LAC_LOG_ERROR("Can not find device for the instance\n"); 1241 LAC_OS_BZERO(pInstanceInfo2, sizeof(CpaInstanceInfo2)); 1242 return CPA_STATUS_FAIL; 1243 } 1244 snprintf((char *)pInstanceInfo2->partName, 1245 CPA_INST_PART_NAME_SIZE, 1246 SAL_INFO2_PART_NAME, 1247 dev->deviceName); 1248 pInstanceInfo2->partName[CPA_INST_PART_NAME_SIZE - 1] = '\0'; 1249 1250 status = 1251 Sal_StringParsing("Cy", 1252 pCryptoService->generic_service_info.instance, 1253 "Name", 1254 keyStr); 1255 LAC_CHECK_STATUS(status); 1256 1257 if (CPA_FALSE == pCryptoService->generic_service_info.is_dyn) { 1258 section = icpGetProcessName(); 1259 } 1260 1261 status = icp_adf_cfgGetParamValue(dev, section, keyStr, valStr); 1262 LAC_CHECK_STATUS(status); 1263 1264 snprintf((char *)pInstanceInfo2->instName, 1265 CPA_INST_NAME_SIZE, 1266 "%s", 1267 valStr); 1268 snprintf((char *)pInstanceInfo2->instID, 1269 CPA_INST_ID_SIZE, 1270 "%s_%s", 1271 section, 1272 valStr); 1273 return CPA_STATUS_SUCCESS; 1274 } 1275 1276 /** 1277 ****************************************************************************** 1278 * @ingroup cpaCyCommon 1279 *****************************************************************************/ 1280 1281 CpaStatus 1282 cpaCyQueryCapabilities(const CpaInstanceHandle instanceHandle_in, 1283 CpaCyCapabilitiesInfo *pCapInfo) 1284 { 1285 /* Verify Instance exists */ 1286 CpaInstanceHandle instanceHandle = NULL; 1287 1288 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) { 1289 instanceHandle = Lac_CryptoGetFirstHandle(); 1290 } else { 1291 instanceHandle = instanceHandle_in; 1292 } 1293 1294 LAC_CHECK_NULL_PARAM(instanceHandle); 1295 SAL_CHECK_INSTANCE_TYPE(instanceHandle, 1296 (SAL_SERVICE_TYPE_CRYPTO | 1297 SAL_SERVICE_TYPE_CRYPTO_ASYM | 1298 SAL_SERVICE_TYPE_CRYPTO_SYM)); 1299 LAC_CHECK_NULL_PARAM(pCapInfo); 1300 1301 SalCtrl_CyQueryCapabilities((sal_service_t *)instanceHandle, pCapInfo); 1302 1303 return CPA_STATUS_SUCCESS; 1304 } 1305 1306 /** 1307 ****************************************************************************** 1308 * @ingroup cpaCySym 1309 *****************************************************************************/ 1310 CpaStatus 1311 cpaCySymQueryCapabilities(const CpaInstanceHandle instanceHandle_in, 1312 CpaCySymCapabilitiesInfo *pCapInfo) 1313 { 1314 sal_crypto_service_t *pCryptoService = NULL; 1315 sal_service_t *pGenericService = NULL; 1316 CpaInstanceHandle instanceHandle = NULL; 1317 1318 /* Verify Instance exists */ 1319 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) { 1320 instanceHandle = Lac_GetFirstHandle(SAL_SERVICE_TYPE_CRYPTO); 1321 if (!instanceHandle) { 1322 instanceHandle = 1323 Lac_GetFirstHandle(SAL_SERVICE_TYPE_CRYPTO_SYM); 1324 } 1325 } else { 1326 instanceHandle = instanceHandle_in; 1327 } 1328 1329 LAC_CHECK_NULL_PARAM(instanceHandle); 1330 SAL_CHECK_INSTANCE_TYPE(instanceHandle, 1331 (SAL_SERVICE_TYPE_CRYPTO | 1332 SAL_SERVICE_TYPE_CRYPTO_ASYM | 1333 SAL_SERVICE_TYPE_CRYPTO_SYM)); 1334 LAC_CHECK_NULL_PARAM(pCapInfo); 1335 1336 pCryptoService = (sal_crypto_service_t *)instanceHandle; 1337 pGenericService = &(pCryptoService->generic_service_info); 1338 1339 memset(pCapInfo, '\0', sizeof(CpaCySymCapabilitiesInfo)); 1340 /* An asym crypto instance does not support sym service */ 1341 if (SAL_SERVICE_TYPE_CRYPTO_ASYM == pGenericService->type) { 1342 return CPA_STATUS_SUCCESS; 1343 } 1344 1345 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_NULL); 1346 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_AES_ECB); 1347 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_AES_CBC); 1348 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_AES_CTR); 1349 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_AES_CCM); 1350 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_AES_GCM); 1351 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_AES_XTS); 1352 if (isCyGen2x(pCryptoService)) { 1353 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_ARC4); 1354 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, 1355 CPA_CY_SYM_CIPHER_DES_ECB); 1356 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, 1357 CPA_CY_SYM_CIPHER_DES_CBC); 1358 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, 1359 CPA_CY_SYM_CIPHER_3DES_ECB); 1360 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, 1361 CPA_CY_SYM_CIPHER_3DES_CBC); 1362 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, 1363 CPA_CY_SYM_CIPHER_3DES_CTR); 1364 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, 1365 CPA_CY_SYM_CIPHER_KASUMI_F8); 1366 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, 1367 CPA_CY_SYM_CIPHER_SNOW3G_UEA2); 1368 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_AES_F8); 1369 } 1370 1371 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA1); 1372 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA224); 1373 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA256); 1374 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA384); 1375 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA512); 1376 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_AES_XCBC); 1377 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_AES_CCM); 1378 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_AES_GCM); 1379 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_AES_CMAC); 1380 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_AES_GMAC); 1381 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_AES_CBC_MAC); 1382 if (isCyGen2x(pCryptoService)) { 1383 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_MD5); 1384 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_KASUMI_F9); 1385 CPA_BITMAP_BIT_SET(pCapInfo->hashes, 1386 CPA_CY_SYM_HASH_SNOW3G_UIA2); 1387 } 1388 1389 if (pGenericService->capabilitiesMask & 1390 ICP_ACCEL_CAPABILITIES_CRYPTO_ZUC) { 1391 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, 1392 CPA_CY_SYM_CIPHER_ZUC_EEA3); 1393 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_ZUC_EIA3); 1394 } 1395 1396 if (pGenericService->capabilitiesMask & 1397 ICP_ACCEL_CAPABILITIES_CHACHA_POLY) { 1398 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_POLY); 1399 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_CHACHA); 1400 } 1401 1402 if (pGenericService->capabilitiesMask & ICP_ACCEL_CAPABILITIES_SM3) { 1403 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SM3); 1404 } 1405 1406 pCapInfo->partialPacketSupported = CPA_TRUE; 1407 1408 if (pGenericService->capabilitiesMask & ICP_ACCEL_CAPABILITIES_SHA3) { 1409 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA3_256); 1410 pCapInfo->partialPacketSupported = CPA_FALSE; 1411 } 1412 1413 if (pGenericService->capabilitiesMask & 1414 ICP_ACCEL_CAPABILITIES_SHA3_EXT) { 1415 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA3_224); 1416 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA3_256); 1417 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA3_384); 1418 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA3_512); 1419 pCapInfo->partialPacketSupported = CPA_FALSE; 1420 } 1421 1422 if (pGenericService->capabilitiesMask & ICP_ACCEL_CAPABILITIES_SM4) { 1423 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, 1424 CPA_CY_SYM_CIPHER_SM4_ECB); 1425 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, 1426 CPA_CY_SYM_CIPHER_SM4_CBC); 1427 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, 1428 CPA_CY_SYM_CIPHER_SM4_CTR); 1429 pCapInfo->partialPacketSupported = CPA_FALSE; 1430 } 1431 1432 return CPA_STATUS_SUCCESS; 1433 } 1434 1435 /** 1436 ****************************************************************************** 1437 * @ingroup cpaCyCommon 1438 *****************************************************************************/ 1439 CpaStatus 1440 cpaCySetAddressTranslation(const CpaInstanceHandle instanceHandle_in, 1441 CpaVirtualToPhysical virtual2physical) 1442 { 1443 1444 CpaInstanceHandle instanceHandle = NULL; 1445 sal_service_t *pService = NULL; 1446 1447 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) { 1448 instanceHandle = Lac_CryptoGetFirstHandle(); 1449 } else { 1450 instanceHandle = instanceHandle_in; 1451 } 1452 1453 LAC_CHECK_NULL_PARAM(instanceHandle); 1454 SAL_CHECK_INSTANCE_TYPE(instanceHandle, 1455 (SAL_SERVICE_TYPE_CRYPTO | 1456 SAL_SERVICE_TYPE_CRYPTO_ASYM | 1457 SAL_SERVICE_TYPE_CRYPTO_SYM)); 1458 LAC_CHECK_NULL_PARAM(virtual2physical); 1459 1460 pService = (sal_service_t *)instanceHandle; 1461 1462 pService->virt2PhysClient = virtual2physical; 1463 1464 return CPA_STATUS_SUCCESS; 1465 } 1466 1467 /** 1468 ****************************************************************************** 1469 * @ingroup cpaCyCommon 1470 * Crypto specific polling function which polls a crypto instance. 1471 *****************************************************************************/ 1472 CpaStatus 1473 icp_sal_CyPollInstance(CpaInstanceHandle instanceHandle_in, 1474 Cpa32U response_quota) 1475 { 1476 CpaStatus status = CPA_STATUS_SUCCESS; 1477 sal_crypto_service_t *crypto_handle = NULL; 1478 sal_service_t *gen_handle = NULL; 1479 icp_comms_trans_handle trans_hndTable[MAX_CY_RX_RINGS] = { 0 }; 1480 Cpa32U num_rx_rings = 0; 1481 1482 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) { 1483 crypto_handle = 1484 (sal_crypto_service_t *)Lac_CryptoGetFirstHandle(); 1485 } else { 1486 crypto_handle = (sal_crypto_service_t *)instanceHandle_in; 1487 } 1488 LAC_CHECK_NULL_PARAM(crypto_handle); 1489 SAL_RUNNING_CHECK(crypto_handle); 1490 SAL_CHECK_INSTANCE_TYPE(crypto_handle, 1491 (SAL_SERVICE_TYPE_CRYPTO | 1492 SAL_SERVICE_TYPE_CRYPTO_ASYM | 1493 SAL_SERVICE_TYPE_CRYPTO_SYM)); 1494 1495 gen_handle = &(crypto_handle->generic_service_info); 1496 1497 /* 1498 * From the instanceHandle we must get the trans_handle and send 1499 * down to adf for polling. 1500 * Populate our trans handle table with the appropriate handles. 1501 */ 1502 1503 switch (gen_handle->type) { 1504 case SAL_SERVICE_TYPE_CRYPTO_ASYM: 1505 trans_hndTable[TH_CY_RX_0] = 1506 crypto_handle->trans_handle_asym_rx; 1507 num_rx_rings = 1; 1508 break; 1509 case SAL_SERVICE_TYPE_CRYPTO_SYM: 1510 trans_hndTable[TH_CY_RX_0] = crypto_handle->trans_handle_sym_rx; 1511 num_rx_rings = 1; 1512 break; 1513 case SAL_SERVICE_TYPE_CRYPTO: 1514 trans_hndTable[TH_CY_RX_0] = crypto_handle->trans_handle_sym_rx; 1515 trans_hndTable[TH_CY_RX_1] = 1516 crypto_handle->trans_handle_asym_rx; 1517 num_rx_rings = MAX_CY_RX_RINGS; 1518 break; 1519 default: 1520 break; 1521 } 1522 1523 /* Call adf to do the polling. */ 1524 status = 1525 icp_adf_pollInstance(trans_hndTable, num_rx_rings, response_quota); 1526 1527 return status; 1528 } 1529 1530 /** 1531 ****************************************************************************** 1532 * @ingroup cpaCyCommon 1533 * Crypto specific polling function which polls sym crypto ring. 1534 *****************************************************************************/ 1535 CpaStatus 1536 icp_sal_CyPollSymRing(CpaInstanceHandle instanceHandle_in, 1537 Cpa32U response_quota) 1538 { 1539 CpaStatus status = CPA_STATUS_SUCCESS; 1540 sal_crypto_service_t *crypto_handle = NULL; 1541 icp_comms_trans_handle trans_hndTable[NUM_CRYPTO_SYM_RX_RINGS] = { 0 }; 1542 1543 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) { 1544 crypto_handle = (sal_crypto_service_t *)Lac_GetFirstHandle( 1545 SAL_SERVICE_TYPE_CRYPTO_SYM); 1546 } else { 1547 crypto_handle = (sal_crypto_service_t *)instanceHandle_in; 1548 } 1549 LAC_CHECK_NULL_PARAM(crypto_handle); 1550 SAL_CHECK_INSTANCE_TYPE(crypto_handle, 1551 (SAL_SERVICE_TYPE_CRYPTO | 1552 SAL_SERVICE_TYPE_CRYPTO_SYM)); 1553 SAL_RUNNING_CHECK(crypto_handle); 1554 1555 /* 1556 * From the instanceHandle we must get the trans_handle and send 1557 * down to adf for polling. 1558 * Populate our trans handle table with the appropriate handles. 1559 */ 1560 trans_hndTable[TH_SINGLE_RX] = crypto_handle->trans_handle_sym_rx; 1561 /* Call adf to do the polling. */ 1562 status = icp_adf_pollInstance(trans_hndTable, 1563 NUM_CRYPTO_SYM_RX_RINGS, 1564 response_quota); 1565 return status; 1566 } 1567 1568 /** 1569 ****************************************************************************** 1570 * @ingroup cpaCyCommon 1571 * Crypto specific polling function which polls an nrbg crypto ring. 1572 *****************************************************************************/ 1573 CpaStatus 1574 icp_sal_CyPollNRBGRing(CpaInstanceHandle instanceHandle_in, 1575 Cpa32U response_quota) 1576 { 1577 return CPA_STATUS_UNSUPPORTED; 1578 } 1579 1580 /* Returns the handle to the first asym crypto instance */ 1581 static CpaInstanceHandle 1582 Lac_GetFirstAsymHandle(icp_accel_dev_t *adfInsts[ADF_MAX_DEVICES], 1583 Cpa16U num_dev) 1584 { 1585 CpaStatus status = CPA_STATUS_SUCCESS; 1586 icp_accel_dev_t *dev_addr = NULL; 1587 sal_t *base_addr = NULL; 1588 sal_list_t *list_temp = NULL; 1589 CpaInstanceHandle cyInst = NULL; 1590 CpaInstanceInfo2 info; 1591 Cpa16U i = 0; 1592 1593 for (i = 0; i < num_dev; i++) { 1594 dev_addr = (icp_accel_dev_t *)adfInsts[i]; 1595 base_addr = dev_addr->pSalHandle; 1596 if (NULL == base_addr) { 1597 continue; 1598 } 1599 list_temp = base_addr->asym_services; 1600 while (NULL != list_temp) { 1601 cyInst = SalList_getObject(list_temp); 1602 status = cpaCyInstanceGetInfo2(cyInst, &info); 1603 list_temp = SalList_next(list_temp); 1604 if (CPA_STATUS_SUCCESS != status || 1605 CPA_TRUE != info.isPolled) { 1606 cyInst = NULL; 1607 continue; 1608 } 1609 break; 1610 } 1611 if (cyInst) { 1612 break; 1613 } 1614 } 1615 1616 return cyInst; 1617 } 1618 1619 /* Returns the handle to the first sym crypto instance */ 1620 static CpaInstanceHandle 1621 Lac_GetFirstSymHandle(icp_accel_dev_t *adfInsts[ADF_MAX_DEVICES], 1622 Cpa16U num_dev) 1623 { 1624 CpaStatus status = CPA_STATUS_SUCCESS; 1625 icp_accel_dev_t *dev_addr = NULL; 1626 sal_t *base_addr = NULL; 1627 sal_list_t *list_temp = NULL; 1628 CpaInstanceHandle cyInst = NULL; 1629 CpaInstanceInfo2 info; 1630 Cpa16U i = 0; 1631 1632 for (i = 0; i < num_dev; i++) { 1633 dev_addr = (icp_accel_dev_t *)adfInsts[i]; 1634 base_addr = dev_addr->pSalHandle; 1635 if (NULL == base_addr) { 1636 continue; 1637 } 1638 list_temp = base_addr->sym_services; 1639 while (NULL != list_temp) { 1640 cyInst = SalList_getObject(list_temp); 1641 status = cpaCyInstanceGetInfo2(cyInst, &info); 1642 list_temp = SalList_next(list_temp); 1643 if (CPA_STATUS_SUCCESS != status || 1644 CPA_TRUE != info.isPolled) { 1645 cyInst = NULL; 1646 continue; 1647 } 1648 break; 1649 } 1650 if (cyInst) { 1651 break; 1652 } 1653 } 1654 1655 return cyInst; 1656 } 1657 1658 /* Returns the handle to the first crypto instance 1659 * Note that the crypto instance in this case supports 1660 * both asym and sym services */ 1661 static CpaInstanceHandle 1662 Lac_GetFirstCyHandle(icp_accel_dev_t *adfInsts[ADF_MAX_DEVICES], Cpa16U num_dev) 1663 { 1664 CpaStatus status = CPA_STATUS_SUCCESS; 1665 icp_accel_dev_t *dev_addr = NULL; 1666 sal_t *base_addr = NULL; 1667 sal_list_t *list_temp = NULL; 1668 CpaInstanceHandle cyInst = NULL; 1669 CpaInstanceInfo2 info; 1670 Cpa16U i = 0; 1671 1672 for (i = 0; i < num_dev; i++) { 1673 dev_addr = (icp_accel_dev_t *)adfInsts[i]; 1674 base_addr = dev_addr->pSalHandle; 1675 if (NULL == base_addr) { 1676 continue; 1677 } 1678 list_temp = base_addr->crypto_services; 1679 while (NULL != list_temp) { 1680 cyInst = SalList_getObject(list_temp); 1681 status = cpaCyInstanceGetInfo2(cyInst, &info); 1682 list_temp = SalList_next(list_temp); 1683 if (CPA_STATUS_SUCCESS != status || 1684 CPA_TRUE != info.isPolled) { 1685 cyInst = NULL; 1686 continue; 1687 } 1688 break; 1689 } 1690 if (cyInst) { 1691 break; 1692 } 1693 } 1694 1695 return cyInst; 1696 } 1697 1698 CpaInstanceHandle 1699 Lac_GetFirstHandle(sal_service_type_t svc_type) 1700 { 1701 CpaStatus status = CPA_STATUS_SUCCESS; 1702 static icp_accel_dev_t *adfInsts[ADF_MAX_DEVICES] = { 0 }; 1703 CpaInstanceHandle cyInst = NULL; 1704 Cpa16U num_cy_dev = 0; 1705 Cpa32U capabilities = 0; 1706 1707 switch (svc_type) { 1708 case SAL_SERVICE_TYPE_CRYPTO_ASYM: 1709 capabilities = ICP_ACCEL_CAPABILITIES_CRYPTO_ASYMMETRIC; 1710 break; 1711 case SAL_SERVICE_TYPE_CRYPTO_SYM: 1712 capabilities = ICP_ACCEL_CAPABILITIES_CRYPTO_SYMMETRIC; 1713 break; 1714 case SAL_SERVICE_TYPE_CRYPTO: 1715 capabilities = ICP_ACCEL_CAPABILITIES_CRYPTO_ASYMMETRIC; 1716 capabilities |= ICP_ACCEL_CAPABILITIES_CRYPTO_SYMMETRIC; 1717 break; 1718 default: 1719 LAC_LOG_ERROR("Invalid service type\n"); 1720 return NULL; 1721 } 1722 /* Only need 1 dev with crypto enabled - so check all devices*/ 1723 status = icp_amgr_getAllAccelDevByEachCapability(capabilities, 1724 adfInsts, 1725 &num_cy_dev); 1726 if ((0 == num_cy_dev) || (CPA_STATUS_SUCCESS != status)) { 1727 LAC_LOG_ERROR("No crypto devices enabled in the system\n"); 1728 return NULL; 1729 } 1730 1731 switch (svc_type) { 1732 case SAL_SERVICE_TYPE_CRYPTO_ASYM: 1733 /* Try to find an asym only instance first */ 1734 cyInst = Lac_GetFirstAsymHandle(adfInsts, num_cy_dev); 1735 /* Try to find a cy instance since it also supports asym */ 1736 if (NULL == cyInst) { 1737 cyInst = Lac_GetFirstCyHandle(adfInsts, num_cy_dev); 1738 } 1739 break; 1740 case SAL_SERVICE_TYPE_CRYPTO_SYM: 1741 /* Try to find a sym only instance first */ 1742 cyInst = Lac_GetFirstSymHandle(adfInsts, num_cy_dev); 1743 /* Try to find a cy instance since it also supports sym */ 1744 if (NULL == cyInst) { 1745 cyInst = Lac_GetFirstCyHandle(adfInsts, num_cy_dev); 1746 } 1747 break; 1748 case SAL_SERVICE_TYPE_CRYPTO: 1749 /* Try to find a cy instance */ 1750 cyInst = Lac_GetFirstCyHandle(adfInsts, num_cy_dev); 1751 break; 1752 default: 1753 break; 1754 } 1755 if (NULL == cyInst) { 1756 LAC_LOG_ERROR("No remaining crypto instances available\n"); 1757 } 1758 return cyInst; 1759 } 1760 1761 CpaStatus 1762 icp_sal_NrbgGetInflightRequests(CpaInstanceHandle instanceHandle_in, 1763 Cpa32U *maxInflightRequests, 1764 Cpa32U *numInflightRequests) 1765 { 1766 return CPA_STATUS_UNSUPPORTED; 1767 } 1768 1769 CpaStatus 1770 icp_sal_SymGetInflightRequests(CpaInstanceHandle instanceHandle, 1771 Cpa32U *maxInflightRequests, 1772 Cpa32U *numInflightRequests) 1773 { 1774 sal_crypto_service_t *crypto_handle = NULL; 1775 1776 crypto_handle = (sal_crypto_service_t *)instanceHandle; 1777 1778 LAC_CHECK_NULL_PARAM(crypto_handle); 1779 LAC_CHECK_NULL_PARAM(maxInflightRequests); 1780 LAC_CHECK_NULL_PARAM(numInflightRequests); 1781 SAL_RUNNING_CHECK(crypto_handle); 1782 1783 return icp_adf_getInflightRequests(crypto_handle->trans_handle_sym_tx, 1784 maxInflightRequests, 1785 numInflightRequests); 1786 } 1787 1788 CpaStatus 1789 icp_sal_dp_SymGetInflightRequests(CpaInstanceHandle instanceHandle, 1790 Cpa32U *maxInflightRequests, 1791 Cpa32U *numInflightRequests) 1792 { 1793 sal_crypto_service_t *crypto_handle = NULL; 1794 1795 crypto_handle = (sal_crypto_service_t *)instanceHandle; 1796 1797 return icp_adf_dp_getInflightRequests( 1798 crypto_handle->trans_handle_sym_tx, 1799 maxInflightRequests, 1800 numInflightRequests); 1801 } 1802 1803 CpaStatus 1804 icp_sal_setForceAEADMACVerify(CpaInstanceHandle instanceHandle, 1805 CpaBoolean forceAEADMacVerify) 1806 { 1807 sal_crypto_service_t *crypto_handle = NULL; 1808 1809 crypto_handle = (sal_crypto_service_t *)instanceHandle; 1810 LAC_CHECK_NULL_PARAM(crypto_handle); 1811 crypto_handle->forceAEADMacVerify = forceAEADMacVerify; 1812 1813 return CPA_STATUS_SUCCESS; 1814 } 1815