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